[glibmm/vector] Fixed one test and refactored another a bit.

[Krzesimir Nowak <krnowak src gnome org>]

commit 46e66522324a08a132c0e47c9b5cab0a371285c0
Author: Krzesimir Nowak <qdlacz gmail com>
Date:   Sat Jan 22 18:40:56 2011 +0100

    Fixed one test and refactored another a bit.

 tests/glibmm_bool_vector/main.cc |    3 +-
 tests/glibmm_vector/main.cc      |  458 ++++++++++++++++++--------------------
 2 files changed, 220 insertions(+), 241 deletions(-)
---
diff --git a/tests/glibmm_bool_vector/main.cc b/tests/glibmm_bool_vector/main.cc
index 29cbf1e..47b6796 100644
--- a/tests/glibmm_bool_vector/main.cc
+++ b/tests/glibmm_bool_vector/main.cc
@@ -30,6 +30,7 @@ setup_rand ()
 
   if (!setup)
   {
+    setup = true;
     std::srand (std::time (0));
   }
 }
@@ -60,7 +61,7 @@ c_print_bool_array (gboolean* array)
 std::vector<bool>
 cxx_get_bool_array ()
 {
-  return Glib::ArrayHandler<bool>::array_to_vector (c_get_bool_array (), Glib::OWNERSHIP_SHALLOW);
+  return Glib::ArrayHandler<bool>::array_to_vector (c_get_bool_array (), magic_limit, Glib::OWNERSHIP_SHALLOW);
 }
 
 void
diff --git a/tests/glibmm_vector/main.cc b/tests/glibmm_vector/main.cc
index dc3211f..4b64276 100644
--- a/tests/glibmm_vector/main.cc
+++ b/tests/glibmm_vector/main.cc
@@ -17,18 +17,18 @@
 
 // ugly code ahead.
 
+#include <iostream>
+
+#include <gio/gio.h>
+
 #include <glibmm/vectorutils.h>
-#include <glibmm/containerhandle_shared.h> /* Because its specializations may be here. */
-#include <glibmm/object.h>
-// we use GCredentials as a simple GObject without fancy constructor.
+
 #include <giomm/credentials.h>
 #include <giomm/init.h>
-#include <glib.h>
-#include <glib-object.h>
-#include <gio/gio.h>
-#include <iostream>
 
-const unsigned int magic_limit (42);
+// utilities
+
+const unsigned int magic_limit (5);
 
 GList*
 create_list ()
@@ -42,6 +42,25 @@ create_list ()
   return g_list_reverse (head);
 }
 
+void
+print_list (GList* list)
+{
+  unsigned int counter (1);
+
+  for (GList* node (list); node; node = node->next, ++counter)
+  {
+    std::cout << counter << ": ";
+    if (G_IS_CREDENTIALS (node->data))
+    {
+      std::cout << node->data << ", ref: " << G_OBJECT (node->data)->ref_count <<"\n";
+    }
+    else
+    {
+      std::cout << "no C instance?\n";
+    }
+  }
+}
+
 GSList*
 create_slist ()
 {
@@ -54,6 +73,25 @@ create_slist ()
   return g_slist_reverse (head);
 }
 
+void
+print_slist (GSList* slist)
+{
+  unsigned int counter (1);
+
+  for (GSList* node (slist); node; node = node->next, ++counter)
+  {
+    std::cout << counter << ": ";
+    if (G_IS_CREDENTIALS (node->data))
+    {
+      std::cout << node->data << ", ref: " << G_OBJECT (node->data)->ref_count <<"\n";
+    }
+    else
+    {
+      std::cout << "no C instance?\n";
+    }
+  }
+}
+
 GCredentials**
 create_array ()
 {
@@ -66,6 +104,25 @@ create_array ()
   return array;
 }
 
+void
+print_array (GCredentials** array)
+{
+  for (unsigned int iter (0); iter < magic_limit; ++iter)
+  {
+    GCredentials* credentials (array[iter]);
+
+    std::cout << iter + 1 << ": ";
+    if (G_IS_CREDENTIALS (credentials))
+    {
+      std::cout << reinterpret_cast<gpointer> (credentials) << ", ref: " << G_OBJECT (credentials)->ref_count << "\n";
+    }
+    else
+    {
+      std::cout << "no C instance?\n";
+    }
+  }
+}
+
 // shallow copy
 GCredentials**
 copy_array (GCredentials** array)
@@ -76,9 +133,53 @@ copy_array (GCredentials** array)
   {
     dup[iter] = array[iter];
   }
+  dup[magic_limit] = 0;
   return dup;
 }
 
+void
+free_array (GCredentials** array, bool container_too = true)
+{
+  for (unsigned int iter (0); iter < magic_limit; ++iter)
+  {
+    g_object_unref (array[iter]);
+  }
+  if (container_too)
+  {
+    g_free (array);
+  }
+}
+
+void
+print_vector (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
+{
+  const unsigned int size (v.size ());
+
+  for (unsigned int iter (0); iter < size; ++iter)
+  {
+    const Glib::RefPtr<Gio::Credentials>& obj_ptr (v[iter]);
+
+    std::cout << iter + 1 << ": ";
+    if (obj_ptr)
+    {
+      GCredentials* gobj (obj_ptr->gobj ());
+
+      if (G_IS_CREDENTIALS (gobj))
+      {
+        std::cout << static_cast<gpointer> (gobj) << ", ref: " << G_OBJECT (gobj)->ref_count << "\n";
+      }
+      else
+      {
+        std::cout << "No C instance?\n";
+      }
+    }
+    else
+    {
+      std::cout << "No C++ instance?\n";
+    }
+  }
+}
+
 struct Cache
 {
 public:
@@ -102,435 +203,311 @@ public:
     }
     if (garray_)
     {
-      for (unsigned int iter (0); iter < magic_limit; ++iter)
-      {
-        g_object_unref (garray_[iter]);
-      }
-      g_free (garray_);
+      free_array (garray_);
     }
   }
 
-  void print_list ()
+  GList*
+  get_list () const
   {
-    unsigned int counter (1);
-
-    for (GList* node (glist_); node; node = node->next, ++counter)
-    {
-      std::cout << counter << ": ";
-      if (G_IS_CREDENTIALS (node->data))
-      {
-        std::cout << node->data << ", ref: " << G_OBJECT (node->data)->ref_count <<"\n";
-      }
-      else
-      {
-        std::cout << "no C instance?\n";
-      }
-    }
+    return glist_;
   }
 
-  void print_slist ()
+  GSList*
+  get_slist () const
   {
-    unsigned int counter (1);
-
-    for (GSList* node (gslist_); node; node = node->next, ++counter)
-    {
-      std::cout << counter << ": ";
-      if (G_IS_CREDENTIALS (node->data))
-      {
-        std::cout << node->data << ", ref: " << G_OBJECT (node->data)->ref_count <<"\n";
-      }
-      else
-      {
-        std::cout << "no C instance?\n";
-      }
-    }
+    return gslist_;
   }
 
-  void print_array ()
+  GCredentials**
+  get_array () const
   {
-    for (unsigned int iter (0); iter < magic_limit; ++iter)
-    {
-      std::cout << iter + 1 << ": ";
-      if (G_IS_CREDENTIALS (garray_[iter]))
-      {
-        std::cout << reinterpret_cast<gpointer> (garray_[iter]) << ", ref: " << G_OBJECT (garray_[iter])->ref_count << "\n";
-      }
-      else
-      {
-        std::cout << "no C instance?\n";
-      }
-    }
+    return garray_;
   }
 
-  GList* glist_;
-  GSList* gslist_;
-  GCredentials** garray_;
-
 private:
   // just in case
   Cache (const Cache&);
   Cache operator= (const Cache&);
+
+  GList* glist_;
+  GSList* gslist_;
+  GCredentials** garray_;
 };
 
-Cache& get_cache ()
+Cache&
+get_cache ()
 {
   static Cache global_cache;
 
   return global_cache;
 }
 
+// C functions
+
 GList*
-return_deep_owned_list ()
+c_get_deep_owned_list ()
 {
-  return get_cache ().glist_;
+  return get_cache ().get_list ();
 }
 
 GList*
-return_shallow_owned_list ()
+c_get_shallow_owned_list ()
 {
-  return g_list_copy (return_deep_owned_list ());
+  return g_list_copy (c_get_deep_owned_list ());
 }
 
 GList*
-return_unowned_list ()
+c_get_unowned_list ()
 {
   return create_list ();
 }
 
 GSList*
-return_deep_owned_slist ()
+c_get_deep_owned_slist ()
 {
-  return get_cache ().gslist_;
+  return get_cache ().get_slist ();
 }
 
 GSList*
-return_shallow_owned_slist ()
+c_get_shallow_owned_slist ()
 {
-  return g_slist_copy (return_deep_owned_slist ());
+  return g_slist_copy (c_get_deep_owned_slist ());
 }
 
 GSList*
-return_unowned_slist ()
+c_get_unowned_slist ()
 {
   return create_slist ();
 }
 
 GCredentials**
-return_deep_owned_array ()
+c_get_deep_owned_array ()
 {
-  return get_cache ().garray_;
+  return get_cache ().get_array ();
 }
 
 GCredentials**
-return_shallow_owned_array ()
+c_get_shallow_owned_array ()
 {
-  return copy_array (return_deep_owned_array ());
+  return copy_array (c_get_deep_owned_array ());
 }
 
 GCredentials**
-return_unowned_array ()
+c_get_unowned_array ()
 {
   return create_array ();
 }
 
-/* they are probably buggy by design...
+/* these are probably buggy by design...
 void
-take_list_all (GList* list)
+c_take_list_all (GList* list)
 {
   if (list)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GList* backup = cache.glist_;
-
-    cache.glist_ = list;
-    cache.print_list ();
-    cache.glist_ = backup;
+    print_list (list);
     g_list_foreach (list, reinterpret_cast<GFunc> (g_object_unref), 0);
     g_list_free (list);
   }
 }
 
 void
-take_list_members (GList* list)
+c_take_list_members (GList* list)
 {
   if (list)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GList* backup = cache.glist_;
-
-    cache.glist_ = list;
-    cache.print_list ();
-    cache.glist_ = backup;
+    print_list (list);
     g_list_foreach (list, reinterpret_cast<GFunc> (g_object_unref), 0);
   }
 }
 */
 
 void
-take_list_nothing (GList* list)
+c_take_list_nothing (GList* list)
 {
   if (list)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GList* backup = cache.glist_;
-
-    cache.glist_ = list;
-    cache.print_list ();
-    cache.glist_ = backup;
+    print_list (list);
   }
 }
 
 /* they are probably buggy by design...
 void
-take_slist_all (GSList* slist)
+c_take_slist_all (GSList* slist)
 {
   if (slist)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GSList* backup = cache.gslist_;
-
-    cache.gslist_ = slist;
-    cache.print_slist ();
-    cache.gslist_ = backup;
+    print_slist (slist);
     g_slist_foreach (slist, reinterpret_cast<GFunc> (g_object_unref), 0);
     g_slist_free (slist);
   }
 }
 
 void
-take_list_members (GSList* slist)
+c_take_list_members (GSList* slist)
 {
   if (slist)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GSList* backup = cache.gslist_;
-
-    cache.gslist_ = slist;
-    cache.print_slist ();
-    cache.gslist_ = backup;
+    print_slist (slist);
     g_slist_foreach (slist, reinterpret_cast<GFunc> (g_object_unref), 0);
   }
 }
 */
 
 void
-take_slist_nothing (GSList* slist)
+c_take_slist_nothing (GSList* slist)
 {
   if (slist)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GSList* backup = cache.gslist_;
-
-    cache.gslist_ = slist;
-    cache.print_slist ();
-    cache.gslist_ = backup;
+    print_slist (slist);
   }
 }
 
 /* they are probably buggy by design...
 void
-take_array_all (GCredentials** array)
+c_take_array_all (GCredentials** array)
 {
   if (array)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GCredentials** backup = cache.garray_;
-
-    cache.garray_ = array;
-    cache.print_array ();
-    cache.garray_ = backup;
-    for (unsigned int iter (0); iter < magic_limit; ++iter)
-    {
-      g_object_unref (array[iter]);
-    }
-    g_free (array);
+    print_array (array);
+    free_array (array);
   }
 }
 
 void
-take_array_members (GCredentials** array)
+c_take_array_members (GCredentials** array)
 {
   if (array)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GCredentials** backup = cache.garray_;
-
-    cache.garray_ = array;
-    cache.print_array ();
-    cache.garray_ = backup;
-    for (unsigned int iter (0); iter < magic_limit; ++iter)
-    {
-      g_object_unref (array[iter]);
-    }
+    print_array (array);
+    free_array (array, false);
   }
 }
 */
 
 void
-take_array_nothing (GCredentials** array)
+c_take_array_nothing (GCredentials** array)
 {
   if (array)
   {
-    // i'm lazy.
-    Cache& cache (get_cache ());
-    GCredentials** backup = cache.garray_;
-
-    cache.garray_ = array;
-    cache.print_array ();
-    cache.garray_ = backup;
+    print_array (array);
   }
 }
 
+// C++ wrappers.
+
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_deep_list ()
+cxx_get_deep_owned_list ()
 {
-  return Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::list_to_vector (return_deep_owned_list (), Glib::OWNERSHIP_NONE);
+  return Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::list_to_vector (c_get_deep_owned_list (), Glib::OWNERSHIP_NONE);
 }
 
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_shallow_list ()
+cxx_get_shallow_owned_list ()
 {
-  return Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::list_to_vector (return_shallow_owned_list (), Glib::OWNERSHIP_SHALLOW);
+  return Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::list_to_vector (c_get_shallow_owned_list (), Glib::OWNERSHIP_SHALLOW);
 }
 
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_none_list ()
+cxx_get_unowned_list ()
 {
-  return Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::list_to_vector (return_unowned_list (), Glib::OWNERSHIP_DEEP);
+  return Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::list_to_vector (c_get_unowned_list (), Glib::OWNERSHIP_DEEP);
 }
 
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_deep_slist ()
+cxx_get_deep_owned_slist ()
 {
-  return Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::slist_to_vector (return_deep_owned_slist (), Glib::OWNERSHIP_NONE);
+  return Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::slist_to_vector (c_get_deep_owned_slist (), Glib::OWNERSHIP_NONE);
 }
 
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_shallow_slist ()
+cxx_get_shallow_owned_slist ()
 {
-  return Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::slist_to_vector (return_shallow_owned_slist (), Glib::OWNERSHIP_SHALLOW);
+  return Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::slist_to_vector (c_get_shallow_owned_slist (), Glib::OWNERSHIP_SHALLOW);
 }
 
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_none_slist ()
+cxx_get_unowned_slist ()
 {
-  return Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::slist_to_vector (return_unowned_slist (), Glib::OWNERSHIP_DEEP);
+  return Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::slist_to_vector (c_get_unowned_slist (), Glib::OWNERSHIP_DEEP);
 }
 
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_deep_array ()
+cxx_get_deep_owned_array ()
 {
-  return Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::array_to_vector (return_deep_owned_array (), Glib::OWNERSHIP_NONE);
+  return Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::array_to_vector (c_get_deep_owned_array (), Glib::OWNERSHIP_NONE);
 }
 
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_shallow_array ()
+cxx_get_shallow_owned_array ()
 {
-  return Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::array_to_vector (return_shallow_owned_array (), Glib::OWNERSHIP_SHALLOW);
+  return Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::array_to_vector (c_get_shallow_owned_array (), Glib::OWNERSHIP_SHALLOW);
 }
 
 std::vector<Glib::RefPtr<Gio::Credentials> >
-cxx_get_none_array ()
+cxx_get_unowned_array ()
 {
-  return Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::array_to_vector (return_unowned_array (), Glib::OWNERSHIP_DEEP);
-}
-
-void
-print_vector (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
-{
-  const unsigned int size (v.size ());
-
-  for (unsigned int iter (0); iter < size; ++iter)
-  {
-    const Glib::RefPtr<Gio::Credentials>& obj_ptr (v[iter]);
-
-    std::cout << iter + 1 << ": ";
-    if (obj_ptr)
-    {
-      GCredentials* gobj (obj_ptr->gobj ());
-
-      if (G_IS_CREDENTIALS (gobj))
-      {
-        std::cout << static_cast<gpointer> (gobj) << ", ref: " << G_OBJECT (gobj)->ref_count << "\n";
-      }
-      else
-      {
-        std::cout << "No C instance?\n";
-      }
-    }
-    else
-    {
-      std::cout << "No C++ instance?\n";
-    }
-  }
+  return Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::array_to_vector (c_get_unowned_array (), Glib::OWNERSHIP_DEEP);
 }
 
 /* they are probably buggy by design...
 void
 cxx_list_take_all (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_list_all (Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_list (v).data ());
+  c_take_list_all (Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_list (v).data ());
 }
 
 void
 cxx_list_take_members (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_list_members (Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_list (v).data ());
+  c_take_list_members (Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_list (v).data ());
 }
 */
 
 void
 cxx_list_take_nothing (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_list_nothing (Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_list (v).data ());
+  c_take_list_nothing (Glib::ListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_list (v).data ());
 }
 
 /* they are probably buggy by design...
 void
 cxx_slist_take_all (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_slist_all (Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_slist (v).data ());
+  c_take_slist_all (Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_slist (v).data ());
 }
 
 void
 cxx_slist_take_members (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_slist_members (Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_slist (v).data ());
+  c_take_slist_members (Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_slist (v).data ());
 }
 */
 
 void
 cxx_slist_take_nothing (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_slist_nothing (Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_slist (v).data ());
+  c_take_slist_nothing (Glib::SListHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_slist (v).data ());
 }
 
 /* they are probably buggy by design...
 void
 cxx_array_take_all (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_array_all (Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_array (v).data ());
+  c_take_array_all (Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_array (v).data ());
 }
 
 void
 cxx_array_take_members (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_array_members (Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_array (v).data ());
+  c_take_array_members (Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_array (v).data ());
 }
 */
 
 void
 cxx_array_take_nothing (const std::vector<Glib::RefPtr<Gio::Credentials> >& v)
 {
-  take_array_nothing (Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_array (v).data ());
+  c_take_array_nothing (Glib::ArrayHandler<Glib::RefPtr<Gio::Credentials> >::vector_to_array (v).data ());
 }
 
 
@@ -542,37 +519,37 @@ main()
   Cache& cache (get_cache ());
 
   std::cout << "Cache list before:\n";
-  cache.print_list ();
+  print_list (cache.get_list ());
   std::cout << "Cache slist before:\n";
-  cache.print_slist ();
+  print_slist (cache.get_slist ());
   std::cout << "Cache array before:\n";
-  cache.print_array ();
-  std::cout << "Deep list:\n";
-  print_vector (cxx_get_deep_list ());
-  std::cout << "Shallow list:\n";
-  print_vector (cxx_get_shallow_list ());
-  std::cout << "None list:\n";
-  print_vector (cxx_get_none_list ());
-  std::cout << "Deep slist:\n";
-  print_vector (cxx_get_deep_slist ());
-  std::cout << "Shallow slist:\n";
-  print_vector (cxx_get_shallow_slist ());
-  std::cout << "None slist:\n";
-  print_vector (cxx_get_none_slist ());
-  std::cout << "Deep array:\n";
-  print_vector (cxx_get_deep_array ());
-  std::cout << "Shallow array:\n";
-  print_vector (cxx_get_shallow_array ());
-  std::cout << "None array:\n";
-  print_vector (cxx_get_none_array ());
+  print_array (cache.get_array ());
+  std::cout << "Deep owned list:\n";
+  print_vector (cxx_get_deep_owned_list ());
+  std::cout << "Shallow owned list:\n";
+  print_vector (cxx_get_shallow_owned_list ());
+  std::cout << "Unowned list:\n";
+  print_vector (cxx_get_unowned_list ());
+  std::cout << "Deep owned slist:\n";
+  print_vector (cxx_get_deep_owned_slist ());
+  std::cout << "Shallow owned slist:\n";
+  print_vector (cxx_get_shallow_owned_slist ());
+  std::cout << "Unowned slist:\n";
+  print_vector (cxx_get_unowned_slist ());
+  std::cout << "Deep owned array:\n";
+  print_vector (cxx_get_deep_owned_array ());
+  std::cout << "Shallow owned array:\n";
+  print_vector (cxx_get_shallow_owned_array ());
+  std::cout << "Unowned array:\n";
+  print_vector (cxx_get_unowned_array ());
   std::cout << "Cache list after:\n";
-  cache.print_list ();
+  print_list (cache.get_list ());
   std::cout << "Cache slist after:\n";
-  cache.print_slist ();
+  print_slist (cache.get_slist ());
   std::cout << "Cache array after:\n";
-  cache.print_array ();
+  print_array (cache.get_array ());
 
-  std::vector<Glib::RefPtr<Gio::Credentials> > v (cxx_get_none_list ());
+  std::vector<Glib::RefPtr<Gio::Credentials> > v (cxx_get_unowned_list ());
 
   std::cout << "Gotten vector before:\n";
   print_vector (v);
@@ -584,6 +561,7 @@ main()
   //cxx_list_take_members (v);
   std::cout << "Take list nothing:\n";
   cxx_list_take_nothing (v);
+  // Ditto.
   //std::cout << "Take slist all:\n";
   //cxx_slist_take_all (v);
   //std::cout << "Take slist members:\n";