From: Adam Megacz <adam.megacz@sun.com>
Date: Tue, 24 Mar 2009 18:05:59 +0000 (+0000)
Subject: move methods out of MarinaUtils and into BitVectorGenerators
X-Git-Url: http://git.megacz.com/?a=commitdiff_plain;h=a1a5b360690cc3536c0da6573fecbddc2b096bf0;p=fleet.git

move methods out of MarinaUtils and into BitVectorGenerators
---

diff --git a/testCode/com/sun/vlsi/chips/marina/test/BitVectorGenerators.java b/testCode/com/sun/vlsi/chips/marina/test/BitVectorGenerators.java
new file mode 100644
index 0000000..3ef73a1
--- /dev/null
+++ b/testCode/com/sun/vlsi/chips/marina/test/BitVectorGenerators.java
@@ -0,0 +1,309 @@
+package com.sun.vlsi.chips.marina.test;
+import com.sun.async.test.BitVector;
+import com.sun.async.test.Infrastructure;
+
+import java.util.List;
+import java.util.Random;
+import java.util.ArrayList;
+
+/**
+ *  Miscellaneous routines to generate BitVectors as test inputs.
+ *  Currently not used.
+ */
+public class BitVectorGenerators {
+
+    private static void fatal(boolean pred, String msg) { MarinaUtils.fatal(pred, msg); }
+
+    public static BitVector generateBits(int start, boolean alternate, int n) {
+        int temp = start;
+        String bits = Integer.toString(start);
+        if (alternate){
+            for (int i = 2; i<= n; i++) {
+                temp = (temp+1)%2;
+                bits += Integer.toString (temp);
+            }
+        }
+        else {
+            for (int i = 2; i <= n; i++){
+                bits += Integer.toString(start);
+            }
+        }
+        BitVector bv = new BitVector (n, bits);
+        bv.put(0,bits);
+        return bv;
+    }
+
+
+    public static String generateTokenContent(int i) {
+        BitVector data0 = generateBits(0, true, 37);     // 37 bits, alternating
+        BitVector  tag0 =  generateBits(1, false, 1);
+        BitVector addr0 = generateBits(0, true, 14);    // 14 bits, alternating
+        //BitVector addr0 = new BitVector ("00000001111111", "addr0");    // 14 bits, alternating
+        BitVector data1 = generateBits(1, true, 37);     // 37 bits, alternating
+        BitVector  tag1 =  generateBits(1, false, 1);
+        //BitVector addr1 = generateBits(1, true, 14);    // 14 bits, alternating
+        BitVector addr1 = new BitVector ("00101010101011", "addr1");    // 14 bits, alternating
+        if (i==0){
+            return generateBits(0, false, 37).getState()+"1"+addr0.getState();
+        }
+        else if (i%4 == 1){
+            return data1.getState()+tag1.getState()+addr1.getState();// the addr data MAY enable cross: bit 0 (cross active high for Ring 1) and 13 (cross active low for Ring 2)
+            //return data1.getState()+tag1.getState()+addr0.getState();//
+        }
+        else if (i%4 == 2){
+            return data0.getState()+tag1.getState()+addr0.getState();
+        }
+        else if (i%4 == 3){
+            return data1.getState()+tag0.getState()+addr1.getState();
+            //return data1.getState()+tag0.getState()+addr0.getState();
+        }
+        else {
+            return data0.getState()+tag0.getState()+addr0.getState();
+        }
+    }
+    public static boolean compareTags(BitVector inputContent, BitVector exitContent){
+        return inputContent.get(37) == exitContent.get(37);         //bit 37 is the tag bit
+    }
+
+    public static boolean compareData(BitVector inputContent, BitVector exitContent){
+        return inputContent.get(0, 37).getState().equals(exitContent.get(0, 37).getState()); //bits 0:36 are the data bits
+    }
+
+    public static boolean compareAddress(BitVector inputContent, BitVector exitContent){
+        return inputContent.get(38, 14).getState().equals(exitContent.get(38, 14).getState()); //bits 38:38+14 are the data bits
+    }
+
+    public static boolean insertedVsRemoved(BitVector [] insertedTokenContent, BitVector [] removedTokenContent, int numTokens){
+        for (int i = 0; i < numTokens; i++) {
+            if (insertedTokenContent[i].get(37)){ //tag = 1 meaning data is valid
+
+                if (!insertedTokenContent[i].getState().equals(removedTokenContent[i].getState())){
+                    System.out.println ("Inserted vs removed data, tag and address @ stage " + i + " does NOT match!");
+                    return false;
+                }
+                System.out.println ("Inserted vs removed data, tag and address @ stage " + i + " matches!");
+            }
+            else {//if tag=0, just need to make sure tag bit is still the same as inserted but data and address are no longer important
+                if (!compareTags(insertedTokenContent[i], removedTokenContent[i])){
+                    System.out.println ("Inserted vs removed tag @ stage " + i + " does NOT match!");
+                    return false;
+                }
+                System.out.println ("Inserted vs removed tag @ stage " + i + " matches!");
+            }
+        }
+        System.out.println("Inserted tokens match removed tokens...All is well!");
+        return true;
+
+    }
+    public static void checkRingData(String ringNm, List<BitVector> dIn,
+                                     List<BitVector> dOut) {
+        int sz = dIn.size();
+
+        fatal(dOut.size()!=sz,  ringNm+
+              " wrong number of items. Expected:"+sz+", got:"+dOut.size());
+
+        // find offset
+        BitVector first = dIn.get(0);
+        int offset=0;
+        for (; offset<sz; offset++) {
+            if (dOut.get(offset).equals(first)) break;
+        }
+        fatal(offset==sz, "first input item not found in output: "+first.getState());
+        //prln("Output item offset: "+offset);
+        System.out.println("Output item offset: "+offset);
+
+        // compare all items
+        for (int i=0; i<sz; i++) {
+            int outNdx = (i + offset + sz) % sz;
+            BitVector out = dOut.get(outNdx);
+            BitVector in = dIn.get(i);
+
+            fatal(!in.equals(out), i+"th input item:"+in.getState()+"\n"+
+                  "doesn't match "+outNdx+"th output item: "+out.getState());
+        }
+    }
+    /** Generate List of BitVectors where Token=true, high 25 data bits
+     * are alternating ones and zeros, low 12 data bits increment from
+     * zero, and address is given by random number generator. */
+    public static List<BitVector> makeIncrDataRandAdr(int num, Random rand) {
+        List<BitVector> ans = new ArrayList<BitVector>();
+        BitVector dHi = new BitVector(25, "dataHi");
+        BitVector dLo = new BitVector(12, "dataLo");
+        BitVector t = new BitVector("1", "token");
+        BitVector a = new BitVector(14, "addr");
+        dHi.setFromLong(0x00aaaaa);
+        for (int i=0; i<num; i++) {
+            dLo.setFromLong(i);
+            a.setFromLong((long)rand.nextInt());
+            ans.add(dHi.cat(dLo).cat(t).cat(a));
+            dHi = dHi.not();
+        }
+        return ans;
+    }
+
+    /** Generate List of BitVectors where Token=true, high 25 data bits
+     * are alternating ones and zeros, low 12 data bits increment from
+     * zero, and address is given by addr. */
+
+    public static List<BitVector> makeIncrDataConstAdr(int num, int addr) {
+        List<BitVector> ans = new ArrayList<BitVector>();
+        BitVector dHi = new BitVector(25, "dataHi");
+        BitVector dLo = new BitVector(12, "dataLo");
+        BitVector t = new BitVector("1", "token");
+        BitVector a = new BitVector(14, "addr");
+        dHi.setFromLong(0x00aaaaa);
+        a.setFromLong(addr);
+        for (int i=0; i<num; i++) {
+            dLo.setFromLong(i);
+            ans.add(dHi.cat(dLo).cat(t).cat(a));
+            dHi = dHi.not();
+        }
+        return ans;
+    }
+    public static List<BitVector> makeIncrDataConstAdr(int num, String addr) {
+        List<BitVector> ans = new ArrayList<BitVector>();
+        BitVector dHi = new BitVector(25, "dataHi");
+        BitVector dLo = new BitVector(12, "dataLo");
+        BitVector t = new BitVector("1", "token");
+        BitVector a = new BitVector(addr, "addr");
+        dHi.setFromLong(0x00aaaaa);
+        //a.setFromLong(addr);
+        for (int i=0; i<num; i++) {
+            dLo.setFromLong(i);
+            ans.add(dHi.cat(dLo).cat(t).cat(a));
+            dHi = dHi.not();
+        }
+        return ans;
+    }
+    public static List<BitVector> makeConstDataConstAdr(int num, boolean dataValue, String addr) {
+        List<BitVector> ans = new ArrayList<BitVector>();
+        BitVector d = new BitVector(37, "dataHi");
+        BitVector t = new BitVector("1", "token");
+        BitVector a = new BitVector(addr, "addr");
+        Long dat = dataValue ? -1L : 0L;
+        d.setFromLong(dat);
+        for (int i=0; i<num; i++) {
+            ans.add(d.cat(t).cat(a));
+        }
+        return ans;
+    }
+    public static List<BitVector> make0TokenAdd(int num, int addrMsb, int addrLsb) {
+        List<BitVector> ans = new ArrayList<BitVector>();
+        BitVector d = new BitVector(37, "data");
+        BitVector t = new BitVector("0", "token");
+        BitVector aHi = new BitVector(1, "addrHi");
+        BitVector aLo = new BitVector(1, "addrLo");
+        BitVector aMid = new BitVector(12, "addrMid");
+        d.setFromLong(0x0000000000L);
+        aHi.setFromLong(addrMsb);
+        aLo.setFromLong(addrLsb);
+        aMid.setFromLong(0x000);
+        for (int i=0; i<num; i++) {
+            ans.add(d.cat(t).cat(aHi).cat(aMid).cat(aLo));
+        }
+        return ans;
+    }
+
+    /** Generate List of BitVectors where Token=true, the address MSB
+     * is given by addrMsb, the address LSB is set by addrLSB,
+     * data bits alternate between 0xaaaa and 0x5555.
+     * 12 insignificant address bits to crosser alternate between 0xaaa and 0x555 */
+
+    public static List<BitVector> makeAltDataAdd(int num, Long longValue, int addrMsb, int addrLsb, boolean crosser) {
+        List<BitVector> ans = new ArrayList<BitVector>();
+        BitVector d = new BitVector(37, "data");
+        BitVector t = new BitVector("1", "token");
+        BitVector aHi = new BitVector(1, "addrHi");
+        BitVector aLo = new BitVector(1, "addrLo");
+        BitVector aMid = new BitVector(12, "addrMid");
+        BitVector aRing = new BitVector(14, "addrRing");    //address bits for ring, bit 0 and 13 do not need to be anything specific b/c there isn't a cross element in the ring
+        //d.setFromLong(0xaaaaaaaaaaL);
+        d.setFromLong(longValue);
+        aHi.setFromLong(addrMsb);
+        aLo.setFromLong(addrLsb);
+        aMid.setFromLong(0xaaa);
+        aRing.setFromLong(0xaaaa);
+        for (int i=0; i<num; i++) {
+            if (crosser){
+                ans.add(d.cat(t).cat(aHi).cat(aMid).cat(aLo));
+            } else {
+                ans.add(d.cat(t).cat(aRing));
+            }
+            d = d.not();
+            aMid = aMid.not();
+            aRing = aRing.not();
+        }
+        return ans;
+    }
+    public static void compareJUSTDataTag(List<BitVector> din, List<BitVector> dout) {
+        fatal(din.size()!=dout.size(),
+              "in count="+din.size()+" out count="+dout.size());
+        for (int i=0; i<din.size(); i++) {
+            BitVector dI = din.get(i);
+            BitVector dO = dout.get(i);
+            //prln("Count = " + i + ", dI = " + dI + ", dO = " + dO);
+            fatal(!dI.get(0,37).equals(dO.get(0,37)),
+                  "data mismatch! in data + tag:"+dI.get(0,37).getState()+" out data + tag:"+dO.get(0,37).getState());
+        }
+    }
+
+    public static void checkUnorderedData(List<BitVector> din, List<BitVector> dout) {
+        int sz = din.size();
+        fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
+        for (BitVector in : din) {
+            boolean found = false;
+            for (BitVector out : dout) {
+                if (in.equals(out)) {
+                    found = true;
+                    break;
+                }
+            }
+            fatal(!found, "Can't find vector in output: "+in.getState());
+        }
+    }
+    public static void checkUnorderedJUSTDataTag(List<BitVector> din, List<BitVector> dout) {
+        int sz = din.size();
+        fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
+        for (BitVector in : din) {
+            boolean found = false;
+            for (BitVector out : dout) {
+                if (in.get(0,37).equals(out.get(0,37))) {
+                    found = true;
+                    break;
+                }
+            }
+            fatal(!found, "Can't find vector in output: "+in.getState());
+        }
+    }
+
+    public static void checkToken0Add(List<BitVector> din, List<BitVector> dout) {
+        int sz = din.size();
+        fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
+        for (BitVector in : din) {
+            boolean found = false;
+            for (BitVector out : dout) {
+                if (in.get(38,14).equals(out.get(38,14))) {
+                    found = true;
+                    break;
+                }
+            }
+            fatal(!found, "Can't find vector in output: "+in.getState());
+        }
+    }
+
+    public static int findBitVectorIndex(List<BitVector> din, BitVector findThis) {
+        int sz = din.size();
+        boolean found=false;
+        int i=0;
+        for (BitVector in : din) {
+            if (in.equals(findThis)) {
+                found = true;
+                break;
+            } else {i++;}
+        }
+        fatal(!found, "Can't find vector in output: "+findThis.getState());
+        return i;
+
+    }
+
+}
\ No newline at end of file
diff --git a/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java b/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java
index 63cd7b8..934c16c 100644
--- a/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java
+++ b/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java
@@ -11,229 +11,11 @@ public class MarinaUtils {
     /** StateWireState hides whether the state wire being high means FULL 
      * or whether high means EMPTY */
     public static enum StateWireState {FULL, EMPTY};
-
     
     public static void fatal(boolean pred, String msg) {
         if (pred) Infrastructure.fatal(msg);
     }
-        
-    public static BitVector generateBits (int start, boolean alternate, int n){
-        int temp = start;
-        String bits = Integer.toString(start);
-        if (alternate){
-            for (int i = 2; i<= n; i++) {
-                temp = (temp+1)%2;
-                bits += Integer.toString (temp);
-            }
-        }
-        else {
-            for (int i = 2; i <= n; i++){
-                bits += Integer.toString(start);
-            }
-        }
-        BitVector bv = new BitVector (n, bits);
-        bv.put(0,bits);
-        return bv;
-    }
-
-    public static String generateTokenContent (int i){
-        BitVector data0 = generateBits(0, true, 37);     // 37 bits, alternating
-        BitVector  tag0 =  generateBits(1, false, 1);
-        BitVector addr0 = generateBits(0, true, 14);    // 14 bits, alternating
-        //BitVector addr0 = new BitVector ("00000001111111", "addr0");    // 14 bits, alternating
-        BitVector data1 = generateBits(1, true, 37);     // 37 bits, alternating
-        BitVector  tag1 =  generateBits(1, false, 1);
-        //BitVector addr1 = generateBits(1, true, 14);    // 14 bits, alternating
-        BitVector addr1 = new BitVector ("00101010101011", "addr1");    // 14 bits, alternating
-        if (i==0){
-            return generateBits(0, false, 37).getState()+"1"+addr0.getState();
-        }
-        else if (i%4 == 1){
-            return data1.getState()+tag1.getState()+addr1.getState();// the addr data MAY enable cross: bit 0 (cross active high for Ring 1) and 13 (cross active low for Ring 2)
-            //return data1.getState()+tag1.getState()+addr0.getState();//
-        }
-        else if (i%4 == 2){
-            return data0.getState()+tag1.getState()+addr0.getState();
-        }
-        else if (i%4 == 3){
-            return data1.getState()+tag0.getState()+addr1.getState();
-            //return data1.getState()+tag0.getState()+addr0.getState();
-        }
-        else {
-            return data0.getState()+tag0.getState()+addr0.getState();
-        }
-    }
-    public static boolean compareTags(BitVector inputContent, BitVector exitContent){
-        return inputContent.get(37) == exitContent.get(37);         //bit 37 is the tag bit
-    }
-
-    public static boolean compareData(BitVector inputContent, BitVector exitContent){
-        return inputContent.get(0, 37).getState().equals(exitContent.get(0, 37).getState()); //bits 0:36 are the data bits
-    }
-
-    public static boolean compareAddress(BitVector inputContent, BitVector exitContent){
-        return inputContent.get(38, 14).getState().equals(exitContent.get(38, 14).getState()); //bits 38:38+14 are the data bits
-    }
-
-    public static boolean insertedVsRemoved(BitVector [] insertedTokenContent, BitVector [] removedTokenContent, int numTokens){
-        for (int i = 0; i < numTokens; i++) {
-            if (insertedTokenContent[i].get(37)){ //tag = 1 meaning data is valid
-
-                if (!insertedTokenContent[i].getState().equals(removedTokenContent[i].getState())){
-                    System.out.println ("Inserted vs removed data, tag and address @ stage " + i + " does NOT match!");
-                    return false;
-                }
-                System.out.println ("Inserted vs removed data, tag and address @ stage " + i + " matches!");
-            }
-            else {//if tag=0, just need to make sure tag bit is still the same as inserted but data and address are no longer important
-                if (!compareTags(insertedTokenContent[i], removedTokenContent[i])){
-                    System.out.println ("Inserted vs removed tag @ stage " + i + " does NOT match!");
-                    return false;
-                }
-                System.out.println ("Inserted vs removed tag @ stage " + i + " matches!");
-            }
-        }
-        System.out.println("Inserted tokens match removed tokens...All is well!");
-        return true;
-
-    }
-
-    public static void checkRingData(String ringNm, List<BitVector> dIn,
-                                     List<BitVector> dOut) {
-        int sz = dIn.size();
-
-        fatal(dOut.size()!=sz,  ringNm+
-              " wrong number of items. Expected:"+sz+", got:"+dOut.size());
 
-        // find offset
-        BitVector first = dIn.get(0);
-        int offset=0;
-        for (; offset<sz; offset++) {
-            if (dOut.get(offset).equals(first)) break;
-        }
-        fatal(offset==sz, "first input item not found in output: "+first.getState());
-        //prln("Output item offset: "+offset);
-        System.out.println("Output item offset: "+offset);
-
-        // compare all items
-        for (int i=0; i<sz; i++) {
-            int outNdx = (i + offset + sz) % sz;
-            BitVector out = dOut.get(outNdx);
-            BitVector in = dIn.get(i);
-
-            fatal(!in.equals(out), i+"th input item:"+in.getState()+"\n"+
-                  "doesn't match "+outNdx+"th output item: "+out.getState());
-        }
-    }
-    /** Generate List of BitVectors where Token=true, high 25 data bits
-     * are alternating ones and zeros, low 12 data bits increment from
-     * zero, and address is given by random number generator. */
-    public static List<BitVector> makeIncrDataRandAdr(int num, Random rand) {
-        List<BitVector> ans = new ArrayList<BitVector>();
-        BitVector dHi = new BitVector(25, "dataHi");
-        BitVector dLo = new BitVector(12, "dataLo");
-        BitVector t = new BitVector("1", "token");
-        BitVector a = new BitVector(14, "addr");
-        dHi.setFromLong(0x00aaaaa);
-        for (int i=0; i<num; i++) {
-            dLo.setFromLong(i);
-            a.setFromLong((long)rand.nextInt());
-            ans.add(dHi.cat(dLo).cat(t).cat(a));
-            dHi = dHi.not();
-        }
-        return ans;
-    }
-    /** Generate List of BitVectors where Token=true, high 25 data bits
-     * are alternating ones and zeros, low 12 data bits increment from
-     * zero, and address is given by addr. */
-    public static List<BitVector> makeIncrDataConstAdr(int num, int addr) {
-        List<BitVector> ans = new ArrayList<BitVector>();
-        BitVector dHi = new BitVector(25, "dataHi");
-        BitVector dLo = new BitVector(12, "dataLo");
-        BitVector t = new BitVector("1", "token");
-        BitVector a = new BitVector(14, "addr");
-        dHi.setFromLong(0x00aaaaa);
-        a.setFromLong(addr);
-        for (int i=0; i<num; i++) {
-            dLo.setFromLong(i);
-            ans.add(dHi.cat(dLo).cat(t).cat(a));
-            dHi = dHi.not();
-        }
-        return ans;
-    }
-    public static List<BitVector> makeIncrDataConstAdr(int num, String addr) {
-        List<BitVector> ans = new ArrayList<BitVector>();
-        BitVector dHi = new BitVector(25, "dataHi");
-        BitVector dLo = new BitVector(12, "dataLo");
-        BitVector t = new BitVector("1", "token");
-        BitVector a = new BitVector(addr, "addr");
-        dHi.setFromLong(0x00aaaaa);
-        //a.setFromLong(addr);
-        for (int i=0; i<num; i++) {
-            dLo.setFromLong(i);
-            ans.add(dHi.cat(dLo).cat(t).cat(a));
-            dHi = dHi.not();
-        }
-        return ans;
-    }
-    public static List<BitVector> makeConstDataConstAdr(int num, boolean dataValue, String addr) {
-        List<BitVector> ans = new ArrayList<BitVector>();
-        BitVector d = new BitVector(37, "dataHi");
-        BitVector t = new BitVector("1", "token");
-        BitVector a = new BitVector(addr, "addr");
-        Long dat = dataValue ? -1L : 0L;
-        d.setFromLong(dat);
-        for (int i=0; i<num; i++) {
-            ans.add(d.cat(t).cat(a));
-        }
-        return ans;
-    }
-    public static List<BitVector> make0TokenAdd(int num, int addrMsb, int addrLsb) {
-        List<BitVector> ans = new ArrayList<BitVector>();
-        BitVector d = new BitVector(37, "data");
-        BitVector t = new BitVector("0", "token");
-        BitVector aHi = new BitVector(1, "addrHi");
-        BitVector aLo = new BitVector(1, "addrLo");
-        BitVector aMid = new BitVector(12, "addrMid");
-        d.setFromLong(0x0000000000L);
-        aHi.setFromLong(addrMsb);
-        aLo.setFromLong(addrLsb);
-        aMid.setFromLong(0x000);
-        for (int i=0; i<num; i++) {
-            ans.add(d.cat(t).cat(aHi).cat(aMid).cat(aLo));
-        }
-        return ans;
-    }
-    /** Generate List of BitVectors where Token=true, the address MSB
-     * is given by addrMsb, the address LSB is set by addrLSB,
-     * data bits alternate between 0xaaaa and 0x5555.
-     * 12 insignificant address bits to crosser alternate between 0xaaa and 0x555 */
-    public static List<BitVector> makeAltDataAdd(int num, Long longValue, int addrMsb, int addrLsb, boolean crosser) {
-        List<BitVector> ans = new ArrayList<BitVector>();
-        BitVector d = new BitVector(37, "data");
-        BitVector t = new BitVector("1", "token");
-        BitVector aHi = new BitVector(1, "addrHi");
-        BitVector aLo = new BitVector(1, "addrLo");
-        BitVector aMid = new BitVector(12, "addrMid");
-        BitVector aRing = new BitVector(14, "addrRing");    //address bits for ring, bit 0 and 13 do not need to be anything specific b/c there isn't a cross element in the ring
-        //d.setFromLong(0xaaaaaaaaaaL);
-        d.setFromLong(longValue);
-        aHi.setFromLong(addrMsb);
-        aLo.setFromLong(addrLsb);
-        aMid.setFromLong(0xaaa);
-        aRing.setFromLong(0xaaaa);
-        for (int i=0; i<num; i++) {
-            if (crosser){
-                ans.add(d.cat(t).cat(aHi).cat(aMid).cat(aLo));
-            } else {
-                ans.add(d.cat(t).cat(aRing));
-            }
-            d = d.not();
-            aMid = aMid.not();
-            aRing = aRing.not();
-        }
-        return ans;
-    }
     public static void compareItemsOrdered(List<BitVector> din, List<BitVector> dout) {
         fatal(din.size()!=dout.size(),
               "in count="+din.size()+" out count="+dout.size());
@@ -244,76 +26,6 @@ public class MarinaUtils {
                   "item mismatch! in:"+dI.getState()+" out:"+dO.getState());
         }
     }
-    public static void compareJUSTDataTag(List<BitVector> din, List<BitVector> dout) {
-        fatal(din.size()!=dout.size(),
-              "in count="+din.size()+" out count="+dout.size());
-        for (int i=0; i<din.size(); i++) {
-            BitVector dI = din.get(i);
-            BitVector dO = dout.get(i);
-            //prln("Count = " + i + ", dI = " + dI + ", dO = " + dO);
-            fatal(!dI.get(0,37).equals(dO.get(0,37)),
-                  "data mismatch! in data + tag:"+dI.get(0,37).getState()+" out data + tag:"+dO.get(0,37).getState());
-        }
-    }
-
-    public static void checkUnorderedData(List<BitVector> din, List<BitVector> dout) {
-        int sz = din.size();
-        fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
-        for (BitVector in : din) {
-            boolean found = false;
-            for (BitVector out : dout) {
-                if (in.equals(out)) {
-                    found = true;
-                    break;
-                }
-            }
-            fatal(!found, "Can't find vector in output: "+in.getState());
-        }
-    }
-    public static void checkUnorderedJUSTDataTag(List<BitVector> din, List<BitVector> dout) {
-        int sz = din.size();
-        fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
-        for (BitVector in : din) {
-            boolean found = false;
-            for (BitVector out : dout) {
-                if (in.get(0,37).equals(out.get(0,37))) {
-                    found = true;
-                    break;
-                }
-            }
-            fatal(!found, "Can't find vector in output: "+in.getState());
-        }
-    }
-
-    public static void checkToken0Add(List<BitVector> din, List<BitVector> dout) {
-        int sz = din.size();
-        fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
-        for (BitVector in : din) {
-            boolean found = false;
-            for (BitVector out : dout) {
-                if (in.get(38,14).equals(out.get(38,14))) {
-                    found = true;
-                    break;
-                }
-            }
-            fatal(!found, "Can't find vector in output: "+in.getState());
-        }
-    }
-
-    public static int findBitVectorIndex(List<BitVector> din, BitVector findThis) {
-        int sz = din.size();
-        boolean found=false;
-        int i=0;
-        for (BitVector in : din) {
-            if (in.equals(findThis)) {
-                found = true;
-                break;
-            } else {i++;}
-        }
-        fatal(!found, "Can't find vector in output: "+findThis.getState());
-        return i;
-
-    }
 
     public static BitVector berkToSun(edu.berkeley.fleet.api.BitVector berkBits) {
         BitVector sunBits = new BitVector(berkBits.length(), "berkToSun()");
diff --git a/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java b/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java
index a83e30d..56a1028 100644
--- a/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java
+++ b/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java
@@ -378,7 +378,9 @@ public class ProperStopper {
             SINK       ("000101"),
             STOPSINK   ("000001");
         private BitVector scanBits;
-        CommandCodes(String bits) {scanBits = new BitVector(bits,"CommandCodes");}
+        CommandCodes(String bits) {
+            scanBits = new BitVector(bits,"CommandCodes");
+        }
         public BitVector bits() {return scanBits;}
     }