Exemple #1
0
    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

        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 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")