Small bugfix: object._destroy wasn't working for directly passed objects.

src/gsi/gsi_test/gsiTest.cc

@@ -83,7 +83,7 @@ A &A::operator= (const A &a)
   return *this;
 }
 
-int A::a0 ()
+int A::instance_count ()
 {
   return a_count;
 }
@@ -780,6 +780,7 @@ static gsi::QFlagsClass<Enum> decl_qflags_enum ("", "Enums");
 
 static gsi::Class<A> decl_a ("", "A",
   gsi::constructor ("new_a|new", &a_ctor) +
+  gsi::method ("instance_count", &A::instance_count) +
   gsi::method ("br", &A::br) +
   gsi::method ("get_e", &A::get_e) +
   gsi::method ("get_eptr", &A::get_eptr) +
@@ -814,7 +815,6 @@ static gsi::Class<A> decl_a ("", "A",
   gsi::method ("af?|af", &A::af1) +
   gsi::method ("aa", &A::a) +
   gsi::method ("aa", &A::a_static) +
-  gsi::method ("a0", &A::a0) +
   gsi::method ("a1", &A::a1) +
   gsi::method ("a1c", &A::a1c) +
   gsi::method ("a2", &A::a2) +
@@ -904,22 +904,22 @@ static gsi::Class<B> decl_b ("", "B",
   gsi::method ("b5", &B::b5) +
   gsi::method ("b5a", &B::b5a) +
   gsi::method ("b5b", &B::b5b) +
-  gsi::method ("b6|make_a", &B::b6) +
+  gsi::method ("make_a", &B::make_a) +
-  gsi::method ("b8|set_an", &B::b8) +
+  gsi::method ("set_an", &B::set_an) +
-  gsi::method ("b9|an", &B::b9) +
+  gsi::method ("an", &B::an) +
-  gsi::method ("b8cref|set_an_cref", &B::b8) +
+  gsi::method ("set_an_cref", &B::set_an_cref) +
-  gsi::method ("b9cref|an_cref", &B::b9) +
+  gsi::method ("an_cref", &B::an_cref) +
   //  implemented by extension below:
   // gsi::iterator_ext ("b10", &b10b_ext, &b10e_ext) +
   gsi::iterator ("b10_nc", &B::b10b_nc, &B::b10e_nc) +
   gsi::iterator ("b11", &B::b11b, &B::b11e) +
   gsi::iterator ("b12", &B::b12b, &B::b12e) +
   gsi::iterator ("b13", &B::b13b, &B::b13e) +
-  gsi::method ("b14a|amember_or_nil", &B::amember_or_nil) +
+  gsi::method ("amember_or_nil_alt|amember_or_nil", &B::amember_or_nil) +
-  gsi::method ("b14b|amember_ptr", &B::amember_ptr) +
+  gsi::method ("amember_ptr_alt|amember_ptr", &B::amember_ptr) +
-  gsi::method ("b7|b14c|amember_cptr", &B::amember_cptr) +
+  gsi::method ("xxx|amember_cptr", &B::amember_cptr) +
-  gsi::method ("b7c|amember_cref", &B::amember_cref) +
+  gsi::method ("yyy|amember_cref", &B::amember_cref) +
-  gsi::method ("b7d|amember_ref", &B::amember_ref) +
+  gsi::method ("zzz|amember_ref", &B::amember_ref) +
   gsi::method ("b15|arg_is_not_nil", &B::b15) +
   gsi::method ("b16a|av", &B::b16a) +
   gsi::method ("b16b|av_cref", &B::b16b) +

src/gsi/gsi_test/gsiTest.h

@@ -104,7 +104,7 @@ struct A
   void set_af (bool _f) { f = _f; }
   bool af1 (bool /*dummy*/) { return f; }
 
-  static int a0 ();
+  static int instance_count ();
   int a1 () { 
     return n; 
   }
@@ -465,26 +465,26 @@ struct B
     return m.c_str ();
   }
 
-  A b6 (int n) { 
+  A make_a (int n) {
     return A(n);
   }
 
-  void b8 (int n) 
+  void set_an (int n)
   { 
     a.n = n;
   }
 
-  int b9 (A a) 
+  int an (A a)
   { 
     return a.n;
   }
 
-  void b8cref (const int &n) 
+  void set_an_cref (const int &n)
   { 
     a.n = n;
   }
 
-  const int &b9cref (const A &a) 
+  const int &an_cref (const A &a)
   { 
     return a.n;
   }

src/pya/pya/pyaObject.cc

@@ -538,7 +538,7 @@ PYAObjectBase::destroy ()
     return;
   }
 
-  if (!m_can_destroy && m_obj) {
+  if (! (m_owned || m_can_destroy) && m_obj) {
     throw tl::Exception (tl::to_string (tr ("Object cannot be destroyed explicitly")));
   }
 

src/rba/rba/rbaInternal.cc

@@ -364,7 +364,7 @@ Proxy::destroy ()
     return;
   }
 
-  if (!m_can_destroy && m_obj) {
+  if (! (m_owned || m_can_destroy) && m_obj) {
     throw tl::Exception (tl::to_string (tr ("Object cannot be destroyed explicitly")));
   }
 

testdata/python/basic.py

@@ -135,10 +135,10 @@ class BasicTest(unittest.TestCase):
   def test_00(self):
 
     # all references of PA are released now:
-    ac0 = pya.A.a0()
+    ic0 = pya.A.instance_count()
 
     a = pya.A.new_a(100)
-    self.assertEqual( pya.A.a0(), ac0 + 1 )
+    self.assertEqual( pya.A.instance_count(), ic0 + 1 )
 
     a = pya.A()
     self.assertEqual(a.a1(), 17)
@@ -146,28 +146,28 @@ class BasicTest(unittest.TestCase):
     self.assertEqual(a.a1(), 110)
 
     a = None
-    self.assertEqual( pya.A.a0(), ac0 )
+    self.assertEqual( pya.A.instance_count(), ic0 )
 
     a = pya.A()
-    self.assertEqual( pya.A.a0(), ac0 )  # delayed instantiation of detached objects - A is actually created if it is used first
+    self.assertEqual( pya.A.instance_count(), ic0 )  # delayed instantiation of detached objects - A is actually created if it is used first
     a.a2()   # just check, if it can be called
-    self.assertEqual( pya.A.a0(), ac0 + 1 )
+    self.assertEqual( pya.A.instance_count(), ic0 + 1 )
 
     # open question: with ruby 1.8, aa is not deleted if the self.assertEqual is missing. Why?
     # maybe the GC does not like to be called that frequently?
     aa = a.dup()
-    self.assertEqual( pya.A.a0(), ac0 + 2 )
+    self.assertEqual( pya.A.instance_count(), ic0 + 2 )
 
     aa = None
-    self.assertEqual( pya.A.a0(), ac0 + 1 )
+    self.assertEqual( pya.A.instance_count(), ic0 + 1 )
 
     a = None
-    self.assertEqual( pya.A.a0(), ac0 )
+    self.assertEqual( pya.A.instance_count(), ic0 )
 
     a = pya.A()
-    self.assertEqual( pya.A.a0(), ac0 )  # delayed instantiation of detached objects - A is actually created if it is used first
+    self.assertEqual( pya.A.instance_count(), ic0 )  # delayed instantiation of detached objects - A is actually created if it is used first
     a.a2()   # just check, if it can be called
-    self.assertEqual( pya.A.a0(), ac0 + 1 )
+    self.assertEqual( pya.A.instance_count(), ic0 + 1 )
 
     # static and non-static methods can be mixed, but they will be made non-ambiguous too
     self.assertEqual( pya.A.aa(), "static_a" )
@@ -219,7 +219,7 @@ class BasicTest(unittest.TestCase):
     self.assertEqual(arr, [5, 1, -1.25])
 
     a.destroy()
-    self.assertEqual( pya.A.a0(), ac0 )
+    self.assertEqual( pya.A.instance_count(), ic0 )
 
     if not leak_check:
 
@@ -237,13 +237,13 @@ class BasicTest(unittest.TestCase):
         error_caught = True
       self.assertEqual( error_caught, True )
 
-    self.assertEqual( pya.A.a0(), ac0 )
+    self.assertEqual( pya.A.instance_count(), ic0 )
     a = pya.A.new_a( 55 )
-    self.assertEqual( pya.A.a0(), ac0 + 1 )
+    self.assertEqual( pya.A.instance_count(), ic0 + 1 )
     self.assertEqual( a.a1(), 55 )
     self.assertEqual( a.a_vp1( a.a_vp2() ), "abc" )
     a.destroy()
-    self.assertEqual( pya.A.a0(), ac0 )
+    self.assertEqual( pya.A.instance_count(), ic0 )
 
     a = pya.A.new_a(0)
     self.assertEqual( str(a.a9a(5)), "True" )
@@ -594,12 +594,12 @@ class BasicTest(unittest.TestCase):
 
       err_caught = False
       try:
-        b.b7().a1() # cannot call non-const method on const reference
+        b.amember_cptr().a1() # cannot call non-const method on const reference
       except: 
         err_caught = True
       self.assertEqual( err_caught, True )
 
-    b.b7().a2()
+    b.amember_cptr().a2()
 
     self.assertEqual( b.b1(), 5 )
     self.assertEqual( b.b2(), "" )
@@ -973,50 +973,58 @@ class BasicTest(unittest.TestCase):
     # test copies of objects being returned
 
     b = pya.B()
+    b._create()  # force constructor of B to allocate some A instances internally
 
-    a = b.b6( 1971 );
+    a_count = pya.A.instance_count()
+    a = b.make_a( 1971 );
+    self.assertEqual( pya.A.instance_count(), a_count + 1 )
     self.assertEqual( a.a1(), 1971 );
-    self.assertEqual( b.b9( a ), 1971 );
+    self.assertEqual( b.an( a ), 1971 );
 
-    aa = b.b6( -61 );
+    aa = b.make_a( -61 );
-    self.assertEqual( b.b9cref( aa ), -61 );
+    self.assertEqual( pya.A.instance_count(), a_count + 2 )
+    self.assertEqual( b.an_cref( aa ), -61 );
     self.assertEqual( a.a1(), 1971 );
-    self.assertEqual( b.b9( a ), 1971 );
+    self.assertEqual( b.an( a ), 1971 );
     self.assertEqual( aa.a1(), -61 );
-    self.assertEqual( b.b9( aa ), -61 );
+    self.assertEqual( b.an( aa ), -61 );
 
     aa.a5(98);
     a.a5(100);
     
     self.assertEqual( a.a1(), 100 );
-    self.assertEqual( b.b9( a ), 100 );
+    self.assertEqual( b.an( a ), 100 );
     self.assertEqual( aa.a1(), 98 );
-    self.assertEqual( b.b9( aa ), 98 );
+    self.assertEqual( b.an( aa ), 98 );
+
+    a._destroy()
+    aa = None
+    self.assertEqual( pya.A.instance_count(), a_count )
 
   def test_18(self):
 
-    # Test references to objects (returned by b.b7)
+    # Test references to objects (returned by b.amember_cptr)
 
     b = pya.B()
-    b.b8( 77 )
+    b.set_an( 77 )
-    self.assertEqual( b.b7().a1c(), 77 );
+    self.assertEqual( b.amember_cptr().a1c(), 77 );
 
-    b.b8cref( 79 )
+    b.set_an_cref( 79 )
-    self.assertEqual( b.b7().a1c(), 79 );
+    self.assertEqual( b.amember_cptr().a1c(), 79 );
 
-    aref = b.b7()
+    aref = b.amember_cptr()
     err_caught = False
 
     if not leak_check:
 
       try:
-        x = aref.a1() # cannot call non-const method on const reference (as delivered by b7)
+        x = aref.a1() # cannot call non-const method on const reference (as delivered by amember_cptr)
       except:
         err_caught = True
       self.assertEqual( err_caught, True )
       self.assertEqual( aref.a1c(), 79 );
 
-    b.b8( -1 )
+    b.set_an( -1 )
     self.assertEqual( aref.a1c(), -1 );
 
   def test_19(self):
@@ -1068,19 +1076,19 @@ class BasicTest(unittest.TestCase):
 
     b = pya.B()
 
-    a1 = b.b14a( True )
+    a1 = b.amember_or_nil_alt( True )
-    a2 = b.b14b()
+    a2 = b.amember_ptr_alt()
     self.assertEqual( a1.a1(), 17 )
     self.assertEqual( a2.a1(), 17 )
     a1.a5( 761 )
     self.assertEqual( a1.a1(), 761 )
     self.assertEqual( a2.a1(), 761 )
 
-    a1 = b.b14a( False )
+    a1 = b.amember_or_nil( False )
     self.assertEqual( a1, None )
     
-    self.assertEqual( b.b15( b.b14b() ), True )
+    self.assertEqual( b.b15( b.amember_ptr() ), True )
-    self.assertEqual( b.b15( b.b14a( False ) ), False )
+    self.assertEqual( b.b15( b.amember_or_nil( False ) ), False )
     self.assertEqual( b.b15( None ), False )
 
   def test_21(self):
@@ -1094,9 +1102,9 @@ class BasicTest(unittest.TestCase):
 
     b = pya.B()
     
-    # b14b() returns a pya.A object, but it cannot be extended dynamically by a method s ...
+    # amember_ptr() returns a pya.A object, but it cannot be extended dynamically by a method s ...
-    b.b14b().s( 117 )
+    b.amember_ptr().s( 117 )
-    self.assertEqual( b.b14b().g(), 117 )
+    self.assertEqual( b.amember_ptr().g(), 117 )
 
     n = 0
 
@@ -1247,9 +1255,9 @@ class BasicTest(unittest.TestCase):
     self.assertEqual( b.bx("a", 15), 20.5 )
     self.assertEqual( b.b32("b", 25), 20.5 )
 
-    na = pya.A.a0()    # instance count
+    na = pya.A.instance_count()    # instance count
     self.assertEqual(b.bx(a, 15), "aref+i")
-    self.assertEqual(pya.A.a0(), na)
+    self.assertEqual(pya.A.instance_count(), na)
     err_caught = False
     try: 
       # cannot cast second argument to int
@@ -1258,7 +1266,7 @@ class BasicTest(unittest.TestCase):
       err_caught = True
     self.assertEqual(err_caught, True)
     # the exception thrown before must not leave an instance on the call stack:
-    self.assertEqual(pya.A.a0(), na)
+    self.assertEqual(pya.A.instance_count(), na)
 
     err_caught = False
     try: 
@@ -1368,52 +1376,52 @@ class BasicTest(unittest.TestCase):
 
     # destruction of an instance via c++
     pya.A.a20(None) 
-    ac0 = pya.A.a0()
+    ic0 = pya.A.instance_count()
     a = pya.A()
     a.create()
     self.assertEqual(a.destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0 + 1)
+    self.assertEqual(pya.A.instance_count(), ic0 + 1)
     pya.A.a20(a)    # install static instance of A
     self.assertEqual(a.destroyed(), False)
     pya.A.a20(None) 
     self.assertEqual(a.destroyed(), True)
-    self.assertEqual(pya.A.a0(), ac0)
+    self.assertEqual(pya.A.instance_count(), ic0)
 
     a = pya.A()
     a.create()
     self.assertEqual(a.destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0 + 1)
+    self.assertEqual(pya.A.instance_count(), ic0 + 1)
     pya.A.a20(a)    # install static instance of A
     self.assertEqual(a.destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0 + 1)
+    self.assertEqual(pya.A.instance_count(), ic0 + 1)
     pya.A.a20(a)    # re-install static instance of A
     self.assertEqual(a.destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0 + 1)
+    self.assertEqual(pya.A.instance_count(), ic0 + 1)
     
     # install another instance
     aa = pya.A()
     aa.create()
     self.assertEqual(aa.destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0 + 2)
+    self.assertEqual(pya.A.instance_count(), ic0 + 2)
     pya.A.a20(aa)    # install static instance of A
 
     # original one is destroyed now, only new instance remains
     self.assertEqual(a.destroyed(), True)
     self.assertEqual(aa.destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0 + 1)
+    self.assertEqual(pya.A.instance_count(), ic0 + 1)
     pya.A.a20(None)    # discard installed instance
     self.assertEqual(aa.destroyed(), True)
-    self.assertEqual(pya.A.a0(), ac0)
+    self.assertEqual(pya.A.instance_count(), ic0)
 
     # the same without create .. should work too, but not create an instance because of late 
     # instantiation in default ctor
     a = pya.A()
     self.assertEqual(a.destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0)
+    self.assertEqual(pya.A.instance_count(), ic0)
     pya.A.a20(a)    # install static instance of A
     self.assertEqual(a.destroyed(), False)
     pya.A.a20(None) 
-    self.assertEqual(pya.A.a0(), ac0)
+    self.assertEqual(pya.A.instance_count(), ic0)
     self.assertEqual(a.destroyed(), True)
 
   def test_26(self):
@@ -1463,36 +1471,36 @@ class BasicTest(unittest.TestCase):
 
     # destruction of an instance via c++
     pya.A.a20(None)
-    ac0 = pya.A.a0()
+    ic0 = pya.A.instance_count()
 
     a = pya.A()
     a._create()
     self.assertEqual(a._destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0 + 1)
+    self.assertEqual(pya.A.instance_count(), ic0 + 1)
     pya.A.a20(a)    
     self.assertEqual(pya.A.a20_get() == None, False)
     # release A instance -> will delete it
     a = None
-    self.assertEqual(pya.A.a0(), ac0)
+    self.assertEqual(pya.A.instance_count(), ic0)
     self.assertEqual(pya.A.a20_get() == None, True)
 
     a = pya.A()
     a._create()
     self.assertEqual(a.destroyed(), False)
-    self.assertEqual(pya.A.a0(), ac0 + 1)
+    self.assertEqual(pya.A.instance_count(), ic0 + 1)
     pya.A.a20(a)    # install static instance of A
     self.assertEqual(pya.A.a20_get() == None, False)
     a._unmanage()
     # release A instance -> won't delete it since it is unmanaged
     a = None
-    self.assertEqual(pya.A.a0(), ac0 + 1)
+    self.assertEqual(pya.A.instance_count(), ic0 + 1)
     self.assertEqual(pya.A.a20_get() == None, False)
 
     a = pya.A.a20_get()
     a._manage()
     # release A instance -> will be deleted since now it's managed again
     a = None
-    self.assertEqual(pya.A.a0(), ac0)
+    self.assertEqual(pya.A.instance_count(), ic0)
     self.assertEqual(pya.A.a20_get() == None, True)
 
   def test_28(self):

testdata/ruby/basic_testcore.rb

@@ -14,11 +14,11 @@ class Basic_TestClass < TestBase
     GC.start 
     
     # all references of A are released now:
-    ac0 = RBA::A::a0
+    ic0 = RBA::A::instance_count
-    assert_equal( ac0, 0 )
+    assert_equal( ic0, 0 )
 
     a = RBA::A.new_a(100)
-    assert_equal( RBA::A::a0, ac0 + 1 )
+    assert_equal( RBA::A::instance_count, ic0 + 1 )
 
     a = RBA::A.new
     assert_equal(a.a1, 17)
@@ -27,26 +27,26 @@ class Basic_TestClass < TestBase
 
     a = nil
     GC.start
-    assert_equal( RBA::A::a0, ac0 )
+    assert_equal( RBA::A::instance_count, ic0 )
 
     a = RBA::A.new
-    assert_equal( RBA::A::a0, ac0 )  # delayed instantiation of detached objects - A is actually created if it is used first
+    assert_equal( RBA::A::instance_count, ic0 )  # delayed instantiation of detached objects - A is actually created if it is used first
     a.a2   # just check, if it can be called
-    assert_equal( RBA::A::a0, ac0 + 1 )
+    assert_equal( RBA::A::instance_count, ic0 + 1 )
 
     # open question: with ruby 1.8, aa is not deleted if the assert_equal is missing. Why?
     # maybe the GC does not like to be called that frequently?
     aa = a.dup
-    assert_equal( RBA::A::a0, ac0 + 2 )
+    assert_equal( RBA::A::instance_count, ic0 + 2 )
 
     aa = nil
     GC.start 
 
     if RUBY_VERSION >= "1.9.0"
       # GC works differently in >=1.9.x - but no leak (verified with valgrind)
-      ac0 = RBA::A::a0
+      ic0 = RBA::A::instance_count
     else
-      assert_equal( RBA::A::a0, ac0 + 1 )
+      assert_equal( RBA::A::instance_count, ic0 + 1 )
     end
 
     a = nil
@@ -54,15 +54,15 @@ class Basic_TestClass < TestBase
 
     if RUBY_VERSION >= "1.9.0"
       # GC works differently in >=1.9.x - but no leak (verified with valgrind)
-      ac0 = RBA::A::a0
+      ic0 = RBA::A::instance_count
     else
-      assert_equal( RBA::A::a0, ac0 )
+      assert_equal( RBA::A::instance_count, ic0 )
     end
 
     a = RBA::A.new
-    assert_equal( RBA::A::a0, ac0 )  # delayed instantiation of detached objects - A is actually created if it is used first
+    assert_equal( RBA::A::instance_count, ic0 )  # delayed instantiation of detached objects - A is actually created if it is used first
     a.a2   # just check, if it can be called
-    assert_equal( RBA::A::a0, ac0 + 1 )
+    assert_equal( RBA::A::instance_count, ic0 + 1 )
 
     # mix of getters, setters, predicates
     assert_equal( a.af, false )
@@ -116,7 +116,7 @@ class Basic_TestClass < TestBase
     assert_equal(arr, [5, 1, -1.25])
 
     a.destroy
-    assert_equal( RBA::A::a0, ac0 )
+    assert_equal( RBA::A::instance_count, ic0 )
 
     if !$leak_check 
 
@@ -138,13 +138,13 @@ class Basic_TestClass < TestBase
 
     end
 
-    assert_equal( RBA::A::a0, ac0 )
+    assert_equal( RBA::A::instance_count, ic0 )
     a = RBA::A::new_a( 55 )
-    assert_equal( RBA::A::a0, ac0 + 1 )
+    assert_equal( RBA::A::instance_count, ic0 + 1 )
     assert_equal( a.a1, 55 )
     assert_equal( a.a_vp1( a.a_vp2 ), "abc" )
     a.destroy
-    assert_equal( RBA::A::a0, ac0 )
+    assert_equal( RBA::A::instance_count, ic0 )
 
     a = RBA::A::new_a(0)
     assert_equal( a.a9a(5).to_s, "true" )
@@ -506,7 +506,7 @@ class Basic_TestClass < TestBase
 
       err_caught = false
       begin
-        b.b7.a1 # cannot call non-const method on const reference
+        b.amember_cptr.a1 # cannot call non-const method on const reference
       rescue 
         err_caught = true
       end
@@ -514,7 +514,7 @@ class Basic_TestClass < TestBase
 
     end
       
-    b.b7.a2 
+    b.amember_cptr.a2 
 
     assert_equal( b.b1, 5 )
     assert_equal( b.b2, "" )
@@ -857,46 +857,57 @@ class Basic_TestClass < TestBase
     # test copies of objects being returned
 
     b = RBA::B.new
+    b._create
 
-    a = b.b6( 1971 );
+    GC.start
-    assert_equal( a.a1, 1971 );
+    a_count = RBA::A.instance_count
-    assert_equal( b.b9( a ), 1971 );
+    a = b.make_a( 1971 );
+    assert_equal( RBA::A.instance_count, a_count + 1 )
 
-    aa = b.b6( -61 );
-    assert_equal( b.b9cref( aa ), -61 );
     assert_equal( a.a1, 1971 );
-    assert_equal( b.b9( a ), 1971 );
+    assert_equal( b.an( a ), 1971 );
+
+    aa = b.make_a( -61 );
+    assert_equal( RBA::A.instance_count, a_count + 2 )
+    assert_equal( b.an_cref( aa ), -61 );
+    assert_equal( a.a1, 1971 );
+    assert_equal( b.an( a ), 1971 );
     assert_equal( aa.a1, -61 );
-    assert_equal( b.b9( aa ), -61 );
+    assert_equal( b.an( aa ), -61 );
 
     aa.a5 98;
     a.a5 100;
     
     assert_equal( a.a1, 100 );
-    assert_equal( b.b9( a ), 100 );
+    assert_equal( b.an( a ), 100 );
     assert_equal( aa.a1, 98 );
-    assert_equal( b.b9( aa ), 98 );
+    assert_equal( b.an( aa ), 98 );
+
+    a._destroy
+    aa = nil
+    GC.start
+    assert_equal( RBA::A.instance_count, a_count )
 
   end
 
   def test_18
 
-    # Test references to objects (returned by b.b7)
+    # Test references to objects (returned by b.amember_cptr)
 
     b = RBA::B.new
-    b.b8( 77 )
+    b.set_an( 77 )
-    assert_equal( b.b7.a1c, 77 );
+    assert_equal( b.amember_cptr.a1c, 77 );
 
-    b.b8cref( 79 )
+    b.set_an_cref( 79 )
-    assert_equal( b.b7.a1c, 79 );
+    assert_equal( b.amember_cptr.a1c, 79 );
 
-    aref = b.b7
+    aref = b.amember_cptr
     err_caught = false
 
     if !$leak_check 
 
       begin 
-        x = aref.a1 # cannot call non-const method on const reference (as delivered by b7)
+        x = aref.a1 # cannot call non-const method on const reference (as delivered by amember_cptr)
       rescue
         err_caught = true
       end
@@ -905,7 +916,7 @@ class Basic_TestClass < TestBase
 
     end
 
-    b.b8( -1 )
+    b.set_an( -1 )
     assert_equal( aref.a1c, -1 );
 
   end
@@ -973,19 +984,19 @@ class Basic_TestClass < TestBase
 
     b = RBA::B.new
 
-    a1 = b.b14a( true )
+    a1 = b.amember_or_nil( true )
-    a2 = b.b14b
+    a2 = b.amember_ptr
     assert_equal( a1.a1, 17 )
     assert_equal( a2.a1, 17 )
     a1.a5( 761 )
     assert_equal( a1.a1, 761 )
     assert_equal( a2.a1, 761 )
 
-    a1 = b.b14a( false )
+    a1 = b.amember_or_nil( false )
     assert_equal( a1, nil )
     
-    assert_equal( b.b15( b.b14b ), true )
+    assert_equal( b.b15( b.amember_ptr ), true )
-    assert_equal( b.b15( b.b14a( false ) ), false )
+    assert_equal( b.b15( b.amember_or_nil( false ) ), false )
     assert_equal( b.b15( nil ), false )
 
   end
@@ -996,8 +1007,8 @@ class Basic_TestClass < TestBase
     
     b = RBA::B.new
     
-    b.b14b.s( 117 )
+    b.amember_ptr.s( 117 )
-    assert_equal( b.b14b.g, 117 )
+    assert_equal( b.amember_ptr.g, 117 )
 
     n = 0
     b.b10_nc { |a| a.s( n ); n += 1 } 
@@ -1138,10 +1149,10 @@ class Basic_TestClass < TestBase
     assert_equal( b.b32( "b", 25 ), 20.5 )
 
     GC.start
-    na = RBA::A::a0    # instance count
+    na = RBA::A::instance_count    # instance count
     assert_equal( b.bx( a, 15 ), "aref+i" )
     GC.start
-    assert_equal( RBA::A::a0, na )
+    assert_equal( RBA::A::instance_count, na )
     err_caught = false
     begin 
       # cannot cast second argument to int
@@ -1152,7 +1163,7 @@ class Basic_TestClass < TestBase
     assert_equal( err_caught, true )
     # the exception thrown before must not leave an instance on the call stack:
     GC.start
-    assert_equal( RBA::A::a0, na )
+    assert_equal( RBA::A::instance_count, na )
 
     err_caught = false
     begin 
@@ -1254,53 +1265,53 @@ class Basic_TestClass < TestBase
 
     # destruction of an instance via c++
     GC.start
-    ac0 = RBA::A.a0 
+    ic0 = RBA::A.instance_count 
 
     a = RBA::A::new
     a.create
     assert_equal(a.destroyed?, false)
-    assert_equal(RBA::A.a0, ac0 + 1)
+    assert_equal(RBA::A.instance_count, ic0 + 1)
     RBA::A.a20(a)    # install static instance of A
     assert_equal(a.destroyed?, false)
     RBA::A.a20(nil) 
-    assert_equal(RBA::A.a0, ac0)
+    assert_equal(RBA::A.instance_count, ic0)
     assert_equal(a.destroyed?, true)
 
     a = RBA::A::new
     a.create
     assert_equal(a.destroyed?, false)
-    assert_equal(RBA::A.a0, ac0 + 1)
+    assert_equal(RBA::A.instance_count, ic0 + 1)
     RBA::A.a20(a)    # install static instance of A
     assert_equal(a.destroyed?, false)
-    assert_equal(RBA::A.a0, ac0 + 1)
+    assert_equal(RBA::A.instance_count, ic0 + 1)
     RBA::A.a20(a)    # re-install static instance of A
     assert_equal(a.destroyed?, false)
-    assert_equal(RBA::A.a0, ac0 + 1)
+    assert_equal(RBA::A.instance_count, ic0 + 1)
     
     # install another instance
     aa = RBA::A::new
     aa.create
     assert_equal(aa.destroyed?, false)
-    assert_equal(RBA::A.a0, ac0 + 2)
+    assert_equal(RBA::A.instance_count, ic0 + 2)
     RBA::A.a20(aa)    # install static instance of A
 
     # original one is destroyed now, only new instance remains
     assert_equal(a.destroyed?, true)
     assert_equal(aa.destroyed?, false)
-    assert_equal(RBA::A.a0, ac0 + 1)
+    assert_equal(RBA::A.instance_count, ic0 + 1)
     RBA::A.a20(nil)    # discard installed instance
     assert_equal(aa.destroyed, true)
-    assert_equal(RBA::A.a0, ac0)
+    assert_equal(RBA::A.instance_count, ic0)
 
     # the same without create .. should work too, but not create an instance because of late 
     # instantiation in default ctor
     a = RBA::A::new
     assert_equal(a.destroyed?, false)
-    assert_equal(RBA::A.a0, ac0)
+    assert_equal(RBA::A.instance_count, ic0)
     RBA::A.a20(a)    # install static instance of A
     assert_equal(a.destroyed?, false)
     RBA::A.a20(nil) 
-    assert_equal(RBA::A.a0, ac0)
+    assert_equal(RBA::A.instance_count, ic0)
     assert_equal(a.destroyed?, true)
 
   end
@@ -1309,13 +1320,13 @@ class Basic_TestClass < TestBase
 
     # destruction of an instance via c++
     GC.start
-    ac0 = RBA::A.a0 
+    ic0 = RBA::A.instance_count 
 
     1.times do
       a = RBA::A::new
       a._create
       assert_equal(a.destroyed?, false)
-      assert_equal(RBA::A.a0, ac0 + 1)
+      assert_equal(RBA::A.instance_count, ic0 + 1)
       RBA::A.a20(a)    # install static instance of A
       assert_equal(RBA::A.a20_get == nil, false)
     end
@@ -1323,7 +1334,7 @@ class Basic_TestClass < TestBase
     # makes sure the objects inside the block before are deleted
     GC.start
 
-    assert_equal(RBA::A.a0, ac0)
+    assert_equal(RBA::A.instance_count, ic0)
     assert_equal(RBA::A.a20_get == nil, true)
 
     # "unmanage" will freeze the object and not make it destroyed by the GC
@@ -1331,7 +1342,7 @@ class Basic_TestClass < TestBase
       a = RBA::A::new
       a._create
       assert_equal(a.destroyed?, false)
-      assert_equal(RBA::A.a0, ac0 + 1)
+      assert_equal(RBA::A.instance_count, ic0 + 1)
       RBA::A.a20(a)    # install static instance of A
       assert_equal(RBA::A.a20_get == nil, false)
       a._unmanage
@@ -1340,7 +1351,7 @@ class Basic_TestClass < TestBase
     # makes sure the objects inside the block before are deleted
     GC.start
 
-    assert_equal(RBA::A.a0, ac0 + 1)
+    assert_equal(RBA::A.instance_count, ic0 + 1)
     assert_equal(RBA::A.a20_get == nil, false)
 
     # after "manage" the object gets volatile again
@@ -1352,7 +1363,7 @@ class Basic_TestClass < TestBase
     # makes sure the objects inside the block before are deleted
     GC.start
 
-    assert_equal(RBA::A.a0, ac0)
+    assert_equal(RBA::A.instance_count, ic0)
     assert_equal(RBA::A.a20_get == nil, true)
 
   end
@@ -1786,7 +1797,7 @@ class Basic_TestClass < TestBase
     assert_equal(1, yy.size)
     assert_equal("RBA::Y", yy[0].class.to_s)
     assert_equal(true, yy[0] != nil)
-    yy[0].destroy
+    yy[0]._destroy
     assert_equal(true, yy[0].destroyed?)
     assert_equal(yc, y.vx_dyn_count)