X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmisc%2FRegressionTests.java;h=13be93f254169f0f0162a20d5896b8788f48f56f;hp=5a86bf1c9f6e9f51f76630c90ebbed3adecd7b63;hb=f17fca21d99030d325624f839efcd17bc93f1548;hpb=107df9a4aee6ba593b64d3bbe8b2efac84596cad

diff --git a/src/edu/berkeley/sbp/misc/RegressionTests.java b/src/edu/berkeley/sbp/misc/RegressionTests.java
index 5a86bf1..13be93f 100644
--- a/src/edu/berkeley/sbp/misc/RegressionTests.java
+++ b/src/edu/berkeley/sbp/misc/RegressionTests.java
@@ -1,31 +1,33 @@
+// Copyright 2006 all rights reserved; see LICENSE file for BSD-style license
+
 package edu.berkeley.sbp.misc;
 import java.io.*;
 import java.util.*;
+import java.lang.reflect.*;
 import edu.berkeley.sbp.*;
-import edu.berkeley.sbp.misc.*;
-import edu.berkeley.sbp.tib.*;
+import edu.berkeley.sbp.meta.*;
+import edu.berkeley.sbp.chr.*;
+import edu.berkeley.sbp.util.*;
 
 public class RegressionTests {
 
     public static boolean yes = false;
-    public static class MyWalker extends ReflectiveWalker {
-        public String top(Object[] o) { return "top("+join(o)+")"; }
-        public String str(String[] s) { String ret = ""; for(String st : s) ret += st; return ret; }
-        public String join(Object[] o) { String ret = ""; for(Object st : o) ret += st; return ret; }
-        public String whilex(Object s, Object y) { return "while("+s+") " + y; }
-        public String seq(Object[] statements) {
-            String ret = "";
-            for(Object s : statements) ret += s + ";\n";
-            return ret;
-        }
-        /*
-        public String bl(String s) { return "{" + s + "}"; }
-        */
-    };
+    public static boolean graph = false;
+    public static File[] includes = new File[] { new File("tests") };
+
+    public static void main() throws Exception {
+        main(new String[] { "tests/meta.g", "tests/testcase.g", "tests/regression.tc" });
+    }
 
     public static void main(String[] s) throws Exception {
         try {
             boolean profile = false;
+            if (s[0].equals("-graph")) {
+                graph = true;
+                String[] s2 = new String[s.length-1];
+                System.arraycopy(s, 1, s2, 0, s2.length);
+                s = s2;
+            }
             if (s[0].equals("-profile")) {
                 profile = true;
                 String[] s2 = new String[s.length-1];
@@ -33,31 +35,37 @@ public class RegressionTests {
                 s = s2;
             }
 
-            //MetaGrammar mg0 = new MetaGrammar();
-            //mg0.walk(MetaGrammar.meta);
-            //System.out.println(mg0);
-            Tree<String> res = new Parser(MetaGrammar.make(), CharToken.top()).parse1(new CharToken.Stream(new InputStreamReader(new FileInputStream(s[0]))));
-            MetaGrammar mg = (MetaGrammar)new MetaGrammar().walk(res);
-            //System.out.println(mg);
-            Union meta = mg.done();
-            SequenceInputStream sis = new SequenceInputStream(new FileInputStream(s[0]), new FileInputStream(s[1]));
-            res = new Parser(meta, CharToken.top()).parse1(new CharToken.Stream(new InputStreamReader(sis), "parsing " + s[1] + " using " + s[0]));
-            Union testcasegrammar = ((MetaGrammar)new MetaGrammar("ts").walk(res)).done("ts");
+            System.err.println("parsing " + s[0]);
+            Tree<String> res = new CharParser(MetaGrammar.newInstance()).parse(new FileInputStream(s[0])).expand1();
+            Union meta = GrammarAST.buildFromAST(res, "s", includes);
+
+            System.err.println("parsing " + s[1]);
+            res = new CharParser(meta).parse(new FileInputStream(s[1])).expand1();
+
+            Union testcasegrammar = GrammarAST.buildFromAST(res, "s", includes);
             if (testcasegrammar==null) return;
-            CharToken.Stream cs = new CharToken.Stream(new InputStreamReader(new FileInputStream(s[2])), "parsing " + s[2] + " using " + s[1]);
-            Parser parser = new Parser(testcasegrammar, CharToken.top());
+            CharParser parser = new CharParser(testcasegrammar);
 
             if (profile) {
                 System.out.println("\nready...");
                 System.in.read();
             }
-            Forest<String> r2 = parser.parse(cs);
+            System.gc();
+            long now = System.currentTimeMillis();
+            System.err.println("parsing " + s[2]);
+            Forest<String> r2 = parser.parse(new FileInputStream(s[2]));
+            System.out.println();
+            System.out.println("elapsed = " + (System.currentTimeMillis()-now) + "ms");
             if (profile) {
                 System.out.println("\ndone");
                 System.in.read();
                 System.exit(0);
             }
-            for(TestCase tc : (TestCase[])new TestCaseBuilder().walk(r2.expand1())) tc.execute();
+            System.err.println("expanding...");
+
+            TestCase[] expanded = (TestCase[])new GrammarAST(includes, "").walkChildren(r2.expand1());
+            for(TestCase tc : expanded)
+                tc.execute();
 
         } catch (Throwable t) {
             System.err.println("\n\nexception thrown, class == " + t.getClass().getName());
@@ -69,16 +77,20 @@ public class RegressionTests {
     }
 
     public static class TestCase {
-        private final Token.Stream inp;
-        public final String input;
+        private final boolean tib;
+        private final boolean jav;
+        public /*final*/ String input;        
         public final String[] output;
         public final Union grammar;
-        public TestCase(String input, String[] output, Union grammar, boolean tib) throws IOException {
-            this.inp = tib
-                ? new Tib(input)
-                : new CharToken.Stream(new StringReader(input), input.indexOf('\n')==-1?"\""+input+"\": ":"");
+        public final String name;
+
+        public TestCase(String name, String input, String[] output,
+                        Union grammar, boolean tib, boolean jav) {
+            this.tib = tib;
+            this.name = name;
+            this.jav = jav;
             this.input = input;
-            this.output = output;
+            this.output = output==null ? new String[0] : output;
             this.grammar = grammar;
         }
         public String toString() {
@@ -88,15 +100,42 @@ public class RegressionTests {
             return ret;
         }
         public boolean execute() throws Exception {
-            Forest<String> res = new Parser(grammar, CharToken.top()).parse(inp);
-            Collection<Tree<String>> results = res==null ? new HashSet<Tree<String>>() : res.expand(false);
+            Forest<String> res = null;
+            ParseFailed pfe = null;
+            CharParser parser = new CharParser(grammar);
+            System.out.print("     "+name+"\r");
+            //parser.helpgc = false;
+            try {
+                res = tib 
+                    ? /*new CharParser(grammar).parse(new Tib(input))*/ null
+                : parser.parse(new StringReader(input));
+            } catch (ParseFailed pf) {
+                pfe = pf;
+            }
+            //ystem.out.println("res=="+res);
+
+            if (graph) {
+                FileOutputStream fos = new FileOutputStream("out.dot");
+                PrintWriter p = new PrintWriter(new OutputStreamWriter(fos));
+                GraphViz gv = new GraphViz();
+                res.toGraphViz(gv);
+                gv.dump(p);
+                p.flush();
+                p.close();
+                System.out.println(parser);
+            }
+
+            Iterable<Tree<String>> results =
+                res==null ? new HashSet<Tree<String>>() : res.expand();
+
             System.out.print("\r");
-            if (results.size() == 0 && output.length > 0) {
+            if (results == null || (!results.iterator().hasNext() && (output!=null && output.length > 0))) {
                 System.out.print("\033[31m");
-                System.out.println("PARSE FAILED");
-                System.out.print("\033[0m");
+                System.out.print("FAIL ");
+                System.out.println("\033[0m "+name);
+                if (pfe != null) pfe.printStackTrace();
             } else {
-                System.out.println("\r                                                                                                              \r");
+                System.out.print("\r                                                                                                              \r");
             }
             HashSet<String> outs = new HashSet<String>();
             if (output != null) for(String s : output) outs.add(s.trim());
@@ -104,45 +143,37 @@ public class RegressionTests {
             for (Tree<String> r : results) {
                 String s = r.toString().trim();
                 if (outs.contains(s)) { outs.remove(s); continue; }
+                if (!bad) System.out.println(input);
                 System.out.print("\033[33m");
                 System.out.println("     GOT: " + s);
                 bad = true;
             }
             for(String s : outs) {
+                if (!bad) System.out.println(input);
                 System.out.print("\033[31m");
                 System.out.println("EXPECTED: " + s);
                 bad = true;
             }
             if (bad) {
-                System.out.print("\033[0m");
+                System.out.println("\033[0m");
                 return true;
             }             
-            System.out.println("\033[32mPASS\033[0m");
-            return false;
-        }
-    }
+            System.out.println("\r\033[32mPASS\033[0m "+name);
 
-    public static class TestCaseBuilder extends MetaGrammar {
-        public TestCase[] ts(Object o1, TestCase[] ts, Object o2) { return ts; }
-        public TestCase[] ts(TestCase[] ts) { return ts; }
-        public TestCase testcase(String input, String[] output, Union grammar) throws IOException {
-            return new TestCase(input, output,        grammar, false); }
-        public TestCase testcase(String input,                  Union grammar) throws IOException {
-            return new TestCase(input, new String[0], grammar, false); }
-        public TestCase tibcase(String input, String[] output, Union grammar) throws IOException {
-            return new TestCase(input, output,        grammar, true); }
-        public TestCase  tibcase(String input,                  Union grammar) throws IOException {
-            return new TestCase(input, new String[0], grammar, true); }
-        public MetaGrammar grammar(Object[] o) { return this; }
-        public Object walk(String tag, Object[] args) {
-            if ("grammar".equals(tag)) {
-                //System.out.println("\n" + this + "\n");
-                return done("s");
-            }
-            else return super.walk(tag, args);
+            return false;
         }
     }
 
     private static String pad(int i,String s) { return s.length() >= i ? s : pad(i-1,s)+" "; }
+    public static String string(Tree<String> tree) {
+        String ret = "";
+        if (tree.head()!=null) ret += tree.head();
+        ret += string(tree.children());
+        return ret;
+    }
+    public static String string(Iterable<Tree<String>> children) {
+        String ret = "";
+        for(Tree<String> t : children) ret += string(t);
+        return ret;
+    }
 }
-