/trunk/Examples/test-suite/java/li_boost_intrusive_ptr_runme.java

import li_boost_intrusive_ptr.*;



public class li_boost_intrusive_ptr_runme {

  static {

    try {

        System.loadLibrary("li_boost_intrusive_ptr");

    } catch (UnsatisfiedLinkError e) {

      System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e);

      System.exit(1);

    }

  }



  // Debugging flag

  public final static boolean debug = false;



  public static void main(String argv[])

  {

    if (debug)

      System.out.println("Started");



    li_boost_intrusive_ptr.setDebug_shared(debug);



    // Change loop count to run for a long time to monitor memory

    final int loopCount = 5000; //5000;

    for (int i=0; i<loopCount; i++) {

      new li_boost_intrusive_ptr_runme().runtest();

      System.gc();

      System.runFinalization();

      try {

        if (i%100 == 0) {

          java.lang.Thread.sleep(1); // give some time to the lower priority finalizer thread

        }

      } catch (java.lang.InterruptedException e) {

      }

    }



    if (debug)

      System.out.println("Nearly finished");



    int countdown = 50;

    while (true) {

      System.gc();

      System.runFinalization();

      try {

        java.lang.Thread.sleep(100);

      } catch (java.lang.InterruptedException e) {

      }

      if (--countdown == 0)

        break;

      if (Klass.getTotal_count() == 1 && KlassWithoutRefCount.getTotal_count() == 0 &&

          li_boost_intrusive_ptr.getTotal_IgnoredRefCountingBase_count() == 0 &&

          KlassDerived.getTotal_count() == 0 && KlassDerivedDerived.getTotal_count() == 1)

        // Expect 1 Klass instance - the one global variable (GlobalValue)

        break;

    };

    if (Klass.getTotal_count() != 1)

      throw new RuntimeException("Klass.total_count=" + Klass.getTotal_count());

    if (KlassWithoutRefCount.getTotal_count() != 0)

      throw new RuntimeException("KlassWithoutRefCount.total_count=" + KlassWithoutRefCount.getTotal_count());

    if (li_boost_intrusive_ptr.getTotal_IgnoredRefCountingBase_count() != 0)

      throw new RuntimeException("IgnoredRefCountingBase.total_count=" + li_boost_intrusive_ptr.getTotal_IgnoredRefCountingBase_count());

    if (KlassDerived.getTotal_count() != 0)

      throw new RuntimeException("KlassDerived.total_count=" + KlassDerived.getTotal_count());

    if (KlassDerivedDerived.getTotal_count() != 0)

      throw new RuntimeException("KlassDerivedDerived.total_count=" + KlassDerivedDerived.getTotal_count());



    int wrapper_count = li_boost_intrusive_ptr.intrusive_ptr_wrapper_count();

    if (wrapper_count != li_boost_intrusive_ptr.getNOT_COUNTING())

      if (wrapper_count != 1) // Expect 1 instance - the one global variable (GlobalSmartValue)

        throw new RuntimeException("shared_ptr wrapper count=" + wrapper_count);



    if (debug)

      System.out.println("Finished");

  }



  private void runtest() {

    // simple shared_ptr usage - created in C++

    {

      Klass k = new Klass("me oh my");

      String val = k.getValue();

      verifyValue("me oh my", val);

      verifyCount(1, k);

    }



    // simple shared_ptr usage - not created in C++

    {

      Klass k = li_boost_intrusive_ptr.factorycreate();

      String val = k.getValue();

      verifyValue("factorycreate", val);

      verifyCount(1, k);

    }



    // pass by shared_ptr

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.smartpointertest(k);

      String val = kret.getValue();

      verifyValue("me oh my smartpointertest", val);

      verifyCount(1, k);

      verifyIntrusiveCount(2, k);

      verifyCount(1, kret);

      verifyIntrusiveCount(2, kret);

    }



    // pass by shared_ptr pointer

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.smartpointerpointertest(k);

      String val = kret.getValue();

      verifyValue("me oh my smartpointerpointertest", val);

      verifyCount(1, k);

      verifyIntrusiveCount(2, k);

      verifyCount(1, kret);

      verifyIntrusiveCount(2, kret);

    }



    // pass by shared_ptr reference

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.smartpointerreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my smartpointerreftest", val);

      verifyCount(1, k);

      verifyIntrusiveCount(2, k);

      verifyCount(1, kret);

      verifyIntrusiveCount(2, kret);

    }



    // pass by shared_ptr pointer reference

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.smartpointerpointerreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my smartpointerpointerreftest", val);

      verifyCount(1, k);

      verifyIntrusiveCount(2, k);

      verifyCount(1, kret);

      verifyIntrusiveCount(2, kret);

    }



    // const pass by shared_ptr

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.constsmartpointertest(k);

      String val = kret.getValue();

      verifyValue("me oh my", val);

      verifyCount(1, k);

      verifyIntrusiveCount(2, k);

      verifyCount(1, kret);

      verifyIntrusiveCount(2, kret);

    }



    // const pass by shared_ptr pointer

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.constsmartpointerpointertest(k);

      String val = kret.getValue();

      verifyValue("me oh my", val);

      verifyCount(1, k);

      verifyIntrusiveCount(2, k);

      verifyCount(1, kret);

      verifyIntrusiveCount(2, kret);

    }



    // const pass by shared_ptr reference

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.constsmartpointerreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my", val);

      verifyCount(1, k);

      verifyIntrusiveCount(2, k);

      verifyCount(1, kret);

      verifyIntrusiveCount(2, kret);

    }



    // pass by value

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.valuetest(k);

      String val = kret.getValue();

      verifyValue("me oh my valuetest", val);

      verifyCount(1, k);

      verifyCount(1, kret);

    }



    // pass by pointer

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.pointertest(k);

      String val = kret.getValue();

      verifyValue("me oh my pointertest", val);

      verifyCount(1, k);

      verifyCount(1, kret);

    }



    // pass by reference

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.reftest(k);

      String val = kret.getValue();

      verifyValue("me oh my reftest", val);

      verifyCount(1, k);

      verifyCount(1, kret);

    }



    // pass by pointer reference

    {

      Klass k = new Klass("me oh my");

      Klass kret = li_boost_intrusive_ptr.pointerreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my pointerreftest", val);

      verifyCount(1, k);

      verifyCount(1, kret);

    }



    // null tests

    {

      Klass k = null;



      if (li_boost_intrusive_ptr.smartpointertest(k) != null)

        throw new RuntimeException("return was not null");



      if (li_boost_intrusive_ptr.smartpointerpointertest(k) != null)

        throw new RuntimeException("return was not null");



      if (li_boost_intrusive_ptr.smartpointerreftest(k) != null)

        throw new RuntimeException("return was not null");



      if (li_boost_intrusive_ptr.smartpointerpointerreftest(k) != null)

        throw new RuntimeException("return was not null");



      if (!li_boost_intrusive_ptr.nullsmartpointerpointertest(null).equals("null pointer"))

        throw new RuntimeException("not null smartpointer pointer");



      try { li_boost_intrusive_ptr.valuetest(k); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}



      if (li_boost_intrusive_ptr.pointertest(k) != null)

        throw new RuntimeException("return was not null");



      try { li_boost_intrusive_ptr.reftest(k); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}

    }



    // $owner

    {

      Klass k = li_boost_intrusive_ptr.pointerownertest();

      String val = k.getValue();

      verifyValue("pointerownertest", val);

      verifyCount(1, k);

    }

    {

      Klass k = li_boost_intrusive_ptr.smartpointerpointerownertest();

      String val = k.getValue();

      verifyValue("smartpointerpointerownertest", val);

      verifyCount(1, k);

    }



    ////////////////////////////////// Derived classes ////////////////////////////////////////

    // derived access to base class which cannot be wrapped in an intrusive_ptr

	{

	  KlassWithoutRefCount k = new KlassDerived("me oh my");

	  verifyValue("this class cannot be wrapped by intrusive_ptrs but we can still use it", k.getSpecialValueFromUnwrappableClass());

	}

    // derived pass by shared_ptr

    {

      KlassDerived k = new KlassDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrtest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedsmartptrtest-Derived", val);

      verifyIntrusiveCount(2, k);

      verifyCount(2, k); // includes extra reference for upcast

      verifyIntrusiveCount(2, kret);

      verifyCount(2, kret);

	}



    // derived pass by shared_ptr pointer

    {

      KlassDerived k = new KlassDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrpointertest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedsmartptrpointertest-Derived", val);

      verifyIntrusiveCount(2, k);

      verifyCount(2, k); // includes extra reference for upcast

      verifyIntrusiveCount(2, kret);

      verifyCount(2, kret);

    }

    // derived pass by shared_ptr ref

    {

      KlassDerived k = new KlassDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedsmartptrreftest-Derived", val);

      verifyIntrusiveCount(2, k);

      verifyCount(2, k); // includes extra reference for upcast

      verifyIntrusiveCount(2, kret);

      verifyCount(2, kret);

    }

    // derived pass by shared_ptr pointer ref

    {

      KlassDerived k = new KlassDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrpointerreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val);

      verifyIntrusiveCount(2, k);

      verifyCount(2, k); // includes extra reference for upcast

      verifyIntrusiveCount(2, kret);

      verifyCount(2, kret);

    }

    // derived pass by pointer

    {

      KlassDerived k = new KlassDerived("me oh my");

      verifyCount(2, k); // includes an extra reference for the upcast in the proxy class

      KlassDerived kret = li_boost_intrusive_ptr.derivedpointertest(k);

      verifyCount(2, kret);

      String val = kret.getValue();

      verifyValue("me oh my derivedpointertest-Derived", val);

      verifyIntrusiveCount(1, k); //one shared_ptr has a null deleter

      verifyCount(2, k); // includes extra reference for upcast

      verifyIntrusiveCount(1, kret); //one shared_ptr has a null deleter

      verifyCount(2, kret);

    }

    // derived pass by ref

    {

      KlassDerived k = new KlassDerived("me oh my");

      verifyCount(2, k); // includes an extra reference for the upcast in the proxy class

      KlassDerived kret = li_boost_intrusive_ptr.derivedreftest(k);

      verifyCount(2, kret);

      String val = kret.getValue();

      verifyValue("me oh my derivedreftest-Derived", val);

      verifyIntrusiveCount(1, k); //one shared_ptr has a null deleter

      verifyCount(2, k); // includes extra reference for upcast

      verifyIntrusiveCount(1, kret); //one shared_ptr has a null deleter

      verifyCount(2, kret);

    }



    ////////////////////////////////// Derived and base class mixed ////////////////////////////////////////

    // pass by shared_ptr (mixed)

    {

      KlassDerived k = new KlassDerivedDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrtest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedsmartptrtest-DerivedDerived", val);

      verifyIntrusiveCount(2, k);

      verifyCount(3, k); // an extra reference for the upcast in the proxy class

      verifyIntrusiveCount(2, kret);

      verifyCount(2, kret);

    }



    // pass by shared_ptr pointer (mixed)

    {

      KlassDerived k = new KlassDerivedDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrpointertest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedsmartptrpointertest-DerivedDerived", val);

      verifyIntrusiveCount(2, k);

      verifyCount(3, k); // an extra reference for the upcast in the proxy class

      verifyIntrusiveCount(2, kret);

      verifyCount(2, kret);

    }



    // pass by shared_ptr reference (mixed)

    {

      KlassDerived k = new KlassDerivedDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedsmartptrreftest-DerivedDerived", val);

      verifyIntrusiveCount(2, k);

      verifyCount(3, k); // an extra reference for the upcast in the proxy class

      verifyIntrusiveCount(2, kret);

      verifyCount(2, kret);

    }



    // pass by shared_ptr pointer reference (mixed)

    {

      KlassDerived k = new KlassDerivedDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrpointerreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedsmartptrpointerreftest-DerivedDerived", val);

      verifyIntrusiveCount(2, k);

      verifyCount(3, k); // an extra reference for the upcast in the proxy class

      verifyIntrusiveCount(2, kret);

      verifyCount(2, kret);

    }



    // pass by value (mixed)

    {

      KlassDerived k = new KlassDerivedDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedvaluetest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedvaluetest-Derived", val); // note slicing

      verifyIntrusiveCount(1, k);

      verifyCount(3, k); // an extra reference for the upcast in the proxy class

      verifyIntrusiveCount(1, kret);

      verifyCount(2, kret);

    }



    // pass by pointer (mixed)

    {

      KlassDerived k = new KlassDerivedDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedpointertest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedpointertest-DerivedDerived", val);

      verifyIntrusiveCount(1, k); //one shared_ptr has a null deleter

      verifyCount(3, k); // an extra reference for the upcast in the proxy class

      verifyIntrusiveCount(1, kret); //one shared_ptr has a null deleter

      verifyCount(2, kret);

    }



    // pass by ref (mixed)

    {

      KlassDerived k = new KlassDerivedDerived("me oh my");

      KlassDerived kret = li_boost_intrusive_ptr.derivedreftest(k);

      String val = kret.getValue();

      verifyValue("me oh my derivedreftest-DerivedDerived", val);

      verifyIntrusiveCount(1, k); //one shared_ptr has a null deleter

      verifyCount(3, k); // an extra reference for the upcast in the proxy class

      verifyIntrusiveCount(1, kret); //one shared_ptr has a null deleter

      verifyCount(2, kret);

    }



    ////////////////////////////////// Member variables ////////////////////////////////////////

    // smart pointer by value

    {

      MemberVariables m = new MemberVariables();

      Klass k = new Klass("smart member value");

      m.setSmartMemberValue(k);

      String val = k.getValue();

      verifyValue("smart member value", val);

      verifyIntrusiveCount(2, k);

      verifyCount(1, k);



      Klass kmember = m.getSmartMemberValue();

      val = kmember.getValue();

      verifyValue("smart member value", val);

      verifyIntrusiveCount(3, kmember);

      verifyIntrusiveCount(3, k);

      verifyCount(1, k);

      verifyCount(1, kmember);



      m.delete();

      verifyIntrusiveCount(2, kmember);

      verifyIntrusiveCount(2, k);

    }



    // smart pointer by pointer

    {

      MemberVariables m = new MemberVariables();

      Klass k = new Klass("smart member pointer");

      m.setSmartMemberPointer(k);

      String val = k.getValue();

      verifyValue("smart member pointer", val);

      verifyCount(1, k);

      verifyIntrusiveCount(2, k);



      Klass kmember = m.getSmartMemberPointer();

      val = kmember.getValue();

      verifyValue("smart member pointer", val);

      verifyIntrusiveCount(3, kmember);

      verifyCount(1, kmember);

      verifyIntrusiveCount(3, k);

      verifyCount(1, k);



      m.delete();

      verifyIntrusiveCount(2, kmember);

      verifyCount(1, kmember);

      verifyIntrusiveCount(2, k);

      verifyCount(1, k);

    }

    // smart pointer by reference

    {

      MemberVariables m = new MemberVariables();

      Klass k = new Klass("smart member reference");

      m.setSmartMemberReference(k);

      String val = k.getValue();

      verifyValue("smart member reference", val);

      verifyIntrusiveCount(2, k);

      verifyCount(1, k);



      Klass kmember = m.getSmartMemberReference();

      val = kmember.getValue();

      verifyValue("smart member reference", val);

      verifyIntrusiveCount(3, kmember);

      verifyCount(1, kmember);

      verifyIntrusiveCount(3, k);

      verifyCount(1, k);



      // The C++ reference refers to SmartMemberValue...

      m.setSmartMemberValue(k);

      Klass kmemberVal = m.getSmartMemberValue();

      val = kmember.getValue();

      verifyValue("smart member reference", val);

      verifyIntrusiveCount(5, kmemberVal);

      verifyCount(1, kmemberVal);

      verifyIntrusiveCount(5, kmember);

      verifyCount(1, kmember);

      verifyIntrusiveCount(5, k);

      verifyCount(1, k);



      m.delete();

      verifyIntrusiveCount(3, kmemberVal);

      verifyCount(1, kmemberVal);

      verifyIntrusiveCount(3, kmember);

      verifyCount(1, kmember);

      verifyIntrusiveCount(3, k);

      verifyCount(1, k);

    }



    //plain by value

    {

      MemberVariables m = new MemberVariables();

      Klass k = new Klass("plain member value");

      m.setMemberValue(k);

      String val = k.getValue();

      verifyValue("plain member value", val);

      verifyCount(1, k);



      Klass kmember = m.getMemberValue();

      val = kmember.getValue();

      verifyValue("plain member value", val);

      verifyCount(1, kmember);

      verifyCount(1, k);



      m.delete();

      verifyCount(1, kmember);

      verifyCount(1, k);

    }

    //plain by pointer

    {

      MemberVariables m = new MemberVariables();

      Klass k = new Klass("plain member pointer");

      m.setMemberPointer(k);

      String val = k.getValue();

      verifyValue("plain member pointer", val);

      verifyCount(1, k);



      Klass kmember = m.getMemberPointer();

      val = kmember.getValue();

      verifyValue("plain member pointer", val);

      verifyCount(1, kmember);

      verifyCount(1, k);



      m.delete();

      verifyCount(1, kmember);

      verifyCount(1, k);

    }

    //plain by reference

    {

      MemberVariables m = new MemberVariables();

      Klass k = new Klass("plain member reference");

      m.setMemberReference(k);

      String val = k.getValue();

      verifyValue("plain member reference", val);

      verifyCount(1, k);



      Klass kmember = m.getMemberReference();

      val = kmember.getValue();

      verifyValue("plain member reference", val);

      verifyCount(1, kmember);

      verifyCount(1, k);



      m.delete();

      verifyCount(1, kmember);

      verifyCount(1, k);

    }

    //null member variables

    {

      MemberVariables m = new MemberVariables();



      // shared_ptr by value

      Klass k = m.getSmartMemberValue();

      if (k != null)

        throw new RuntimeException("expected null");

      m.setSmartMemberValue(null);

      k = m.getSmartMemberValue();

      if (k != null)

        throw new RuntimeException("expected null");

      verifyCount(0, k);



      // plain by value

      try { m.setMemberValue(null); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}

    }

}

private void toIgnore() {

    ////////////////////////////////// Global variables ////////////////////////////////////////

    // smart pointer

    {

      Klass kglobal = li_boost_intrusive_ptr.getGlobalSmartValue();

      if (kglobal != null)

        throw new RuntimeException("expected null");



      Klass k = new Klass("smart global value");

      li_boost_intrusive_ptr.setGlobalSmartValue(k);

      verifyIntrusiveCount(2, k);

      verifyCount(1, k);



      kglobal = li_boost_intrusive_ptr.getGlobalSmartValue();

      String val = kglobal.getValue();

      verifyValue("smart global value", val);

      verifyIntrusiveCount(3, kglobal);

      verifyCount(1, kglobal);

      verifyIntrusiveCount(3, k);

      verifyCount(1, k);

      verifyValue("smart global value", li_boost_intrusive_ptr.getGlobalSmartValue().getValue());

      li_boost_intrusive_ptr.setGlobalSmartValue(null);

    }

    // plain value

    {

      Klass kglobal;



      Klass k = new Klass("global value");

      li_boost_intrusive_ptr.setGlobalValue(k);

      verifyCount(1, k);



      kglobal = li_boost_intrusive_ptr.getGlobalValue();

      String val = kglobal.getValue();

      verifyValue("global value", val);

      verifyCount(1, kglobal);

      verifyCount(1, k);

      verifyValue("global value", li_boost_intrusive_ptr.getGlobalValue().getValue());



      try { li_boost_intrusive_ptr.setGlobalValue(null); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}

    }

    //plain pointer

    {

      Klass kglobal = li_boost_intrusive_ptr.getGlobalPointer();

      if (kglobal != null)

        throw new RuntimeException("expected null");



      Klass k = new Klass("global pointer");

      li_boost_intrusive_ptr.setGlobalPointer(k);

      verifyCount(1, k);



      kglobal = li_boost_intrusive_ptr.getGlobalPointer();

      String val = kglobal.getValue();

      verifyValue("global pointer", val);

      verifyCount(1, kglobal);

      verifyCount(1, k);

      li_boost_intrusive_ptr.setGlobalPointer(null);

    }



    // plain reference

    {

      Klass kglobal;



      Klass k = new Klass("global reference");

      li_boost_intrusive_ptr.setGlobalReference(k);

      verifyCount(1, k);



      kglobal = li_boost_intrusive_ptr.getGlobalReference();

      String val = kglobal.getValue();

      verifyValue("global reference", val);

      verifyCount(1, kglobal);

      verifyCount(1, k);



      try { li_boost_intrusive_ptr.setGlobalReference(null); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}

    }



    ////////////////////////////////// Templates ////////////////////////////////////////

    {

      PairIntDouble pid = new PairIntDouble(10, 20.2);

      if (pid.getBaseVal1() != 20 || pid.getBaseVal2() != 40.4)

        throw new RuntimeException("Base values wrong");

      if (pid.getVal1() != 10 || pid.getVal2() != 20.2)

        throw new RuntimeException("Derived Values wrong");

    }

  }

  private void verifyValue(String expected, String got) {

    if (!expected.equals(got))

      throw new RuntimeException("verify value failed. Expected: " + expected + " Got: " + got);

  }

  private void verifyCount(int expected, Klass k) {

    int got = li_boost_intrusive_ptr.use_count(k);

    if (expected != got)

      throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);

  }

  private void verifyCount(int expected, KlassDerived kd) {

      int got = li_boost_intrusive_ptr.use_count(kd);

      if (expected != got)

        throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);

  }

  private void verifyCount(int expected, KlassDerivedDerived kdd) {

      int got = li_boost_intrusive_ptr.use_count(kdd);

      if (expected != got)

        throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);

  }

  private void verifyIntrusiveCount(int expected, Klass k) {

    int got = k.use_count();

    if (expected != got)

      throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);

  }

  private void verifyIntrusiveCount(int expected, KlassDerived kd) {

      int got = kd.use_count();

      if (expected != got)

        throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);

  }

  private void verifyIntrusiveCount(int expected, KlassDerivedDerived kdd) {

      int got = kdd.use_count();

      if (expected != got)

        throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);

  }

}