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