/* code to create classes C and D */
static void setup_classes()
{
#ifdef TAGGING
pyobj zero = inject_int(0);
pyobj one = inject_int(1);
#else
pyobj zero = create_int(0);
pyobj one = create_int(1);
#endif
pyobj list0 = create_list(zero);
pyobj list1 = create_list(one);
// class C:
// def m(self):
// return self.f
C = create_class(list0);
// Add method m to the class.
set_attr(C, "m", create_closure(C_m, list0));
// class D(C):
// def m(self):
// return self.f + 1
set_subscript(list1, zero, C); // list1[0] = C
D = create_class(list1);
pyobj D_m_closure = create_closure(D_m, list0);
set_attr(D, "m", create_closure(D_m, list0));
pyobj D_n_closure = create_closure(D_n, list0);
set_attr(D, "n", create_closure(D_n, list0));
}
int main (int argc, char *argv[])
{
big_pyobj *A, *B, *C;
big_pyobj *A_parents, *B_parents, *C_parents;
big_pyobj *list;
int i;
/**
* test1: simple class with no superclasses
* class A:
*/
pymem_init();
A_parents = create_list(inject_int(0));
incref(A_parents);
A = create_class(inject_big(A_parents));
incref(A);
assert (A_parents->ref_ctr == 2);
decref(A);
assert (A_parents->ref_ctr == 1);
decref(A_parents);
pymem_print_stats();
pymem_shutdown();
/**
* test2: class with one superclass
* class A:
* class B(A):
* B -> B_parents -> A -> A_parents
*/
pymem_init();
A_parents = create_list(inject_int(0));
incref(A_parents);
A = create_class(inject_big(A_parents));
incref(A);
assert (A_parents->ref_ctr == 2);
B_parents = create_list(inject_int(1));
incref(B_parents);
set_subscript(inject_big(B_parents), inject_int(0), inject_big(A));
assert (A->ref_ctr == 2);
B = create_class(inject_big(B_parents));
incref(B);
assert (B_parents->ref_ctr == 2);
decref(A_parents);
assert (A_parents->ref_ctr == 1);
decref(A);
assert (A->ref_ctr == 1);
decref(B_parents);
assert (B_parents->ref_ctr == 1);
pymem_print_stats();
decref(B); // everything should go away at this point.
pymem_print_stats();
pymem_shutdown();
/**
* test3: simple class with attribute.
* list = []
* class A:
* a = list
*/
pymem_init();
list = create_list(inject_int(0));
incref(list);
A_parents = create_list(inject_int(0));
incref(A_parents);
A = create_class(inject_big(A_parents));
incref(A);
assert (A_parents->ref_ctr == 2);
set_attr(inject_big(A), "a", inject_big(list));
decref(list); // the list should not go away here.
assert (list->ref_ctr == 1);
decref(A_parents);
assert (A_parents->ref_ctr == 1);
pymem_print_stats();
decref(A); // now everything should be de-allocated.
pymem_print_stats();
pymem_shutdown();
}
int main (int argc, char *argv[])
{
big_pyobj *list, *list2;
int i;
/**
* test1: simple list creation
* list = []
* decref(list)
*/
pymem_init();
list = create_list(inject_int(0));
incref(list);
decref(list);
pymem_print_stats();
pymem_shutdown();
/**
* test2: list with primitive (int) elements
* list = [99,88,77,66,55]
* decref(list)
*/
pymem_init();
list = create_list(inject_int(5));
incref(list);
set_subscript(inject_big(list), inject_int(0), inject_int(99));
set_subscript(inject_big(list), inject_int(1), inject_int(88));
set_subscript(inject_big(list), inject_int(2), inject_int(77));
set_subscript(inject_big(list), inject_int(3), inject_int(66));
set_subscript(inject_big(list), inject_int(4), inject_int(55));
decref(list);
pymem_print_stats();
pymem_shutdown();
/**
* test3: list with another list (int) element
* list = [99]
* list2 = [list] // increments list's ref count by one...
* decref(list2) // decrements list's ref count by one (in addition to list2)
* // list2 should be deallocated completely.
* decref(list) // list should be deallocated completely.
*/
pymem_init();
list = create_list(inject_int(1));
incref(list);
set_subscript(inject_big(list), inject_int(0), inject_int(99));
list2 = create_list(inject_int(1));
incref(list2);
set_subscript(inject_big(list2), inject_int(0), inject_big(list));
assert (list->ref_ctr == 2);
decref(list2);
assert (list->ref_ctr == 1);
decref(list);
pymem_print_stats();
pymem_shutdown();
}
