1 files changed, 478 insertions, 0 deletions
diff --git a/Examples/test-suite/octave/li_boost_shared_ptr_runme.m b/Examples/test-suite/octave/li_boost_shared_ptr_runme.m
new file mode 100644
index 0000000..ca09316
--- /dev/null
+++ b/Examples/test-suite/octave/li_boost_shared_ptr_runme.m
@@ -0,0 +1,478 @@
+li_boost_shared_ptr
+
+debug = false;
+
+function main()
+    if (debug)
+      printf("Started\n")
+    endif
+
+    li_boost_shared_ptr.cvar.debug_shared = debug;
+
+    # Change loop count to run for a long time to monitor memory
+    loopCount = 1; #5000
+    for i=0:loopCount,
+      self.runtest();
+    endfor
+
+    if (li_boost_shared_ptr.Klass.getTotal_count() != 0)
+      error("Klass.total_count=", li_boost_shared_ptr.Klass.getTotal_count())
+    endif
+
+    wrapper_count = li_boost_shared_ptr.shared_ptr_wrapper_count();
+    if (wrapper_count != li_boost_shared_ptr.NOT_COUNTING)
+      if (wrapper_count != 0)
+        error("shared_ptr wrapper count not zero: %i", wrapper_count)
+      endif
+    endif
+
+    if (debug)
+      error("Finished")
+    endif
+endfunction
+
+function runtest()
+    # simple shared_ptr usage - created in C++
+    k = li_boost_shared_ptr.Klass("me oh my");
+    val = k.getValue();
+    self.verifyValue("me oh my", val);
+    self.verifyCount(1, k);
+
+    # simple shared_ptr usage - not created in C++
+    k = li_boost_shared_ptr.factorycreate();
+    val = k.getValue();
+    self.verifyValue("factorycreate", val);
+    self.verifyCount(1, k);
+
+    # pass by shared_ptr
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.smartpointertest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my smartpointertest", val);
+    self.verifyCount(2, k);
+    self.verifyCount(2, kret);
+
+    # pass by shared_ptr pointer
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.smartpointerpointertest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my smartpointerpointertest", val);
+    self.verifyCount(2, k);
+    self.verifyCount(2, kret);
+
+    # pass by shared_ptr reference
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.smartpointerreftest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my smartpointerreftest", val);
+    self.verifyCount(2, k);
+    self.verifyCount(2, kret);
+
+    # pass by shared_ptr pointer reference
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.smartpointerpointerreftest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my smartpointerpointerreftest", val);
+    self.verifyCount(2, k);
+    self.verifyCount(2, kret);
+
+    # const pass by shared_ptr
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.constsmartpointertest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my", val);
+    self.verifyCount(2, k);
+    self.verifyCount(2, kret);
+
+    # const pass by shared_ptr pointer
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.constsmartpointerpointertest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my", val);
+    self.verifyCount(2, k);
+    self.verifyCount(2, kret);
+
+    # const pass by shared_ptr reference
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.constsmartpointerreftest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my", val);
+    self.verifyCount(2, k);
+    self.verifyCount(2, kret);
+
+    # pass by value
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.valuetest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my valuetest", val);
+    self.verifyCount(1, k);
+    self.verifyCount(1, kret);
+
+    # pass by pointer
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.pointertest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my pointertest", val);
+    self.verifyCount(1, k);
+    self.verifyCount(1, kret);
+
+    # pass by reference
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.reftest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my reftest", val);
+    self.verifyCount(1, k);
+    self.verifyCount(1, kret);
+
+    # pass by pointer reference
+    k = li_boost_shared_ptr.Klass("me oh my");
+    kret = li_boost_shared_ptr.pointerreftest(k);
+    val = kret.getValue();
+    self.verifyValue("me oh my pointerreftest", val);
+    self.verifyCount(1, k);
+    self.verifyCount(1, kret);
+
+    # null tests
+    k = None;
+
+    if (li_boost_shared_ptr.smartpointertest(k) != None)
+      error("return was not null")
+    endif
+
+    if (li_boost_shared_ptr.smartpointerpointertest(k) != None)
+      error("return was not null")
+    endif
+
+    if (li_boost_shared_ptr.smartpointerreftest(k) != None)
+      error("return was not null")
+    endif
+
+    if (li_boost_shared_ptr.smartpointerpointerreftest(k) != None)
+      error("return was not null")
+    endif
+
+    if (li_boost_shared_ptr.nullsmartpointerpointertest(None) != "null pointer")
+      error("not null smartpointer pointer")
+    endif
+
+    try
+      li_boost_shared_ptr.valuetest(k)
+      error("Failed to catch null pointer")
+    catch
+    end_try_catch
+
+    if (li_boost_shared_ptr.pointertest(k) != None)
+      error("return was not null")
+    endif
+
+    try
+      li_boost_shared_ptr.reftest(k)
+      error("Failed to catch null pointer")
+    catch
+    end_try_catch
+
+    # $owner
+    k = li_boost_shared_ptr.pointerownertest();
+    val = k.getValue();
+    self.verifyValue("pointerownertest", val);
+    self.verifyCount(1, k);
+    k = li_boost_shared_ptr.smartpointerpointerownertest();
+    val = k.getValue();
+    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);
+
+    # //////////////////////////////// Overloading tests ////////////////////////////////////////
+    # Base class
+    k = li_boost_shared_ptr.Klass("me oh my");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref");
+
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyval(k), "smartbyval");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyref(k), "smartbyref");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref");
+
+    # Derived class
+    k = li_boost_shared_ptr.KlassDerived("me oh my");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyval(k), "rawbyval");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyref(k), "rawbyref");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyptr(k), "rawbyptr");
+    self.verifyValue(li_boost_shared_ptr.overload_rawbyptrref(k), "rawbyptrref");
+
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyval(k), "smartbyval");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyref(k), "smartbyref");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyptr(k), "smartbyptr");
+    self.verifyValue(li_boost_shared_ptr.overload_smartbyptrref(k), "smartbyptrref");
+
+    # //////////////////////////////// Member variables ////////////////////////////////////////
+    # smart pointer by value
+    m = li_boost_shared_ptr.MemberVariables();
+    k = li_boost_shared_ptr.Klass("smart member value");
+    m.SmartMemberValue = k;
+    val = k.getValue();
+    self.verifyValue("smart member value", val);
+    self.verifyCount(2, k);
+
+    kmember = m.SmartMemberValue;
+    val = kmember.getValue();
+    self.verifyValue("smart member value", val);
+    self.verifyCount(3, kmember);
+    self.verifyCount(3, k);
+
+    clear m;
+    self.verifyCount(2, kmember);
+    self.verifyCount(2, k);
+
+    # smart pointer by pointer
+    m = li_boost_shared_ptr.MemberVariables();
+    k = li_boost_shared_ptr.Klass("smart member pointer");
+    m.SmartMemberPointer = k;
+    val = k.getValue();
+    self.verifyValue("smart member pointer", val);
+    self.verifyCount(1, k);
+
+    kmember = m.SmartMemberPointer;
+    val = kmember.getValue();
+    self.verifyValue("smart member pointer", val);
+    self.verifyCount(2, kmember);
+    self.verifyCount(2, k);
+
+    clear m;
+    self.verifyCount(2, kmember);
+    self.verifyCount(2, k);
+
+    # smart pointer by reference
+    m = li_boost_shared_ptr.MemberVariables();
+    k = li_boost_shared_ptr.Klass("smart member reference");
+    m.SmartMemberReference = k;
+    val = k.getValue();
+    self.verifyValue("smart member reference", val);
+    self.verifyCount(2, k);
+
+    kmember = m.SmartMemberReference;
+    val = kmember.getValue();
+    self.verifyValue("smart member reference", val);
+    self.verifyCount(3, kmember);
+    self.verifyCount(3, k);
+
+    # The C++ reference refers to SmartMemberValue...
+    kmemberVal = m.SmartMemberValue;
+    val = kmember.getValue();
+    self.verifyValue("smart member reference", val);
+    self.verifyCount(4, kmemberVal);
+    self.verifyCount(4, kmember);
+    self.verifyCount(4, k);
+
+    clear m;
+    self.verifyCount(3, kmemberVal);
+    self.verifyCount(3, kmember);
+    self.verifyCount(3, k);
+
+    # plain by value
+    m = li_boost_shared_ptr.MemberVariables();
+    k = li_boost_shared_ptr.Klass("plain member value");
+    m.MemberValue = k;
+    val = k.getValue();
+    self.verifyValue("plain member value", val);
+    self.verifyCount(1, k);
+
+    kmember = m.MemberValue;
+    val = kmember.getValue();
+    self.verifyValue("plain member value", val);
+    self.verifyCount(1, kmember);
+    self.verifyCount(1, k);
+
+    clear m;
+    self.verifyCount(1, kmember);
+    self.verifyCount(1, k);
+
+    # plain by pointer
+    m = li_boost_shared_ptr.MemberVariables();
+    k = li_boost_shared_ptr.Klass("plain member pointer");
+    m.MemberPointer = k;
+    val = k.getValue();
+    self.verifyValue("plain member pointer", val);
+    self.verifyCount(1, k);
+
+    kmember = m.MemberPointer;
+    val = kmember.getValue();
+    self.verifyValue("plain member pointer", val);
+    self.verifyCount(1, kmember);
+    self.verifyCount(1, k);
+
+    clear m;
+    self.verifyCount(1, kmember);
+    self.verifyCount(1, k);
+
+    # plain by reference
+    m = li_boost_shared_ptr.MemberVariables();
+    k = li_boost_shared_ptr.Klass("plain member reference");
+    m.MemberReference = k;
+    val = k.getValue();
+    self.verifyValue("plain member reference", val);
+    self.verifyCount(1, k);
+
+    kmember = m.MemberReference;
+    val = kmember.getValue();
+    self.verifyValue("plain member reference", val);
+    self.verifyCount(1, kmember);
+    self.verifyCount(1, k);
+
+    clear m;
+    self.verifyCount(1, kmember);
+    self.verifyCount(1, k);
+
+    # null member variables
+    m = li_boost_shared_ptr.MemberVariables();
+
+    # shared_ptr by value
+    k = m.SmartMemberValue;
+    if (k != None)
+      error("expected null")
+    endif
+    m.SmartMemberValue = None;
+    k = m.SmartMemberValue;
+    if (k != None)
+      error("expected null")
+    endif
+    self.verifyCount(0, k);
+
+    # plain by value
+    try
+      m.MemberValue = None;
+      error("Failed to catch null pointer");
+    catch
+    end_try_catch
+
+    # templates
+    pid = li_boost_shared_ptr.PairIntDouble(10, 20.2)
+    if (pid.baseVal1 != 20 || pid.baseVal2 != 40.4)
+      error("Base values wrong")
+    endif
+    if (pid.val1 != 10 || pid.val2 != 20.2)
+      error("Derived Values wrong")
+    endif
+endfunction
+
+function verifyValue(expected,got)
+  if (expected != got)
+    error("verify value failed. Expected: %i, Got %i\n",expected,got)
+  endif
+endfunction
+
+function verifyCount(expected,k)
+  got = li_boost_shared_ptr.use_count(k);
+  if (expected != got)
+    error("verify value failed. Expected: %i, Got %i\n",expected,got)
+  endif
+endfunction
+
+