Imported from /srv/lorry/lorry-area/swig-tarball/swig-1.3.40.tar.gz.HEADswig-1.3.40master

1 files changed, 544 insertions, 0 deletions

diff --git a/Examples/test-suite/python/li_boost_shared_ptr_runme.py b/Examples/test-suite/python/li_boost_shared_ptr_runme.py
new file mode 100644
index 0000000..f967def
--- /dev/null
+++ b/Examples/test-suite/python/li_boost_shared_ptr_runme.py
@@ -0,0 +1,544 @@
+import li_boost_shared_ptr
+import gc
+
+debug = False
+
+# simple shared_ptr usage - created in C++
+class li_boost_shared_ptr_runme:
+  def main(self):
+    if (debug):
+      print "Started"
+
+    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 in range (0,loopCount):
+      self.runtest()
+
+    # Expect 1 instance - the one global variable (GlobalValue)
+    if (li_boost_shared_ptr.Klass.getTotal_count() != 1):
+      raise RuntimeError("Klass.total_count=%s" % li_boost_shared_ptr.Klass.getTotal_count())
+
+    wrapper_count = li_boost_shared_ptr.shared_ptr_wrapper_count() 
+    if (wrapper_count != li_boost_shared_ptr.NOT_COUNTING):
+      # Expect 1 instance - the one global variable (GlobalSmartValue)
+      if (wrapper_count != 1):
+        raise RuntimeError("shared_ptr wrapper count=%s" % wrapper_count)
+
+    if (debug):
+      print "Finished"
+
+  def runtest(self):
+    # 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):
+      raise RuntimeError("return was not null")
+
+    if (li_boost_shared_ptr.smartpointerpointertest(k) != None):
+      raise RuntimeError("return was not null")
+
+    if (li_boost_shared_ptr.smartpointerreftest(k) != None):
+      raise RuntimeError("return was not null")
+
+    if (li_boost_shared_ptr.smartpointerpointerreftest(k) != None):
+      raise RuntimeError("return was not null")
+
+    if (li_boost_shared_ptr.nullsmartpointerpointertest(None) != "null pointer"):
+      raise RuntimeError("not null smartpointer pointer")
+
+    try:
+      li_boost_shared_ptr.valuetest(k)
+      raise RuntimeError("Failed to catch null pointer")
+    except ValueError:
+      pass
+
+    if (li_boost_shared_ptr.pointertest(k) != None):
+      raise RuntimeError("return was not null")
+
+    try:
+      li_boost_shared_ptr.reftest(k)
+      raise RuntimeError("Failed to catch null pointer")
+    except ValueError:
+      pass
+
+    # $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")
+
+    # 3rd derived class
+    k = li_boost_shared_ptr.Klass3rdDerived("me oh my")
+    val = k.getValue()
+    self.verifyValue("me oh my-3rdDerived", val)
+    self.verifyCount(1, k)
+    val = li_boost_shared_ptr.test3rdupcast(k)
+    self.verifyValue("me oh my-3rdDerived", val)
+    self.verifyCount(1, k)
+
+    # //////////////////////////////// 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)
+
+    del 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)
+
+    del 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)
+
+    del 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)
+
+    del 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)
+
+    del 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)
+
+    del 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):
+      raise RuntimeError("expected null")
+    m.SmartMemberValue = None
+    k = m.SmartMemberValue
+    if (k != None):
+      raise RuntimeError("expected null")
+    self.verifyCount(0, k)
+
+    # plain by value
+    try:
+      m.MemberValue = None
+      raise RuntimeError("Failed to catch null pointer")
+    except ValueError:
+      pass
+
+    # ////////////////////////////////// Global variables ////////////////////////////////////////
+    # smart pointer
+    kglobal = li_boost_shared_ptr.cvar.GlobalSmartValue
+    if (kglobal != None):
+      raise RuntimeError("expected null")
+
+    k = li_boost_shared_ptr.Klass("smart global value")
+    li_boost_shared_ptr.cvar.GlobalSmartValue = k
+    self.verifyCount(2, k)
+
+    kglobal = li_boost_shared_ptr.cvar.GlobalSmartValue
+    val = kglobal.getValue()
+    self.verifyValue("smart global value", val)
+    self.verifyCount(3, kglobal)
+    self.verifyCount(3, k)
+    self.verifyValue("smart global value", li_boost_shared_ptr.cvar.GlobalSmartValue.getValue())
+    li_boost_shared_ptr.cvar.GlobalSmartValue = None
+
+    # plain value
+    k = li_boost_shared_ptr.Klass("global value")
+    li_boost_shared_ptr.cvar.GlobalValue = k
+    self.verifyCount(1, k)
+
+    kglobal = li_boost_shared_ptr.cvar.GlobalValue
+    val = kglobal.getValue()
+    self.verifyValue("global value", val)
+    self.verifyCount(1, kglobal)
+    self.verifyCount(1, k)
+    self.verifyValue("global value", li_boost_shared_ptr.cvar.GlobalValue.getValue())
+
+    try:
+      li_boost_shared_ptr.cvar.GlobalValue = None
+      raise RuntimeError("Failed to catch null pointer")
+    except ValueError:
+      pass
+
+    # plain pointer
+    kglobal = li_boost_shared_ptr.cvar.GlobalPointer
+    if (kglobal != None):
+      raise RuntimeError("expected null")
+
+    k = li_boost_shared_ptr.Klass("global pointer")
+    li_boost_shared_ptr.cvar.GlobalPointer = k
+    self.verifyCount(1, k)
+
+    kglobal = li_boost_shared_ptr.cvar.GlobalPointer
+    val = kglobal.getValue()
+    self.verifyValue("global pointer", val)
+    self.verifyCount(1, kglobal)
+    self.verifyCount(1, k)
+    li_boost_shared_ptr.cvar.GlobalPointer = None
+
+    # plain reference
+    kglobal
+
+    k = li_boost_shared_ptr.Klass("global reference")
+    li_boost_shared_ptr.cvar.GlobalReference = k
+    self.verifyCount(1, k)
+
+    kglobal = li_boost_shared_ptr.cvar.GlobalReference
+    val = kglobal.getValue()
+    self.verifyValue("global reference", val)
+    self.verifyCount(1, kglobal)
+    self.verifyCount(1, k)
+
+    try:
+      li_boost_shared_ptr.cvar.GlobalReference = None 
+      raise RuntimeError("Failed to catch null pointer")
+    except ValueError:
+      pass
+
+    # ////////////////////////////////// Templates ////////////////////////////////////////
+    pid = li_boost_shared_ptr.PairIntDouble(10, 20.2)
+    if (pid.baseVal1 != 20 or pid.baseVal2 != 40.4):
+      raise RuntimeError("Base values wrong")
+    if (pid.val1 != 10 or pid.val2 != 20.2):
+      raise RuntimeError("Derived Values wrong")
+
+  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)
+
+
+runme = li_boost_shared_ptr_runme()
+runme.main()
+