mirror of https://github.com/swig/swig
575 lines
20 KiB
Python
575 lines
20 KiB
Python
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 TypeError:
|
|
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 TypeError:
|
|
pass
|
|
|
|
# test null pointers emitted from C++
|
|
k = li_boost_shared_ptr.sp_pointer_null()
|
|
if (li_boost_shared_ptr.smartpointertest(k) != None):
|
|
raise RuntimeError("return was not null")
|
|
|
|
k = li_boost_shared_ptr.null_sp_pointer()
|
|
if (li_boost_shared_ptr.smartpointertest(k) != None):
|
|
raise RuntimeError("return was not null")
|
|
|
|
k = li_boost_shared_ptr.sp_value_null()
|
|
if (li_boost_shared_ptr.smartpointertest(k) != None):
|
|
raise RuntimeError("return was not null")
|
|
|
|
# $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 TypeError:
|
|
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 TypeError:
|
|
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
|
|
|
|
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 TypeError:
|
|
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()
|