test fixes

diff --git a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
index 508289d..7c80022 100644 (file)
--- a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
+++ b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
@@ -124,16 +124,8 @@ public class MarinaTest {
     private void pr(String msg) {indenter.pr(msg);}
     private void adjustIndent(int n) {indenter.adjustIndent(n);}
         
-    public static void fatal(boolean pred, String msg) {
-        if (pred) {
-            Exception err = new Exception(msg);
-            err.printStackTrace();
-            System.out.println("Test Result: Test Failed");
+    public static void fatal(boolean pred, String msg) { MarinaUtils.fatal(pred, msg); }
 
-            printTestTime();
-            Infrastructure.exit(2);
-        }
-    }
     public static void fatalIfBitVectorsDoNotMatch(BitVector bv1, BitVector bv2) {
         // FIXME: better error reporting needed here
 
@@ -499,6 +491,7 @@ public class MarinaTest {
         int nbToks = marina.getNumTokens();
         fatal(nbToks!=0, "Expected no tokens on initialization but got: "+nbToks+" tokens");
 
+        marina.instrIn.fill(setIlc(1));
         marina.instrIn.fill(SEND_TOKEN);
         nbToks = marina.getNumTokens();
         fatal(nbToks!=1, "Expected one token to emerge but got: "+nbToks+" tokens");
@@ -515,6 +508,7 @@ public class MarinaTest {
         for(int i=0; i<bv.length(); i+=2) bv.set(i, false);
         MarinaPath path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(), bv);
 
+        marina.instrIn.fill(setIlc(1));
         marina.instrIn.fill(SEND_DATA);
         
         List<BitVector> dataItems = marina.data.drainMany();
@@ -549,6 +543,9 @@ public class MarinaTest {
     private Instruction setOlc(int olc) {
         return new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, olc);
     }
+    private Instruction setIlc(int ilc) {
+        return new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, ilc);
+    }
 
     private void testFlagD(Marina marina) {
         prln("Begin testFlagD");
@@ -559,9 +556,11 @@ public class MarinaTest {
         Predicate only_if_olc_zero    = Predicate.FlagD;
         Predicate only_if_olc_nonzero = Predicate.Default;
 
+        marina.instrIn.fill(setIlc(1));
+
         for(int olc : new int[] { 1, 0 }) {
             for(boolean predicate_olc_nonzero : new boolean[] { true, false }) {
-                prln("Attempting send token with "+
+                prln("Attempting send data item with "+
                      "olc=="+olc+" and "+
                      "predicate olc"+(predicate_olc_nonzero?"!=0":"==0"));
                 adjustIndent(2);
@@ -583,9 +582,7 @@ public class MarinaTest {
                                              false                  // tokenOut    
                                              ),
                     });
-                toks = marina.data.drainMany();
-                int expected = (predicate_olc_nonzero == (olc!=0)) ? 1 : 0;
-                fatal(toks.size()!=expected, "Expected "+expected+" token to emerge but got: "+toks.size()+" token(s)");
+                expectNorthFifoExactly((predicate_olc_nonzero == (olc!=0)) ? 1 : 0);
                 adjustIndent(-2);
             }
         }
@@ -727,8 +724,8 @@ public class MarinaTest {
                                                  ));
         
         // wait for ILC to count from 63 to 0
-        //model.waitNS(64 * CYCLE_TIME_NS);
-        model.waitNS(10000);
+        model.waitNS(128 * CYCLE_TIME_NS);
+        //model.waitNS(10000);
 
         prln("Check that ILC==0");
         ilc = marina.getILC().getCount();
@@ -873,12 +870,14 @@ public class MarinaTest {
 
 
     private void expectNorthFifoNoMoreThan(int num) {
+        model.waitNS(128 * CYCLE_TIME_NS);
         List<BitVector> dataItems = marina.data.drainMany(num+1);
         fatal(dataItems.size()>num,
               "Expected no more than "+num+
               " data items to emerge but got at least: "+dataItems.size());
     }
     private void expectNorthFifoExactly(int num) {
+        model.waitNS(128 * CYCLE_TIME_NS);
         List<BitVector> dataItems = marina.data.drainMany(num+1);
         fatal(dataItems.size()!=num,
               "Expected exactly "+num+
@@ -899,6 +898,7 @@ public class MarinaTest {
     }
 
     private void testFlagDRecomputationTime(Marina marina) {
+        marina.instrIn.fill(setIlc(1));
         marina.fillSouthProperStopper(new Instruction[] {
                 RECV_DATA,
                 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
@@ -937,6 +937,7 @@ public class MarinaTest {
     }
 
     private void testTailWaitsForHead(Marina marina) {
+        marina.instrIn.fill(setIlc(1));
         marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
 
         marina.enableInstructionSend(false);
@@ -964,6 +965,7 @@ public class MarinaTest {
     }
 
     private void testTailWithoutHead(Marina marina) {
+        marina.instrIn.fill(setIlc(1));
         marina.fillSouthProperStopper(new Instruction[] {
                 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
                 new Instruction.Tail(dock),
@@ -979,6 +981,7 @@ public class MarinaTest {
         prln("Begin testHeadWaitsForTail");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
         marina.fillSouthProperStopper(new Instruction[] {
                 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
                 new Instruction.Head(dock),
@@ -997,6 +1000,7 @@ public class MarinaTest {
     }
 
     private void testNonTorpedoableMoveDoesNotResetDFlag(Marina marina) {
+        marina.instrIn.fill(setIlc(1));
         marina.fillSouthProperStopper(new Instruction[] {
                 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,3),
                 new Instruction.Move(dock,
@@ -1042,6 +1046,7 @@ public class MarinaTest {
 
     private void testAbort(Marina marina) {
 
+        marina.instrIn.fill(setIlc(1));
         marina.fillSouthProperStopper(new Instruction[] {
                 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.DataLatch,1),
                 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
@@ -1057,16 +1062,19 @@ public class MarinaTest {
         for(int i=0; i<4; i++) {
             BitVector bv;
 
+            model.waitNS(128 * CYCLE_TIME_NS);
             bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
             fatal(bv==null, "no data item found");
             prln("got " + bv.toLong());
             fatal(bv.toLong()!=1, "expected 1, got " + bv.toLong());
 
+            model.waitNS(128 * CYCLE_TIME_NS);
             bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
             fatal(bv==null, "no data item found");
             prln("got " + bv.toLong());
             fatal(bv.toLong()!=1, "expected 1, got " + bv.toLong());
 
+            model.waitNS(128 * CYCLE_TIME_NS);
             bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
             fatal(bv==null, "no data item found");
             prln("got " + bv.toLong());
@@ -1076,6 +1084,7 @@ public class MarinaTest {
     }
 
     private void testAbortOutsideOfLoop(Marina marina) {
+        marina.instrIn.fill(setIlc(1));
         marina.fillSouthProperStopper(new Instruction[] {
                 // ensure that an abort doesn't cause problems if no loop is in progress
                 new Instruction.Abort(dock, Predicate.IgnoreFlagD),
@@ -1103,18 +1112,34 @@ public class MarinaTest {
         one = one.add(Predicate.FlagC);
         one = one.add(Predicate.NotFlagC);
 
-        // clear the flags to a known state, then check both 0->1 and 1->0 transitions
-        for(boolean b : new boolean[] { false, true, false }) {
-            prln("state: a="+marina.getFlagA()+", b="+marina.getFlagB());
-            prln((b?"Setting":"Clearing")+" flags");
+        marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
+        for(boolean fast : new boolean[] { true, false }) {
+            // clear the flags to a known state, then check both 0->1 and 1->0 transitions
+            for(boolean b : new boolean[] { false, true, false }) {
+                prln("state: a="+marina.getFlagA()+", b="+marina.getFlagB());
+                prln((b?"Setting":"Clearing")+" flags");
+                
+                Instruction inst = new Instruction.Set(dock,Predicate.IgnoreFlagD,
+                                                       b ? one : zero,
+                                                       b ? one : zero
+                                                       );
+                if (fast) {
+                    marina.fillSouthProperStopper(new Instruction[] {
+                            RECV_DATA,
+                            inst,
+                            setOlc(1),
+                        });
+                    model.waitNS(64 * CYCLE_TIME_NS);
+                    marina.fillNorthProperStopper();
+                } else {
+                    marina.instrIn.fill(inst);
+                }
 
-            marina.instrIn.fill(new 
-                                Instruction.Set(dock,Predicate.IgnoreFlagD,
-                                                b ? one : zero,
-                                                b ? one : zero
-                                                ));
-            fatal(marina.getFlagA()!=b, "after "+(b?"setting":"clearing")+" FlagA, it was still "+(b?"clear":"set"));
-            fatal(marina.getFlagB()!=b, "after "+(b?"setting":"clearing")+" FlagB, it was still "+(b?"clear":"set"));
+                fatal(marina.getFlagA()!=b,
+                      "after "+(b?"setting":"clearing")+" FlagA, it was still "+(b?"clear":"set"));
+                fatal(marina.getFlagB()!=b,
+                      "after "+(b?"setting":"clearing")+" FlagB, it was still "+(b?"clear":"set"));
+            }
         }
 
         adjustIndent(-2);
@@ -1129,6 +1154,7 @@ public class MarinaTest {
         prln("Begin testFlagTruthTable");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
         Instruction.Set.FlagFunction zero = Instruction.Set.FlagFunction.ZERO;
         Instruction.Set.FlagFunction one  = zero.add(Predicate.FlagA).add(Predicate.NotFlagA);
 
@@ -1186,6 +1212,7 @@ public class MarinaTest {
         prln("Begin recvData");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
         marina.fillSouthProperStopper(new Instruction[] {
                 new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
                 new Instruction.Move(dock,
@@ -1226,6 +1253,8 @@ public class MarinaTest {
         prln("Begin testRecvAndSendWalkingOne");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
+
         List<BitVector> dataItems;
         for(int bit=0; bit<37; bit++) {
 
@@ -1275,6 +1304,8 @@ public class MarinaTest {
         prln("Begin setOlcFromDataLatch");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
+
         // walk a bit from 0 to 5
         for(int bit=0; bit<6; bit++) {
             prln("inserting data item in north fifo ring");
@@ -1302,6 +1333,8 @@ public class MarinaTest {
         prln("Begin setIlcFromDataLatch");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
+
         // walk a bit from 0 to 5
         for(int bit=5; bit>=0; bit--) {
             prln("inserting data item in north fifo ring");
@@ -1331,6 +1364,7 @@ public class MarinaTest {
         prln("Begin testSendAndRecvToken");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
         marina.fillSouthProperStopper(new Instruction[] {
                 SEND_TOKEN,
                 RECV_TOKEN,
@@ -1348,6 +1382,7 @@ public class MarinaTest {
         prln("Begin testSignExtendedLiteral");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
         for(long val : new long[] { (-1L << 14), -1, 0, 1 }) {
 
             marina.fillSouthProperStopper(new Instruction[] {
@@ -1383,6 +1418,7 @@ public class MarinaTest {
         prln("Begin testShiftedLiteral");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
         marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,
                                                 Instruction.Set.SetDest.DataLatch,
                                                 0));
@@ -1433,6 +1469,7 @@ public class MarinaTest {
         // Dc=1 => sigS is copied into C-flag
         // Dc=0 => sigA is copied into C-flag
        
+        marina.instrIn.fill(setIlc(1));
         for(boolean dc : new boolean[] { false, true }) {
             for(boolean c_flag : new boolean[] { true, false, true }) {
 
@@ -1489,6 +1526,7 @@ public class MarinaTest {
         adjustIndent(2);
 
         edu.berkeley.fleet.api.BitVector bv = new edu.berkeley.fleet.api.BitVector(13);
+        marina.instrIn.fill(setIlc(1));
 
         // alternating ones and zeroes
         for(int i=0; i<bv.length(); i+=2)
@@ -1554,6 +1592,7 @@ public class MarinaTest {
         prln("Begin recvPath");
         adjustIndent(2);
 
+        marina.instrIn.fill(setIlc(1));
         for(int bit=0; bit<11; bit++) {
             BitVector packet_data = new BitVector(37, "inbound data item");
             for(int i=0; i<37; i++) packet_data.set(i, false);
@@ -1621,6 +1660,7 @@ public class MarinaTest {
     private void sendTorpedo(Marina marina) {
         prln("Begin sendTorpedo");
         adjustIndent(2);
+        marina.instrIn.fill(setIlc(1));
         marina.instrIn.fill(new 
                             Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 1));
         int olc = marina.getOLC();
@@ -1689,6 +1729,7 @@ public class MarinaTest {
 
         List<BitVector> dataItems;
 
+        marina.instrIn.fill(setIlc(1));
         for(boolean torpedoable : new boolean[] { true, false }) {
             
             marina.fillSouthProperStopper(new Instruction[] {
@@ -1885,7 +1926,7 @@ public class MarinaTest {
             BitVector path = new BitVector(MarinaPacket.PATH_WIDTH, "path");
             BitVector data = new BitVector(MarinaPacket.WORD_WIDTH, "path");
             path.set(0, MarinaPacket.PATH_WIDTH, false);
-            data.setFromLong(i+1);
+            data.setFromLong(i+9);
             marina.instrIn.fill(new MarinaPacket(data, false, path));
         }
         adjustIndent(-2);
@@ -1897,7 +1938,7 @@ public class MarinaTest {
         for (int i=0; i<AMOUNT; i++) {
             prln("extracting item " + (i+1) + " / " + AMOUNT);
             //int expect = (i+Marina.SOUTH_RING_CAPACITY-1) % Marina.SOUTH_RING_CAPACITY;
-            int expect = i+1;
+            int expect = i+9;
             long got = new MarinaPacket(out.get(i)).data.toLong();
             if (got!=expect) {
                 bad = true;
@@ -1922,121 +1963,126 @@ public class MarinaTest {
         marina.masterClear();
         marina.enableInstructionSend(true);
         
-        switch (testNum) {
-            case 0: {
-
-                // these tests run fairly quickly
-                doOneTest(1);
-                doOneTest(2);
-                doOneTest(3);
-                doOneTest(4);
-                doOneTest(5);
-                doOneTest(6);
-                doOneTest(1000);
-                doOneTest(1001);
-                doOneTest(1003);
-                doOneTest(3000);
-                doOneTest(3001);
-                doOneTest(3003);
-                doOneTest(3004);
-                doOneTest(3005);
-                doOneTest(3006);
-                doOneTest(3007);
-                doOneTest(3008);
-                doOneTest(3009);
-                doOneTest(3010);
-                doOneTest(3011);
-                doOneTest(3012);
-                doOneTest(3013);
-                doOneTest(3014);
-                doOneTest(3015);
-                doOneTest(3019);
-                doOneTest(3020);
-                doOneTest(3022);
-                doOneTest(3023);
-                doOneTest(3026);
-                doOneTest(3027);
-                doOneTest(3028);
-
-                // these tests take a while and usually pass
-                doOneTest(1002);
-                doOneTest(1004);
-                doOneTest(1005);
-                doOneTest(1006);
-                doOneTest(3002);
-                doOneTest(3016);
-                doOneTest(3021);
-                doOneTest(3024);
-                doOneTest(3025);
-
-                // this takes an insanely long time
-                doOneTest(3017);
+        
+        try {
+            switch (testNum) {
+                case 0: {
+
+                    // these tests run fairly quickly
+                    doOneTest(1);       // passes extracted parasitics
+                    doOneTest(2);       // passes extracted parasitics
+                    doOneTest(3);       // passes extracted parasitics
+                    doOneTest(4);       // passes extracted parasitics
+                    doOneTest(5);       // passes extracted parasitics
+                    doOneTest(6);       // passes extracted parasitics
+                    doOneTest(1000);    // passes extracted parasitics
+                    doOneTest(1001);    // passes extracted parasitics
+                    doOneTest(1003);    // passes extracted parasitics
+                    doOneTest(3000);    // passes extracted parasitics
+                    doOneTest(3001);    // passes extracted parasitics
+                    doOneTest(3003);    // passes extracted parasitics
+                    doOneTest(3004);    // passes extracted parasitics
+                    doOneTest(3005);    // passes extracted parasitics
+                    doOneTest(3006);    // passes extracted parasitics
+                    doOneTest(3007);    // passes extracted parasitics
+                    doOneTest(3008);    // passes extracted parasitics
+                    doOneTest(3009);    // fails extracted parasitics
+                    doOneTest(3010);    // passes extracted parasitics
+                    doOneTest(3011);    // passes extracted parasitics
+                    doOneTest(3012);    // passes extracted parasitics
+                    doOneTest(3013);    // passes extracted parasitics
+                    doOneTest(3014);    // passes extracted parasitics
+                    doOneTest(3015);    // fails extracted parasitics
+                    doOneTest(3019);    // fails extracted parasitics
+                    doOneTest(3020);    // passes extracted parasitics
+                    doOneTest(3022);    // passes extracted parasitics
+                    doOneTest(3023);    // passes extracted parasitics
+                    doOneTest(3026);    // passes extracted parasitics
+                    doOneTest(3027);    // passes extracted parasitics
+                    doOneTest(3028);    // passes extracted parasitics
+
+                    // these tests take a while and usually pass
+                    doOneTest(1002);
+                    doOneTest(1004);
+                    doOneTest(1005);
+                    doOneTest(1006);
+                    doOneTest(3002);
+                    doOneTest(3016);
+                    doOneTest(3021);
+                    doOneTest(3024);
+                    doOneTest(3025);
+
+                    // this takes an insanely long time
+                    doOneTest(3017);
 
-                break;
-            }
-            case 1:    testChains(marina);                     break; // passes, 24-Mar (+verilog)
-            case 2:    testProperStoppers(marina);             break; // passes, 24-Mar (+verilog)
-            case 3:    testSouthRecirculate(marina, 1);        break; // passes, 24-Mar (+verilog)
-            case 4:    getCtrsFlags(marina);                   break; //         20-Apr (+verilog)
-            case 5:    sendInstructions(marina);               break; // passes, 24-Mar (+verilog)
-            case 6:    walkOneOLC(marina);                     break; //         21-Apr (+verilog)
+                    break;
+                }
+                case 1:    testChains(marina);                     break; // passes, 24-Mar (+verilog)
+                case 2:    testProperStoppers(marina);             break; // passes, 24-Mar (+verilog)
+                case 3:    testSouthRecirculate(marina, 1);        break; // passes, 24-Mar (+verilog)
+                case 4:    getCtrsFlags(marina);                   break; //         20-Apr (+verilog)
+                case 5:    sendInstructions(marina);               break; // passes, 24-Mar (+verilog)
+                case 6:    walkOneOLC(marina);                     break; //         21-Apr (+verilog)
                 
-                // Russell's tests begin with 1000
-            case 1000: walkOneILC(marina);                     break; //         20-Apr (+verilog)
-            case 1001: countIlc(marina);                       break; //         20-Apr (+verilog)
-            case 1002: countOlc(marina);                       break; //         23-Apr (+verilog)
-
-            case 1003: sendTorpedo(marina);                    break; //         23-Apr (+verilog)  [with wor-hack]
-
-            case 1004: flipIlcBit(marina);                     break; //         20-Apr (+verilog)
-            case 1005: flipOlcBit(marina);                     break; //         21-Apr (+verilog)
-
-            case 1006: testSouthRecirculate(marina, Marina.SOUTH_RING_CAPACITY-1);        break; // passes, 24-Mar (+verilog)
-
-                // Adam's tests begin with 3000
-            case 3000: sendToken(marina);                      break; // passes, 24-Mar (+verilog)
-            case 3001: testFlagAB(marina);                     break; // passes, 08-Apr (+verilog)
-            case 3002: testPredicationOnAB(marina);            break; //         22-Apr (+verilog)
-            case 3003: testFlagC(marina);                      break; //         23-Apr (+verilog)
-            case 3004: testFlagD(marina);                      break; //         23-Apr (+verilog)
-            case 3005: testFlagDRecomputationTime(marina);     break;
-
-            case 3006: testTailWaitsForHead(marina);           break;
-            case 3007: testTailWithoutHead(marina);            break;
-            case 3008: testHeadWaitsForTail(marina);           break; //         22-Apr (+verilog)
-            case 3009: testAbort(marina);                      break; //         22-Apr (+verilog)
-
-            case 3010: sendData(marina);                       break; // passes, 24-Mar (+verilog)
-            case 3011: recvData(marina);                       break; //         21-Apr (+verilog)
-            case 3012: sendDataWithPath(marina);               break; // passes, 13-Apr (+verilog)
-
-            case 3013: testSignExtendedLiteral(marina);        break; //         20-Apr (+verilog)
-            case 3014: testShiftedLiteral(marina);             break; //         20-Apr (+verilog)
-            case 3015: testSendAndRecvToken(marina);           break; //         21-Apr (+verilog)
-
-            case 3016: sendDataIlcInfinite(marina);            break; //         22-Apr (+verilog)
-            case 3017: testFlagTruthTable(marina);             break; //         23-Apr (+verilog)
-
-            case 3019: setOlcFromDataLatch(marina);            break; //         23-Apr (+verilog)
-            case 3020: setIlcFromDataLatch(marina);            break; //         23-Apr (+verilog)
-            case 3021: recvPath(marina);                       break; //         22-Apr (+verilog)
-            case 3022: testILC(marina);                        break; //         23-Apr (+verilog)
-            case 3023: testTorpedoOnAnInfinite(marina);        break; //         23-Apr (+verilog)
-            case 3024: testRecvAndSendWalkingOne(marina);      break; //         21-Apr (+verilog)
-            case 3025: testOlcDecrementAtHighSpeed(marina);    break; //         23-Apr (+verilog)
-
-            case 3026: testNonTorpedoableMoveDoesNotResetDFlag(marina);        break; //         23-Apr (+verilog)
-            case 3027: testILCZero(marina);                    break;
-            case 3028: testAbortOutsideOfLoop(marina); break;
+                    // Russell's tests begin with 1000
+                case 1000: walkOneILC(marina);                     break; //         20-Apr (+verilog)
+                case 1001: countIlc(marina);                       break; //         20-Apr (+verilog)
+                case 1002: countOlc(marina);                       break; //         23-Apr (+verilog)
+
+                case 1003: sendTorpedo(marina);                    break; //         23-Apr (+verilog)  [with wor-hack]
+
+                case 1004: flipIlcBit(marina);                     break; //         20-Apr (+verilog)
+                case 1005: flipOlcBit(marina);                     break; //         21-Apr (+verilog)
+
+                case 1006: testSouthRecirculate(marina, Marina.SOUTH_RING_CAPACITY-1);        break; // passes, 24-Mar (+verilog)
+
+                    // Adam's tests begin with 3000
+                case 3000: sendToken(marina);                      break; // passes, 24-Mar (+verilog)
+                case 3001: testFlagAB(marina);                     break; // passes, 08-Apr (+verilog)
+                case 3002: testPredicationOnAB(marina);            break; //         22-Apr (+verilog)
+                case 3003: testFlagC(marina);                      break; //         23-Apr (+verilog)
+                case 3004: testFlagD(marina);                      break; //         23-Apr (+verilog)
+                case 3005: testFlagDRecomputationTime(marina);     break;
+
+                case 3006: testTailWaitsForHead(marina);           break;
+                case 3007: testTailWithoutHead(marina);            break;
+                case 3008: testHeadWaitsForTail(marina);           break; //         22-Apr (+verilog)
+                case 3009: testAbort(marina);                      break; //         22-Apr (+verilog)
+
+                case 3010: sendData(marina);                       break; // passes, 24-Mar (+verilog)
+                case 3011: recvData(marina);                       break; //         21-Apr (+verilog)
+                case 3012: sendDataWithPath(marina);               break; // passes, 13-Apr (+verilog)
+
+                case 3013: testSignExtendedLiteral(marina);        break; //         20-Apr (+verilog)
+                case 3014: testShiftedLiteral(marina);             break; //         20-Apr (+verilog)
+                case 3015: testSendAndRecvToken(marina);           break; //         21-Apr (+verilog)
+
+                case 3016: sendDataIlcInfinite(marina);            break; //         22-Apr (+verilog)
+                case 3017: testFlagTruthTable(marina);             break; //         23-Apr (+verilog)
+
+                case 3019: setOlcFromDataLatch(marina);            break; //         23-Apr (+verilog)
+                case 3020: setIlcFromDataLatch(marina);            break; //         23-Apr (+verilog)
+                case 3021: recvPath(marina);                       break; //         22-Apr (+verilog)
+                case 3022: testILC(marina);                        break; //         23-Apr (+verilog)
+                case 3023: testTorpedoOnAnInfinite(marina);        break; //         23-Apr (+verilog)
+                case 3024: testRecvAndSendWalkingOne(marina);      break; //         21-Apr (+verilog)
+                case 3025: testOlcDecrementAtHighSpeed(marina);    break; //         23-Apr (+verilog)
+
+                case 3026: testNonTorpedoableMoveDoesNotResetDFlag(marina);        break; //         23-Apr (+verilog)
+                case 3027: testILCZero(marina);                    break;
+                case 3028: testAbortOutsideOfLoop(marina); break;
 
-            default:
-                fatal(true, "Test number: "+testNum+" doesn't exist.");
-                break;
+                default:
+                    fatal(true, "Test number: "+testNum+" doesn't exist.");
+                    break;
+            }
+            // If we get here then test passed
+            prln("Test Result: Passed");
+            printTestTime();
+            //Infrastructure.exit(0);
+        } catch (MarinaUtils.FailureException fe) {
+            fe.printStackTrace();
         }
-        // If we get here then test passed
-        prln("Test Result: Passed");
-        printTestTime();
-        //Infrastructure.exit(0);
     }
 
 

diff --git a/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java b/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java
index b8b4646..2ccc8c8 100644 (file)
--- a/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java
+++ b/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java
@@ -17,7 +17,11 @@ public class MarinaUtils {
             };
     
     public static void fatal(boolean pred, String msg) {
-        if (pred) Infrastructure.fatal(msg);
+        if (pred) throw new FailureException(msg);
+    }
+
+    public static class FailureException extends RuntimeException {
+        public FailureException(String s) { super(s); }
     }
 
     /**

diff --git a/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java b/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java
index fa096ec..8783725 100644 (file)
--- a/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java
+++ b/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java
@@ -48,7 +48,7 @@ public class ProperStopper {
     private final ChipModel model;
     private final Indenter indenter;
 
-    protected static void fatal(boolean pred, String msg) { if (pred) Infrastructure.fatal(msg); }
+    protected static void fatal(boolean pred, String msg) { MarinaUtils.fatal(pred, msg); }
     private void prln(String msg) { indenter.prln(msg); }
     private void adjustIndent(int n) { indenter.adjustIndent(n); }