Changeset 1e5cd9a for tests


Ignore:
Timestamp:
May 12, 2021, 1:37:09 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
8cd40bf
Parents:
1680072 (diff), 7d51ef8 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
tests/list
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • tests/list/.expect/dlist-insert-remove-2.txt

    r1680072 r1e5cd9a  
    10921092-
    10931093-
     1094
     1095~~~~~~~~~~~~~~~~~~~ Ease-of-access cases ~~~~~~~~~~~~~~~~~~
     1096
     1097~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1098Test 18-i.  Modifying Freds on MINE
     1099~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1100Not implmented
     1101~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1102Test 18-ii.  Modifying Freds on YOURS
     1103~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1104Not implmented
     1105~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1106Test 18-iii.  Modifying Maries
     1107~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     1108accessor_cases done
     1109try_pop cases done
     1110origin_mutation cases done

  • tests/list/dlist-insert-remove-2.cfa

    r1680072 r1e5cd9a  
    5555////////////////////////////////////////////////////////////
    5656
    57 void printMyFredsFwd(diref(fred, fred.mine) f) {
     57void printMyFredsFwd(fred & f) {
     58    with( DLINK_VIA( fred, fred.mine ) )
    5859        do {
    5960                sout | f.adatum;
    … …  
    6162}
    6263
    63 void printMyFredsRev(diref(fred, fred.mine) f) {
     64void printMyFredsRev(fred & f) {
     65    with( DLINK_VIA( fred, fred.mine ) )
    6466        do {
    6567                sout | f.adatum;
    … …  
    7577        }
    7678        if (&f1) {
    77                 printMyFredsFwd(f1`from);       sout | '-';
    78                 printMyFredsRev(f1`from);       sout | '-';
     79                printMyFredsFwd(f1);    sout | '-';
     80                printMyFredsRev(f1);    sout | '-';
    7981        } else {
    8082                sout | '-'; sout | '-';
    8183        }
    8284        if (&f2) {
    83                 printMyFredsFwd(f2`from);       sout | '-';
    84                 printMyFredsRev(f2`from);       sout | '-';
     85                printMyFredsFwd(f2);    sout | '-';
     86                printMyFredsRev(f2);    sout | '-';
    8587        } else {
    8688                sout | '-'; sout | '-';
    … …  
    8890}
    8991
    90 void printYourFredsFwd(diref(fred, fred.yours) f) {
     92void printYourFredsFwd(fred & f) {
     93    with( DLINK_VIA( fred, fred.yours ) )
    9194        do {
    9295                sout | f.adatum;
    … …  
    9497}
    9598
    96 void printYourFredsRev(diref(fred, fred.yours) f) {
     99void printYourFredsRev(fred & f) {
     100    with( DLINK_VIA( fred, fred.yours ) )
    97101        do {
    98102                sout | f.adatum;
    … …  
    107111        }
    108112        if (&f1) {
    109                 printYourFredsFwd(f1`from);     sout | '-';
    110                 printYourFredsRev(f1`from);     sout | '-';
     113                printYourFredsFwd(f1);  sout | '-';
     114                printYourFredsRev(f1);  sout | '-';
    111115        } else {
    112116                sout | '-'; sout | '-';
    113117        }
    114118        if (&f2) {
    115                 printYourFredsFwd(f2`from);     sout | '-';
    116                 printYourFredsRev(f2`from);     sout | '-';
     119                printYourFredsFwd(f2);  sout | '-';
     120                printYourFredsRev(f2);  sout | '-';
    117121        } else {
    118122                sout | '-'; sout | '-';
    … …  
    275279// All three tests exercise the case of creating an empty container and
    276280// adding two items to it.
    277 
    278281void test__insertfirst_two_on_empty__fred_mine() {
    279282
    … …  
    317320        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    318321}
    319 
    320322void test__insertfirst_two_on_empty__mary() {
    321323
    … …  
    323325        mary m2 = {0.5};
    324326
    325         dlist(mary, mary) lm;
     327        dlist(mary) lm;
    326328
    327329        verify(validate(lm));
    … …  
    392394        mary m2 = {0.5};
    393395
    394         dlist(mary, mary) lm;
     396        dlist(mary) lm;
    395397
    396398        verify(validate(lm));
    … …  
    421423        dlist(fred, fred.mine) lf;
    422424
    423         assert(! lf`first);
    424         assert(! lf`last);
     425        assert( & lf`first == 0p );
     426        assert( & lf`last == 0p );
    425427
    426428        insert_first(lf, f1);
    427429
    428         assert(DUMB_COMPARE(lf`first, & f1));
    429         assert(DUMB_COMPARE(lf`last , & f1));
     430        assert( & lf`first == & f1 );
     431        assert( & lf`last  == & f1 );
    430432
    431433        verify(validate(lf));
    432434
    433         diref(fred, fred.mine) f1_mine = f1`from;
    434         insert_after(f1_mine, f2);
     435        with ( DLINK_VIA(fred, fred.mine) ) insert_after(f1, f2);
    435436
    436437        verify(validate(lf));
    … …  
    439440        printYourFreddies(f1, f2, 0);   // 3.14; 3.14; 0.5; 0.5 (unmodified)
    440441
    441         assert(DUMB_COMPARE(lf`first, & f1));
    442         assert(DUMB_COMPARE(lf`last , & f2));
     442        assert( & lf`first == & f1 );
     443        assert( & lf`last  == & f2 );
    443444}
    444445
    … …  
    450451        dlist(fred, fred.yours) lf;
    451452
    452         assert(! lf`first);
    453         assert(! lf`last);
     453        assert( & lf`first == 0p );
     454        assert( & lf`last == 0p );
    454455
    455456        insert_first(lf, f1);
    456457
    457         assert(DUMB_COMPARE(lf`first, & f1));
    458         assert(DUMB_COMPARE(lf`last , & f1));
     458        assert( & lf`first == & f1 );
     459        assert( & lf`last  == & f1 );
    459460
    460461        verify(validate(lf));
    461462
    462         diref(fred, fred.yours) f1_yours = f1`from;
    463         insert_after(f1_yours, f2);
     463    with ( DLINK_VIA(fred, fred.yours) ) insert_after(f1, f2);
    464464
    465465        verify(validate(lf));
    … …  
    468468        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    469469
    470         assert(DUMB_COMPARE(lf`first, & f1));
    471         assert(DUMB_COMPARE(lf`last , & f2));
     470        assert( & lf`first == & f1 );
     471        assert( & lf`last  == & f2 );
    472472}
    473473
    … …  
    477477        mary m2 = {0.5};
    478478
    479         dlist(mary, mary) lm;
    480 
    481         assert(! lm`first);
    482         assert(! lm`last);
     479        dlist(mary) lm;
     480
     481        assert( & lm`first == 0p );
     482        assert( & lm`last == 0p );
    483483
    484484        insert_first(lm, m1);
    485485
    486         assert(DUMB_COMPARE(lm`first, & m1));
    487         assert(DUMB_COMPARE(lm`last , & m1));
     486        assert( & lm`first == & m1 );
     487        assert( & lm`last  == & m1 );
    488488
    489489        verify(validate(lm));
    … …  
    495495        printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    496496
    497         assert(DUMB_COMPARE(lm`first, & m1));
    498         assert(DUMB_COMPARE(lm`last , & m2));
     497        assert( & lm`first == & m1 );
     498        assert( & lm`last  == & m2 );
    499499}
    500500
    … …  
    516516        dlist(fred, fred.mine) lf;
    517517
    518         assert(! lf`first);
    519         assert(! lf`last);
     518        assert( & lf`first == 0p );
     519        assert( & lf`last == 0p );
    520520
    521521        insert_last(lf, f2);
    522522
    523         assert(DUMB_COMPARE(lf`first, & f2));
    524         assert(DUMB_COMPARE(lf`last , & f2));
     523        assert( & lf`first == & f2 );
     524        assert( & lf`last  == & f2 );
    525525
    526526        verify(validate(lf));
    527527
    528         diref(fred, fred.mine) f2_mine = f2`from;
    529         insert_before(f2_mine, f1);
     528        with ( DLINK_VIA(fred, fred.mine) ) insert_before(f2, f1);
    530529
    531530        verify(validate(lf));
    … …  
    534533        printYourFreddies(f1, f2, 0);   // 3.14; 3.14; 0.5; 0.5 (unmodified)
    535534
    536         assert(DUMB_COMPARE(lf`first, & f1));
    537         assert(DUMB_COMPARE(lf`last , & f2));
     535        assert( & lf`first == & f1 );
     536        assert( & lf`last  == & f2 );
    538537}
    539538
    … …  
    545544        dlist(fred, fred.yours) lf;
    546545
    547         assert(! lf`first);
    548         assert(! lf`last);
     546        assert( & lf`first == 0p );
     547        assert( & lf`last == 0p );
    549548
    550549        insert_last(lf, f2);
    551550
    552         assert(DUMB_COMPARE(lf`first, & f2));
    553         assert(DUMB_COMPARE(lf`last , & f2));
     551        assert( & lf`first == & f2 );
     552        assert( & lf`last  == & f2 );
    554553
    555554        verify(validate(lf));
    556555
    557         diref(fred, fred.yours) f2_yours = f2`from;
    558         insert_before(f2_yours, f1);
     556        with ( DLINK_VIA(fred, fred.yours) )insert_before(f2, f1);
    559557
    560558        verify(validate(lf));
    … …  
    563561        printYourFreddies(f1, f2, 0);   // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    564562
    565         assert(DUMB_COMPARE(lf`first, & f1));
    566         assert(DUMB_COMPARE(lf`last , & f2));
     563        assert( & lf`first == & f1 );
     564        assert( & lf`last  == & f2 );
    567565}
    568566
    … …  
    572570        mary m2 = {0.5};
    573571
    574         dlist(mary, mary) lm;
    575 
    576         assert(! lm`first);
    577         assert(! lm`last);
     572        dlist(mary) lm;
     573
     574        assert( & lm`first == 0p );
     575        assert( & lm`last == 0p );
    578576
    579577        insert_last(lm, m2);
    580578
    581         assert(DUMB_COMPARE(lm`first, & m2));
    582         assert(DUMB_COMPARE(lm`last , & m2));
     579        assert( & lm`first == & m2 );
     580        assert( & lm`last  == & m2 );
    583581
    584582        verify(validate(lm));
    … …  
    590588        printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified)
    591589
    592         assert(DUMB_COMPARE(lm`first, & m1));
    593         assert(DUMB_COMPARE(lm`last , & m2));
    594 }
    595 
     590        assert( & lm`first == & m1 );
     591        assert( & lm`last  == & m2 );
     592}
    596593#if 0
    597594
    … …  
    900897        verify(validate(flm));
    901898
    902         diref(fred, fred.mine) f1_mine = f1`from;
    903         remove(f1_mine);
     899        with( DLINK_VIA(fred, fred.mine) ) remove(f1);
    904900
    905901        verify(validate(fly));
    … …  
    916912        // assert(f1.$links_mine.prev.is_terminator == false);
    917913}
     914
    918915
    919916void test__remove_at_head__fred_yours() {
    … …  
    939936        verify(validate(flm));
    940937
    941         diref(fred, fred.yours) f1_yours = f1`from;
    942         remove(f1_yours);
     938        with( DLINK_VIA(fred, fred.yours) ) remove(f1);
    943939
    944940        verify(validate(fly));
    … …  
    962958        mary m3 = {3.7};
    963959
    964         dlist(mary, mary) ml;
     960        dlist(mary) ml;
    965961        insert_last(ml, m1);
    966962        insert_last(ml, m2);
    … …  
    10171013        verify(validate(flm));
    10181014
    1019         diref(fred, fred.mine) f3_mine = f3`from;
    1020         remove(f3_mine);
     1015        with( DLINK_VIA(fred, fred.mine) ) remove(f3);
    10211016
    10221017        verify(validate(fly));
    … …  
    10561051        verify(validate(flm));
    10571052
    1058         diref(fred, fred.yours) f3_yours = f3`from;
    1059         remove(f3_yours);
     1053        with( DLINK_VIA(fred, fred.yours) ) remove(f3);
    10601054
    10611055        verify(validate(fly));
    … …  
    10791073        mary m3 = {3.7};
    10801074
    1081         dlist(mary, mary) ml;
     1075        dlist(mary) ml;
    10821076        insert_last(ml, m1);
    10831077        insert_last(ml, m2);
    … …  
    11281122        verify(validate(flm));
    11291123
    1130         diref(fred, fred.mine) f_mine = f`from;
    1131         remove(f_mine);
    1132 
    1133         verify(validate(fly));
    1134         verify(validate(flm));
    1135 
    1136         assert(! flm`first);
    1137         assert(! flm`last);
     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 );
    11381131
    11391132        printYourFreddies(fly`first, fly`last, 0);   // 0.7; 0.7; 0.7; 0.7 (unmodified)
    … …  
    11681161        verify(validate(flm));
    11691162
    1170         diref(fred, fred.yours) f_yours = f`from;
    1171         remove(f_yours);
    1172 
    1173         verify(validate(fly));
    1174         verify(validate(flm));
    1175 
    1176         assert(! fly`first);
    1177         assert(! fly`last);
     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 );
    11781170
    11791171        printYourFreddies(flm`first, flm`last, 0);   // 0.7; 0.7; 0.7; 0.7 (unmodified)
    … …  
    11961188        mary m = {0.7};
    11971189
    1198         dlist(mary, mary) ml;
     1190        dlist(mary) ml;
    11991191        insert_last(ml, m);
    12001192
    … …  
    12071199        verify(validate(ml));
    12081200
    1209         assert(! ml`first);
    1210         assert(! ml`last);
     1201        assert( & ml`first == 0p );
     1202        assert( & ml`last == 0p );
    12111203
    12121204        // observe f is solo in mine (now unlisted); in yours, it was just traversed
    … …  
    12561248        verify(validate(flm));
    12571249
    1258         fred & popped = remove(flm`first);
     1250        fred & popped = try_pop_front(flm);
    12591251
    12601252        verify(validate(fly));
    … …  
    12921284        verify(validate(flm));
    12931285
    1294         fred & popped = remove(fly`first);
     1286        fred & popped = try_pop_front(fly);
    12951287
    12961288        verify(validate(fly));
    … …  
    13121304        mary m3 = {3.7};
    13131305
    1314         dlist(mary, mary) ml;
     1306        dlist(mary) ml;
    13151307        insert_last(ml, m1);
    13161308        insert_last(ml, m2);
    … …  
    13211313        verify(validate(ml));
    13221314
    1323         mary & popped = remove(ml`first);
     1315        mary & popped = try_pop_front(ml);
    13241316
    13251317        verify(validate(ml));
    … …  
    13551347        verify(validate(flm));
    13561348
    1357         fred & popped = remove(flm`last);
     1349        fred & popped = try_pop_back(flm);
    13581350
    13591351        verify(validate(fly));
    … …  
    13911383        verify(validate(flm));
    13921384
    1393         fred & popped = remove(fly`last);
     1385        fred & popped = try_pop_back(fly);
    13941386
    13951387        verify(validate(fly));
    … …  
    14111403        mary m3 = {3.7};
    14121404
    1413         dlist(mary, mary) ml;
     1405        dlist(mary) ml;
    14141406        insert_last(ml, m1);
    14151407        insert_last(ml, m2);
    … …  
    14201412        verify(validate(ml));
    14211413
    1422         mary & popped = remove(ml`last);
     1414        mary & popped = try_pop_back(ml);
    14231415
    14241416        verify(validate(ml));
    … …  
    14301422
    14311423        assert( &popped == &m3 );
     1424}
     1425
     1426////////////////////////////////////////////////////////////
     1427//
     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");
    14321607}
    14331608
    … …  
    17081883        test__pop_last__maries();
    17091884
     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
    17101907        return 0;
    17111908}
Note: See TracChangeset for help on using the changeset viewer.