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

Merge pull request #1546 from KLayout/issue-1530 

Issue 1530 - size-2 tuples for points
This commit is contained in:
Matthias Köfferlein 2023-11-26 22:18:52 +01:00 committed by GitHub
parent 0e9849c32b 5a0b7e9fb5
commit 3b83230de0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 746 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
src/gsi/gsi/gsiExpression.cc
View File

@ -286,6 +286,25 @@ struct test_arg_func<gsi::ObjectType>
return;
}
if (arg.is_list ()) {
// we may implicitly convert an array into a constructor call of a target object -
// for now we only check whether the number of arguments is compatible with the array given.
int n = int (arg.size ());
*ret = false;
for (gsi::ClassBase::method_iterator c = atype.cls ()->begin_constructors (); c != atype.cls ()->end_constructors (); ++c) {
if ((*c)->compatible_with_num_args (n)) {
*ret = true;
break;
}
}
return;
}
if (! arg.is_user ()) {
*ret = false;
return;
@ -620,6 +639,8 @@ struct writer<gsi::VoidType>
}
};
void push_args (gsi::SerialArgs &arglist, const tl::Variant &args, const gsi::MethodBase *meth, tl::Heap *heap);
/**
* @brief Specialization for void
*/
@ -628,29 +649,67 @@ struct writer<gsi::ObjectType>
{
void operator() (gsi::SerialArgs *aa, tl::Variant *arg, const gsi::ArgType &atype, tl::Heap *heap)
{
if (atype.is_ref () || atype.is_cref () || atype.is_ptr () || atype.is_cptr ()) {
if (arg->is_nil ()) {
if (arg->is_nil ()) {
if (atype.is_ref () || atype.is_cref ()) {
throw tl::Exception (tl::to_string (tr ("Cannot pass nil to reference parameters")));
} else if (! atype.is_cptr () && ! atype.is_ptr ()) {
throw tl::Exception (tl::to_string (tr ("Cannot pass nil to direct parameters")));
}
if (atype.is_ref () || atype.is_cref ()) {
throw tl::Exception (tl::to_string (tr ("Cannot pass nil to reference parameters")));
aa->write<void *> ((void *) 0);
} else if (arg->is_list ()) {
// we may implicitly convert an array into a constructor call of a target object -
// for now we only check whether the number of arguments is compatible with the array given.
int n = int (arg->size ());
const gsi::MethodBase *meth = 0;
for (gsi::ClassBase::method_iterator c = atype.cls ()->begin_constructors (); c != atype.cls ()->end_constructors (); ++c) {
if ((*c)->compatible_with_num_args (n)) {
meth = *c;
break;
}
}
aa->write<void *> ((void *) 0);
if (!meth) {
throw tl::Exception (tl::to_string (tr ("No constructor of %s available that takes %d arguments (implicit call from tuple)")), atype.cls ()->name (), n);
}
} else {
// implicit call of constructor
gsi::SerialArgs retlist (meth->retsize ());
gsi::SerialArgs arglist (meth->argsize ());
if (! arg->is_user ()) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
push_args (arglist, *arg, meth, heap);
const tl::VariantUserClassBase *cls = arg->user_cls ();
if (!cls) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
if (cls->is_const () && (atype.is_ref () || atype.is_ptr ())) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Cannot pass a const reference of class %s to a non-const reference or pointer parameter")), atype.cls ()->name ()));
}
meth->call (0, arglist, retlist);
void *new_obj = retlist.read<void *> (*heap);
if (new_obj && (atype.is_ptr () || atype.is_cptr () || atype.is_ref () || atype.is_cref ())) {
// For pointers or refs, ownership over these objects is not transferred.
// Hence we have to keep them on the heap.
// TODO: what if the called method takes ownership using keep()?
heap->push (new gsi::ObjectHolder (atype.cls (), new_obj));
}
aa->write<void *> (new_obj);
} else {
if (! arg->is_user ()) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
const tl::VariantUserClassBase *cls = arg->user_cls ();
if (!cls) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
if (cls->is_const () && (atype.is_ref () || atype.is_ptr ())) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Cannot pass a const reference of class %s to a non-const reference or pointer parameter")), atype.cls ()->name ()));
}
if (atype.is_ref () || atype.is_cref () || atype.is_ptr () || atype.is_cptr ()) {
if (cls->gsi_cls ()->is_derived_from (atype.cls ())) {
@ -673,36 +732,24 @@ struct writer<gsi::ObjectType>
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
}
} else {
} else {
if (cls->gsi_cls ()->is_derived_from (atype.cls ())) {
if (! arg->is_user ()) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
if (cls->gsi_cls ()->adapted_type_info ()) {
aa->write<void *> (cls->gsi_cls ()->create_adapted_from_obj (get_object (*arg)));
} else {
aa->write<void *> ((void *) cls->gsi_cls ()->clone (get_object (*arg)));
}
const tl::VariantUserClassBase *cls = arg->user_cls ();
if (!cls) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
if (cls->is_const () && (atype.is_ref () || atype.is_ptr ())) {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Cannot pass a const reference of class %s to a non-const reference or pointer parameter")), atype.cls ()->name ()));
}
} else if (cls->gsi_cls ()->can_convert_to (atype.cls ())) {
if (cls->gsi_cls ()->is_derived_from (atype.cls ())) {
aa->write<void *> (atype.cls ()->create_obj_from (cls->gsi_cls (), get_object (*arg)));
if (cls->gsi_cls ()->adapted_type_info ()) {
aa->write<void *> (cls->gsi_cls ()->create_adapted_from_obj (get_object (*arg)));
} else {
aa->write<void *> ((void *) cls->gsi_cls ()->clone (get_object (*arg)));
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
} else if (cls->gsi_cls ()->can_convert_to (atype.cls ())) {
aa->write<void *> (atype.cls ()->create_obj_from (cls->gsi_cls (), get_object (*arg)));
} else {
throw tl::Exception (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s)")), atype.cls ()->name ()));
}
}
@ -710,6 +757,23 @@ struct writer<gsi::ObjectType>
}
};
void push_args (gsi::SerialArgs &arglist, const tl::Variant &args, const gsi::MethodBase *meth, tl::Heap *heap)
{
int n = int (args.size ());
int narg = 0;
for (gsi::MethodBase::argument_iterator a = meth->begin_arguments (); a != meth->end_arguments () && narg < n; ++a, ++narg) {
try {
// Note: this const_cast is ugly, but it will basically enable "out" parameters
// TODO: clean this up.
gsi::do_on_type<writer> () (a->type (), &arglist, const_cast<tl::Variant *> ((args.get_list ().begin () + narg).operator-> ()), *a, heap);
} catch (tl::Exception &ex) {
std::string msg = ex.msg () + tl::sprintf (tl::to_string (tr (" (argument '%s')")), a->spec ()->name ());
throw tl::Exception (msg);
}
}
}
// ---------------------------------------------------------------------
// Reader function for serialization

10
src/gsi/gsi/gsiSerialisation.cc
View File

@ -23,6 +23,7 @@
#include "gsi.h"
#include "gsiSerialisation.h"
#include "tlLog.h"
namespace gsi
{
@ -38,7 +39,14 @@ public:
~AdaptorSynchronizer ()
{
mp_src->copy_to (mp_target, *mp_heap);
try {
// NOTE: exceptions must not escape destructors as a basic C++ design requirement
mp_src->copy_to (mp_target, *mp_heap);
} catch (tl::Exception &ex) {
tl::error << ex.msg ();
} catch (...) {
}
delete mp_src;
delete mp_target;
mp_src = 0;

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

@ -65,6 +65,20 @@ A::A (int nn) {
f = false;
}
A::A (int n1, int n2) {
++a_count;
e = Enum (0);
n = n1 + n2;
f = false;
}
A::A (int n1, int n2, double n3) {
++a_count;
e = Enum (0);
n = (n1 + n2) * n3;
f = false;
}
A::A (const A &a)
: gsi::ObjectBase (a)
{
@ -339,7 +353,17 @@ static A *a_ctor (int i)
return new A (i);
}
void A::a20 (A *ptr)
static A *a_ctor2 (int i, int j)
{
return new A (i, j);
}
static A *a_ctor3 (int i, int j, double f)
{
return new A (i, j, f);
}
void A::a20 (A *ptr)
{
if (a_inst.get () != ptr) {
a_inst.reset (ptr);
@ -360,26 +384,26 @@ static int b_count = 0;
B::B ()
{
++b_count;
av.push_back (A (100));
av.push_back (A (121));
av.push_back (A (144));
avc_nc.push_back (new A_NC (-3100));
avc_nc.push_back (new A_NC (-3121));
av_nc.push_back (new A_NC (7100));
av_nc.push_back (new A_NC (7121));
av_nc.push_back (new A_NC (7144));
av_nc.push_back (new A_NC (7169));
m_av.push_back (A (100));
m_av.push_back (A (121));
m_av.push_back (A (144));
m_avc_nc.push_back (new A_NC (-3100));
m_avc_nc.push_back (new A_NC (-3121));
m_av_nc.push_back (new A_NC (7100));
m_av_nc.push_back (new A_NC (7121));
m_av_nc.push_back (new A_NC (7144));
m_av_nc.push_back (new A_NC (7169));
}
B::~B ()
{
while (! av_nc.empty ()) {
delete av_nc.back ();
av_nc.pop_back ();
while (! m_av_nc.empty ()) {
delete m_av_nc.back ();
m_av_nc.pop_back ();
}
while (! avc_nc.empty ()) {
delete const_cast<A_NC *> (avc_nc.back ());
avc_nc.pop_back ();
while (! m_avc_nc.empty ()) {
delete const_cast<A_NC *> (m_avc_nc.back ());
m_avc_nc.pop_back ();
}
if (b_inst == this) {
b_inst = 0;
@ -405,22 +429,22 @@ B &B::operator=(const B &d)
}
m = d.m;
a = d.a;
bv = d.bv;
av = d.av;
while (! av_nc.empty ()) {
delete av_nc.back ();
av_nc.pop_back ();
m_a = d.m_a;
m_bv = d.m_bv;
m_av = d.m_av;
while (! m_av_nc.empty ()) {
delete m_av_nc.back ();
m_av_nc.pop_back ();
}
for (std::vector <A_NC *>::const_iterator i = d.av_nc.begin (); i != d.av_nc.end (); ++i) {
av_nc.push_back (new A_NC (**i));
for (std::vector <A_NC *>::const_iterator i = d.m_av_nc.begin (); i != d.m_av_nc.end (); ++i) {
m_av_nc.push_back (new A_NC (**i));
}
while (! avc_nc.empty ()) {
delete const_cast<A_NC *> (avc_nc.back ());
avc_nc.pop_back ();
while (! m_avc_nc.empty ()) {
delete const_cast<A_NC *> (m_avc_nc.back ());
m_avc_nc.pop_back ();
}
for (std::vector <const A_NC *>::const_iterator i = d.avc_nc.begin (); i != d.avc_nc.end (); ++i) {
avc_nc.push_back (new A_NC (**i));
for (std::vector <const A_NC *>::const_iterator i = d.m_avc_nc.begin (); i != d.m_avc_nc.end (); ++i) {
m_avc_nc.push_back (new A_NC (**i));
}
m_var = d.m_var;
m_vars = d.m_vars;
@ -461,7 +485,7 @@ std::string B::addr () const
return c;
}
static int b3_ext (const B *b, A *aptr)
static int aptr_to_n_ext (const B *b, A *aptr)
{
return b->b3 (aptr);
}
@ -1030,6 +1054,8 @@ static gsi::QFlagsClass<Enum> decl_qflags_enum ("", "Enums");
static gsi::Class<A> decl_a ("", "A",
gsi::constructor ("new_a|new", &a_ctor) +
gsi::constructor ("new", &a_ctor2) +
gsi::constructor ("new", &a_ctor3) +
gsi::method ("instance_count", &A::instance_count) +
gsi::method ("new_a_by_variant", &A::new_a_by_variant) +
@ -1146,8 +1172,8 @@ 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 ("a1", &A::a1) +
gsi::method ("a1c", &A::a1c) +
gsi::method ("a1|get_n", &A::a1) +
gsi::method ("a1c|get_n_const", &A::a1c) +
gsi::method ("a2", &A::a2) +
gsi::method ("a3", &A::a3) +
#if defined(HAVE_QT)
@ -1262,8 +1288,8 @@ static gsi::Class<B> decl_b ("", "B",
gsi::method ("set_str", &B::set_str) +
gsi::method ("str_ccptr", &B::str_ccptr) +
gsi::method ("set_str_combine", &B::set_str_combine) +
gsi::method_ext ("b3|aptr_to_n", &b3_ext) +
gsi::method ("b4|aref_to_s", &B::b4) +
gsi::method_ext ("b3|aptr_to_n", &aptr_to_n_ext) +
gsi::method ("b4|aref_to_s", &B::aref_to_s) +
gsi::method ("make_a", &B::make_a) +
gsi::method ("set_an", &B::set_an) +
gsi::method ("an", &B::an) +
@ -1280,18 +1306,23 @@ static gsi::Class<B> decl_b ("", "B",
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) +
gsi::method ("b16c|av_ref", &B::b16c) +
gsi::method ("b17a|av_cref=", &B::b17a) +
gsi::method ("b17b|av_ref=", &B::b17b) +
gsi::method ("b17c|av=", &B::b17c) +
gsi::method ("b17d|av_cptr=", &B::b17d) +
gsi::method ("b17e|av_ptr=", &B::b17e) +
gsi::iterator ("b18", &B::b18) +
gsi::iterator ("b18b", &B::b18b) +
gsi::iterator ("b18c", &B::b18b) +
gsi::method ("b15|arg_is_not_nil", &B::arg_is_not_nil) +
gsi::method ("b16a|av", &B::av) +
gsi::method ("b16b|av_cref", &B::av_cref) +
gsi::method ("b16c|av_ref", &B::av_ref) +
gsi::method ("push_a", &B::push_a) +
gsi::method ("push_a_cref", &B::push_a_cref) +
gsi::method ("push_a_cptr", &B::push_a_cptr) +
gsi::method ("push_a_ref", &B::push_a_ref) +
gsi::method ("push_a_ptr", &B::push_a_ptr) +
gsi::method ("b17a|av_cref=", &B::set_av_cref) +
gsi::method ("b17b|av_ref=", &B::set_av_ref) +
gsi::method ("b17c|av=", &B::set_av) +
gsi::method ("b17d|av_cptr=", &B::set_av_cptr) +
gsi::method ("b17e|av_ptr=", &B::set_av_ptr) +
gsi::iterator ("b18|each_a", &B::b18) +
gsi::iterator ("b18b|each_a_ref", &B::b18b) +
gsi::iterator ("b18c|each_a_ptr", &B::b18c) +
gsi::method ("b20a|var_is_nil", &B::b20a) +
gsi::method ("b20b|var_is_double", &B::b20b) +
gsi::method ("b20c|var_is_long", &B::b20c) +

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

@ -73,7 +73,17 @@ struct A
*/
A (int nn);
/**
/**
* @brief Parametrized constructor 2
*/
A (int n1, int n2);
/**
* @brief Parametrized constructor 3
*/
A (int n1, int n2, double n3);
/**
* @brief Copy constructor
*/
A (const A &a);
@ -640,7 +650,7 @@ struct B
return aptr->n;
}
std::string b4 (const A &aref) {
std::string aref_to_s (const A &aref) {
return tl::sprintf ("b4_result: %d", aref.n);
}
@ -650,7 +660,7 @@ struct B
void set_an (int n)
{
a.n = n;
m_a.n = n;
}
int an (A a)
@ -660,7 +670,7 @@ struct B
void set_an_cref (const int &n)
{
a.n = n;
m_a.n = n;
}
const int &an_cref (const A &a)
@ -670,122 +680,155 @@ struct B
std::vector <A>::const_iterator b10b () const
{
return av.begin ();
return m_av.begin ();
}
std::vector <A>::const_iterator b10e () const
{
return av.end ();
return m_av.end ();
}
std::vector <A>::iterator b10b_nc ()
{
return av.begin ();
return m_av.begin ();
}
std::vector <A>::iterator b10e_nc ()
{
return av.end ();
return m_av.end ();
}
ValueIter<std::vector <A>::const_iterator> b11b () const
{
return ValueIter<std::vector <A>::const_iterator> (av.begin ());
return ValueIter<std::vector <A>::const_iterator> (m_av.begin ());
}
ValueIter<std::vector <A>::const_iterator> b11e () const
{
return ValueIter<std::vector <A>::const_iterator> (av.end ());
return ValueIter<std::vector <A>::const_iterator> (m_av.end ());
}
std::vector <A_NC *>::const_iterator b12b () const
{
return av_nc.begin ();
return m_av_nc.begin ();
}
std::vector <A_NC *>::const_iterator b12e () const
{
return av_nc.end ();
return m_av_nc.end ();
}
std::vector <const A_NC *>::const_iterator b13b () const
{
return avc_nc.begin ();
return m_avc_nc.begin ();
}
std::vector <const A_NC *>::const_iterator b13e () const
{
return avc_nc.end ();
return m_avc_nc.end ();
}
A *amember_or_nil (bool nn) { return nn ? &a : 0; }
A *amember_ptr () { return &a; }
A &amember_ref () { return a; }
const A *amember_cptr () const { return &a; }
const A &amember_cref () const { return a; }
A *amember_or_nil (bool nn) { return nn ? &m_a : 0; }
A *amember_ptr () { return &m_a; }
A &amember_ref () { return m_a; }
const A *amember_cptr () const { return &m_a; }
const A &amember_cref () const { return m_a; }
bool b15 (A *a)
bool arg_is_not_nil (A *a)
{
return a != 0;
}
std::vector <A> b16a () const
std::vector <A> av () const
{
return av;
return m_av;
}
const std::vector <A> &b16b () const
const std::vector <A> &av_cref () const
{
return av;
return m_av;
}
std::vector <A> &b16c ()
std::vector <A> &av_ref ()
{
return av;
return m_av;
}
void b17a (const std::vector <A> &v)
void set_av_cref (const std::vector <A> &v)
{
av = v;
m_av = v;
}
void b17b (std::vector <A> &v)
void set_av_ref (std::vector <A> &v)
{
av = v;
m_av = v;
}
void b17c (std::vector <A> v)
void set_av (std::vector <A> v)
{
av = v;
m_av = v;
}
void b17d (const std::vector <A> *v)
void set_av_cptr (const std::vector <A> *v)
{
if (v) {
av = *v;
m_av = *v;
} else {
m_av.clear ();
}
}
void b17e (std::vector <A> *v)
void set_av_ptr (std::vector <A> *v)
{
if (v) {
av = *v;
m_av = *v;
} else {
m_av.clear ();
}
}
void push_a (A a)
{
m_av.push_back (a);
}
void push_a_cref (const A &a)
{
m_av.push_back (a);
}
void push_a_ref (A &a)
{
m_av.push_back (a);
}
void push_a_cptr (const A *a)
{
if (a) {
m_av.push_back (*a);
}
}
void push_a_ptr (A *a)
{
if (a) {
m_av.push_back (*a);
}
}
FreeIter<std::vector <A>::const_iterator> b18 () const
{
return FreeIter<std::vector <A>::const_iterator> (av.begin (), av.end ());
return FreeIter<std::vector <A>::const_iterator> (m_av.begin (), m_av.end ());
}
FreeIterUseRef<std::vector <A>::const_iterator> b18b () const
{
return FreeIterUseRef<std::vector <A>::const_iterator> (av.begin (), av.end ());
return FreeIterUseRef<std::vector <A>::const_iterator> (m_av.begin (), m_av.end ());
}
FreeIterUsePtr<std::vector <A>::const_iterator> b18c () const
{
return FreeIterUsePtr<std::vector <A>::const_iterator> (av.begin (), av.end ());
return FreeIterUsePtr<std::vector <A>::const_iterator> (m_av.begin (), m_av.end ());
}
bool b20a (const tl::Variant &var) const { return var.is_nil (); }
@ -862,30 +905,30 @@ struct B
FreeIter<std::vector <B>::const_iterator> each_b_copy () const
{
return FreeIter<std::vector <B>::const_iterator> (bv.begin (), bv.end ());
return FreeIter<std::vector <B>::const_iterator> (m_bv.begin (), m_bv.end ());
}
FreeIterUseRef<std::vector <B>::const_iterator> each_b_cref () const
{
return FreeIterUseRef<std::vector <B>::const_iterator> (bv.begin (), bv.end ());
return FreeIterUseRef<std::vector <B>::const_iterator> (m_bv.begin (), m_bv.end ());
}
FreeIterUsePtr<std::vector <B>::const_iterator> each_b_cptr () const
{
return FreeIterUsePtr<std::vector <B>::const_iterator> (bv.begin (), bv.end ());
return FreeIterUsePtr<std::vector <B>::const_iterator> (m_bv.begin (), m_bv.end ());
}
FreeIterUseRef<std::vector <B>::iterator> each_b_ref ()
{
return FreeIterUseRef<std::vector <B>::iterator> (bv.begin (), bv.end ());
return FreeIterUseRef<std::vector <B>::iterator> (m_bv.begin (), m_bv.end ());
}
FreeIterUsePtr<std::vector <B>::iterator> each_b_ptr ()
{
return FreeIterUsePtr<std::vector <B>::iterator> (bv.begin (), bv.end ());
return FreeIterUsePtr<std::vector <B>::iterator> (m_bv.begin (), m_bv.end ());
}
void push_b (const B &b) { bv.push_back (b); }
void push_b (const B &b) { m_bv.push_back (b); }
std::map<int, A *> map_iaptr () { return m_map_iaptr; }
const std::map<int, A *> &map_iaptr_cref () { return m_map_iaptr; }
@ -996,11 +1039,11 @@ struct B
#endif
std::string m;
A a;
std::vector <B> bv;
std::vector <A> av;
std::vector <A_NC *> av_nc;
std::vector <const A_NC *> avc_nc;
A m_a;
std::vector <B> m_bv;
std::vector <A> m_av;
std::vector <A_NC *> m_av_nc;
std::vector <const A_NC *> m_avc_nc;
tl::Variant m_var;
std::vector<tl::Variant> m_vars;
std::map<int, std::string> m_map1;

55
src/gsi/unit_tests/gsiExpressionTests.cc
View File

@ -57,14 +57,14 @@ TEST(1)
v = e.parse ("A.aa").execute ();
EXPECT_EQ (v.to_string (), std::string ("static_a"));
v = e.parse ("A.new.a1").execute ();
v = e.parse ("A.new.get_n").execute ();
EXPECT_EQ (v.to_string (), std::string ("17"));
v = e.parse ("var a=A.new").execute ();
v = e.parse ("a.a5(-5); a.a1").execute ();
v = e.parse ("a.a5(-5); a.get_n").execute ();
EXPECT_EQ (v.to_string (), std::string ("-5"));
// mapping of property assignment to method
v = e.parse ("a.n = -177; a.a1").execute ();
v = e.parse ("a.n = -177; a.get_n").execute ();
EXPECT_EQ (v.to_string (), std::string ("-177"));
bool error = false;
try {
@ -104,9 +104,9 @@ TEST(1)
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 ();
v = e.parse ("var a1=A.new; a1.a5(-15); var a2=a1.dup; a2.a5(107); a1.get_n").execute ();
EXPECT_EQ (v.to_string (), std::string ("-15"));
v = e.parse ("var a1=A.new; a1.a5(-15); var a2=a1.dup; a2.a5(107); a2.a1").execute ();
v = e.parse ("var a1=A.new; a1.a5(-15); var a2=a1.dup; a2.a5(107); a2.get_n").execute ();
EXPECT_EQ (v.to_string (), std::string ("107"));
v = e.parse ("var a=A.new; a.get_e.to_s").execute ();
@ -218,12 +218,22 @@ TEST(2)
EXPECT_EQ (v.to_string (), std::string ("5"));
v = e.parse ("var b=B.new; var a1=A.new(-17); var a2=A.new(42); b.av = [ a1, a2 ]; to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: -17,A: 42"));
v = e.parse ("var b=B.new; var a1=A.new(-17); var a2=A.new(42); b.av = []; b.push_a(a1); b.push_a(a2); to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: -17,A: 42"));
v = e.parse ("var b=B.new; var a1=A.new(-17); var a2=A.new(42); b.av = []; b.push_a_cref(a1); b.push_a_cptr(a2); to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: -17,A: 42"));
v = e.parse ("var b=B.new; var a1=A.new(-17); var a2=A.new(42); b.av = []; b.push_a_ref(a1); b.push_a_ptr(a2); to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: -17,A: 42"));
v = e.parse ("var b=B.new; var a1=A.new(-17); var a2=A.new(1); b.av_cref = [ a1, a2 ]; to_s(b.av_cref)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: -17,A: 1"));
v = e.parse ("var b=B.new; b.av = [ A.new(-13) ]; b.av_cptr = nil; to_s(b.av)").execute ();
v = e.parse ("var b=B.new; b.av_cptr = [ A.new(-13) ]; to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: -13"));
v = e.parse ("var b=B.new; b.av = [ A.new(13) ]; b.av_ptr = nil; to_s(b.av)").execute ();
v = e.parse ("var b=B.new; b.av_ptr = [ A.new(13) ]; to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: 13"));
v = e.parse ("var b=B.new; b.av = [ A.new(-13) ]; b.av_cptr = nil; to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string (""));
v = e.parse ("var b=B.new; b.av = [ A.new(13) ]; b.av_ptr = nil; to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string (""));
v = e.parse ("var b=B.new; var a1=A.new(17); b.av_ref = [ a1 ]; to_s(b.av_ref)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: 17"));
v = e.parse ("var b=B.new; b.arg_is_not_nil(nil)").execute ();
@ -234,6 +244,21 @@ TEST(2)
EXPECT_EQ (v.to_string (), std::string ("17"));
v = e.parse ("var b=B.new; b.bx(-1)").execute ();
EXPECT_EQ (v.to_string (), std::string ("xz"));
// List to constructor call
v = e.parse ("var b=B.new; b.av = [ [5, 6], [4, 6, 0.5], [42] ]; to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: 11,A: 5,A: 42"));
v = e.parse ("var b=B.new; b.av = []; b.push_a([ 1, 2 ]); b.push_a([ 17 ]); to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: 3,A: 17"));
v = e.parse ("var b=B.new; b.av = []; b.push_a([ 1, 2 ]); b.push_a_cref([ 17 ]); to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: 3,A: 17"));
v = e.parse ("var b=B.new; b.av = []; b.push_a([ 1, 2 ]); b.push_a_cptr([ 17 ]); to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: 3,A: 17"));
v = e.parse ("var b=B.new; b.av = []; b.push_a([ 1, 2 ]); b.push_a_ref([ 17 ]); to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: 3,A: 17"));
v = e.parse ("var b=B.new; b.av = []; b.push_a([ 1, 2 ]); b.push_a_ptr([ 17 ]); to_s(b.av)").execute ();
EXPECT_EQ (v.to_string (), std::string ("A: 3,A: 17"));
/*
TODO: No detailed type analysis for ambiguity resolution so far:
v = e.parse ("var b=B.new; b.bx('hello', 1)").execute ();
@ -316,15 +341,15 @@ TEST(2)
EXPECT_EQ (v.to_string (), std::string ("A: 177"));
v = e.parse ("b.amember_or_nil(false)").execute ();
EXPECT_EQ (v.to_string (), std::string ("nil"));
v = e.parse ("b.amember_ptr.a5(177); b.amember_ref.a1").execute ();
v = e.parse ("b.amember_ptr.a5(177); b.amember_ref.get_n").execute ();
EXPECT_EQ (v.to_string (), std::string ("177"));
v = e.parse ("b.amember_ref.a1c").execute ();
v = e.parse ("b.amember_ref.get_n_const").execute ();
EXPECT_EQ (v.to_string (), std::string ("177"));
v = e.parse ("b.amember_cref.a1c").execute ();
v = e.parse ("b.amember_cref.get_n_const").execute ();
EXPECT_EQ (v.to_string (), std::string ("177"));
error = false;
try {
v = e.parse ("b.amember_cref.a1").execute ();
v = e.parse ("b.amember_cref.get_n").execute ();
} catch (...) {
// can't call non-const method on const ref
error = true;
@ -334,16 +359,16 @@ TEST(2)
// references: storage in variables
v = e.parse ("var aref = b.amember_ptr").execute ();
v = e.parse ("aref.n = 178").execute ();
v = e.parse ("aref.a1").execute ();
v = e.parse ("aref.get_n").execute ();
EXPECT_EQ (v.to_string (), std::string ("178"));
v = e.parse ("aref.a1 == 178").execute ();
v = e.parse ("aref.get_n == 178").execute ();
EXPECT_EQ (v.to_string (), std::string ("true"));
v = e.parse ("b.amember_ref.a1").execute ();
v = e.parse ("b.amember_ref.get_n").execute ();
EXPECT_EQ (v.to_string (), std::string ("178"));
// references: storage in variables
v = e.parse ("var aref = b.amember_cptr").execute ();
v = e.parse ("aref.a1c").execute ();
v = e.parse ("aref.get_n_const").execute ();
EXPECT_EQ (v.to_string (), std::string ("178"));
error = false;
try {

27
src/pya/pya/pyaCallables.cc
View File

@ -200,7 +200,8 @@ match_method (int mid, PyObject *self, PyObject *args, bool strict)
tl_assert (cls_decl != 0);
int argc = args == NULL ? 0 : int (PyTuple_Size (args));
bool is_tuple = PyTuple_Check (args);
int argc = args == NULL ? 0 : (is_tuple ? int (PyTuple_Size (args)) : int (PyList_Size (args)));
// get number of candidates by argument count
const gsi::MethodBase *meth = 0;
@ -277,9 +278,10 @@ match_method (int mid, PyObject *self, PyObject *args, bool strict)
int sc = 0;
int i = 0;
for (gsi::MethodBase::argument_iterator a = (*m)->begin_arguments (); is_valid && i < argc && a != (*m)->end_arguments (); ++a, ++i) {
if (test_arg (*a, PyTuple_GetItem (args, i), false /*strict*/)) {
PyObject *arg = is_tuple ? PyTuple_GetItem (args, i) : PyList_GetItem (args, i);
if (test_arg (*a, arg, false /*strict*/)) {
++sc;
} else if (test_arg (*a, PyTuple_GetItem (args, i), true /*loose*/)) {
} else if (test_arg (*a, arg, true /*loose*/)) {
// non-scoring match
} else {
is_valid = false;
@ -326,7 +328,8 @@ match_method (int mid, PyObject *self, PyObject *args, bool strict)
// one candidate, but needs checking whether compatibility is given - this avoid having to route NotImplemented over TypeError exceptions later
int i = 0;
for (gsi::MethodBase::argument_iterator a = meth->begin_arguments (); i < argc && a != meth->end_arguments (); ++a, ++i) {
if (! test_arg (*a, PyTuple_GetItem (args, i), true /*loose*/)) {
PyObject *arg = is_tuple ? PyTuple_GetItem (args, i) : PyList_GetItem (args, i);
if (! test_arg (*a, arg, true /*loose*/)) {
return 0;
}
}
@ -607,16 +610,17 @@ special_method_impl (gsi::MethodBase::special_method_type smt, PyObject *self, P
}
}
static void
void
push_args (gsi::SerialArgs &arglist, const gsi::MethodBase *meth, PyObject *args, tl::Heap &heap)
{
bool is_tuple = PyTuple_Check (args);
int i = 0;
int argc = args == NULL ? 0 : int (PyTuple_Size (args));
int argc = args == NULL ? 0 : (is_tuple ? int (PyTuple_Size (args)) : int (PyList_Size (args)));
try {
for (gsi::MethodBase::argument_iterator a = meth->begin_arguments (); i < argc && a != meth->end_arguments (); ++a, ++i) {
push_arg (*a, arglist, PyTuple_GetItem (args, i), heap);
push_arg (*a, arglist, is_tuple ? PyTuple_GetItem (args, i) : PyList_GetItem (args, i), heap);
}
} catch (tl::Exception &ex) {
@ -726,7 +730,7 @@ property_getter_adaptor (int mid, PyObject *self, PyObject *args)
PYA_TRY
int argc = args == NULL ? 0 : int (PyTuple_Size (args));
int argc = args == NULL ? 0 : (PyTuple_Check (args) ? int (PyTuple_Size (args)) : int (PyList_Size (args)));
if (argc != 0) {
throw tl::Exception (tl::to_string (tr ("Property getters must not have an argument")));
}
@ -747,12 +751,12 @@ property_setter_adaptor (int mid, PyObject *self, PyObject *args)
PYA_TRY
int argc = args == NULL ? 0 : int (PyTuple_Size (args));
int argc = args == NULL ? 0 : (PyTuple_Check (args) ? int (PyTuple_Size (args)) : int (PyList_Size (args)));
if (argc != 1) {
throw tl::Exception (tl::to_string (tr ("Property setter needs exactly one argument")));
}
PyObject *value = PyTuple_GetItem (args, 0);
PyObject *value = PyTuple_Check (args) ? PyTuple_GetItem (args, 0) : PyList_GetItem (args, 0);
if (value) {
ret = property_setter_impl (mid, self, value);
}
@ -777,7 +781,8 @@ method_init_adaptor (int mid, PyObject *self, PyObject *args)
p->destroy ();
}
const gsi::MethodBase *meth = match_method (mid, self, args, PyTuple_Size (args) > 0 || ! p->cls_decl ()->can_default_create ());
int argc = PyTuple_Check (args) ? int (PyTuple_Size (args)) : int (PyList_Size (args));
const gsi::MethodBase *meth = match_method (mid, self, args, argc > 0 || ! p->cls_decl ()->can_default_create ());
if (meth && meth->smt () == gsi::MethodBase::None) {

82
src/pya/pya/pyaMarshal.cc
View File

@ -32,6 +32,8 @@
namespace pya
{
void push_args (gsi::SerialArgs &arglist, const gsi::MethodBase *meth, PyObject *args, tl::Heap &heap);
// -------------------------------------------------------------------
// Serialization adaptors for strings, variants, vectors and maps
@ -471,6 +473,8 @@ struct writer<gsi::ObjectType>
{
void operator() (gsi::SerialArgs *aa, PyObject *arg, const gsi::ArgType &atype, tl::Heap *heap)
{
const gsi::ClassBase *acls = atype.cls ();
if (arg == Py_None || arg == NULL) {
if (! (atype.is_ptr () || atype.is_cptr ())) {
@ -482,14 +486,50 @@ struct writer<gsi::ObjectType>
}
if (atype.is_ptr () || atype.is_cptr () || atype.is_ref () || atype.is_cref ()) {
if (PyTuple_Check (arg) || PyList_Check (arg)) {
// we may implicitly convert a tuple into a constructor call of a target object -
// for now we only check whether the number of arguments is compatible with the list given.
int n = PyTuple_Check (arg) ? int (PyTuple_Size (arg)) : int (PyList_Size (arg));
const gsi::MethodBase *meth = 0;
for (gsi::ClassBase::method_iterator c = acls->begin_constructors (); c != acls->end_constructors (); ++c) {
if ((*c)->compatible_with_num_args (n)) {
meth = *c;
break;
}
}
if (!meth) {
throw tl::Exception (tl::to_string (tr ("No constructor of %s available that takes %d arguments (implicit call from tuple)")), acls->name (), n);
}
// implicit call of constructor
gsi::SerialArgs retlist (meth->retsize ());
gsi::SerialArgs arglist (meth->argsize ());
push_args (arglist, meth, arg, *heap);
meth->call (0, arglist, retlist);
void *new_obj = retlist.read<void *> (*heap);
if (new_obj && (atype.is_ptr () || atype.is_cptr () || atype.is_ref () || atype.is_cref ())) {
// For pointers or refs, ownership over these objects is not transferred.
// Hence we have to keep them on the heap.
// TODO: what if the called method takes ownership using keep()?
heap->push (new gsi::ObjectHolder (acls, new_obj));
}
aa->write<void *> (new_obj);
} else if (atype.is_ptr () || atype.is_cptr () || atype.is_ref () || atype.is_cref ()) {
const gsi::ClassBase *cls_decl = PythonModule::cls_for_type (Py_TYPE (arg));
if (! cls_decl) {
throw tl::TypeError (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s, got %s)")), atype.cls ()->name (), Py_TYPE (arg)->tp_name));
}
if (cls_decl->is_derived_from (atype.cls ())) {
if (cls_decl->is_derived_from (acls)) {
PYAObjectBase *p = PYAObjectBase::from_pyobject (arg);
@ -500,14 +540,15 @@ struct writer<gsi::ObjectType>
aa->write<void *> (p->obj ());
}
} else if (cls_decl->can_convert_to (atype.cls ())) {
} else if (cls_decl->can_convert_to (acls)) {
PYAObjectBase *p = PYAObjectBase::from_pyobject (arg);
// We can convert objects for cref and cptr, but ownership over these objects is not transferred.
// Hence we have to keep them on the heap.
void *new_obj = atype.cls ()->create_obj_from (p->cls_decl (), p->obj ());
heap->push (new gsi::ObjectHolder (atype.cls (), new_obj));
// TODO: what if the called method takes ownership using keep()?
void *new_obj = acls->create_obj_from (p->cls_decl (), p->obj ());
heap->push (new gsi::ObjectHolder (acls, new_obj));
aa->write<void *> (new_obj);
} else {
@ -521,7 +562,7 @@ struct writer<gsi::ObjectType>
throw tl::TypeError (tl::sprintf (tl::to_string (tr ("Unexpected object type (expected argument of class %s, got %s)")), atype.cls ()->name (), Py_TYPE (arg)->tp_name));
}
if (cls_decl->is_derived_from (atype.cls ())) {
if (cls_decl->is_derived_from (acls)) {
PYAObjectBase *p = PYAObjectBase::from_pyobject (arg);
@ -532,7 +573,7 @@ struct writer<gsi::ObjectType>
aa->write<void *> (atype.cls ()->clone (p->obj ()));
}
} else if (cls_decl->can_convert_to (atype.cls ())) {
} else if (cls_decl->can_convert_to (acls)) {
PYAObjectBase *p = PYAObjectBase::from_pyobject (arg);
aa->write<void *> (atype.cls ()->create_obj_from (cls_decl, p->obj ()));
@ -904,8 +945,10 @@ void PythonBasedVectorAdaptor::push (gsi::SerialArgs &r, tl::Heap &heap)
void PythonBasedVectorAdaptor::clear ()
{
if (PySequence_Check (m_array.get ())) {
PySequence_DelSlice (m_array.get (), 0, PySequence_Length (m_array.get ()));
if (PyList_Check (m_array.get ())) {
PyList_SetSlice (m_array.get (), 0, PyList_Size (m_array.get ()), NULL);
} else if (PyTuple_Check (m_array.get ())) {
throw tl::Exception (tl::to_string (tr ("Tuples cannot be modified and cannot be used as out parameters")));
}
}
@ -1158,19 +1201,38 @@ struct test_arg_func<gsi::ObjectType>
{
void operator() (bool *ret, PyObject *arg, const gsi::ArgType &atype, bool loose)
{
const gsi::ClassBase *acls = atype.cls ();
// for const X * or X *, null is an allowed value
if ((atype.is_cptr () || atype.is_ptr ()) && arg == Py_None) {
*ret = true;
return;
}
if (loose && (PyTuple_Check (arg) || PyList_Check (arg))) {
// we may implicitly convert a tuple into a constructor call of a target object -
// for now we only check whether the number of arguments is compatible with the list given.
int n = PyTuple_Check (arg) ? int (PyTuple_Size (arg)) : int (PyList_Size (arg));
*ret = false;
for (gsi::ClassBase::method_iterator c = acls->begin_constructors (); c != acls->end_constructors (); ++c) {
if ((*c)->compatible_with_num_args (n)) {
*ret = true;
break;
}
}
return;
}
const gsi::ClassBase *cls_decl = PythonModule::cls_for_type (Py_TYPE (arg));
if (! cls_decl) {
*ret = false;
return;
}
if (! (cls_decl == atype.cls () || (loose && (cls_decl->is_derived_from (atype.cls ()) || cls_decl->can_convert_to(atype.cls ()))))) {
if (! (cls_decl == acls || (loose && (cls_decl->is_derived_from (atype.cls ()) || cls_decl->can_convert_to (atype.cls ()))))) {
*ret = false;
return;
}

5
src/pya/pya/pyaUtils.cc
View File

@ -117,8 +117,9 @@ void check_error ()
} else if (PyErr_GivenExceptionMatches (exc_type.get (), PyExc_SystemExit)) {
int status = 0;
if (exc_value && test_type<int> (exc_value.get (), true)) {
status = python2c<int> (exc_value.get ());
if (exc_value) {
tl::Variant st = python2c<tl::Variant> (exc_value.get ());
status = st.to_int ();
}
throw tl::ExitException (status);

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

@ -943,7 +943,7 @@ static gsi::ArgType create_void_type ()
static gsi::ArgType s_void_type = create_void_type ();
static void
void
push_args (gsi::SerialArgs &arglist, const gsi::MethodBase *meth, VALUE *argv, int argc, tl::Heap &heap)
{
int i = 0;

53
src/rba/rba/rbaMarshal.cc
View File

@ -34,6 +34,8 @@
namespace rba
{
void push_args (gsi::SerialArgs &arglist, const gsi::MethodBase *meth, VALUE *argv, int argc, tl::Heap &heap);
// -------------------------------------------------------------------
// Serialization adaptors for strings, variants, vectors and maps
@ -497,6 +499,42 @@ struct writer <gsi::ObjectType>
aa->write<void *> ((void *) 0);
}
} else if (TYPE (arg) == T_ARRAY) {
// we may implicitly convert an array into a constructor call of a target object -
// for now we only check whether the number of arguments is compatible with the array given.
int n = RARRAY_LEN (arg);
const gsi::MethodBase *meth = 0;
for (gsi::ClassBase::method_iterator c = atype.cls ()->begin_constructors (); c != atype.cls ()->end_constructors (); ++c) {
if ((*c)->compatible_with_num_args (n)) {
meth = *c;
break;
}
}
if (!meth) {
throw tl::Exception (tl::to_string (tr ("No constructor of %s available that takes %d arguments (implicit call from tuple)")), atype.cls ()->name (), n);
}
// implicit call of constructor
gsi::SerialArgs retlist (meth->retsize ());
gsi::SerialArgs arglist (meth->argsize ());
push_args (arglist, meth, RARRAY_PTR (arg), n, *heap);
meth->call (0, arglist, retlist);
void *new_obj = retlist.read<void *> (*heap);
if (new_obj && (atype.is_ptr () || atype.is_cptr () || atype.is_ref () || atype.is_cref ())) {
// For pointers or refs, ownership over these objects is not transferred.
// Hence we have to keep them on the heap.
// TODO: what if the called method takes ownership using keep()?
heap->push (new gsi::ObjectHolder (atype.cls (), new_obj));
}
aa->write<void *> (new_obj);
} else {
if (TYPE (arg) != T_DATA) {
@ -1152,6 +1190,21 @@ struct test_arg_func<gsi::ObjectType>
// for const X * or X *, nil is an allowed value
*ret = true;
} else if (loose && TYPE (arg) == T_ARRAY) {
// we may implicitly convert an array into a constructor call of a target object -
// for now we only check whether the number of arguments is compatible with the array given.
int n = RARRAY_LEN (arg);
*ret = false;
for (gsi::ClassBase::method_iterator c = atype.cls ()->begin_constructors (); c != atype.cls ()->end_constructors (); ++c) {
if ((*c)->compatible_with_num_args (n)) {
*ret = true;
break;
}
}
} else {
*ret = (TYPE (arg) == T_DATA);

12
src/tl/tl/tlUnitTest.cc
View File

@ -265,7 +265,17 @@ bool TestBase::do_test (bool editable, bool slow)
reset_checkpoint ();
execute (this);
try {
execute (this);
} catch (tl::CancelException &) {
throw;
} catch (tl::Exception &ex) {
raise (std::string ("Exception caught: ") + ex.msg ());
} catch (std::runtime_error &ex) {
raise (std::string ("std::runtime_error caught: ") + ex.what ());
} catch (...) {
raise (std::string ("unspecific exception caught: "));
}
m_testtmp.clear ();

215
testdata/python/basic.py vendored
View File

@ -41,7 +41,7 @@ class AEXT(pya.A):
def g(self):
return self.offset
def m(self):
return self.offset+self.a1()
return self.offset+self.get_n()
# Note: there are no protected methods, but this emulates the respective test for RBA
def call_a10_prot(self, f):
a10_prot(f)
@ -49,7 +49,7 @@ class AEXT(pya.A):
return str(self.offset)
def repr_of_a(self):
return "a1=" + str(self.a1())
return "a1=" + str(self.get_n())
pya.A.__repr__ = repr_of_a
@ -156,9 +156,9 @@ class BasicTest(unittest.TestCase):
self.assertEqual( pya.A.instance_count(), ic0 + 1 )
a = pya.A()
self.assertEqual(a.a1(), 17)
self.assertEqual(a.get_n(), 17)
a.assign(pya.A(110))
self.assertEqual(a.a1(), 110)
self.assertEqual(a.get_n(), 110)
a = None
self.assertEqual( pya.A.instance_count(), ic0 )
@ -188,13 +188,13 @@ class BasicTest(unittest.TestCase):
self.assertEqual( pya.A.aa(), "static_a" )
self.assertEqual( a.aa(), "a" )
self.assertEqual( a.a1(), 17 )
self.assertEqual( a.get_n(), 17 )
a.a5(-5)
self.assertEqual( a.a1(), -5 )
self.assertEqual( a.get_n(), -5 )
a.a5(0x7fffffff)
self.assertEqual( a.a1(), 0x7fffffff )
self.assertEqual( a.get_n(), 0x7fffffff )
a.a5(-0x80000000)
self.assertEqual( a.a1(), -0x80000000 )
self.assertEqual( a.get_n(), -0x80000000 )
self.assertEqual( a.a3("a"), 1 )
self.assertEqual( a.a3(ObjectWithStr("abcde")), 5 ) # implicitly using to_s for string conversion
@ -256,7 +256,7 @@ class BasicTest(unittest.TestCase):
self.assertEqual( pya.A.instance_count(), ic0 )
a = pya.A.new_a( 55 )
self.assertEqual( pya.A.instance_count(), ic0 + 1 )
self.assertEqual( a.a1(), 55 )
self.assertEqual( a.get_n(), 55 )
self.assertEqual( a.a_vp1( a.a_vp2() ), "abc" )
a.destroy()
self.assertEqual( pya.A.instance_count(), ic0 )
@ -410,9 +410,9 @@ class BasicTest(unittest.TestCase):
a = pya.A.new_a_by_variant()
self.assertEqual(pya.A.instance_count(), ic0 + 1)
self.assertEqual(a.a1(), 17)
self.assertEqual(a.get_n(), 17)
a.a5(-15)
self.assertEqual(a.a1(), -15)
self.assertEqual(a.get_n(), -15)
a = None
self.assertEqual(pya.A.instance_count(), ic0)
@ -429,6 +429,85 @@ class BasicTest(unittest.TestCase):
b._destroy()
self.assertEqual(pya.B.instance_count(), ic0)
def test_11(self):
# implicitly converting tuples/lists to objects by calling the constructor
b = pya.B()
b.av_cptr = [ pya.A(17), [1,2], [4,6,0.5] ]
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [17, 3, 5])
b = pya.B()
# NOTE: this gives an error (printed only) that tuples can't be modified as out parameters
b.av_ref = ( (1,2), (6,2,0.25), [42] )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [3, 2, 42])
b = pya.B()
aa = [ (1,2), (6,2,0.25), [42] ]
b.av_ptr = aa
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [3, 2, 42])
# NOTE: as we used aa in "av_ptr", it got modified as out parameter and
# now holds A object references
arr = []
for a in aa:
arr.append(a.get_n_const())
self.assertEqual(arr, [3, 2, 42])
b.av = ()
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [])
b.push_a_ref( (1, 7) )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8])
b.push_a_ptr( (1, 7, 0.25) )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8, 2])
b.push_a_cref( [42] )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8, 2, 42])
b.push_a_cptr( (1, 16) )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8, 2, 42, 17])
b.push_a( (4, 6, 0.5) )
arr = []
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [8, 2, 42, 17, 5])
def test_12(self):
a1 = pya.A()
@ -436,16 +515,16 @@ class BasicTest(unittest.TestCase):
a2 = a1
a3 = a2.dup()
self.assertEqual( a1.a1(), -15 )
self.assertEqual( a2.a1(), -15 )
self.assertEqual( a3.a1(), -15 )
self.assertEqual( a1.get_n(), -15 )
self.assertEqual( a2.get_n(), -15 )
self.assertEqual( a3.get_n(), -15 )
a1.a5( 11 )
a3.a5( -11 )
self.assertEqual( a1.a1(), 11 )
self.assertEqual( a2.a1(), 11 )
self.assertEqual( a3.a1(), -11 )
self.assertEqual( a1.get_n(), 11 )
self.assertEqual( a2.get_n(), 11 )
self.assertEqual( a3.get_n(), -11 )
self.assertEqual( a1.a10_d(5.2), "5.2" )
self.assertEqual( a1.a10_s(0x70000000), "0" )
@ -658,7 +737,7 @@ class BasicTest(unittest.TestCase):
err_caught = False
try:
b.amember_cptr().a1() # cannot call non-const method on const reference
b.amember_cptr().get_n() # cannot call non-const method on const reference
except:
err_caught = True
self.assertEqual( err_caught, True )
@ -682,7 +761,7 @@ class BasicTest(unittest.TestCase):
try:
for a in b.b10():
arr.append(a.a1()) # b10 is a const iterator - cannot call a1 on it
arr.append(a.get_n()) # b10 is a const iterator - cannot call a1 on it
except:
err_caught = True
self.assertEqual( err_caught, True )
@ -694,7 +773,7 @@ class BasicTest(unittest.TestCase):
try:
for a in b.b10p():
arr.append(a.a1()) # b10p is a const iterator - cannot call a1 on it
arr.append(a.get_n()) # b10p is a const iterator - cannot call a1 on it
except:
err_caught = True
self.assertEqual( err_caught, True )
@ -702,7 +781,7 @@ class BasicTest(unittest.TestCase):
arr = []
for a in b.b10():
arr.append(a.dup().a1())
arr.append(a.dup().get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
@ -713,99 +792,99 @@ class BasicTest(unittest.TestCase):
# destroyed too early.
bdup = b.dup()
for a in bdup.b10():
arr.append(a.dup().a1())
arr.append(a.dup().get_n())
self.assertEqual(arr, [100, 121, 144])
return
arr = []
for a in b.b10():
arr.append(a.a1c())
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b10p():
arr.append(a.dup().a1())
arr.append(a.dup().get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
# Ticket #811:
for a in b.dup().b10p():
arr.append(a.dup().a1())
arr.append(a.dup().get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
bdup = b.dup()
for a in bdup.b10p():
arr.append(a.dup().a1())
arr.append(a.dup().get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b10p():
arr.append(a.a1c())
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b11():
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
bdup = b.dup()
for a in bdup.b11():
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b12():
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [7100, 7121, 7144, 7169])
arr = []
bdup = b.dup()
for a in bdup.b12():
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [7100, 7121, 7144, 7169])
aarr = b.b16a()
arr = []
for a in aarr:
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
aarr = b.b16b()
arr = []
for a in aarr:
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
aarr = b.b16c()
arr = []
for a in aarr:
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
b.b17a( [ pya.A.new_a( 101 ), pya.A.new_a( -122 ) ] )
arr = []
for a in b.b11():
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [101, -122])
b.b17a( [] )
arr = []
for a in b.b11():
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [])
b.b17b( [ pya.A.new_a( 102 ), pya.A.new_a( -123 ) ] )
arr = []
for a in b.b11():
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [102, -123])
b.b17c( [ pya.A.new_a( 100 ), pya.A.new_a( 121 ), pya.A.new_a( 144 ) ] )
arr = []
for a in b.b11():
arr.append(a.a1())
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
if not leak_check:
@ -813,7 +892,7 @@ class BasicTest(unittest.TestCase):
arr = []
try:
for a in b.b13():
arr.append(a.a1())
arr.append(a.get_n())
except:
err_caught = True
self.assertEqual( err_caught, True )
@ -821,28 +900,28 @@ class BasicTest(unittest.TestCase):
arr = []
for a in b.b13():
arr.append(a.a1c())
arr.append(a.get_n_const())
self.assertEqual(arr, [-3100, -3121])
arr = []
bdup = b.dup()
for a in bdup.b13():
arr.append(a.a1c())
arr.append(a.get_n_const())
self.assertEqual(arr, [-3100, -3121])
arr = []
for a in b.b18():
arr.append(a.a1c())
for a in b.each_a():
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b18():
arr.append(a.a1())
for a in b.each_a():
arr.append(a.get_n())
self.assertEqual(arr, [100, 121, 144])
arr = []
for a in b.b18b():
arr.append(a.a1c())
for a in b.each_a_ref():
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
@ -850,8 +929,8 @@ class BasicTest(unittest.TestCase):
# since A is a managed object and is not turned into a copy.
err_caught = False
try:
for a in b.b18b():
arr.append(a.a1())
for a in b.each_a_ref():
arr.append(a.get_n())
except:
err_caught = True
end
@ -859,17 +938,17 @@ class BasicTest(unittest.TestCase):
self.assertEqual(err_caught, True)
arr = []
for a in b.b18c():
arr.append(a.a1c())
for a in b.each_a_ptr():
arr.append(a.get_n_const())
self.assertEqual(arr, [100, 121, 144])
arr = []
# this does not work since b18c delivers a "const *" which cannot be used to call a non-const
# this does not work since each_a_ptr delivers a "const *" which cannot be used to call a non-const
# method on
err_caught = False
try:
for a in b.b18c():
arr.append(a.a1())
for a in b.each_a_ptr():
arr.append(a.get_n())
except:
err_caught = True
end
@ -1042,23 +1121,23 @@ class BasicTest(unittest.TestCase):
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( a.get_n(), 1971 );
self.assertEqual( b.an( a ), 1971 );
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( a.get_n(), 1971 );
self.assertEqual( b.an( a ), 1971 );
self.assertEqual( aa.a1(), -61 );
self.assertEqual( aa.get_n(), -61 );
self.assertEqual( b.an( aa ), -61 );
aa.a5(98);
a.a5(100);
self.assertEqual( a.a1(), 100 );
self.assertEqual( a.get_n(), 100 );
self.assertEqual( b.an( a ), 100 );
self.assertEqual( aa.a1(), 98 );
self.assertEqual( aa.get_n(), 98 );
self.assertEqual( b.an( aa ), 98 );
a._destroy()
@ -1071,10 +1150,10 @@ class BasicTest(unittest.TestCase):
b = pya.B()
b.set_an( 77 )
self.assertEqual( b.amember_cptr().a1c(), 77 );
self.assertEqual( b.amember_cptr().get_n_const(), 77 );
b.set_an_cref( 79 )
self.assertEqual( b.amember_cptr().a1c(), 79 );
self.assertEqual( b.amember_cptr().get_n_const(), 79 );
aref = b.amember_cptr()
err_caught = False
@ -1082,14 +1161,14 @@ class BasicTest(unittest.TestCase):
if not leak_check:
try:
x = aref.a1() # cannot call non-const method on const reference (as delivered by amember_cptr)
x = aref.get_n() # 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 );
self.assertEqual( aref.get_n_const(), 79 );
b.set_an( -1 )
self.assertEqual( aref.a1c(), -1 );
self.assertEqual( aref.get_n_const(), -1 );
def test_19(self):
@ -1147,11 +1226,11 @@ class BasicTest(unittest.TestCase):
a1 = b.amember_or_nil_alt( True )
a2 = b.amember_ptr_alt()
self.assertEqual( a1.a1(), 17 )
self.assertEqual( a2.a1(), 17 )
self.assertEqual( a1.get_n(), 17 )
self.assertEqual( a2.get_n(), 17 )
a1.a5( 761 )
self.assertEqual( a1.a1(), 761 )
self.assertEqual( a2.a1(), 761 )
self.assertEqual( a1.get_n(), 761 )
self.assertEqual( a2.get_n(), 761 )
a1 = b.amember_or_nil( False )
self.assertEqual( a1, None )

183
testdata/ruby/basic_testcore.rb vendored
View File

@ -34,9 +34,9 @@ class Basic_TestClass < TestBase
assert_equal( RBA::A::instance_count, ic0 + 1 )
a = RBA::A.new
assert_equal(a.a1, 17)
assert_equal(a.get_n, 17)
a.assign(RBA::A.new(110))
assert_equal(a.a1, 110)
assert_equal(a.get_n, 110)
a = nil
GC.start
@ -89,13 +89,13 @@ class Basic_TestClass < TestBase
assert_equal( RBA::A.aa, "static_a" )
assert_equal( a.aa, "a" )
assert_equal( a.a1, 17 )
assert_equal( a.get_n, 17 )
a.a5 -5
assert_equal( a.a1, -5 )
assert_equal( a.get_n, -5 )
a.a5 0x7fffffff
assert_equal( a.a1, 0x7fffffff )
assert_equal( a.get_n, 0x7fffffff )
a.a5 -0x80000000
assert_equal( a.a1, -0x80000000 )
assert_equal( a.get_n, -0x80000000 )
assert_equal( a.a3("a"), 1 )
assert_equal( a.a3(ObjectWithStr::new("abcde")), 5 ) # implicitly using to_s for string conversion
@ -156,7 +156,7 @@ class Basic_TestClass < TestBase
assert_equal( RBA::A::instance_count, ic0 )
a = RBA::A::new_a( 55 )
assert_equal( RBA::A::instance_count, ic0 + 1 )
assert_equal( a.a1, 55 )
assert_equal( a.get_n, 55 )
assert_equal( a.a_vp1( a.a_vp2 ), "abc" )
a.destroy
assert_equal( RBA::A::instance_count, ic0 )
@ -316,9 +316,9 @@ class Basic_TestClass < TestBase
a = RBA::A.new_a_by_variant
assert_equal(RBA::A::instance_count, ic0 + 1)
assert_equal(a.a1, 17)
assert_equal(a.get_n, 17)
a.a5(-15)
assert_equal(a.a1, -15)
assert_equal(a.get_n, -15)
a = nil
GC.start
@ -341,6 +341,67 @@ class Basic_TestClass < TestBase
end
def test_11
# implicitly converting tuples/lists to objects by calling the constructor
b = RBA::B::new()
b.av_cptr = [ RBA::A::new(17), [1,2], [4,6,0.5] ]
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [17, 3, 5])
b = RBA::B::new()
# NOTE: this gives an error (printed only) that tuples can't be modified as out parameters
b.av_ref = [ [1,2], [6,2,0.25], [42] ]
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [3, 2, 42])
b = RBA::B::new()
aa = [ [1,2], [6,2,0.25], [42] ]
b.av_ptr = aa
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [3, 2, 42])
# NOTE: as we used aa in "av_ptr", it got modified as out parameter and
# now holds A object references
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [3, 2, 42])
b.av = []
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [])
b.push_a_ref([1, 7])
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [8])
b.push_a_ptr([1, 7, 0.25])
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [8, 2])
b.push_a_cref([42])
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [8, 2, 42])
b.push_a_cptr([1, 16])
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [8, 2, 42, 17])
b.push_a([4, 6, 0.5])
arr = b.each_a.collect { |a| a.get_n_const }
assert_equal(arr, [8, 2, 42, 17, 5])
end
def test_12
a1 = RBA::A.new
@ -348,16 +409,16 @@ class Basic_TestClass < TestBase
a2 = a1
a3 = a2.dup
assert_equal( a1.a1, -15 )
assert_equal( a2.a1, -15 )
assert_equal( a3.a1, -15 )
assert_equal( a1.get_n, -15 )
assert_equal( a2.get_n, -15 )
assert_equal( a3.get_n, -15 )
a1.a5( 11 )
a3.a5( -11 )
assert_equal( a1.a1, 11 )
assert_equal( a2.a1, 11 )
assert_equal( a3.a1, -11 )
assert_equal( a1.get_n, 11 )
assert_equal( a2.get_n, 11 )
assert_equal( a3.get_n, -11 )
assert_equal( a1.a10_s(0x70000000), "0" )
assert_equal( a1.a10_s(0x7fffffff), "-1" )
@ -578,7 +639,7 @@ class Basic_TestClass < TestBase
err_caught = false
begin
b.amember_cptr.a1 # cannot call non-const method on const reference
b.amember_cptr.get_n # cannot call non-const method on const reference
rescue
err_caught = true
end
@ -604,7 +665,7 @@ class Basic_TestClass < TestBase
if !$leak_check
begin
b.b10 { |a| arr.push(a.a1) } # b10 is a const iterator - cannot call a1 on it
b.b10 { |a| arr.push(a.get_n) } # b10 is a const iterator - cannot call a1 on it
rescue
err_caught = true
end
@ -618,7 +679,7 @@ class Basic_TestClass < TestBase
if !$leak_check
begin
b.b10p { |a| arr.push(a.a1) } # b10p is a const iterator - cannot call a1 on it
b.b10p { |a| arr.push(a.get_n) } # b10p is a const iterator - cannot call a1 on it
rescue
err_caught = true
end
@ -628,85 +689,85 @@ class Basic_TestClass < TestBase
end
arr = []
b.b10 { |a| arr.push(a.dup.a1) }
b.b10 { |a| arr.push(a.dup.get_n) }
assert_equal(arr, [100, 121, 144])
arr = []
b.dup.b10 { |a| arr.push(a.dup.a1) }
b.dup.b10 { |a| arr.push(a.dup.get_n) }
assert_equal(arr, [100, 121, 144])
arr = []
b.b10 { |a| arr.push(a.a1c) }
b.b10 { |a| arr.push(a.get_n_const) }
assert_equal(arr, [100, 121, 144])
arr = []
b.b10p { |a| arr.push(a.dup.a1) }
b.b10p { |a| arr.push(a.dup.get_n) }
assert_equal(arr, [100, 121, 144])
arr = []
b.dup.b10p { |a| arr.push(a.dup.a1) }
b.dup.b10p { |a| arr.push(a.dup.get_n) }
assert_equal(arr, [100, 121, 144])
arr = []
b.b10p { |a| arr.push(a.a1c) }
b.b10p { |a| arr.push(a.get_n_const) }
assert_equal(arr, [100, 121, 144])
arr = []
b.b11 { |a| arr.push(a.a1) }
b.b11 { |a| arr.push(a.get_n) }
assert_equal(arr, [100, 121, 144])
arr = []
b.dup.b11 { |a| arr.push(a.a1) }
b.dup.b11 { |a| arr.push(a.get_n) }
assert_equal(arr, [100, 121, 144])
arr = []
b.b12 { |a| arr.push(a.a1) }
b.b12 { |a| arr.push(a.get_n) }
assert_equal(arr, [7100, 7121, 7144, 7169])
arr = []
b.dup.b12 { |a| arr.push(a.a1) }
b.dup.b12 { |a| arr.push(a.get_n) }
assert_equal(arr, [7100, 7121, 7144, 7169])
aarr = b.b16a
arr = []
aarr.each { |a| arr.push(a.a1) }
aarr.each { |a| arr.push(a.get_n) }
assert_equal(arr, [100, 121, 144])
aarr = b.b16b
arr = []
aarr.each { |a| arr.push(a.a1) }
aarr.each { |a| arr.push(a.get_n) }
assert_equal(arr, [100, 121, 144])
aarr = b.b16c
arr = []
aarr.each { |a| arr.push(a.a1) }
aarr.each { |a| arr.push(a.get_n) }
assert_equal(arr, [100, 121, 144])
b.b17a( [ RBA::A.new_a( 101 ), RBA::A.new_a( -122 ) ] )
arr = []
b.b11 { |a| arr.push(a.a1) }
b.b11 { |a| arr.push(a.get_n) }
assert_equal(arr, [101, -122])
b.b17a( [] )
arr = []
b.b11 { |a| arr.push(a.a1) }
b.b11 { |a| arr.push(a.get_n) }
assert_equal(arr, [])
b.b17b( [ RBA::A.new_a( 102 ), RBA::A.new_a( -123 ) ] )
arr = []
b.b11 { |a| arr.push(a.a1) }
b.b11 { |a| arr.push(a.get_n) }
assert_equal(arr, [102, -123])
b.b17c( [ RBA::A.new_a( 100 ), RBA::A.new_a( 121 ), RBA::A.new_a( 144 ) ] )
arr = []
b.b11 { |a| arr.push(a.a1) }
b.b11 { |a| arr.push(a.get_n) }
assert_equal(arr, [100, 121, 144])
if !$leak_check
arr = []
begin
b.b13 { |a| arr.push(a.a1) }
b.b13 { |a| arr.push(a.get_n) }
rescue
err_caught = true
end
@ -716,31 +777,31 @@ class Basic_TestClass < TestBase
end
arr = []
b.b13 { |a| arr.push(a.a1c) }
b.b13 { |a| arr.push(a.get_n_const) }
assert_equal(arr, [-3100, -3121])
arr = []
b.dup.b13 { |a| arr.push(a.a1c) }
b.dup.b13 { |a| arr.push(a.get_n_const) }
assert_equal(arr, [-3100, -3121])
arr = []
b.b18 { |a| arr.push(a.a1c) }
b.each_a { |a| arr.push(a.get_n_const) }
assert_equal(arr, [100, 121, 144])
arr = []
b.b18 { |a| arr.push(a.a1) }
b.each_a { |a| arr.push(a.get_n) }
assert_equal(arr, [100, 121, 144])
arr = []
b.b18b { |a| arr.push(a.a1c) }
b.each_a_ref { |a| arr.push(a.get_n_const) }
assert_equal(arr, [100, 121, 144])
arr = []
# even though b18b returns a "const A &", calling a non-const method does not work
# even though each_a_ref returns a "const A &", calling a non-const method does not work
# since A is a managed object and is not turned into a copy.
err_caught = false
begin
b.b18b { |a| arr.push(a.a1) }
b.each_a_ref { |a| arr.push(a.get_n) }
rescue
err_caught = true
end
@ -748,15 +809,15 @@ class Basic_TestClass < TestBase
assert_equal(err_caught, true)
arr = []
b.b18c { |a| arr.push(a.a1c) }
b.each_a_ptr { |a| arr.push(a.get_n_const) }
assert_equal(arr, [100, 121, 144])
arr = []
# this does not work since b18c delivers a "const *" which cannot be used to call a non-const
# this does not work since each_a_ptr delivers a "const *" which cannot be used to call a non-const
# method on
err_caught = false
begin
b.b18c { |a| arr.push(a.a1) }
b.each_a_ptr { |a| arr.push(a.get_n) }
rescue
err_caught = true
end
@ -966,23 +1027,23 @@ class Basic_TestClass < TestBase
a = b.make_a( 1971 );
assert_equal( RBA::A.instance_count, a_count + 1 )
assert_equal( a.a1, 1971 );
assert_equal( a.get_n, 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( a.get_n, 1971 );
assert_equal( b.an( a ), 1971 );
assert_equal( aa.a1, -61 );
assert_equal( aa.get_n, -61 );
assert_equal( b.an( aa ), -61 );
aa.a5 98;
a.a5 100;
assert_equal( a.a1, 100 );
assert_equal( a.get_n, 100 );
assert_equal( b.an( a ), 100 );
assert_equal( aa.a1, 98 );
assert_equal( aa.get_n, 98 );
assert_equal( b.an( aa ), 98 );
a._destroy
@ -998,10 +1059,10 @@ class Basic_TestClass < TestBase
b = RBA::B.new
b.set_an( 77 )
assert_equal( b.amember_cptr.a1c, 77 );
assert_equal( b.amember_cptr.get_n_const, 77 );
b.set_an_cref( 79 )
assert_equal( b.amember_cptr.a1c, 79 );
assert_equal( b.amember_cptr.get_n_const, 79 );
aref = b.amember_cptr
err_caught = false
@ -1009,17 +1070,17 @@ class Basic_TestClass < TestBase
if !$leak_check
begin
x = aref.a1 # cannot call non-const method on const reference (as delivered by amember_cptr)
x = aref.get_n # cannot call non-const method on const reference (as delivered by amember_cptr)
rescue
err_caught = true
end
assert_equal( err_caught, true )
assert_equal( aref.a1c, 79 );
assert_equal( aref.get_n_const, 79 );
end
b.set_an( -1 )
assert_equal( aref.a1c, -1 );
assert_equal( aref.get_n_const, -1 );
end
@ -1109,11 +1170,11 @@ class Basic_TestClass < TestBase
a1 = b.amember_or_nil( true )
a2 = b.amember_ptr
assert_equal( a1.a1, 17 )
assert_equal( a2.a1, 17 )
assert_equal( a1.get_n, 17 )
assert_equal( a2.get_n, 17 )
a1.a5( 761 )
assert_equal( a1.a1, 761 )
assert_equal( a2.a1, 761 )
assert_equal( a1.get_n, 761 )
assert_equal( a2.get_n, 761 )
a1 = b.amember_or_nil( false )
assert_equal( a1, nil )
@ -2989,7 +3050,7 @@ class Basic_TestClass < TestBase
assert_equal(RBA::B::int_to_optional(1, true), 1)
assert_equal(RBA::B::int_to_optional(1, false), nil)
assert_equal(RBA::B::int_to_optional_a(1, true).a1, 1)
assert_equal(RBA::B::int_to_optional_a(1, true).get_n, 1)
assert_equal(RBA::B::int_to_optional_a(1, false), nil)
assert_equal(RBA::B::optional_to_int(1, -1), 1)