Ignore:
Timestamp:
May 12, 2021, 4:30:27 PM (13 months ago)
Author:
Michael Brooks <mlbrooks@…>
Branches:
arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr
Children:
e2f601f
Parents:
67b421c
Message:

Replacing "Mike's old linked list" with "Mike's new linked list," including replatforming uses of the old one.

libcfa/src/containers/list.hfa ---[becomes]--> tests/zombies/linked-list-perf/mike-old.hfa
libcfa/src/containers/list2.hfa ---[becomes]--> libcfa/src/containers/list.hfa

There are no more multiple versions of "Mike's list" in libcfa, nor tests thereof.

The libcfa concurrency uses (alarm, kernel and ready_queue) are hereby ported to "Mike's new."

A best-effort port of executor, which was found not compiling with errors that seem unrelated to the linked list, is attempted too.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • tests/list/dlist-insert-remove.cfa

    r67b421c r69914cbc  
    1919struct fred {
    2020        float adatum;
    21         DLISTED_MGD_EXPL_IN(fred, mine)
    22         DLISTED_MGD_EXPL_IN(fred, yours)
     21        inline struct mine { inline dlink(fred); };
     22        inline struct yours { inline dlink(fred); };
    2323};
    24 
    25 DLISTED_MGD_EXPL_OUT(fred, mine)
    26 DLISTED_MGD_EXPL_OUT(fred, yours)
     24P9_EMBEDDED(fred, fred.mine)
     25P9_EMBEDDED(fred, fred.yours)
     26P9_EMBEDDED(fred.mine, dlink(fred))
     27P9_EMBEDDED(fred.yours, dlink(fred))
     28
    2729
    2830void ?{}(fred &this, float adatum) {
     
    3335struct mary {
    3436        float anotherdatum;
    35         DLISTED_MGD_IMPL_IN(mary)
     37        inline dlink(mary);
    3638};
    3739
    38 DLISTED_MGD_IMPL_OUT(mary)
     40P9_EMBEDDED(mary, dlink(mary))
    3941
    4042void ?{}(mary &this, float anotherdatum) {
     
    5355////////////////////////////////////////////////////////////
    5456
    55 void printMyFredsFwd(fred &f) {
    56         while (&f != 0p) {
     57void printMyFredsFwd(fred & f) {
     58    with( DLINK_VIA( fred, fred.mine ) )
     59        do {
    5760                sout | f.adatum;
    58                 &f = &f`in_mine`next;
    59         }
    60 }
    61 
    62 void printMyFredsRev(fred &f) {
    63         while (&f != 0p) {
     61        } while (f`moveNext);
     62}
     63
     64void printMyFredsRev(fred & f) {
     65    with( DLINK_VIA( fred, fred.mine ) )
     66        do {
    6467                sout | f.adatum;
    65                 &f = &f`in_mine`prev;
    66         }
    67 }
     68        } while (f`movePrev);
     69}
     70
    6871
    6972void printMyFreddies(fred &f1, fred &f2, int isBefore) {
     
    7376                sout | "==== fred by MINE after ";
    7477        }
    75         printMyFredsFwd(f1);    sout | '-';
    76         printMyFredsRev(f1);    sout | '-';
    77         printMyFredsFwd(f2);    sout | '-';
    78         printMyFredsRev(f2);    sout | '-';
    79 }
    80 
    81 void printYourFredsFwd(fred &f) {
    82         while (&f != 0p) {
     78        if (&f1) {
     79                printMyFredsFwd(f1);    sout | '-';
     80                printMyFredsRev(f1);    sout | '-';
     81        } else {
     82                sout | '-'; sout | '-';
     83        }
     84        if (&f2) {
     85                printMyFredsFwd(f2);    sout | '-';
     86                printMyFredsRev(f2);    sout | '-';
     87        } else {
     88                sout | '-'; sout | '-';
     89        }
     90}
     91
     92void printYourFredsFwd(fred & f) {
     93    with( DLINK_VIA( fred, fred.yours ) )
     94        do {
    8395                sout | f.adatum;
    84                 &f = &f`in_yours`next;
    85         }
    86 }
    87 
    88 void printYourFredsRev(fred &f) {
    89         while (&f != 0p) {
     96        } while (f`moveNext);
     97}
     98
     99void printYourFredsRev(fred & f) {
     100    with( DLINK_VIA( fred, fred.yours ) )
     101        do {
    90102                sout | f.adatum;
    91                 &f = &f`in_yours`prev;
    92         }
     103        } while (f`movePrev);
    93104}
    94105
     
    99110                sout | "==== fred by YOURS after ";
    100111        }
    101         printYourFredsFwd(f1);  sout | '-';
    102         printYourFredsRev(f1);  sout | '-';
    103         printYourFredsFwd(f2);  sout | '-';
    104         printYourFredsRev(f2);  sout | '-';
     112        if (&f1) {
     113                printYourFredsFwd(f1);  sout | '-';
     114                printYourFredsRev(f1);  sout | '-';
     115        } else {
     116                sout | '-'; sout | '-';
     117        }
     118        if (&f2) {
     119                printYourFredsFwd(f2);  sout | '-';
     120                printYourFredsRev(f2);  sout | '-';
     121        } else {
     122                sout | '-'; sout | '-';
     123        }
    105124}
    106125
    107126void printMariesFwd(mary &m) {
    108         while (&m != 0p) {
     127        do {
    109128                sout | m.anotherdatum;
    110                 &m = &m`next;
    111         }
     129        } while (m`moveNext);
    112130}
    113131
    114132void printMariesRev(mary &m) {
    115         while (&m != 0p) {
     133        do {
    116134                sout | m.anotherdatum;
    117                 &m = &m`prev;
    118         }
     135        } while (m`movePrev);
    119136}
    120137
     
    125142                sout | "==== mary after ";
    126143        }
    127         printMariesFwd(m1);     sout | '-';
    128         printMariesRev(m1);     sout | '-';
    129         printMariesFwd(m2);     sout | '-';
    130         printMariesRev(m2);     sout | '-';
     144        if (&m1) {
     145                printMariesFwd(m1);     sout | '-';
     146                printMariesRev(m1);     sout | '-';
     147        } else {
     148                sout | '-'; sout | '-';
     149        }
     150        if (&m2) {
     151                printMariesFwd(m2);     sout | '-';
     152                printMariesRev(m2);     sout | '-';
     153        } else {
     154                sout | '-'; sout | '-';
     155        }
    131156}
    132157
     
    153178//  - from list position #2 moving backward (d)
    154179// The expected-output comments are in form a;b;c;d where a::=num,num,num
    155 
     180#if 0
    156181void test__insertafter_singleton_on_singleton__fred_mine () {
    157182        fred f1 = {3.14};
     
    161186        printYourFreddies(f1, f2, 1);   // 3.14; 3.14; 0.5; 0.5
    162187
    163         insert_after(f1`in_mine, f2);
     188        diref(fred, fred.mine) f1_mine = f1`from;
     189        insert_after(f1_mine, f2);
    164190
    165191        printMyFreddies(f1, f2, 0);     // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
     
    174200        printYourFreddies(f1, f2, 1);   // 3.14; 3.14; 0.5; 0.5
    175201
    176         insert_after(f1`in_yours, f2);
     202        diref(fred, fred.yours) f1_yours = f1`from;
     203        insert_after(f1_yours, f2);
    177204
    178205        printMyFreddies(f1, f2, 0);     // 3.14; 3.14; 0.5; 0.5 (unmodified)
     
    208235        printYourFreddies(f1, f2, 1);   // 3.14; 3.14; 0.5; 0.5
    209236
    210         insert_before(f2`in_mine, f1);
     237        diref(fred, fred.mine) f2_mine = f2`from;
     238        insert_before(f2_mine, f1);
    211239
    212240        printMyFreddies(f1, f2, 0);     // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
     
    221249        printYourFreddies(f1, f2, 1);   // 3.14; 3.14; 0.5; 0.5
    222250
    223         insert_before(f2`in_yours, f1);
     251        diref(fred, fred.yours) f2_yours = f2`from;
     252        insert_before(f2_yours, f1);
    224253
    225254        printMyFreddies(f1, f2, 0);     // 3.14; 3.14; 0.5; 0.5 (unmodified)
     
    237266        printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    238267}
    239 
     268#endif
    240269////////////////////////////////////////////////////////////
    241270//
     
    250279// All three tests exercise the case of creating an empty container and
    251280// adding two items to it.
    252 
    253281void test__insertfirst_two_on_empty__fred_mine() {
    254282
     
    256284        fred f2 = {0.5};
    257285
    258         dlist(fred_in_mine, fred) lf;
     286        dlist(fred, fred.mine) lf;
    259287
    260288        verify(validate(lf));
     
    277305        fred f2 = {0.5};
    278306
    279         dlist(fred_in_yours, fred) lf;
     307        dlist(fred, fred.yours) lf;
    280308
    281309        verify(validate(lf));
     
    292320        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    293321}
    294 
    295322void test__insertfirst_two_on_empty__mary() {
    296323
     
    298325        mary m2 = {0.5};
    299326
    300         dlist(mary, mary) lm;
     327        dlist(mary) lm;
    301328
    302329        verify(validate(lm));
     
    325352        fred f2 = {0.5};
    326353
    327         dlist(fred_in_mine, fred) lf;
     354        dlist(fred, fred.mine) lf;
    328355
    329356        verify(validate(lf));
     
    346373        fred f2 = {0.5};
    347374
    348         dlist(fred_in_yours, fred) lf;
     375        dlist(fred, fred.yours) lf;
    349376
    350377        verify(validate(lf));
     
    367394        mary m2 = {0.5};
    368395
    369         dlist(mary, mary) lm;
     396        dlist(mary) lm;
    370397
    371398        verify(validate(lm));
     
    394421        fred f2 = {0.5};
    395422
    396         dlist(fred_in_mine, fred) lf;
    397 
    398         assert(& lf`first == 0p);
    399         assert(& lf`last == 0p);
     423        dlist(fred, fred.mine) lf;
     424
     425        assert( & lf`first == 0p );
     426        assert( & lf`last == 0p );
    400427
    401428        insert_first(lf, f1);
    402429
    403         assert(& lf`first == & f1);
    404         assert(& lf`last == & f1);
     430        assert( & lf`first == & f1 );
     431        assert( & lf`last  == & f1 );
    405432
    406433        verify(validate(lf));
    407434
    408         insert_after(f1`in_mine, f2);
     435        with ( DLINK_VIA(fred, fred.mine) ) insert_after(f1, f2);
    409436
    410437        verify(validate(lf));
     
    413440        printYourFreddies(f1, f2, 0);   // 3.14; 3.14; 0.5; 0.5 (unmodified)
    414441
    415         assert(& lf`first == & f1);
    416         assert(& lf`last == & f2);
     442        assert( & lf`first == & f1 );
     443        assert( & lf`last  == & f2 );
    417444}
    418445
     
    422449        fred f2 = {0.5};
    423450
    424         dlist(fred_in_yours, fred) lf;
    425 
    426         assert(& lf`first == 0p);
    427         assert(& lf`last == 0p);
     451        dlist(fred, fred.yours) lf;
     452
     453        assert( & lf`first == 0p );
     454        assert( & lf`last == 0p );
    428455
    429456        insert_first(lf, f1);
    430457
    431         assert(& lf`first == & f1);
    432         assert(& lf`last == & f1);
     458        assert( & lf`first == & f1 );
     459        assert( & lf`last  == & f1 );
    433460
    434461        verify(validate(lf));
    435462
    436         insert_after(f1`in_yours, f2);
     463    with ( DLINK_VIA(fred, fred.yours) ) insert_after(f1, f2);
    437464
    438465        verify(validate(lf));
     
    441468        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    442469
    443         assert(& lf`first == & f1);
    444         assert(& lf`last == & f2);
     470        assert( & lf`first == & f1 );
     471        assert( & lf`last  == & f2 );
    445472}
    446473
     
    450477        mary m2 = {0.5};
    451478
    452         dlist(mary, mary) lm;
    453 
    454         assert(& lm`first == 0p);
    455         assert(& lm`last == 0p);
     479        dlist(mary) lm;
     480
     481        assert( & lm`first == 0p );
     482        assert( & lm`last == 0p );
    456483
    457484        insert_first(lm, m1);
    458485
    459         assert(& lm`first == & m1);
    460         assert(& lm`last == & m1);
     486        assert( & lm`first == & m1 );
     487        assert( & lm`last  == & m1 );
    461488
    462489        verify(validate(lm));
     
    468495        printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    469496
    470         assert(& lm`first == & m1);
    471         assert(& lm`last == & m2);
     497        assert( & lm`first == & m1 );
     498        assert( & lm`last  == & m2 );
    472499}
    473500
     
    487514        fred f2 = {0.5};
    488515
    489         dlist(fred_in_mine, fred) lf;
    490 
    491         assert(& lf`first == 0p);
    492         assert(& lf`last == 0p);
     516        dlist(fred, fred.mine) lf;
     517
     518        assert( & lf`first == 0p );
     519        assert( & lf`last == 0p );
    493520
    494521        insert_last(lf, f2);
    495522
    496         assert(& lf`first == & f2);
    497         assert(& lf`last == & f2);
     523        assert( & lf`first == & f2 );
     524        assert( & lf`last  == & f2 );
    498525
    499526        verify(validate(lf));
    500527
    501         insert_before(f2`in_mine, f1);
     528        with ( DLINK_VIA(fred, fred.mine) ) insert_before(f2, f1);
    502529
    503530        verify(validate(lf));
     
    506533        printYourFreddies(f1, f2, 0);   // 3.14; 3.14; 0.5; 0.5 (unmodified)
    507534
    508         assert(& lf`first == & f1);
    509         assert(& lf`last == & f2);
     535        assert( & lf`first == & f1 );
     536        assert( & lf`last  == & f2 );
    510537}
    511538
     
    515542        fred f2 = {0.5};
    516543
    517         dlist(fred_in_yours, fred) lf;
    518 
    519         assert(& lf`first == 0p);
    520         assert(& lf`last == 0p);
     544        dlist(fred, fred.yours) lf;
     545
     546        assert( & lf`first == 0p );
     547        assert( & lf`last == 0p );
    521548
    522549        insert_last(lf, f2);
    523550
    524         assert(& lf`first == & f2);
    525         assert(& lf`last == & f2);
     551        assert( & lf`first == & f2 );
     552        assert( & lf`last  == & f2 );
    526553
    527554        verify(validate(lf));
    528555
    529         insert_before(f2`in_yours, f1);
     556        with ( DLINK_VIA(fred, fred.yours) )insert_before(f2, f1);
    530557
    531558        verify(validate(lf));
     
    534561        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    535562
    536         assert(& lf`first == & f1);
    537         assert(& lf`last == & f2);
     563        assert( & lf`first == & f1 );
     564        assert( & lf`last  == & f2 );
    538565}
    539566
     
    543570        mary m2 = {0.5};
    544571
    545         dlist(mary, mary) lm;
    546 
    547         assert(& lm`first == 0p);
    548         assert(& lm`last == 0p);
     572        dlist(mary) lm;
     573
     574        assert( & lm`first == 0p );
     575        assert( & lm`last == 0p );
    549576
    550577        insert_last(lm, m2);
    551578
    552         assert(& lm`first == & m2);
    553         assert(& lm`last == & m2);
     579        assert( & lm`first == & m2 );
     580        assert( & lm`last  == & m2 );
    554581
    555582        verify(validate(lm));
     
    561588        printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    562589
    563         assert(& lm`first == & m1);
    564         assert(& lm`last == & m2);
    565 }
     590        assert( & lm`first == & m1 );
     591        assert( & lm`last  == & m2 );
     592}
     593#if 0
    566594
    567595////////////////////////////////////////////////////////////
     
    846874//
    847875////////////////////////////////////////////////////////////
    848 
     876#endif
    849877void test__remove_at_head__fred_mine() {
    850878
     
    853881        fred f3 = {3.7};
    854882
    855         dlist(fred_in_mine, fred) flm;
     883        dlist(fred, fred.mine) flm;
    856884        insert_last(flm, f1);
    857885        insert_last(flm, f2);
    858886        insert_last(flm, f3);
    859887
    860         dlist(fred_in_yours, fred) fly;
     888        dlist(fred, fred.yours) fly;
    861889        insert_last(fly, f1);
    862890        insert_last(fly, f2);
     
    869897        verify(validate(flm));
    870898
    871         remove(f1`in_mine);
     899        with( DLINK_VIA(fred, fred.mine) ) remove(f1);
    872900
    873901        verify(validate(fly));
     
    881909
    882910        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    883         assert(f1.$links_mine.next.is_terminator == false);
    884         assert(f1.$links_mine.prev.is_terminator == false);
    885 }
     911        // assert(f1.$links_mine.next.is_terminator == false);
     912        // assert(f1.$links_mine.prev.is_terminator == false);
     913}
     914
    886915
    887916void test__remove_at_head__fred_yours() {
     
    891920        fred f3 = {3.7};
    892921
    893         dlist(fred_in_mine, fred) flm;
     922        dlist(fred, fred.mine) flm;
    894923        insert_last(flm, f1);
    895924        insert_last(flm, f2);
    896925        insert_last(flm, f3);
    897926
    898         dlist(fred_in_yours, fred) fly;
     927        dlist(fred, fred.yours) fly;
    899928        insert_last(fly, f1);
    900929        insert_last(fly, f2);
     
    907936        verify(validate(flm));
    908937
    909         remove(f1`in_yours);
     938        with( DLINK_VIA(fred, fred.yours) ) remove(f1);
    910939
    911940        verify(validate(fly));
     
    919948
    920949        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    921         assert(f1.$links_yours.next.is_terminator == false);
    922         assert(f1.$links_yours.prev.is_terminator == false);
     950        // assert(f1.$links_yours.next.is_terminator == false);
     951        // assert(f1.$links_yours.prev.is_terminator == false);
    923952}
    924953
     
    929958        mary m3 = {3.7};
    930959
    931         dlist(mary, mary) ml;
     960        dlist(mary) ml;
    932961        insert_last(ml, m1);
    933962        insert_last(ml, m2);
     
    948977
    949978        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    950         assert(m1.$links.next.is_terminator == false);
    951         assert(m1.$links.prev.is_terminator == false);
     979        // assert(m1.$links.next.is_terminator == false);
     980        // assert(m1.$links.prev.is_terminator == false);
    952981}
    953982
     
    968997        fred f3 = {3.7};
    969998
    970         dlist(fred_in_mine, fred) flm;
     999        dlist(fred, fred.mine) flm;
    9711000        insert_last(flm, f1);
    9721001        insert_last(flm, f2);
    9731002        insert_last(flm, f3);
    9741003
    975         dlist(fred_in_yours, fred) fly;
     1004        dlist(fred, fred.yours) fly;
    9761005        insert_last(fly, f1);
    9771006        insert_last(fly, f2);
     
    9841013        verify(validate(flm));
    9851014
    986         remove(f3`in_mine);
     1015        with( DLINK_VIA(fred, fred.mine) ) remove(f3);
    9871016
    9881017        verify(validate(fly));
     
    9961025
    9971026        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    998         assert(f3.$links_mine.next.is_terminator == false);
    999         assert(f3.$links_mine.prev.is_terminator == false);
     1027        // assert(f3.$links_mine.next.is_terminator == false);
     1028        // assert(f3.$links_mine.prev.is_terminator == false);
    10001029}
    10011030
     
    10061035        fred f3 = {3.7};
    10071036
    1008         dlist(fred_in_mine, fred) flm;
     1037        dlist(fred, fred.mine) flm;
    10091038        insert_last(flm, f1);
    10101039        insert_last(flm, f2);
    10111040        insert_last(flm, f3);
    10121041
    1013         dlist(fred_in_yours, fred) fly;
     1042        dlist(fred, fred.yours) fly;
    10141043        insert_last(fly, f1);
    10151044        insert_last(fly, f2);
     
    10221051        verify(validate(flm));
    10231052
    1024         remove(f3`in_yours);
     1053        with( DLINK_VIA(fred, fred.yours) ) remove(f3);
    10251054
    10261055        verify(validate(fly));
     
    10341063
    10351064        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    1036         assert(f3.$links_yours.next.is_terminator == false);
    1037         assert(f3.$links_yours.prev.is_terminator == false);
     1065        // assert(f3.$links_yours.next.is_terminator == false);
     1066        // assert(f3.$links_yours.prev.is_terminator == false);
    10381067}
    10391068
     
    10441073        mary m3 = {3.7};
    10451074
    1046         dlist(mary, mary) ml;
     1075        dlist(mary) ml;
    10471076        insert_last(ml, m1);
    10481077        insert_last(ml, m2);
     
    10631092
    10641093        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    1065         assert(m3.$links.next.is_terminator == false);
    1066         assert(m3.$links.prev.is_terminator == false);
     1094        // assert(m3.$links.next.is_terminator == false);
     1095        // assert(m3.$links.prev.is_terminator == false);
    10671096}
    10681097
     
    10811110        fred f = {0.7};
    10821111
    1083         dlist(fred_in_mine, fred) flm;
     1112        dlist(fred, fred.mine) flm;
    10841113        insert_last(flm, f);
    10851114
    1086         dlist(fred_in_yours, fred) fly;
     1115        dlist(fred, fred.yours) fly;
    10871116        insert_last(fly, f);
    10881117
     
    10931122        verify(validate(flm));
    10941123
    1095         remove(f`in_mine);
    1096 
    1097         verify(validate(fly));
    1098         verify(validate(flm));
    1099 
    1100         assert(& flm`first == 0p);
    1101         assert(& flm`last  == 0p);
     1124        with( DLINK_VIA(fred, fred.mine) ) remove(f);
     1125
     1126        verify(validate(fly));
     1127        verify(validate(flm));
     1128
     1129        assert( & flm`first == 0p );
     1130        assert( & flm`last == 0p );
    11021131
    11031132        printYourFreddies(fly`first, fly`last, 0);   // 0.7; 0.7; 0.7; 0.7 (unmodified)
     
    11071136
    11081137        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    1109         assert(f.$links_mine.next.is_terminator == false);
    1110         assert(f.$links_mine.prev.is_terminator == false);
     1138        // assert(f.$links_mine.next.is_terminator == false);
     1139        // assert(f.$links_mine.prev.is_terminator == false);
    11111140
    11121141        insert_last(flm, f);
     
    11201149        fred f = {0.7};
    11211150
    1122         dlist(fred_in_mine, fred) flm;
     1151        dlist(fred, fred.mine) flm;
    11231152        insert_last(flm, f);
    11241153
    1125         dlist(fred_in_yours, fred) fly;
     1154        dlist(fred, fred.yours) fly;
    11261155        insert_last(fly, f);
    11271156
     
    11321161        verify(validate(flm));
    11331162
    1134         remove(f`in_yours);
    1135 
    1136         verify(validate(fly));
    1137         verify(validate(flm));
    1138 
    1139         assert(& fly`first == 0p);
    1140         assert(& fly`last  == 0p);
     1163        with( DLINK_VIA(fred, fred.yours) ) remove(f);
     1164
     1165        verify(validate(fly));
     1166        verify(validate(flm));
     1167
     1168        assert( & fly`first == 0p );
     1169        assert( & fly`last == 0p );
    11411170
    11421171        printYourFreddies(flm`first, flm`last, 0);   // 0.7; 0.7; 0.7; 0.7 (unmodified)
     
    11461175
    11471176        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    1148         assert(f.$links_yours.next.is_terminator == false);
    1149         assert(f.$links_yours.prev.is_terminator == false);
     1177        // assert(f.$links_yours.next.is_terminator == false);
     1178        // assert(f.$links_yours.prev.is_terminator == false);
    11501179
    11511180        insert_last(fly, f);
     
    11591188        mary m = {0.7};
    11601189
    1161         dlist(mary, mary) ml;
     1190        dlist(mary) ml;
    11621191        insert_last(ml, m);
    11631192
     
    11701199        verify(validate(ml));
    11711200
    1172         assert(& ml`first == 0p);
    1173         assert(& ml`last  == 0p);
     1201        assert( & ml`first == 0p );
     1202        assert( & ml`last == 0p );
    11741203
    11751204        // observe f is solo in mine (now unlisted); in yours, it was just traversed
     
    11771206
    11781207        // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics
    1179         assert(m.$links.next.is_terminator == false);
    1180         assert(m.$links.prev.is_terminator == false);
     1208        // assert(m.$links.next.is_terminator == false);
     1209        // assert(m.$links.prev.is_terminator == false);
    11811210
    11821211        insert_last(ml, m);
     
    12031232        fred f3 = {3.7};
    12041233
    1205         dlist(fred_in_mine, fred) flm;
     1234        dlist(fred, fred.mine) flm;
    12061235        insert_last(flm, f1);
    12071236        insert_last(flm, f2);
    12081237        insert_last(flm, f3);
    12091238
    1210         dlist(fred_in_yours, fred) fly;
     1239        dlist(fred, fred.yours) fly;
    12111240        insert_last(fly, f1);
    12121241        insert_last(fly, f2);
     
    12191248        verify(validate(flm));
    12201249
    1221         fred & popped = pop_first(flm);
     1250        fred & popped = try_pop_front(flm);
    12221251
    12231252        verify(validate(fly));
     
    12391268        fred f3 = {3.7};
    12401269
    1241         dlist(fred_in_mine, fred) flm;
     1270        dlist(fred, fred.mine) flm;
    12421271        insert_last(flm, f1);
    12431272        insert_last(flm, f2);
    12441273        insert_last(flm, f3);
    12451274
    1246         dlist(fred_in_yours, fred) fly;
     1275        dlist(fred, fred.yours) fly;
    12471276        insert_last(fly, f1);
    12481277        insert_last(fly, f2);
     
    12551284        verify(validate(flm));
    12561285
    1257         fred & popped = pop_first(fly);
     1286        fred & popped = try_pop_front(fly);
    12581287
    12591288        verify(validate(fly));
     
    12751304        mary m3 = {3.7};
    12761305
    1277         dlist(mary, mary) ml;
     1306        dlist(mary) ml;
    12781307        insert_last(ml, m1);
    12791308        insert_last(ml, m2);
     
    12841313        verify(validate(ml));
    12851314
    1286         mary & popped = pop_first(ml);
     1315        mary & popped = try_pop_front(ml);
    12871316
    12881317        verify(validate(ml));
     
    13021331        fred f3 = {3.7};
    13031332
    1304         dlist(fred_in_mine, fred) flm;
     1333        dlist(fred, fred.mine) flm;
    13051334        insert_last(flm, f1);
    13061335        insert_last(flm, f2);
    13071336        insert_last(flm, f3);
    13081337
    1309         dlist(fred_in_yours, fred) fly;
     1338        dlist(fred, fred.yours) fly;
    13101339        insert_last(fly, f1);
    13111340        insert_last(fly, f2);
     
    13181347        verify(validate(flm));
    13191348
    1320         fred & popped = pop_last(flm);
     1349        fred & popped = try_pop_back(flm);
    13211350
    13221351        verify(validate(fly));
     
    13381367        fred f3 = {3.7};
    13391368
    1340         dlist(fred_in_mine, fred) flm;
     1369        dlist(fred, fred.mine) flm;
    13411370        insert_last(flm, f1);
    13421371        insert_last(flm, f2);
    13431372        insert_last(flm, f3);
    13441373
    1345         dlist(fred_in_yours, fred) fly;
     1374        dlist(fred, fred.yours) fly;
    13461375        insert_last(fly, f1);
    13471376        insert_last(fly, f2);
     
    13541383        verify(validate(flm));
    13551384
    1356         fred & popped = pop_last(fly);
     1385        fred & popped = try_pop_back(fly);
    13571386
    13581387        verify(validate(fly));
     
    13741403        mary m3 = {3.7};
    13751404
    1376         dlist(mary, mary) ml;
     1405        dlist(mary) ml;
    13771406        insert_last(ml, m1);
    13781407        insert_last(ml, m2);
     
    13831412        verify(validate(ml));
    13841413
    1385         mary & popped = pop_last(ml);
     1414        mary & popped = try_pop_back(ml);
    13861415
    13871416        verify(validate(ml));
     
    13971426////////////////////////////////////////////////////////////
    13981427//
     1428// Section 4g
     1429//
     1430// Test cases of `isEmpty, `hasPrev, `hasNext,
     1431// try_pop_front, try_pop_back, modifications via `elems
     1432//
     1433// Example of call-side user code
     1434//
     1435////////////////////////////////////////////////////////////
     1436
     1437void test__accessor_cases__mary() {
     1438
     1439        mary m1 = {1.7};
     1440        mary m2 = {2.7};
     1441        mary m3 = {3.7};
     1442
     1443        dlist(mary) ml;                 assert( ml`isEmpty);
     1444
     1445        insert_last(ml, m1);    assert(!ml`isEmpty);
     1446        insert_last(ml, m2);    assert(!ml`isEmpty);
     1447        insert_last(ml, m3);    assert(!ml`isEmpty);
     1448
     1449        mary & m1prev = m1`prev;
     1450        mary & m1next = m1`next;
     1451        mary & m2prev = m2`prev;
     1452        mary & m2next = m2`next;
     1453        mary & m3prev = m3`prev;
     1454        mary & m3next = m3`next;
     1455
     1456        assert (&m1prev == 0p);
     1457        assert (&m1next == &m2);
     1458        assert (&m2prev == &m1);
     1459        assert (&m2next == &m3);
     1460        assert (&m3prev == &m2);
     1461        assert (&m3next == 0p);
     1462
     1463        assert(!m1`hasPrev);
     1464        assert( m1`hasNext);
     1465        assert( m2`hasPrev);
     1466        assert( m2`hasNext);
     1467        assert( m3`hasPrev);
     1468        assert(!m3`hasNext);
     1469
     1470        printf("accessor_cases done\n");
     1471}
     1472
     1473void test__try_pop__mary() {
     1474
     1475        mary m1 = {1.7};
     1476        mary m2 = {2.7};
     1477        mary m3 = {3.7};
     1478
     1479        dlist(mary) ml;
     1480
     1481        mary &m1r = *0p;
     1482        mary &m2r = *0p;
     1483        mary &m3r = *0p;
     1484        mary &mxr = *0p;
     1485
     1486        // queue, back to front
     1487
     1488        assert( ml`isEmpty);
     1489
     1490        insert_last(ml, m1);
     1491        insert_last(ml, m2);
     1492        insert_last(ml, m3);
     1493
     1494        &m1r = & try_pop_front(ml);     assert(!ml`isEmpty);
     1495        &m2r = & try_pop_front(ml);     assert(!ml`isEmpty);
     1496        &m3r = & try_pop_front(ml);     assert( ml`isEmpty);
     1497        &mxr = & try_pop_front(ml);     assert( ml`isEmpty);
     1498
     1499        assert( &m1r == &m1 );
     1500        assert( &m2r == &m2 );
     1501        assert( &m3r == &m3 );
     1502        assert( &mxr == 0p  );
     1503
     1504        &m1r = 0p;
     1505        &m2r = 0p;
     1506        &m3r = 0p;
     1507
     1508        // queue, front to back
     1509
     1510        assert( ml`isEmpty);
     1511
     1512        insert_first(ml, m1);
     1513        insert_first(ml, m2);
     1514        insert_first(ml, m3);
     1515
     1516        &m1r = & try_pop_back(ml);      assert(!ml`isEmpty);
     1517        &m2r = & try_pop_back(ml);      assert(!ml`isEmpty);
     1518        &m3r = & try_pop_back(ml);      assert( ml`isEmpty);
     1519        &mxr = & try_pop_back(ml);      assert( ml`isEmpty);
     1520
     1521        assert( &m1r == &m1 );
     1522        assert( &m2r == &m2 );
     1523        assert( &m3r == &m3 );
     1524        assert( &mxr == 0p  );
     1525
     1526        &m1r = 0p;
     1527        &m2r = 0p;
     1528        &m3r = 0p;
     1529
     1530        // stack at front
     1531
     1532        assert( ml`isEmpty);
     1533
     1534        insert_first(ml, m1);
     1535        insert_first(ml, m2);
     1536        insert_first(ml, m3);
     1537
     1538        &m3r = & try_pop_front(ml);     assert(!ml`isEmpty);
     1539        &m2r = & try_pop_front(ml);     assert(!ml`isEmpty);
     1540        &m1r = & try_pop_front(ml);     assert( ml`isEmpty);
     1541        &mxr = & try_pop_front(ml);     assert( ml`isEmpty);
     1542
     1543        assert( &m1r == &m1 );
     1544        assert( &m2r == &m2 );
     1545        assert( &m3r == &m3 );
     1546        assert( &mxr == 0p  );
     1547
     1548        &m1r = 0p;
     1549        &m2r = 0p;
     1550        &m3r = 0p;
     1551
     1552        // stack at back
     1553
     1554        assert( ml`isEmpty);
     1555
     1556        insert_last(ml, m1);
     1557        insert_last(ml, m2);
     1558        insert_last(ml, m3);
     1559
     1560        &m3r = & try_pop_back(ml);      assert(!ml`isEmpty);
     1561        &m2r = & try_pop_back(ml);      assert(!ml`isEmpty);
     1562        &m1r = & try_pop_back(ml);      assert( ml`isEmpty);
     1563        &mxr = & try_pop_back(ml);      assert( ml`isEmpty);
     1564
     1565        assert( &m1r == &m1 );
     1566        assert( &m2r == &m2 );
     1567        assert( &m3r == &m3 );
     1568        assert( &mxr == 0p  );
     1569
     1570        &m1r = 0p;
     1571        &m2r = 0p;
     1572        &m3r = 0p;
     1573
     1574        printf("try_pop cases done\n");
     1575}
     1576
     1577void test__origin_mutation__mary() {
     1578
     1579        mary m1 = {1.7};
     1580
     1581        dlist(mary) ml;
     1582        mary & mlorigin = ml`elems;
     1583
     1584        // insert before the origin
     1585
     1586        insert_before( ml`elems, m1 );
     1587        assert( ! ml`isEmpty );
     1588
     1589        mary & mlfirst = ml`first;
     1590        mary & mllast = ml`last;
     1591
     1592        assert( &m1 == & mlfirst );
     1593        assert( &m1 == & mllast );
     1594
     1595        // moveNext after last goes back to origin, &vv
     1596
     1597        bool canMoveNext = mllast`moveNext;
     1598        bool canMovePrev = mlfirst`movePrev;
     1599
     1600        assert( ! canMoveNext );
     1601        assert( ! canMovePrev );
     1602
     1603        assert( &mlorigin == & mlfirst );
     1604        assert( &mlorigin == & mllast );
     1605
     1606        printf("origin_mutation cases done\n");
     1607}
     1608
     1609////////////////////////////////////////////////////////////
     1610//
    13991611// Section 5
    14001612//
     
    14041616
    14051617int main() {
    1406 
     1618#if 0
    14071619        sout | "~~~~~~~~~~~~~~~~~ Headless List Tests - insert_after ~~~~~~~~~~~~~~~~";
    14081620        sout | "";
     
    14411653        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
    14421654        test__insertbefore_singleton_on_singleton__mary();
    1443 
     1655#endif
    14441656        sout | "";
    14451657        sout | "~~~~~~~~~~~~~~~~~ Headed List Tests - insert_first ~~~~~~~~~~~~~~~~~~";
     
    15171729        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
    15181730        test__insertbefore_before_first__mary();
     1731#if 0
    15191732
    15201733        sout | "";
     
    15741787        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
    15751788        test__remove_at_last__mary();
    1576 
     1789#endif
    15771790        sout | "";
    15781791        sout | "~~~~~~~~~~ Element removal tests on Headed List: at first ~~~~~~~~~~";
     
    16701883        test__pop_last__maries();
    16711884
     1885        sout | "";
     1886        sout | "~~~~~~~~~~~~~~~~~~~ Ease-of-access cases ~~~~~~~~~~~~~~~~~~";
     1887        sout | "";
     1888
     1889        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1890        sout | "Test 18-i.  Modifying Freds on MINE";
     1891        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1892        sout | "Not implmented";
     1893
     1894        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1895        sout | "Test 18-ii.  Modifying Freds on YOURS";
     1896        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1897        sout | "Not implmented";
     1898
     1899        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1900        sout | "Test 18-iii.  Modifying Maries";
     1901        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
     1902
     1903        test__accessor_cases__mary();
     1904        test__try_pop__mary();
     1905        test__origin_mutation__mary();
     1906
    16721907        return 0;
    16731908}
Note: See TracChangeset for help on using the changeset viewer.