diff --git a/Examples/test-suite/csharp/li_boost_shared_ptr_runme.cs b/Examples/test-suite/csharp/li_boost_shared_ptr_runme.cs index 34c641806..170137c9c 100644 --- a/Examples/test-suite/csharp/li_boost_shared_ptr_runme.cs +++ b/Examples/test-suite/csharp/li_boost_shared_ptr_runme.cs @@ -221,15 +221,131 @@ public class runme } ////////////////////////////////// Derived classes //////////////////////////////////////// + // derived pass by shared_ptr + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedsmartptrtest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedsmartptrtest-Derived", val); + verifyCount(4, k); // includes two extra references for upcasts in the proxy classes + verifyCount(4, kret); + } + // derived pass by shared_ptr pointer + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedsmartptrpointertest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedsmartptrpointertest-Derived", val); + verifyCount(4, k); // includes two extra references for upcasts in the proxy classes + verifyCount(4, kret); + } + // derived pass by shared_ptr ref + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedsmartptrreftest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedsmartptrreftest-Derived", val); + verifyCount(4, k); // includes two extra references for upcasts in the proxy classes + verifyCount(4, kret); + } + // derived pass by shared_ptr pointer ref + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedsmartptrpointerreftest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val); + verifyCount(4, k); // includes two extra references for upcasts in the proxy classes + verifyCount(4, kret); + } // derived pass by pointer { KlassDerived k = new KlassDerived("me oh my"); KlassDerived kret = li_boost_shared_ptr.derivedpointertest(k); String val = kret.getValue(); verifyValue("me oh my derivedpointertest-Derived", val); - verifyCount(2, k); // includes an extra reference for the upcast + verifyCount(2, k); // includes an extra reference for the upcast in the proxy class verifyCount(2, kret); } + // derived pass by ref + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedreftest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedreftest-Derived", val); + verifyCount(2, k); // includes an extra reference for the upcast in the proxy class + verifyCount(2, kret); + } + + ////////////////////////////////// Derived and base class mixed //////////////////////////////////////// + // pass by shared_ptr (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.smartpointertest(k); + String val = kret.getValue(); + verifyValue("me oh my smartpointertest-Derived", val); + verifyCount(3, k); // an extra reference for the upcast in the proxy class + verifyCount(3, kret); + } + + // pass by shared_ptr pointer (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.smartpointerpointertest(k); + String val = kret.getValue(); + verifyValue("me oh my smartpointerpointertest-Derived", val); + verifyCount(3, k); // an extra reference for the upcast in the proxy class + verifyCount(3, kret); + } + + // pass by shared_ptr reference (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.smartpointerreftest(k); + String val = kret.getValue(); + verifyValue("me oh my smartpointerreftest-Derived", val); + verifyCount(3, k); // an extra reference for the upcast in the proxy class + verifyCount(3, kret); + } + + // pass by shared_ptr pointer reference (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.smartpointerpointerreftest(k); + String val = kret.getValue(); + verifyValue("me oh my smartpointerpointerreftest-Derived", val); + verifyCount(3, k); // an extra reference for the upcast in the proxy class + verifyCount(3, kret); + } + + // pass by value (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.valuetest(k); + String val = kret.getValue(); + verifyValue("me oh my valuetest", val); // note slicing + verifyCount(2, k); // an extra reference for the upcast in the proxy class + verifyCount(1, kret); + } + + // pass by pointer (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.pointertest(k); + String val = kret.getValue(); + verifyValue("me oh my pointertest-Derived", val); + verifyCount(2, k); // an extra reference for the upcast in the proxy class + verifyCount(1, kret); + } + + // pass by ref (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.reftest(k); + String val = kret.getValue(); + verifyValue("me oh my reftest-Derived", val); + verifyCount(2, k); // an extra reference for the upcast in the proxy class + verifyCount(1, kret); + } // Member variables diff --git a/Examples/test-suite/java/li_boost_shared_ptr_runme.java b/Examples/test-suite/java/li_boost_shared_ptr_runme.java index 489e4c83e..65b798b27 100644 --- a/Examples/test-suite/java/li_boost_shared_ptr_runme.java +++ b/Examples/test-suite/java/li_boost_shared_ptr_runme.java @@ -231,31 +231,133 @@ public class li_boost_shared_ptr_runme { } ////////////////////////////////// Derived classes //////////////////////////////////////// + // derived pass by shared_ptr + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedsmartptrtest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedsmartptrtest-Derived", val); + verifyCount(4, k); // includes two extra references for upcasts + verifyCount(4, kret); + } + // derived pass by shared_ptr pointer + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedsmartptrpointertest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedsmartptrpointertest-Derived", val); + verifyCount(4, k); // includes two extra references for upcasts in the proxy classes + verifyCount(4, kret); + } + // derived pass by shared_ptr ref + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedsmartptrreftest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedsmartptrreftest-Derived", val); + verifyCount(4, k); // includes two extra references for upcasts in the proxy classes + verifyCount(4, kret); + } + // derived pass by shared_ptr pointer ref + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedsmartptrpointerreftest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val); + verifyCount(4, k); // includes two extra references for upcasts in the proxy classes + verifyCount(4, kret); + } // derived pass by pointer { KlassDerived k = new KlassDerived("me oh my"); KlassDerived kret = li_boost_shared_ptr.derivedpointertest(k); String val = kret.getValue(); verifyValue("me oh my derivedpointertest-Derived", val); - verifyCount(2, k); // includes an extra reference for the upcast + verifyCount(2, k); // includes an extra reference for the upcast in the proxy class + verifyCount(2, kret); + } + // derived pass by ref + { + KlassDerived k = new KlassDerived("me oh my"); + KlassDerived kret = li_boost_shared_ptr.derivedreftest(k); + String val = kret.getValue(); + verifyValue("me oh my derivedreftest-Derived", val); + verifyCount(2, k); // includes an extra reference for the upcast in the proxy class verifyCount(2, kret); } - // check derivedness + ////////////////////////////////// Derived and base class mixed //////////////////////////////////////// + // pass by shared_ptr (mixed) { - /* - KlassDerived k = new KlassDerived("me oh my"); - KlassDerived kret = li_boost_shared_ptr.derivedpointertest(k); + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.smartpointertest(k); String val = kret.getValue(); - k.append("-Appended"); - val = k.getValue(); - verifyValue("me oh my derivedpointertest-Appended-Derived", val); - val = kret.getValue(); - verifyValue("me oh my derivedpointertest-Appended-Derived", val); - // TODO: clone it - */ + verifyValue("me oh my smartpointertest-Derived", val); + verifyCount(3, k); // an extra reference for the upcast in the proxy class + verifyCount(3, kret); } + // pass by shared_ptr pointer (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.smartpointerpointertest(k); + String val = kret.getValue(); + verifyValue("me oh my smartpointerpointertest-Derived", val); + verifyCount(3, k); // an extra reference for the upcast in the proxy class + verifyCount(3, kret); + } + + // pass by shared_ptr reference (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.smartpointerreftest(k); + String val = kret.getValue(); + verifyValue("me oh my smartpointerreftest-Derived", val); + verifyCount(3, k); // an extra reference for the upcast in the proxy class + verifyCount(3, kret); + } + + // pass by shared_ptr pointer reference (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.smartpointerpointerreftest(k); + String val = kret.getValue(); + verifyValue("me oh my smartpointerpointerreftest-Derived", val); + verifyCount(3, k); // an extra reference for the upcast in the proxy class + verifyCount(3, kret); + } + + // pass by value (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.valuetest(k); + String val = kret.getValue(); + verifyValue("me oh my valuetest", val); // note slicing + verifyCount(2, k); // an extra reference for the upcast in the proxy class + verifyCount(1, kret); + } + + // pass by pointer (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.pointertest(k); + String val = kret.getValue(); + verifyValue("me oh my pointertest-Derived", val); + verifyCount(2, k); // an extra reference for the upcast in the proxy class + verifyCount(1, kret); + } + + // pass by ref (mixed) + { + Klass k = new KlassDerived("me oh my"); + Klass kret = li_boost_shared_ptr.reftest(k); + String val = kret.getValue(); + verifyValue("me oh my reftest-Derived", val); + verifyCount(2, k); // an extra reference for the upcast in the proxy class + verifyCount(1, kret); + } + + // Member variables // smart pointer by value { diff --git a/Examples/test-suite/li_boost_shared_ptr.i b/Examples/test-suite/li_boost_shared_ptr.i index 65eb8d880..a81de9472 100644 --- a/Examples/test-suite/li_boost_shared_ptr.i +++ b/Examples/test-suite/li_boost_shared_ptr.i @@ -82,8 +82,8 @@ private: // lock increment and decrement as a destructor could be called at the same time as a // new object is being created - C# / Java, at least, have finalizers run in a separate thread static SwigExamples::CriticalSection critical_section; - static void increment() { SwigExamples::Lock lock(critical_section); total_count++; } - static void decrement() { SwigExamples::Lock lock(critical_section); total_count--; } + static void increment() { SwigExamples::Lock lock(critical_section); total_count++; if (debug_shared) cout << " ++xxxxx Klass::increment tot: " << total_count << endl;} + static void decrement() { SwigExamples::Lock lock(critical_section); total_count--; if (debug_shared) cout << " --xxxxx Klass::decrement tot: " << total_count << endl;} static int total_count; std::string value; int array[1024]; @@ -97,6 +97,7 @@ struct IgnoredMultipleInheritBase { virtual ~IgnoredMultipleInheritBase() {} dou struct KlassDerived : IgnoredMultipleInheritBase, Klass { KlassDerived() : Klass() {} KlassDerived(const std::string &val) : Klass(val) {} + KlassDerived(const KlassDerived &other) : Klass(other) {} virtual ~KlassDerived() {} virtual std::string getValue() const { return Klass::getValue() + "-Derived"; } }; @@ -105,6 +106,33 @@ KlassDerived* derivedpointertest(KlassDerived* kd) { kd->append(" derivedpointertest"); return kd; } +KlassDerived& derivedreftest(KlassDerived& kd) { + kd.append(" derivedreftest"); + return kd; +} +SwigBoost::shared_ptr derivedsmartptrtest(SwigBoost::shared_ptr kd) { + if (kd) + kd->append(" derivedsmartptrtest"); + return kd; +} +SwigBoost::shared_ptr* derivedsmartptrpointertest(SwigBoost::shared_ptr* kd) { + if (kd && *kd) + (*kd)->append(" derivedsmartptrpointertest"); + return kd; +} +SwigBoost::shared_ptr* derivedsmartptrreftest(SwigBoost::shared_ptr* kd) { + if (kd && *kd) + (*kd)->append(" derivedsmartptrreftest"); + return kd; +} +SwigBoost::shared_ptr*& derivedsmartptrpointerreftest(SwigBoost::shared_ptr*& kd) { + if (kd && *kd) + (*kd)->append(" derivedsmartptrpointerreftest"); + return kd; +} + + + SwigBoost::shared_ptr factorycreate() { @@ -289,6 +317,16 @@ namespace SwigBoost { else return "KlassDerived: NULL"; } + template<> std::string show_message(boost::shared_ptr*t) { + if (!t) + return "null shared_ptr!!!"; + if (boost::get_deleter(*t)) + return "KlassDerived NULL DELETER"; // pointer may be dangling so cannot use it + if (*t) + return "KlassDerived: " + (*t)->getValue(); + else + return "KlassDerived: NULL"; + } #endif } %} diff --git a/Examples/test-suite/python/li_boost_shared_ptr_runme.py b/Examples/test-suite/python/li_boost_shared_ptr_runme.py index 0dd0abc11..65533ff3e 100644 --- a/Examples/test-suite/python/li_boost_shared_ptr_runme.py +++ b/Examples/test-suite/python/li_boost_shared_ptr_runme.py @@ -171,14 +171,122 @@ class li_boost_shared_ptr_runme: self.verifyValue("smartpointerpointerownertest", val) self.verifyCount(1, k) + # //////////////////////////////// Derived class //////////////////////////////////////// + # derived pass by shared_ptr + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.derivedsmartptrtest(k) + val = kret.getValue() + self.verifyValue("me oh my derivedsmartptrtest-Derived", val) + self.verifyCount(2, k) + self.verifyCount(2, kret) + + # derived pass by shared_ptr pointer + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.derivedsmartptrpointertest(k) + val = kret.getValue() + self.verifyValue("me oh my derivedsmartptrpointertest-Derived", val) + self.verifyCount(2, k) + self.verifyCount(2, kret) + + # derived pass by shared_ptr ref + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.derivedsmartptrreftest(k) + val = kret.getValue() + self.verifyValue("me oh my derivedsmartptrreftest-Derived", val) + self.verifyCount(2, k) + self.verifyCount(2, kret) + + # derived pass by shared_ptr pointer ref + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.derivedsmartptrpointerreftest(k) + val = kret.getValue() + self.verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val) + self.verifyCount(2, k) + self.verifyCount(2, kret) + + # derived pass by pointer + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.derivedpointertest(k) + val = kret.getValue() + self.verifyValue("me oh my derivedpointertest-Derived", val) + self.verifyCount(1, k) + self.verifyCount(1, kret) + + # derived pass by ref + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.derivedreftest(k) + val = kret.getValue() + self.verifyValue("me oh my derivedreftest-Derived", val) + self.verifyCount(1, k) + self.verifyCount(1, kret) + + # //////////////////////////////// Derived and base class mixed //////////////////////////////////////// + # pass by shared_ptr (mixed) + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.smartpointertest(k) + val = kret.getValue() + self.verifyValue("me oh my smartpointertest-Derived", val) + self.verifyCount(2, k) + self.verifyCount(2, kret) + + # pass by shared_ptr pointer (mixed) + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.smartpointerpointertest(k) + val = kret.getValue() + self.verifyValue("me oh my smartpointerpointertest-Derived", val) + self.verifyCount(2, k) + self.verifyCount(2, kret) + + # pass by shared_ptr reference (mixed) + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.smartpointerreftest(k) + val = kret.getValue() + self.verifyValue("me oh my smartpointerreftest-Derived", val) + self.verifyCount(2, k) + self.verifyCount(2, kret) + + # pass by shared_ptr pointer reference (mixed) + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.smartpointerpointerreftest(k) + val = kret.getValue() + self.verifyValue("me oh my smartpointerpointerreftest-Derived", val) + self.verifyCount(2, k) + self.verifyCount(2, kret) + + # pass by value (mixed) + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.valuetest(k) + val = kret.getValue() + self.verifyValue("me oh my valuetest", val) # note slicing + self.verifyCount(1, k) + self.verifyCount(1, kret) + + # pass by pointer (mixed) + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.pointertest(k) + val = kret.getValue() + self.verifyValue("me oh my pointertest-Derived", val) + self.verifyCount(1, k) + self.verifyCount(1, kret) + + # pass by ref (mixed) + k = li_boost_shared_ptr.KlassDerived("me oh my") + kret = li_boost_shared_ptr.reftest(k) + val = kret.getValue() + self.verifyValue("me oh my reftest-Derived", val) + self.verifyCount(1, k) + self.verifyCount(1, kret) + + def verifyValue(self, expected, got): if (expected != got): raise RuntimeError("verify value failed. Expected: ", expected, " Got: ", got) def verifyCount(self, expected, k): got = li_boost_shared_ptr.use_count(k) - if (expected != got): - raise RuntimeError("verify use_count failed. Expected: ", expected, " Got: ", got) + if (expected != got - 1): # less one additional reference for marshalling the object into use_count() + raise RuntimeError("verify use_count failed. Expected: ", expected, " Got: ", got - 1) + runme = li_boost_shared_ptr_runme() runme.main()