From 971ad89f0b37c7d712aa033f065031349e211349 Mon Sep 17 00:00:00 2001 From: Thomas Ferreira de Lima Date: Thu, 20 Dec 2018 22:38:01 -0500 Subject: [PATCH 1/4] brew qt 5.12 not supported in osx 10.11, reverting to qt 5.11.2 --- .travis.yml | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/.travis.yml b/.travis.yml index 014d8c940..8232608ff 100644 --- a/.travis.yml +++ b/.travis.yml @@ -225,10 +225,9 @@ matrix: homebrew: packages: - python3 - - qt update: true env: - - MATRIX_EVAL="" + - MATRIX_EVAL="brew update; brew config; brew install https://raw.githubusercontent.com/Homebrew/homebrew-core/56c500b569c724b049be7ab9e12d9693f85522f9/Formula/qt.rb" # Qt 5.11.2 - PYTHON_VERSION=B37 - MACOS_VERSION=ElCapitan - KLAYOUT_BUILD=true @@ -265,13 +264,8 @@ matrix: - name: "KLayout macOS 10.11 with py2.7" os: osx osx_image: xcode8 # macOS 10.11 - addons: - homebrew: - packages: - - qt - update: true env: - - MATRIX_EVAL="" + - MATRIX_EVAL="brew update; brew config; brew install https://raw.githubusercontent.com/Homebrew/homebrew-core/56c500b569c724b049be7ab9e12d9693f85522f9/Formula/qt.rb" # Qt 5.11.2 - PYTHON_VERSION=Sys - MACOS_VERSION=ElCapitan - KLAYOUT_BUILD=true From 7deea2706930f0938659eb031ea5a21fd91306e0 Mon Sep 17 00:00:00 2001 From: Thomas Ferreira de Lima Date: Wed, 2 Jan 2019 13:51:18 -0500 Subject: [PATCH 2/4] changing version to 0.26.0.dev11, release pypi wheels after merging #218 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 059f4b44c..e7455d296 100644 --- a/setup.py +++ b/setup.py @@ -322,7 +322,7 @@ class Config(object): """ Gets the version string """ - return "0.26.0.dev10" + return "0.26.0.dev11" config = Config() From e3b8d3635c30b9716b28531e9a204ff6ca163805 Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Wed, 2 Jan 2019 23:18:14 +0100 Subject: [PATCH 3/4] Small bugfix: object._destroy wasn't working for directly passed objects. --- src/gsi/gsi_test/gsiTest.cc | 24 +++--- src/gsi/gsi_test/gsiTest.h | 12 +-- src/pya/pya/pyaObject.cc | 2 +- src/rba/rba/rbaInternal.cc | 2 +- testdata/python/basic.py | 128 +++++++++++++++-------------- testdata/ruby/basic_testcore.rb | 139 +++++++++++++++++--------------- 6 files changed, 163 insertions(+), 144 deletions(-) diff --git a/src/gsi/gsi_test/gsiTest.cc b/src/gsi/gsi_test/gsiTest.cc index 1f5092e68..39a4b8119 100644 --- a/src/gsi/gsi_test/gsiTest.cc +++ b/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 decl_qflags_enum ("", "Enums"); static gsi::Class 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 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 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 ("b8|set_an", &B::b8) + - gsi::method ("b9|an", &B::b9) + - gsi::method ("b8cref|set_an_cref", &B::b8) + - gsi::method ("b9cref|an_cref", &B::b9) + + gsi::method ("make_a", &B::make_a) + + gsi::method ("set_an", &B::set_an) + + gsi::method ("an", &B::an) + + gsi::method ("set_an_cref", &B::set_an_cref) + + 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 ("b14b|amember_ptr", &B::amember_ptr) + - gsi::method ("b7|b14c|amember_cptr", &B::amember_cptr) + - gsi::method ("b7c|amember_cref", &B::amember_cref) + - gsi::method ("b7d|amember_ref", &B::amember_ref) + + gsi::method ("amember_or_nil_alt|amember_or_nil", &B::amember_or_nil) + + gsi::method ("amember_ptr_alt|amember_ptr", &B::amember_ptr) + + gsi::method ("xxx|amember_cptr", &B::amember_cptr) + + gsi::method ("yyy|amember_cref", &B::amember_cref) + + 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) + diff --git a/src/gsi/gsi_test/gsiTest.h b/src/gsi/gsi_test/gsiTest.h index ad3c367aa..7e11c815d 100644 --- a/src/gsi/gsi_test/gsiTest.h +++ b/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; } diff --git a/src/pya/pya/pyaObject.cc b/src/pya/pya/pyaObject.cc index 3ed8d126d..8c1768e9b 100644 --- a/src/pya/pya/pyaObject.cc +++ b/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"))); } diff --git a/src/rba/rba/rbaInternal.cc b/src/rba/rba/rbaInternal.cc index 2b9e2dcfd..f5dc134a8 100644 --- a/src/rba/rba/rbaInternal.cc +++ b/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"))); } diff --git a/testdata/python/basic.py b/testdata/python/basic.py index eb495d0c8..eb459411d 100644 --- a/testdata/python/basic.py +++ b/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 ); - self.assertEqual( b.b9cref( aa ), -61 ); + aa = b.make_a( -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 ) - self.assertEqual( b.b7().a1c(), 77 ); + b.set_an( 77 ) + self.assertEqual( b.amember_cptr().a1c(), 77 ); - b.b8cref( 79 ) - self.assertEqual( b.b7().a1c(), 79 ); + b.set_an_cref( 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 ) - a2 = b.b14b() + a1 = b.amember_or_nil_alt( True ) + 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.b14a( False ) ), False ) + self.assertEqual( b.b15( b.amember_ptr() ), True ) + 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 ... - b.b14b().s( 117 ) - self.assertEqual( b.b14b().g(), 117 ) + # amember_ptr() returns a pya.A object, but it cannot be extended dynamically by a method s ... + b.amember_ptr().s( 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): diff --git a/testdata/ruby/basic_testcore.rb b/testdata/ruby/basic_testcore.rb index 059d92e79..467ceaccf 100644 --- a/testdata/ruby/basic_testcore.rb +++ b/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 - assert_equal( ac0, 0 ) + ic0 = RBA::A::instance_count + 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 ); - assert_equal( a.a1, 1971 ); - assert_equal( b.b9( a ), 1971 ); + GC.start + a_count = RBA::A.instance_count + 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 ) - assert_equal( b.b7.a1c, 77 ); + b.set_an( 77 ) + assert_equal( b.amember_cptr.a1c, 77 ); - b.b8cref( 79 ) - assert_equal( b.b7.a1c, 79 ); + b.set_an_cref( 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 ) - a2 = b.b14b + a1 = b.amember_or_nil( true ) + 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.b14a( false ) ), false ) + assert_equal( b.b15( b.amember_ptr ), true ) + 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 ) - assert_equal( b.b14b.g, 117 ) + b.amember_ptr.s( 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) From bcac78235b2b2675f5f38c9034219f274ffcb86b Mon Sep 17 00:00:00 2001 From: Matthias Koefferlein Date: Fri, 4 Jan 2019 01:59:52 +0100 Subject: [PATCH 4/4] Fixed a testsuite fail after last commit. --- src/gsi/unit_tests/gsiExpression.cc | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/gsi/unit_tests/gsiExpression.cc b/src/gsi/unit_tests/gsiExpression.cc index 960c30c1a..ea87f5e8d 100644 --- a/src/gsi/unit_tests/gsiExpression.cc +++ b/src/gsi/unit_tests/gsiExpression.cc @@ -38,14 +38,14 @@ TEST(1) tl::Eval e; tl::Variant v; - v = e.parse ("A.a0").execute (); + v = e.parse ("A.instance_count").execute (); int base_insts = v.to_int (); EXPECT_EQ (base_insts, 0); v = e.parse ("A.new(35).to_s").execute (); EXPECT_EQ (v.to_string (), std::string ("A: 35")); - EXPECT_EQ (e.parse ("A.a0").execute ().to_int (), 0); + EXPECT_EQ (e.parse ("A.instance_count").execute ().to_int (), 0); // mapping of to_string to to_s method v = e.parse ("A.new(35)").execute (); @@ -97,11 +97,11 @@ TEST(1) EXPECT_EQ (v.to_string (), std::string ("0.125")); v = e.parse ("a.a4([5, 1, -1.25])").execute (); EXPECT_EQ (v.to_string (), std::string ("-1.25")); - v = e.parse ("A.a0").execute (); + v = e.parse ("A.instance_count").execute (); EXPECT_EQ (v.to_int (), base_insts + 1); // one instance more - v = e.parse ("a=1; A.a0").execute (); + v = e.parse ("a=1; A.instance_count").execute (); EXPECT_EQ (v.to_int (), base_insts); // remaining instances - v = e.parse ("A.a0").execute (); + v = e.parse ("A.instance_count").execute (); EXPECT_EQ (v.to_int (), base_insts); // remaining instances v = e.parse ("var a1=A.new; a1.a5(-15); var a2=a1.dup; a2.a5(107); a1.a1").execute ();