1 files changed, 178 insertions, 0 deletions
diff --git a/boost/common/smart-ptr/driver.cxx b/boost/common/smart-ptr/driver.cxx
new file mode 100644
index 0000000..478e4a9
--- /dev/null
+++ b/boost/common/smart-ptr/driver.cxx
@@ -0,0 +1,178 @@
+// file      : boost/common/smart-ptr/driver.cxx
+// author    : Constantin Michael <constantin@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+// Test boost smart pointers.
+//
+
+#include <memory>   // std::auto_ptr
+#include <cassert>
+#include <iostream>
+
+#include <odb/mysql/database.hxx>
+#include <odb/mysql/transaction.hxx>
+
+#include <common/common.hxx>
+
+#include "test.hxx"
+#include "test-odb.hxx"
+
+using namespace std;
+
+using namespace odb::boost;
+using namespace odb::core;
+
+int
+main (int argc, char* argv[])
+{
+  using boost::shared_ptr;
+
+  try
+  {
+    auto_ptr<database> db (create_database (argc, argv));
+
+    shared_ptr<cont> c1 (new cont (1));
+    {
+      transaction t (db->begin ());
+      db->persist (c1);
+      t.commit ();
+    }
+
+    // Test comparison operators.
+    //
+    {
+      assert (lazy_shared_ptr<cont> () == lazy_shared_ptr<cont> ());
+      assert (lazy_shared_ptr<cont> () != lazy_shared_ptr<cont> (c1));
+      assert (lazy_shared_ptr<cont> (c1) == lazy_shared_ptr<cont> (c1));
+
+      lazy_shared_ptr<cont> lc1 (*db, 1);
+      assert (lc1 != lazy_shared_ptr<cont> ());
+      assert (lc1 == lazy_shared_ptr<cont> (*db, c1));
+
+      shared_ptr<cont> c2 (new cont (2));
+      assert (lc1 != lazy_shared_ptr<cont> (*db, c2));
+    }
+
+    // Test swap.
+    //
+    {
+      lazy_shared_ptr<cont> lx (*db, 1), ly;
+      assert (lx == lazy_shared_ptr<cont> (*db, c1));
+
+      swap (lx, ly);
+      assert (lx == lazy_shared_ptr<cont> ());
+      assert (ly == lazy_shared_ptr<cont> (*db, c1));
+    }
+
+    // Test assignment from auto_ptr.
+    //
+    {
+      cont* p = new cont (3);
+      auto_ptr<cont> a (p);
+      lazy_shared_ptr<cont> l;
+      l = a;
+
+      assert (l.get() == p);
+      assert (!a.get ());
+    }
+
+    shared_ptr<obj> o1 (new obj (1));
+    shared_ptr<obj> o2 (new obj (2));
+    shared_ptr<obj> o3 (new obj (3));
+    shared_ptr<obj> o4 (new obj (4));
+    shared_ptr<cont> c2 (new cont (2));
+
+    o1->c = c1;
+    o2->c = c1;
+    o3->c = c2;
+    o4->c = c2;
+
+    // Persist.
+    //
+    {
+      transaction t (db->begin ());
+
+      db->persist (o1);
+      db->persist (o2);
+      db->persist (o3);
+      db->persist (o4);
+      db->persist (c2);
+
+      t.commit ();
+    }
+
+    // Load.
+    //
+    {
+      session s;
+      transaction t (db->begin ());
+
+      shared_ptr<cont> c (db->load<cont> (1));
+      shared_ptr<obj> o (db->load<obj> (1));
+
+      // Ensure that lazy pointers are present but not loaded.
+      //
+      assert (c->o.size () == 2);
+      assert (!c->o[0].loaded ());
+      assert (!c->o[1].loaded ());
+      assert (!o->c.loaded ());
+
+      // Ensure that the correct object IDs were loaded.
+      //
+      assert (c->o[0].object_id<obj> () == 1);
+      assert (c->o[1].object_id<obj> () == 2);
+      assert (o->c.object_id<obj> () == 1);
+
+      // Load the lazy pointer targets ensuring that the loaded
+      // targets correspond to the cached session objects.
+      //
+      shared_ptr<cont> cl (o->c.load ());
+      shared_ptr<obj> ol (c->o[0].load ());
+
+      assert (c->o[0].loaded ());
+      assert (o->c.loaded ());
+
+      assert (cl == c);
+      assert (ol == o);
+
+      t.commit ();
+    }
+
+    // Test lazy weak locking and reloading.
+    //
+    {
+      // No session.
+      //
+      transaction t (db->begin ());
+      shared_ptr<cont> c (db->load<cont> (1));
+
+      // Lock.
+      //
+      assert (!c->o[1].loaded ());
+      lazy_shared_ptr<obj> l (c->o[1].lock ());
+      assert (!l.loaded ());
+      assert (l.object_id<obj> () == c->o[1].object_id<obj> ());
+
+      // Reload.
+      //
+      assert (!c->o[1].loaded ());
+
+      shared_ptr<obj> ol (c->o[1].load ());
+      assert (c->o[1].loaded ());
+
+      ol.reset ();
+      assert (!c->o[1].loaded ());
+
+      ol = c->o[1].load ();
+      assert (c->o[1].loaded ());
+
+      t.commit ();
+    }
+  }
+  catch (const odb::exception& e)
+  {
+    cerr << e.what () << endl;
+    return 1;
+  }
+}