b08713f09f
This tests nulls emitted as pointers and values of shared pointers, created from null, from references, and from default constructors.
574 lines
20 KiB
Python
574 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 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
|
|
|
|
# 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 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
|
|
|
|
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()
|