X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Fsbp%2Fmisc%2FRegressionTests.java;h=d57959056b5baa39f181eb8286dbbcfc26e5ef56;hp=e61673aefc0e24cda20d5d5bdf7536d63dcd97b6;hb=f8adfc66d98670be6553965d7ee9e6c998a4e0a6;hpb=c1325de42a4ddfad3ff9b10bfdda11078e38e8a6 diff --git a/src/edu/berkeley/sbp/misc/RegressionTests.java b/src/edu/berkeley/sbp/misc/RegressionTests.java index e61673a..d579590 100644 --- a/src/edu/berkeley/sbp/misc/RegressionTests.java +++ b/src/edu/berkeley/sbp/misc/RegressionTests.java @@ -1,63 +1,34 @@ +// Copyright 2006 all rights reserved; see LICENSE file for BSD-style license + package edu.berkeley.sbp.misc; import java.io.*; import java.util.*; -import edu.berkeley.sbp.*; +import java.lang.reflect.*; import edu.berkeley.sbp.*; import edu.berkeley.sbp.misc.*; -import edu.berkeley.sbp.*; - -// priorities are all messy and dont get serialized -// 1. Error messages -// 2. Java MetaGrammar (proof of concept) -// 3. Ivan's MetaGrammar -// 4. Documentation format -// - TIB - -// TODO: better API for interfacing with Java -// TODO: error messages -// TODO: integrate with TIB - -// Element -// Walk -// ParseTable / GSS -// MetaGrammar (necessary/relevant?) -// Tree (cleanup?) -// Union.SubUnion -// Repeat - -// FEATURE: serialization of ParseTable's, generation of Java code -// FEATURE: infer reject elements for literals -// FEATURE: prefer whitespace higher up -// FEATURE: full conjunctive and boolean grammars -// FEATURE: "ambiguity modulo dropped fragments"? can this be checked for statically? eliminated statically? -// - drop stuff during the parsing process (drop nodes) - -// LATER: Element -- parameterize over the input token type? Makes a huge mess... -// LATER: Go back to where Sequence is not an Element? -// - The original motivation for making Sequence "first class" was the fact that -// in order to do associativity right you need to have per-Sequence follow sets +import edu.berkeley.sbp.meta.*; +import edu.berkeley.sbp.tib.*; +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 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]; @@ -65,26 +36,37 @@ public class RegressionTests { s = s2; } - Tree res = new Parser(MetaGrammar.make(), CharToken.top()).parse1(new CharToken.Stream(new InputStreamReader(new FileInputStream(s[0])))); - Union meta = ((MetaGrammar)new MetaGrammar().walk(res)).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 res = new CharParser(MetaGrammar.newInstance()).parse(new FileInputStream(s[0])).expand1(); + Union meta = Grammar.create(res, "s"); + + System.err.println("parsing " + s[1]); + res = new CharParser(meta).parse(new FileInputStream(s[1])).expand1(); + + Union testcasegrammar = Grammar.create(res, "s"); 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 r2 = parser.parse(cs); + System.gc(); + long now = System.currentTimeMillis(); + System.err.println("parsing " + s[2]); + Forest 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 GrammarBuilder("tests/", "").walkChildren(r2.expand1()); + for(TestCase tc : expanded) + tc.execute(); } catch (Throwable t) { System.err.println("\n\nexception thrown, class == " + t.getClass().getName()); @@ -96,12 +78,20 @@ public class RegressionTests { } public static class TestCase { - 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) { + 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() { @@ -111,55 +101,80 @@ public class RegressionTests { return ret; } public boolean execute() throws Exception { - Forest res = new Parser(grammar, - CharToken.top()).parse(new CharToken.Stream(new StringReader(input), input.indexOf('\n')==-1?"\""+input+"\": ":"")); - Collection> results = res==null ? new HashSet>() : res.expand(false); + Forest 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); + } + + HashSet> results = new HashSet>(); + if (res != null) res.expand(results); + System.out.print("\r"); - if (results.size() == 0 && output.length > 0) { + if (results == null || (results.size() == 0 && (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 outs = new HashSet(); - for(String s : output) outs.add(s.trim()); + if (output != null) for(String s : output) outs.add(s.trim()); boolean bad = false; for (Tree 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) { return new TestCase(input, output, grammar); } - public MetaGrammar grammar(Object[] o) { return this; } - public Object walk(String tag, Object[] args) { - if ("testcase".equals(tag)) { - if (args.length==2) return testcase((String)args[0], new String[0], (Union)args[1]); - return testcase((String)args[0], (String[])args[1], (Union)args[2]); } - else if ("grammar".equals(tag)) 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 tree) { + String ret = ""; + if (tree.head()!=null) ret += tree.head(); + ret += string(tree.children()); + return ret; + } + public static String string(Iterable> children) { + String ret = ""; + for(Tree t : children) ret += string(t); + return ret; + } } -