luke
/
klayout
mirror of https://github.com/KLayout/klayout.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master' into azure/windows

This commit is contained in:
Thomas Ferreira de Lima 2019-01-04 03:44:54 -05:00
parent 7d2bfc9799 bcac78235b
commit fc9da12b4b
No known key found for this signature in database
GPG Key ID: 43E98870EAA0A86E
9 changed files with 171 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.travis.yml
View File

@ -467,11 +467,9 @@ matrix:
homebrew:
packages:
- python3
- qt
- ccache
update: true
env:
- MATRIX_EVAL="brew update; brew install qt" # homebrew addon fails for xcode8
- 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
@ -516,11 +514,10 @@ matrix:
addons:
homebrew:
packages:
- qt
- ccache
update: true
env:
- MATRIX_EVAL="brew update; brew install qt" # homebrew addon fails for xcode8
- 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

2
setup.py
View File

@ -322,7 +322,7 @@ class Config(object):
"""
Gets the version string
"""
return "0.26.0.dev10"
return "0.26.0.dev11"
config = Config()

24
src/gsi/gsi_test/gsiTest.cc
View File

@ -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 ("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) +

12
src/gsi/gsi_test/gsiTest.h
View File

@ -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;
}

10
src/gsi/unit_tests/gsiExpression.cc
View File

@ -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 ();

2
src/pya/pya/pyaObject.cc
View File

@ -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")));
}

2
src/rba/rba/rbaInternal.cc
View File

@ -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")));
}

128
testdata/python/basic.py vendored
View File

@ -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):

139
testdata/ruby/basic_testcore.rb vendored
View File

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