src/tests/eo_suite/eo_test_general.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "config.h"
   3 #endif
   4
   5 #include <stdio.h>
   6
   7 #include "eo_suite.h"
   8 #include "Eo.h"
   9
  10 #include "class_simple.h"
  11
  12 START_TEST(eo_simple)
  13 {
  14    eo_init();
  15    Eo *obj = eo_add(EO_BASE_CLASS, NULL);
  16    fail_if(obj);
  17
  18    obj = eo_add(SIMPLE_CLASS, NULL);
  19    fail_if(!obj);
  20    eo_do(obj, eo_constructor());
  21    eo_do(obj, eo_destructor());
  22    eo_unref(obj);
  23
  24    eo_shutdown();
  25 }
  26 END_TEST
  27
  28 START_TEST(eo_data_fetch)
  29 {
  30    eo_init();
  31
  32    /* Usually should be const, not const only for the test... */
  33    static Eo_Class_Description class_desc = {
  34         EO_VERSION,
  35         "Simple2",
  36         EO_CLASS_TYPE_REGULAR,
  37         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
  38         NULL,
  39         10,
  40         NULL,
  41         NULL
  42    };
  43
  44    const Eo_Class *klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
  45    fail_if(!klass);
  46
  47    Eo *obj = eo_add(klass, NULL);
  48    fail_if(!obj);
  49 #ifndef NDEBUG
  50    fail_if(eo_data_get(obj, SIMPLE_CLASS));
  51 #endif
  52    eo_unref(obj);
  53
  54    class_desc.data_size = 0;
  55    klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
  56    fail_if(!klass);
  57
  58    obj = eo_add(klass, NULL);
  59    fail_if(!obj);
  60    fail_if(eo_data_get(obj, klass));
  61    eo_unref(obj);
  62
  63    eo_shutdown();
  64 }
  65 END_TEST
  66
  67 START_TEST(eo_isa_tests)
  68 {
  69    eo_init();
  70
  71    const Eo_Class *klass, *iface, *mixin;
  72
  73      {
  74         /* Usually should be const, not const only for the test... */
  75         static Eo_Class_Description class_desc = {
  76              EO_VERSION,
  77              "Iface",
  78              EO_CLASS_TYPE_INTERFACE,
  79              EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
  80              NULL,
  81              0,
  82              NULL,
  83              NULL
  84         };
  85
  86         iface = eo_class_new(&class_desc, NULL, NULL);
  87         fail_if(!iface);
  88      }
  89
  90      {
  91         /* Usually should be const, not const only for the test... */
  92         static Eo_Class_Description class_desc = {
  93              EO_VERSION,
  94              "Mixin",
  95              EO_CLASS_TYPE_MIXIN,
  96              EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
  97              NULL,
  98              0,
  99              NULL,
 100              NULL
 101         };
 102
 103         mixin = eo_class_new(&class_desc, NULL, NULL);
 104         fail_if(!mixin);
 105      }
 106
 107      {
 108         /* Usually should be const, not const only for the test... */
 109         static Eo_Class_Description class_desc = {
 110              EO_VERSION,
 111              "Simple2",
 112              EO_CLASS_TYPE_REGULAR,
 113              EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 114              NULL,
 115              10,
 116              NULL,
 117              NULL
 118         };
 119
 120         klass = eo_class_new(&class_desc, EO_BASE_CLASS, iface, mixin, NULL);
 121         fail_if(!klass);
 122      }
 123
 124    Eo *obj = eo_add(klass, NULL);
 125    fail_if(!obj);
 126    fail_if(eo_isa(obj, SIMPLE_CLASS));
 127    fail_if(!eo_isa(obj, iface));
 128    fail_if(!eo_isa(obj, mixin));
 129    fail_if(!eo_isa(obj, klass));
 130    fail_if(!eo_isa(obj, EO_BASE_CLASS));
 131    eo_unref(obj);
 132
 133    obj = eo_add(SIMPLE_CLASS, NULL);
 134    fail_if(!obj);
 135    fail_if(eo_isa(obj, klass));
 136    fail_if(eo_isa(obj, iface));
 137    fail_if(eo_isa(obj, mixin));
 138    fail_if(!eo_isa(obj, SIMPLE_CLASS));
 139    fail_if(!eo_isa(obj, EO_BASE_CLASS));
 140    eo_unref(obj);
 141
 142    eo_shutdown();
 143 }
 144 END_TEST
 145
 146
 147 START_TEST(eo_composite_tests)
 148 {
 149    eo_init();
 150
 151    Eo *obj = eo_add(SIMPLE_CLASS, NULL);
 152    fail_if(!obj);
 153    Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
 154    fail_if(!obj2);
 155
 156    eo_composite_attach(obj2, obj);
 157    eo_parent_set(obj2, NULL);
 158    fail_if(eo_composite_is(obj2));
 159
 160    eo_unref(obj2);
 161    eo_unref(obj);
 162
 163    eo_shutdown();
 164 }
 165 END_TEST
 166
 167 static Eina_Bool _man_should_con = EINA_TRUE;
 168 static Eina_Bool _man_should_des = EINA_TRUE;
 169
 170 static void
 171 _man_con(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
 172 {
 173    if (_man_should_con)
 174       eo_manual_free_set(obj, EINA_TRUE);
 175    eo_do_super(obj, eo_constructor());
 176 }
 177
 178 static void
 179 _man_des(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
 180 {
 181    eo_do_super(obj, eo_destructor());
 182    if (_man_should_des)
 183       eo_manual_free_set(obj, EINA_FALSE);
 184 }
 185
 186
 187 static void
 188 _man_class_constructor(Eo_Class *klass)
 189 {
 190    const Eo_Op_Func_Description func_desc[] = {
 191         EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _man_con),
 192         EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _man_des),
 193         EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _man_des),
 194         EO_OP_FUNC_SENTINEL
 195    };
 196
 197    eo_class_funcs_set(klass, func_desc);
 198 }
 199
 200 START_TEST(eo_man_free)
 201 {
 202    eo_init();
 203
 204    /* Usually should be const, not const only for the test... */
 205    static Eo_Class_Description class_desc = {
 206         EO_VERSION,
 207         "Simple2",
 208         EO_CLASS_TYPE_REGULAR,
 209         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 210         NULL,
 211         10,
 212         _man_class_constructor,
 213         NULL
 214    };
 215
 216    const Eo_Class *klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
 217    fail_if(!klass);
 218
 219    Eo *obj = eo_add(klass, NULL);
 220    fail_if(!obj);
 221    eo_unref(obj);
 222
 223    obj = eo_add(klass, NULL);
 224    fail_if(!obj);
 225    eo_manual_free(obj);
 226    eo_unref(obj);
 227
 228    _man_should_des = EINA_FALSE;
 229    klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
 230    fail_if(!klass);
 231
 232    obj = eo_add(klass, NULL);
 233    fail_if(!obj);
 234    eo_manual_free(obj);
 235    eo_unref(obj);
 236    eo_manual_free(obj);
 237
 238    obj = eo_add(klass, NULL);
 239    fail_if(!obj);
 240    eo_unref(obj);
 241    eo_manual_free(obj);
 242
 243    _man_should_con = EINA_FALSE;
 244    klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
 245    fail_if(!klass);
 246
 247    obj = eo_add(klass, NULL);
 248    fail_if(!obj);
 249    eo_manual_free(obj);
 250    eo_unref(obj);
 251
 252    obj = eo_add(klass, NULL);
 253    fail_if(!obj);
 254    eo_manual_free_set(obj, EINA_TRUE);
 255    eo_unref(obj);
 256    eo_ref(obj);
 257    eo_unref(obj);
 258    eo_unref(obj);
 259    eo_manual_free(obj);
 260
 261    eo_shutdown();
 262 }
 263 END_TEST
 264
 265 START_TEST(eo_refs)
 266 {
 267    eo_init();
 268    Eo *obj = eo_add(SIMPLE_CLASS, NULL);
 269    Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
 270    Eo *obj3 = eo_add(SIMPLE_CLASS, NULL);
 271
 272    eo_xref(obj, obj2);
 273    fail_if(eo_ref_get(obj) != 2);
 274    eo_xref(obj, obj3);
 275    fail_if(eo_ref_get(obj) != 3);
 276
 277    eo_xunref(obj, obj2);
 278    fail_if(eo_ref_get(obj) != 2);
 279    eo_xunref(obj, obj3);
 280    fail_if(eo_ref_get(obj) != 1);
 281
 282 #ifndef NDEBUG
 283    eo_xunref(obj, obj3);
 284    fail_if(eo_ref_get(obj) != 1);
 285
 286    eo_xref(obj, obj2);
 287    fail_if(eo_ref_get(obj) != 2);
 288
 289    eo_xunref(obj, obj3);
 290    fail_if(eo_ref_get(obj) != 2);
 291
 292    eo_xunref(obj, obj2);
 293    fail_if(eo_ref_get(obj) != 1);
 294 #endif
 295
 296    /* Check we don't seg if there's an extra xref. */
 297    eo_xref(obj, obj2);
 298    eo_unref(obj);
 299
 300    eo_unref(obj);
 301    eo_unref(obj2);
 302    eo_unref(obj3);
 303
 304    /* Check hierarchy */
 305    obj = eo_add(SIMPLE_CLASS, NULL);
 306    obj2 = eo_add(SIMPLE_CLASS, obj);
 307
 308    Eo *wref;
 309    eo_do(obj2, eo_wref_add(&wref));
 310    fail_if(!wref);
 311
 312    eo_unref(obj2);
 313
 314    fail_if(!wref); /* Parent is still holding a reference. */
 315
 316    eo_unref(obj);
 317
 318    fail_if(wref);
 319
 320    /* Just check it doesn't seg atm. */
 321    obj = eo_add(SIMPLE_CLASS, NULL);
 322    eo_ref(obj);
 323    eo_unref(obj);
 324    eo_unref(obj);
 325
 326    obj = eo_add(SIMPLE_CLASS, NULL);
 327    obj2 = eo_add(SIMPLE_CLASS, obj);
 328    eo_unref(obj2);
 329    eo_ref(obj2);
 330    eo_del(obj2);
 331    eo_unref(obj);
 332
 333    eo_shutdown();
 334 }
 335 END_TEST
 336
 337 START_TEST(eo_weak_reference)
 338 {
 339    eo_init();
 340
 341    Eo *obj = eo_add(SIMPLE_CLASS, NULL);
 342    Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
 343    Eo *wref, *wref2, *wref3;
 344    eo_do(obj, eo_wref_add(&wref));
 345    fail_if(!wref);
 346
 347    eo_unref(obj);
 348    fail_if(wref);
 349
 350    obj = eo_add(SIMPLE_CLASS, NULL);
 351    eo_do(obj, eo_wref_add(&wref));
 352
 353    eo_ref(obj);
 354    fail_if(!wref);
 355
 356    eo_unref(obj);
 357    fail_if(!wref);
 358
 359    eo_unref(obj);
 360    fail_if(wref);
 361
 362    obj = eo_add(SIMPLE_CLASS, NULL);
 363
 364    eo_do(obj, eo_wref_add(&wref));
 365    eo_do(obj, eo_wref_del(&wref));
 366    fail_if(wref);
 367
 368    eo_do(obj, eo_wref_add(&wref));
 369    eo_do(obj2, eo_wref_del(&wref));
 370    fail_if(!wref);
 371    eo_wref_del_safe(&wref);
 372    fail_if(wref);
 373
 374    wref = obj;
 375    eo_do(obj, eo_wref_del(&wref));
 376    fail_if(wref);
 377
 378    wref = wref2 = wref3 = NULL;
 379    eo_do(obj, eo_wref_add(&wref), eo_wref_add(&wref2), eo_wref_add(&wref3));
 380    fail_if(!wref);
 381    fail_if(!wref2);
 382    fail_if(!wref3);
 383    eo_do(obj, eo_wref_del(&wref), eo_wref_del(&wref2), eo_wref_del(&wref3));
 384    fail_if(wref);
 385    fail_if(wref2);
 386    fail_if(wref3);
 387
 388    eo_do(obj, eo_wref_add(&wref2), eo_wref_add(&wref3));
 389    wref = obj;
 390    eo_do(obj, eo_wref_del(&wref));
 391    fail_if(wref);
 392    eo_do(obj, eo_wref_del(&wref2), eo_wref_del(&wref3));
 393
 394    eo_unref(obj);
 395    eo_unref(obj2);
 396
 397
 398    eo_shutdown();
 399 }
 400 END_TEST
 401
 402 static void
 403 _a_set(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 404 {
 405    fail_if(EINA_TRUE);
 406 }
 407
 408 static void
 409 _op_errors_class_constructor(Eo_Class *klass)
 410 {
 411    const Eo_Op_Func_Description func_desc[] = {
 412         EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_LAST), _a_set),
 413         EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_LAST + 1), _a_set),
 414         EO_OP_FUNC(0x0F010111, _a_set),
 415         EO_OP_FUNC_SENTINEL
 416    };
 417
 418    eo_class_funcs_set(klass, func_desc);
 419 }
 420
 421 START_TEST(eo_op_errors)
 422 {
 423    eo_init();
 424
 425    static const Eo_Class_Description class_desc = {
 426         EO_VERSION,
 427         "Simple",
 428         EO_CLASS_TYPE_REGULAR,
 429         EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0),
 430         NULL,
 431         0,
 432         _op_errors_class_constructor,
 433         NULL
 434    };
 435
 436    const Eo_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL);
 437    fail_if(!klass);
 438
 439    Eo *obj = eo_add(klass, NULL);
 440
 441    /* Out of bounds op for a legal class. */
 442    fail_if(eo_do(obj, EO_BASE_ID(0x0111)));
 443
 444    /* Ilegal class. */
 445    fail_if(eo_do(obj, 0x0F010111));
 446
 447    fail_if(eo_ref_get(obj) != 1);
 448
 449    eo_ref(obj);
 450    fail_if(eo_ref_get(obj) != 2);
 451
 452    eo_ref(obj);
 453    fail_if(eo_ref_get(obj) != 3);
 454
 455    eo_unref(obj);
 456    fail_if(eo_ref_get(obj) != 2);
 457
 458    eo_unref(obj);
 459    fail_if(eo_ref_get(obj) != 1);
 460
 461    eo_unref(obj);
 462
 463    obj = eo_add(SIMPLE_CLASS, NULL);
 464    fail_if(!eo_do(obj, simple_a_print()));
 465    fail_if(!eo_do(obj, simple_a_print()));
 466    fail_if(!eo_do(obj, simple_a_set(1)));
 467    eo_unref(obj);
 468
 469    eo_shutdown();
 470 }
 471 END_TEST
 472
 473 static void
 474 _fake_free_func(void *data)
 475 {
 476    if (!data)
 477       return;
 478
 479    int *a = data;
 480    ++*a;
 481 }
 482
 483 START_TEST(eo_generic_data)
 484 {
 485    eo_init();
 486    Eo *obj = eo_add(SIMPLE_CLASS, NULL);
 487    void *data;
 488
 489    eo_do(obj, eo_base_data_set("test1", (void *) 1, NULL));
 490    eo_do(obj, eo_base_data_get("test1", &data));
 491    fail_if(1 != (int) data);
 492    eo_do(obj, eo_base_data_del("test1"));
 493    eo_do(obj, eo_base_data_get("test1", &data));
 494    fail_if(data);
 495
 496    eo_do(obj, eo_base_data_set("test1", (void *) 1, NULL));
 497    eo_do(obj, eo_base_data_set("test2", (void *) 2, NULL));
 498    eo_do(obj, eo_base_data_get("test1", &data));
 499    fail_if(1 != (int) data);
 500    eo_do(obj, eo_base_data_get("test2", &data));
 501    fail_if(2 != (int) data);
 502
 503    eo_do(obj, eo_base_data_get("test2", &data));
 504    fail_if(2 != (int) data);
 505    eo_do(obj, eo_base_data_del("test2"));
 506    eo_do(obj, eo_base_data_get("test2", &data));
 507    fail_if(data);
 508
 509    eo_do(obj, eo_base_data_get("test1", &data));
 510    fail_if(1 != (int) data);
 511    eo_do(obj, eo_base_data_del("test1"));
 512    eo_do(obj, eo_base_data_get("test1", &data));
 513    fail_if(data);
 514
 515    int a = 0;
 516    eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func));
 517    eo_do(obj, eo_base_data_get("test3", &data));
 518    fail_if(&a != data);
 519    eo_do(obj, eo_base_data_get("test3", NULL));
 520    eo_do(obj, eo_base_data_del("test3"));
 521    fail_if(a != 1);
 522
 523    a = 0;
 524    eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func));
 525    eo_do(obj, eo_base_data_set("test3", NULL, _fake_free_func));
 526    fail_if(a != 1);
 527    a = 0;
 528    data = (void *) 123;
 529    eo_do(obj, eo_base_data_set(NULL, &a, _fake_free_func));
 530    eo_do(obj, eo_base_data_get(NULL, &data));
 531    fail_if(data);
 532    eo_do(obj, eo_base_data_del(NULL));
 533
 534    a = 0;
 535    eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func));
 536    eo_do(obj, eo_base_data_set("test3", NULL, NULL));
 537    fail_if(a != 1);
 538    eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func));
 539
 540    eo_unref(obj);
 541    fail_if(a != 2);
 542
 543    eo_shutdown();
 544 }
 545 END_TEST
 546
 547 START_TEST(eo_magic_checks)
 548 {
 549    char _buf[sizeof(long)]; /* Just enough to hold eina magic + a bit more. */
 550    char *buf = _buf;
 551    eo_init();
 552
 553    memset(_buf, 1, sizeof(_buf));
 554
 555    Eo *obj = eo_add(SIMPLE_CLASS, (Eo *) buf);
 556    fail_if(obj);
 557
 558    while (1)
 559      {
 560         obj = eo_add((Eo_Class *) buf, NULL);
 561         fail_if(obj);
 562
 563         obj = eo_add(SIMPLE_CLASS, NULL);
 564         fail_if(!obj);
 565
 566         fail_if(eo_do((Eo *) buf, EO_NOOP));
 567         fail_if(eo_do_super((Eo *) buf, EO_NOOP));
 568         fail_if(eo_class_get((Eo *) buf));
 569         fail_if(eo_class_name_get((Eo_Class*) buf));
 570         eo_class_funcs_set((Eo_Class *) buf, NULL);
 571         eo_class_do((Eo_Class *) buf, NULL);
 572         eo_class_do_super((Eo_Class *) buf, EO_NOOP);
 573
 574         fail_if(eo_class_new(NULL, (Eo_Class *) buf), NULL);
 575
 576         eo_xref(obj, (Eo *) buf);
 577         eo_xunref(obj, (Eo *) buf);
 578         eo_xref((Eo *) buf, obj);
 579         eo_xunref((Eo *) buf, obj);
 580
 581         eo_ref((Eo *) buf);
 582         eo_unref((Eo *) buf);
 583         eo_del((Eo *) buf);
 584
 585         eo_isa((Eo *) buf, SIMPLE_CLASS);
 586         eo_isa(obj, (Eo_Class *) buf);
 587
 588         fail_if(0 != eo_ref_get((Eo *) buf));
 589
 590         Eo *wref = NULL;
 591         eo_do((Eo *) buf, eo_wref_add(&wref));
 592         fail_if(wref);
 593
 594         fail_if(eo_parent_get((Eo *) buf));
 595
 596         eo_error_set((Eo *) buf);
 597
 598         fail_if(eo_data_get((Eo *) buf, SIMPLE_CLASS));
 599
 600         eo_composite_attach((Eo *) buf, obj);
 601         eo_composite_attach(obj, (Eo *) buf);
 602         eo_composite_detach((Eo *) buf, obj);
 603         eo_composite_detach(obj, (Eo *) buf);
 604         eo_composite_is((Eo *) buf);
 605
 606         eo_do(obj, eo_event_callback_forwarder_add(NULL, (Eo *) buf));
 607         eo_do(obj, eo_event_callback_forwarder_del(NULL, (Eo *) buf));
 608
 609         eo_manual_free_set((Eo *) buf, EINA_TRUE);
 610         eo_manual_free((Eo *) buf);
 611
 612         eo_unref(obj);
 613
 614         if (!buf)
 615            break;
 616         else
 617            buf = NULL;
 618      }
 619
 620    eo_shutdown();
 621 }
 622 END_TEST
 623
 624 /* MULTI */
 625 static Eo_Op MULTI_BASE_ID;
 626 #define MULTI_ID(sub_id) (MULTI_BASE_ID + sub_id)
 627 #define multi_a_print() MULTI_ID(MULTI_SUB_ID_A_PRINT)
 628 #define multi_class_hi_print() MULTI_ID(MULTI_SUB_ID_CLASS_HI_PRINT)
 629
 630 static void
 631 _a_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
 632 {
 633    printf("Hey\n");
 634 }
 635
 636 static void
 637 _class_hi_print(const Eo_Class *klass EINA_UNUSED, va_list *list EINA_UNUSED)
 638 {
 639    printf("Hi\n");
 640 }
 641
 642 enum {
 643      MULTI_SUB_ID_A_PRINT,
 644      MULTI_SUB_ID_CLASS_HI_PRINT,
 645      MULTI_SUB_ID_LAST
 646 };
 647
 648 static void
 649 _eo_multiple_do_class_constructor(Eo_Class *klass)
 650 {
 651    const Eo_Op_Func_Description func_desc[] = {
 652         EO_OP_FUNC(MULTI_ID(MULTI_SUB_ID_A_PRINT), _a_print),
 653         EO_OP_FUNC_CLASS(MULTI_ID(MULTI_SUB_ID_CLASS_HI_PRINT), _class_hi_print),
 654         EO_OP_FUNC_SENTINEL
 655    };
 656
 657    eo_class_funcs_set(klass, func_desc);
 658 }
 659
 660 static const Eo_Op_Description _eo_multiple_do_op_desc[] = {
 661      EO_OP_DESCRIPTION(MULTI_SUB_ID_A_PRINT, "Print property A"),
 662      EO_OP_DESCRIPTION_CLASS(MULTI_SUB_ID_CLASS_HI_PRINT, "Print Hi"),
 663      EO_OP_DESCRIPTION_SENTINEL
 664 };
 665
 666
 667 START_TEST(eo_multiple_do)
 668 {
 669    eo_init();
 670
 671    /* Usually should be const, not const only for the test... */
 672    static Eo_Class_Description class_desc = {
 673         EO_VERSION,
 674         "Inherit",
 675         EO_CLASS_TYPE_REGULAR,
 676         EO_CLASS_DESCRIPTION_OPS(&MULTI_BASE_ID, _eo_multiple_do_op_desc, MULTI_SUB_ID_LAST),
 677         NULL,
 678         0,
 679         _eo_multiple_do_class_constructor,
 680         NULL
 681    };
 682
 683    const Eo_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL);
 684    fail_if(!klass);
 685
 686    Eo *obj = eo_add(klass, NULL);
 687    fail_if(!obj);
 688
 689    fail_if(!eo_do(obj, simple_a_print(), multi_a_print(), multi_a_print()));
 690    fail_if(!eo_class_do(klass, simple_class_hi_print(), multi_class_hi_print(), multi_class_hi_print()));
 691
 692    eo_unref(obj);
 693
 694    eo_shutdown();
 695 }
 696 END_TEST
 697
 698 START_TEST(eo_add_do_and_custom)
 699 {
 700    Simple_Public_Data *pd = NULL;
 701    Eo *obj = NULL;
 702    eo_init();
 703
 704    obj = eo_add_custom(SIMPLE_CLASS, NULL, eo_constructor());
 705    fail_if(!obj);
 706    eo_unref(obj);
 707
 708    obj = eo_add(SIMPLE_CLASS, NULL, simple_a_set(7));
 709    fail_if(!obj);
 710    pd = eo_data_get(obj, SIMPLE_CLASS);
 711    fail_if(pd->a != 7);
 712    eo_unref(obj);
 713
 714    obj = eo_add_custom(SIMPLE_CLASS, NULL, eo_constructor(), simple_a_set(7));
 715    fail_if(!obj);
 716    pd = eo_data_get(obj, SIMPLE_CLASS);
 717    fail_if(pd->a != 7);
 718    eo_unref(obj);
 719
 720    eo_shutdown();
 721 }
 722 END_TEST
 723
 724 void eo_test_general(TCase *tc)
 725 {
 726    tcase_add_test(tc, eo_generic_data);
 727    tcase_add_test(tc, eo_op_errors);
 728    tcase_add_test(tc, eo_simple);
 729    tcase_add_test(tc, eo_weak_reference);
 730    tcase_add_test(tc, eo_refs);
 731    tcase_add_test(tc, eo_magic_checks);
 732    tcase_add_test(tc, eo_data_fetch);
 733    tcase_add_test(tc, eo_man_free);
 734    tcase_add_test(tc, eo_composite_tests);
 735    tcase_add_test(tc, eo_isa_tests);
 736    tcase_add_test(tc, eo_multiple_do);
 737    tcase_add_test(tc, eo_add_do_and_custom);
 738 }