Examples/test-suite/java/li_boost_intrusive_ptr_runme.java

   1 import li_boost_intrusive_ptr.*;\r
   2 \r
   3 public class li_boost_intrusive_ptr_runme {\r
   4   static {\r
   5     try {\r
   6         System.loadLibrary("li_boost_intrusive_ptr");\r
   7     } catch (UnsatisfiedLinkError e) {\r
   8       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);\r
   9       System.exit(1);\r
  10     }\r
  11   }\r
  12 \r
  13   // Debugging flag\r
  14   public final static boolean debug = false;\r
  15 \r
  16   public static void main(String argv[])\r
  17   {\r
  18     if (debug)\r
  19       System.out.println("Started");\r
  20 \r
  21     li_boost_intrusive_ptr.setDebug_shared(debug);\r
  22 \r
  23     // Change loop count to run for a long time to monitor memory\r
  24     final int loopCount = 5000; //5000;\r
  25     for (int i=0; i<loopCount; i++) {\r
  26       new li_boost_intrusive_ptr_runme().runtest();\r
  27       System.gc();\r
  28       System.runFinalization();\r
  29       try {\r
  30         if (i%100 == 0) {\r
  31           java.lang.Thread.sleep(1); // give some time to the lower priority finalizer thread\r
  32         }\r
  33       } catch (java.lang.InterruptedException e) {\r
  34       }\r
  35     }\r
  36 \r
  37     if (debug)\r
  38       System.out.println("Nearly finished");\r
  39 \r
  40     int countdown = 50;\r
  41     while (true) {\r
  42       System.gc();\r
  43       System.runFinalization();\r
  44       try {\r
  45         java.lang.Thread.sleep(100);\r
  46       } catch (java.lang.InterruptedException e) {\r
  47       }\r
  48       if (--countdown == 0)\r
  49         break;\r
  50       if (Klass.getTotal_count() == 1 && KlassWithoutRefCount.getTotal_count() == 0 &&\r
  51           li_boost_intrusive_ptr.getTotal_IgnoredRefCountingBase_count() == 0 &&\r
  52           KlassDerived.getTotal_count() == 0 && KlassDerivedDerived.getTotal_count() == 1)\r
  53         // Expect 1 Klass instance - the one global variable (GlobalValue)\r
  54         break;\r
  55     };\r
  56     if (Klass.getTotal_count() != 1)\r
  57       throw new RuntimeException("Klass.total_count=" + Klass.getTotal_count());\r
  58     if (KlassWithoutRefCount.getTotal_count() != 0)\r
  59       throw new RuntimeException("KlassWithoutRefCount.total_count=" + KlassWithoutRefCount.getTotal_count());\r
  60     if (li_boost_intrusive_ptr.getTotal_IgnoredRefCountingBase_count() != 0)\r
  61       throw new RuntimeException("IgnoredRefCountingBase.total_count=" + li_boost_intrusive_ptr.getTotal_IgnoredRefCountingBase_count());\r
  62     if (KlassDerived.getTotal_count() != 0)\r
  63       throw new RuntimeException("KlassDerived.total_count=" + KlassDerived.getTotal_count());\r
  64     if (KlassDerivedDerived.getTotal_count() != 0)\r
  65       throw new RuntimeException("KlassDerivedDerived.total_count=" + KlassDerivedDerived.getTotal_count());\r
  66 \r
  67     int wrapper_count = li_boost_intrusive_ptr.intrusive_ptr_wrapper_count();\r
  68     if (wrapper_count != li_boost_intrusive_ptr.getNOT_COUNTING())\r
  69       if (wrapper_count != 1) // Expect 1 instance - the one global variable (GlobalSmartValue)\r
  70         throw new RuntimeException("shared_ptr wrapper count=" + wrapper_count);\r
  71 \r
  72     if (debug)\r
  73       System.out.println("Finished");\r
  74   }\r
  75 \r
  76   private void runtest() {\r
  77     // simple shared_ptr usage - created in C++\r
  78     {\r
  79       Klass k = new Klass("me oh my");\r
  80       String val = k.getValue();\r
  81       verifyValue("me oh my", val);\r
  82       verifyCount(1, k);\r
  83     }\r
  84 \r
  85     // simple shared_ptr usage - not created in C++\r
  86     {\r
  87       Klass k = li_boost_intrusive_ptr.factorycreate();\r
  88       String val = k.getValue();\r
  89       verifyValue("factorycreate", val);\r
  90       verifyCount(1, k);\r
  91     }\r
  92 \r
  93     // pass by shared_ptr\r
  94     {\r
  95       Klass k = new Klass("me oh my");\r
  96       Klass kret = li_boost_intrusive_ptr.smartpointertest(k);\r
  97       String val = kret.getValue();\r
  98       verifyValue("me oh my smartpointertest", val);\r
  99       verifyCount(1, k);\r
 100       verifyIntrusiveCount(2, k);\r
 101       verifyCount(1, kret);\r
 102       verifyIntrusiveCount(2, kret);\r
 103     }\r
 104 \r
 105     // pass by shared_ptr pointer\r
 106     {\r
 107       Klass k = new Klass("me oh my");\r
 108       Klass kret = li_boost_intrusive_ptr.smartpointerpointertest(k);\r
 109       String val = kret.getValue();\r
 110       verifyValue("me oh my smartpointerpointertest", val);\r
 111       verifyCount(1, k);\r
 112       verifyIntrusiveCount(2, k);\r
 113       verifyCount(1, kret);\r
 114       verifyIntrusiveCount(2, kret);\r
 115     }\r
 116 \r
 117     // pass by shared_ptr reference\r
 118     {\r
 119       Klass k = new Klass("me oh my");\r
 120       Klass kret = li_boost_intrusive_ptr.smartpointerreftest(k);\r
 121       String val = kret.getValue();\r
 122       verifyValue("me oh my smartpointerreftest", val);\r
 123       verifyCount(1, k);\r
 124       verifyIntrusiveCount(2, k);\r
 125       verifyCount(1, kret);\r
 126       verifyIntrusiveCount(2, kret);\r
 127     }\r
 128 \r
 129     // pass by shared_ptr pointer reference\r
 130     {\r
 131       Klass k = new Klass("me oh my");\r
 132       Klass kret = li_boost_intrusive_ptr.smartpointerpointerreftest(k);\r
 133       String val = kret.getValue();\r
 134       verifyValue("me oh my smartpointerpointerreftest", val);\r
 135       verifyCount(1, k);\r
 136       verifyIntrusiveCount(2, k);\r
 137       verifyCount(1, kret);\r
 138       verifyIntrusiveCount(2, kret);\r
 139     }\r
 140 \r
 141     // const pass by shared_ptr\r
 142     {\r
 143       Klass k = new Klass("me oh my");\r
 144       Klass kret = li_boost_intrusive_ptr.constsmartpointertest(k);\r
 145       String val = kret.getValue();\r
 146       verifyValue("me oh my", val);\r
 147       verifyCount(1, k);\r
 148       verifyIntrusiveCount(2, k);\r
 149       verifyCount(1, kret);\r
 150       verifyIntrusiveCount(2, kret);\r
 151     }\r
 152 \r
 153     // const pass by shared_ptr pointer\r
 154     {\r
 155       Klass k = new Klass("me oh my");\r
 156       Klass kret = li_boost_intrusive_ptr.constsmartpointerpointertest(k);\r
 157       String val = kret.getValue();\r
 158       verifyValue("me oh my", val);\r
 159       verifyCount(1, k);\r
 160       verifyIntrusiveCount(2, k);\r
 161       verifyCount(1, kret);\r
 162       verifyIntrusiveCount(2, kret);\r
 163     }\r
 164 \r
 165     // const pass by shared_ptr reference\r
 166     {\r
 167       Klass k = new Klass("me oh my");\r
 168       Klass kret = li_boost_intrusive_ptr.constsmartpointerreftest(k);\r
 169       String val = kret.getValue();\r
 170       verifyValue("me oh my", val);\r
 171       verifyCount(1, k);\r
 172       verifyIntrusiveCount(2, k);\r
 173       verifyCount(1, kret);\r
 174       verifyIntrusiveCount(2, kret);\r
 175     }\r
 176 \r
 177     // pass by value\r
 178     {\r
 179       Klass k = new Klass("me oh my");\r
 180       Klass kret = li_boost_intrusive_ptr.valuetest(k);\r
 181       String val = kret.getValue();\r
 182       verifyValue("me oh my valuetest", val);\r
 183       verifyCount(1, k);\r
 184       verifyCount(1, kret);\r
 185     }\r
 186 \r
 187     // pass by pointer\r
 188     {\r
 189       Klass k = new Klass("me oh my");\r
 190       Klass kret = li_boost_intrusive_ptr.pointertest(k);\r
 191       String val = kret.getValue();\r
 192       verifyValue("me oh my pointertest", val);\r
 193       verifyCount(1, k);\r
 194       verifyCount(1, kret);\r
 195     }\r
 196 \r
 197     // pass by reference\r
 198     {\r
 199       Klass k = new Klass("me oh my");\r
 200       Klass kret = li_boost_intrusive_ptr.reftest(k);\r
 201       String val = kret.getValue();\r
 202       verifyValue("me oh my reftest", val);\r
 203       verifyCount(1, k);\r
 204       verifyCount(1, kret);\r
 205     }\r
 206 \r
 207     // pass by pointer reference\r
 208     {\r
 209       Klass k = new Klass("me oh my");\r
 210       Klass kret = li_boost_intrusive_ptr.pointerreftest(k);\r
 211       String val = kret.getValue();\r
 212       verifyValue("me oh my pointerreftest", val);\r
 213       verifyCount(1, k);\r
 214       verifyCount(1, kret);\r
 215     }\r
 216 \r
 217     // null tests\r
 218     {\r
 219       Klass k = null;\r
 220 \r
 221       if (li_boost_intrusive_ptr.smartpointertest(k) != null)\r
 222         throw new RuntimeException("return was not null");\r
 223 \r
 224       if (li_boost_intrusive_ptr.smartpointerpointertest(k) != null)\r
 225         throw new RuntimeException("return was not null");\r
 226 \r
 227       if (li_boost_intrusive_ptr.smartpointerreftest(k) != null)\r
 228         throw new RuntimeException("return was not null");\r
 229 \r
 230       if (li_boost_intrusive_ptr.smartpointerpointerreftest(k) != null)\r
 231         throw new RuntimeException("return was not null");\r
 232 \r
 233       if (!li_boost_intrusive_ptr.nullsmartpointerpointertest(null).equals("null pointer"))\r
 234         throw new RuntimeException("not null smartpointer pointer");\r
 235 \r
 236       try { li_boost_intrusive_ptr.valuetest(k); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}\r
 237 \r
 238       if (li_boost_intrusive_ptr.pointertest(k) != null)\r
 239         throw new RuntimeException("return was not null");\r
 240 \r
 241       try { li_boost_intrusive_ptr.reftest(k); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}\r
 242     }\r
 243 \r
 244     // $owner\r
 245     {\r
 246       Klass k = li_boost_intrusive_ptr.pointerownertest();\r
 247       String val = k.getValue();\r
 248       verifyValue("pointerownertest", val);\r
 249       verifyCount(1, k);\r
 250     }\r
 251     {\r
 252       Klass k = li_boost_intrusive_ptr.smartpointerpointerownertest();\r
 253       String val = k.getValue();\r
 254       verifyValue("smartpointerpointerownertest", val);\r
 255       verifyCount(1, k);\r
 256     }\r
 257 \r
 258     ////////////////////////////////// Derived classes ////////////////////////////////////////\r
 259     // derived access to base class which cannot be wrapped in an intrusive_ptr\r
 260         {\r
 261           KlassWithoutRefCount k = new KlassDerived("me oh my");\r
 262           verifyValue("this class cannot be wrapped by intrusive_ptrs but we can still use it", k.getSpecialValueFromUnwrappableClass());\r
 263         }\r
 264     // derived pass by shared_ptr\r
 265     {\r
 266       KlassDerived k = new KlassDerived("me oh my");\r
 267       KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrtest(k);\r
 268       String val = kret.getValue();\r
 269       verifyValue("me oh my derivedsmartptrtest-Derived", val);\r
 270       verifyIntrusiveCount(2, k);\r
 271       verifyCount(2, k); // includes extra reference for upcast\r
 272       verifyIntrusiveCount(2, kret);\r
 273       verifyCount(2, kret);\r
 274         }\r
 275 \r
 276     // derived pass by shared_ptr pointer\r
 277     {\r
 278       KlassDerived k = new KlassDerived("me oh my");\r
 279       KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrpointertest(k);\r
 280       String val = kret.getValue();\r
 281       verifyValue("me oh my derivedsmartptrpointertest-Derived", val);\r
 282       verifyIntrusiveCount(2, k);\r
 283       verifyCount(2, k); // includes extra reference for upcast\r
 284       verifyIntrusiveCount(2, kret);\r
 285       verifyCount(2, kret);\r
 286     }\r
 287     // derived pass by shared_ptr ref\r
 288     {\r
 289       KlassDerived k = new KlassDerived("me oh my");\r
 290       KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrreftest(k);\r
 291       String val = kret.getValue();\r
 292       verifyValue("me oh my derivedsmartptrreftest-Derived", val);\r
 293       verifyIntrusiveCount(2, k);\r
 294       verifyCount(2, k); // includes extra reference for upcast\r
 295       verifyIntrusiveCount(2, kret);\r
 296       verifyCount(2, kret);\r
 297     }\r
 298     // derived pass by shared_ptr pointer ref\r
 299     {\r
 300       KlassDerived k = new KlassDerived("me oh my");\r
 301       KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrpointerreftest(k);\r
 302       String val = kret.getValue();\r
 303       verifyValue("me oh my derivedsmartptrpointerreftest-Derived", val);\r
 304       verifyIntrusiveCount(2, k);\r
 305       verifyCount(2, k); // includes extra reference for upcast\r
 306       verifyIntrusiveCount(2, kret);\r
 307       verifyCount(2, kret);\r
 308     }\r
 309     // derived pass by pointer\r
 310     {\r
 311       KlassDerived k = new KlassDerived("me oh my");\r
 312       verifyCount(2, k); // includes an extra reference for the upcast in the proxy class\r
 313       KlassDerived kret = li_boost_intrusive_ptr.derivedpointertest(k);\r
 314       verifyCount(2, kret);\r
 315       String val = kret.getValue();\r
 316       verifyValue("me oh my derivedpointertest-Derived", val);\r
 317       verifyIntrusiveCount(1, k); //one shared_ptr has a null deleter\r
 318       verifyCount(2, k); // includes extra reference for upcast\r
 319       verifyIntrusiveCount(1, kret); //one shared_ptr has a null deleter\r
 320       verifyCount(2, kret);\r
 321     }\r
 322     // derived pass by ref\r
 323     {\r
 324       KlassDerived k = new KlassDerived("me oh my");\r
 325       verifyCount(2, k); // includes an extra reference for the upcast in the proxy class\r
 326       KlassDerived kret = li_boost_intrusive_ptr.derivedreftest(k);\r
 327       verifyCount(2, kret);\r
 328       String val = kret.getValue();\r
 329       verifyValue("me oh my derivedreftest-Derived", val);\r
 330       verifyIntrusiveCount(1, k); //one shared_ptr has a null deleter\r
 331       verifyCount(2, k); // includes extra reference for upcast\r
 332       verifyIntrusiveCount(1, kret); //one shared_ptr has a null deleter\r
 333       verifyCount(2, kret);\r
 334     }\r
 335 \r
 336     ////////////////////////////////// Derived and base class mixed ////////////////////////////////////////\r
 337     // pass by shared_ptr (mixed)\r
 338     {\r
 339       KlassDerived k = new KlassDerivedDerived("me oh my");\r
 340       KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrtest(k);\r
 341       String val = kret.getValue();\r
 342       verifyValue("me oh my derivedsmartptrtest-DerivedDerived", val);\r
 343       verifyIntrusiveCount(2, k);\r
 344       verifyCount(3, k); // an extra reference for the upcast in the proxy class\r
 345       verifyIntrusiveCount(2, kret);\r
 346       verifyCount(2, kret);\r
 347     }\r
 348 \r
 349     // pass by shared_ptr pointer (mixed)\r
 350     {\r
 351       KlassDerived k = new KlassDerivedDerived("me oh my");\r
 352       KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrpointertest(k);\r
 353       String val = kret.getValue();\r
 354       verifyValue("me oh my derivedsmartptrpointertest-DerivedDerived", val);\r
 355       verifyIntrusiveCount(2, k);\r
 356       verifyCount(3, k); // an extra reference for the upcast in the proxy class\r
 357       verifyIntrusiveCount(2, kret);\r
 358       verifyCount(2, kret);\r
 359     }\r
 360 \r
 361     // pass by shared_ptr reference (mixed)\r
 362     {\r
 363       KlassDerived k = new KlassDerivedDerived("me oh my");\r
 364       KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrreftest(k);\r
 365       String val = kret.getValue();\r
 366       verifyValue("me oh my derivedsmartptrreftest-DerivedDerived", val);\r
 367       verifyIntrusiveCount(2, k);\r
 368       verifyCount(3, k); // an extra reference for the upcast in the proxy class\r
 369       verifyIntrusiveCount(2, kret);\r
 370       verifyCount(2, kret);\r
 371     }\r
 372 \r
 373     // pass by shared_ptr pointer reference (mixed)\r
 374     {\r
 375       KlassDerived k = new KlassDerivedDerived("me oh my");\r
 376       KlassDerived kret = li_boost_intrusive_ptr.derivedsmartptrpointerreftest(k);\r
 377       String val = kret.getValue();\r
 378       verifyValue("me oh my derivedsmartptrpointerreftest-DerivedDerived", val);\r
 379       verifyIntrusiveCount(2, k);\r
 380       verifyCount(3, k); // an extra reference for the upcast in the proxy class\r
 381       verifyIntrusiveCount(2, kret);\r
 382       verifyCount(2, kret);\r
 383     }\r
 384 \r
 385     // pass by value (mixed)\r
 386     {\r
 387       KlassDerived k = new KlassDerivedDerived("me oh my");\r
 388       KlassDerived kret = li_boost_intrusive_ptr.derivedvaluetest(k);\r
 389       String val = kret.getValue();\r
 390       verifyValue("me oh my derivedvaluetest-Derived", val); // note slicing\r
 391       verifyIntrusiveCount(1, k);\r
 392       verifyCount(3, k); // an extra reference for the upcast in the proxy class\r
 393       verifyIntrusiveCount(1, kret);\r
 394       verifyCount(2, kret);\r
 395     }\r
 396 \r
 397     // pass by pointer (mixed)\r
 398     {\r
 399       KlassDerived k = new KlassDerivedDerived("me oh my");\r
 400       KlassDerived kret = li_boost_intrusive_ptr.derivedpointertest(k);\r
 401       String val = kret.getValue();\r
 402       verifyValue("me oh my derivedpointertest-DerivedDerived", val);\r
 403       verifyIntrusiveCount(1, k); //one shared_ptr has a null deleter\r
 404       verifyCount(3, k); // an extra reference for the upcast in the proxy class\r
 405       verifyIntrusiveCount(1, kret); //one shared_ptr has a null deleter\r
 406       verifyCount(2, kret);\r
 407     }\r
 408 \r
 409     // pass by ref (mixed)\r
 410     {\r
 411       KlassDerived k = new KlassDerivedDerived("me oh my");\r
 412       KlassDerived kret = li_boost_intrusive_ptr.derivedreftest(k);\r
 413       String val = kret.getValue();\r
 414       verifyValue("me oh my derivedreftest-DerivedDerived", val);\r
 415       verifyIntrusiveCount(1, k); //one shared_ptr has a null deleter\r
 416       verifyCount(3, k); // an extra reference for the upcast in the proxy class\r
 417       verifyIntrusiveCount(1, kret); //one shared_ptr has a null deleter\r
 418       verifyCount(2, kret);\r
 419     }\r
 420 \r
 421     ////////////////////////////////// Member variables ////////////////////////////////////////\r
 422     // smart pointer by value\r
 423     {\r
 424       MemberVariables m = new MemberVariables();\r
 425       Klass k = new Klass("smart member value");\r
 426       m.setSmartMemberValue(k);\r
 427       String val = k.getValue();\r
 428       verifyValue("smart member value", val);\r
 429       verifyIntrusiveCount(2, k);\r
 430       verifyCount(1, k);\r
 431 \r
 432       Klass kmember = m.getSmartMemberValue();\r
 433       val = kmember.getValue();\r
 434       verifyValue("smart member value", val);\r
 435       verifyIntrusiveCount(3, kmember);\r
 436       verifyIntrusiveCount(3, k);\r
 437       verifyCount(1, k);\r
 438       verifyCount(1, kmember);\r
 439 \r
 440       m.delete();\r
 441       verifyIntrusiveCount(2, kmember);\r
 442       verifyIntrusiveCount(2, k);\r
 443     }\r
 444 \r
 445     // smart pointer by pointer\r
 446     {\r
 447       MemberVariables m = new MemberVariables();\r
 448       Klass k = new Klass("smart member pointer");\r
 449       m.setSmartMemberPointer(k);\r
 450       String val = k.getValue();\r
 451       verifyValue("smart member pointer", val);\r
 452       verifyCount(1, k);\r
 453       verifyIntrusiveCount(2, k);\r
 454 \r
 455       Klass kmember = m.getSmartMemberPointer();\r
 456       val = kmember.getValue();\r
 457       verifyValue("smart member pointer", val);\r
 458       verifyIntrusiveCount(3, kmember);\r
 459       verifyCount(1, kmember);\r
 460       verifyIntrusiveCount(3, k);\r
 461       verifyCount(1, k);\r
 462 \r
 463       m.delete();\r
 464       verifyIntrusiveCount(2, kmember);\r
 465       verifyCount(1, kmember);\r
 466       verifyIntrusiveCount(2, k);\r
 467       verifyCount(1, k);\r
 468     }\r
 469     // smart pointer by reference\r
 470     {\r
 471       MemberVariables m = new MemberVariables();\r
 472       Klass k = new Klass("smart member reference");\r
 473       m.setSmartMemberReference(k);\r
 474       String val = k.getValue();\r
 475       verifyValue("smart member reference", val);\r
 476       verifyIntrusiveCount(2, k);\r
 477       verifyCount(1, k);\r
 478 \r
 479       Klass kmember = m.getSmartMemberReference();\r
 480       val = kmember.getValue();\r
 481       verifyValue("smart member reference", val);\r
 482       verifyIntrusiveCount(3, kmember);\r
 483       verifyCount(1, kmember);\r
 484       verifyIntrusiveCount(3, k);\r
 485       verifyCount(1, k);\r
 486 \r
 487       // The C++ reference refers to SmartMemberValue...\r
 488       m.setSmartMemberValue(k);\r
 489       Klass kmemberVal = m.getSmartMemberValue();\r
 490       val = kmember.getValue();\r
 491       verifyValue("smart member reference", val);\r
 492       verifyIntrusiveCount(5, kmemberVal);\r
 493       verifyCount(1, kmemberVal);\r
 494       verifyIntrusiveCount(5, kmember);\r
 495       verifyCount(1, kmember);\r
 496       verifyIntrusiveCount(5, k);\r
 497       verifyCount(1, k);\r
 498 \r
 499       m.delete();\r
 500       verifyIntrusiveCount(3, kmemberVal);\r
 501       verifyCount(1, kmemberVal);\r
 502       verifyIntrusiveCount(3, kmember);\r
 503       verifyCount(1, kmember);\r
 504       verifyIntrusiveCount(3, k);\r
 505       verifyCount(1, k);\r
 506     }\r
 507 \r
 508     //plain by value\r
 509     {\r
 510       MemberVariables m = new MemberVariables();\r
 511       Klass k = new Klass("plain member value");\r
 512       m.setMemberValue(k);\r
 513       String val = k.getValue();\r
 514       verifyValue("plain member value", val);\r
 515       verifyCount(1, k);\r
 516 \r
 517       Klass kmember = m.getMemberValue();\r
 518       val = kmember.getValue();\r
 519       verifyValue("plain member value", val);\r
 520       verifyCount(1, kmember);\r
 521       verifyCount(1, k);\r
 522 \r
 523       m.delete();\r
 524       verifyCount(1, kmember);\r
 525       verifyCount(1, k);\r
 526     }\r
 527     //plain by pointer\r
 528     {\r
 529       MemberVariables m = new MemberVariables();\r
 530       Klass k = new Klass("plain member pointer");\r
 531       m.setMemberPointer(k);\r
 532       String val = k.getValue();\r
 533       verifyValue("plain member pointer", val);\r
 534       verifyCount(1, k);\r
 535 \r
 536       Klass kmember = m.getMemberPointer();\r
 537       val = kmember.getValue();\r
 538       verifyValue("plain member pointer", val);\r
 539       verifyCount(1, kmember);\r
 540       verifyCount(1, k);\r
 541 \r
 542       m.delete();\r
 543       verifyCount(1, kmember);\r
 544       verifyCount(1, k);\r
 545     }\r
 546     //plain by reference\r
 547     {\r
 548       MemberVariables m = new MemberVariables();\r
 549       Klass k = new Klass("plain member reference");\r
 550       m.setMemberReference(k);\r
 551       String val = k.getValue();\r
 552       verifyValue("plain member reference", val);\r
 553       verifyCount(1, k);\r
 554 \r
 555       Klass kmember = m.getMemberReference();\r
 556       val = kmember.getValue();\r
 557       verifyValue("plain member reference", val);\r
 558       verifyCount(1, kmember);\r
 559       verifyCount(1, k);\r
 560 \r
 561       m.delete();\r
 562       verifyCount(1, kmember);\r
 563       verifyCount(1, k);\r
 564     }\r
 565     //null member variables\r
 566     {\r
 567       MemberVariables m = new MemberVariables();\r
 568 \r
 569       // shared_ptr by value\r
 570       Klass k = m.getSmartMemberValue();\r
 571       if (k != null)\r
 572         throw new RuntimeException("expected null");\r
 573       m.setSmartMemberValue(null);\r
 574       k = m.getSmartMemberValue();\r
 575       if (k != null)\r
 576         throw new RuntimeException("expected null");\r
 577       verifyCount(0, k);\r
 578 \r
 579       // plain by value\r
 580       try { m.setMemberValue(null); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}\r
 581     }\r
 582 }\r
 583 private void toIgnore() {\r
 584     ////////////////////////////////// Global variables ////////////////////////////////////////\r
 585     // smart pointer\r
 586     {\r
 587       Klass kglobal = li_boost_intrusive_ptr.getGlobalSmartValue();\r
 588       if (kglobal != null)\r
 589         throw new RuntimeException("expected null");\r
 590 \r
 591       Klass k = new Klass("smart global value");\r
 592       li_boost_intrusive_ptr.setGlobalSmartValue(k);\r
 593       verifyIntrusiveCount(2, k);\r
 594       verifyCount(1, k);\r
 595 \r
 596       kglobal = li_boost_intrusive_ptr.getGlobalSmartValue();\r
 597       String val = kglobal.getValue();\r
 598       verifyValue("smart global value", val);\r
 599       verifyIntrusiveCount(3, kglobal);\r
 600       verifyCount(1, kglobal);\r
 601       verifyIntrusiveCount(3, k);\r
 602       verifyCount(1, k);\r
 603       verifyValue("smart global value", li_boost_intrusive_ptr.getGlobalSmartValue().getValue());\r
 604       li_boost_intrusive_ptr.setGlobalSmartValue(null);\r
 605     }\r
 606     // plain value\r
 607     {\r
 608       Klass kglobal;\r
 609 \r
 610       Klass k = new Klass("global value");\r
 611       li_boost_intrusive_ptr.setGlobalValue(k);\r
 612       verifyCount(1, k);\r
 613 \r
 614       kglobal = li_boost_intrusive_ptr.getGlobalValue();\r
 615       String val = kglobal.getValue();\r
 616       verifyValue("global value", val);\r
 617       verifyCount(1, kglobal);\r
 618       verifyCount(1, k);\r
 619       verifyValue("global value", li_boost_intrusive_ptr.getGlobalValue().getValue());\r
 620 \r
 621       try { li_boost_intrusive_ptr.setGlobalValue(null); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}\r
 622     }\r
 623     //plain pointer\r
 624     {\r
 625       Klass kglobal = li_boost_intrusive_ptr.getGlobalPointer();\r
 626       if (kglobal != null)\r
 627         throw new RuntimeException("expected null");\r
 628 \r
 629       Klass k = new Klass("global pointer");\r
 630       li_boost_intrusive_ptr.setGlobalPointer(k);\r
 631       verifyCount(1, k);\r
 632 \r
 633       kglobal = li_boost_intrusive_ptr.getGlobalPointer();\r
 634       String val = kglobal.getValue();\r
 635       verifyValue("global pointer", val);\r
 636       verifyCount(1, kglobal);\r
 637       verifyCount(1, k);\r
 638       li_boost_intrusive_ptr.setGlobalPointer(null);\r
 639     }\r
 640 \r
 641     // plain reference\r
 642     {\r
 643       Klass kglobal;\r
 644 \r
 645       Klass k = new Klass("global reference");\r
 646       li_boost_intrusive_ptr.setGlobalReference(k);\r
 647       verifyCount(1, k);\r
 648 \r
 649       kglobal = li_boost_intrusive_ptr.getGlobalReference();\r
 650       String val = kglobal.getValue();\r
 651       verifyValue("global reference", val);\r
 652       verifyCount(1, kglobal);\r
 653       verifyCount(1, k);\r
 654 \r
 655       try { li_boost_intrusive_ptr.setGlobalReference(null); throw new RuntimeException("Failed to catch null pointer"); } catch (NullPointerException e) {}\r
 656     }\r
 657 \r
 658     ////////////////////////////////// Templates ////////////////////////////////////////\r
 659     {\r
 660       PairIntDouble pid = new PairIntDouble(10, 20.2);\r
 661       if (pid.getBaseVal1() != 20 || pid.getBaseVal2() != 40.4)\r
 662         throw new RuntimeException("Base values wrong");\r
 663       if (pid.getVal1() != 10 || pid.getVal2() != 20.2)\r
 664         throw new RuntimeException("Derived Values wrong");\r
 665     }\r
 666   }\r
 667   private void verifyValue(String expected, String got) {\r
 668     if (!expected.equals(got))\r
 669       throw new RuntimeException("verify value failed. Expected: " + expected + " Got: " + got);\r
 670   }\r
 671   private void verifyCount(int expected, Klass k) {\r
 672     int got = li_boost_intrusive_ptr.use_count(k);\r
 673     if (expected != got)\r
 674       throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);\r
 675   }\r
 676   private void verifyCount(int expected, KlassDerived kd) {\r
 677       int got = li_boost_intrusive_ptr.use_count(kd);\r
 678       if (expected != got)\r
 679         throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);\r
 680   }\r
 681   private void verifyCount(int expected, KlassDerivedDerived kdd) {\r
 682       int got = li_boost_intrusive_ptr.use_count(kdd);\r
 683       if (expected != got)\r
 684         throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);\r
 685   }\r
 686   private void verifyIntrusiveCount(int expected, Klass k) {\r
 687     int got = k.use_count();\r
 688     if (expected != got)\r
 689       throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);\r
 690   }\r
 691   private void verifyIntrusiveCount(int expected, KlassDerived kd) {\r
 692       int got = kd.use_count();\r
 693       if (expected != got)\r
 694         throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);\r
 695   }\r
 696   private void verifyIntrusiveCount(int expected, KlassDerivedDerived kdd) {\r
 697       int got = kdd.use_count();\r
 698       if (expected != got)\r
 699         throw new RuntimeException("verify use_count failed. Expected: " + expected + " Got: " + got);\r
 700   }\r
 701 }\r