|
1 package tests.jfun.parsec;
2 import java.util.Arrays  ;
3
4 import jfun.parsec.Binary;
5 import jfun.parsec.DefaultPositionMap;
6 import jfun.parsec.Expressions;
7 import jfun.parsec.Lexers;
8 import jfun.parsec.Map2;
9 import jfun.parsec.Maps;
10 import jfun.parsec.OperatorTable;
11 import jfun.parsec.Parser;
12 import jfun.parsec.ParserEval;
13 import jfun.parsec.ParserException;
14 import jfun.parsec.Parsers;
15 import jfun.parsec.Scanners;
16 import jfun.parsec.Terms;
17 import jfun.parsec.FromString;
18 import jfun.parsec.Tok;
19 import jfun.parsec.Unary;
20 import jfun.parsec.pattern.Patterns;
21 import jfun.parsec.tokens.TokenInteger;
22 import junit.framework.Test;
23 import junit.framework.TestCase;
24 import junit.framework.TestSuite;
25 public class MathEclipseTestCase extends TestCase {
26 private static String parse(final String src, final Parser<Tok[]> lexer,
27 final Parser<String > p){
28 return Parsers.runParser(src, Parsers.parseTokens(lexer, p, "TestParser"),
29 new DefaultPositionMap(src, 1, 1), "TestParser");
30 }
31 private static void testGood(final String str, final String result){
32 final Parser p = getParser();
33 final Object r = parse(str, lexer1(), p);
34 assertEquals(result, r.toString());
35 }
36 private static String testBad(final String str){
37 try{
38 parse(str, lexer1(), getParser());
39 throw new IllegalStateException ("should have failed!");
40 }
41 catch(ParserException e){
42 return e.getMessage();
43 }
44 }
45 private static final Terms words = Terms.getOperatorsInstance(new String []{
46 "+", "-", "*", "/", "(", ")" ,".", "[", "]", ","
47 });
48 private static final String [] arithmetics = {
49 "+","-","*","/"
50 };
51 private static final Parser<String > lazy_expr = Parsers.lazy("lazy_expr", new ParserEval<String >(){
52 public Parser<String > eval(){
53 return expr();
54 }
55 });
56 private static Parser<Tok> myinteger(){
57 return Lexers.lexer("integer",
58 Scanners.isPattern(Patterns.isInteger(), "integer"),
59 TokenInteger.getTokenizer()
60 );
61 }
62 private static Parser<Tok[]> lexer1(){
63 return Lexers.lexeme(Scanners.javaDelimiter(), Parsers.plus(myinteger(), words.getLexer(), Lexers.word()));
64 }
65 private static Parser<Binary<String >>
66 op(final String n, final Binary<String > m2){
67 return words.getParser(n).seq(Parsers.retn(m2));
68 }
69 private static Parser<Unary<String >>
70 op(final String n, final Unary<String > m){
71 return words.getParser(n).seq(Parsers.retn(m));
72 }
73 private static FromString<String > id = new FromString<String >(){
74 public String fromString(int from, int len, final String str){
75 return str;
76 }
77 };
78 private static final Parser<String > simple_term = Parsers.plus(
79 Parsers.between(
80 words.getParser("("),
81 words.getParser(")"),
82 lazy_expr
83 ),
84 Terms.integerParser(id),
85 Terms.wordParser(id)
86 );
87 private static final Parser<String []> params = Parsers.sepBy(String .class, words.getParser(","), lazy_expr);
88 private static final Parser<String > term = simple_term.and(
89 Parsers.between(words.getParser("["), words.getParser("]"),
90 params).option(null), new Map2<String ,String [],String >(){
91 public String map(String fun, String [] params){
92 if(params==null) return fun;
93 return ""+fun+Arrays.asList((Object [])params).toString();
94 }
95 }
96 );
97 private static final Unary<String > negate = new Unary<String >(){
98 public String map(final String o){
99 return "(-"+o+")";
100 }
101 };
102 private static final Binary<String > add = new Binary<String >(){
103 public String map(final String a, final String b){
104 return "("+a+"+"+b+")";
105 }
106 };
107 private static final Binary<String > sub = new Binary<String >(){
108 public String map(final String a, final String b){
109 return "("+a+"-"+b+")";
110 }
111 };
112 private static final Binary<String > mul = new Binary<String >(){
113 public String map(final String a, final String b){
114 return "("+a+"*"+b+")";
115 }
116 };
117 private static final Binary<String > div = new Binary<String >(){
118 public String map(final String a, final String b){
119 return "("+a+"/"+b+")";
120 }
121 };
122
123
124 private static Parser<String > expr(){
125 final OperatorTable<String > ops = new OperatorTable<String >();
126 ops.prefix(op("+", Maps.id(String .class)), 50)
127 .prefix(op("-", negate), 50)
128 .infixl(op("+", add), 30)
129 .infixl(op("-", sub), 30)
130 .infixl(op("*", mul), 40)
131 .infixl(words.getParser(arithmetics).not().seq(Parsers.retn(mul)), 40)
132 .infixl(op("/", div), 40)
133
134 ;
135 return Expressions.buildExpressionParser("expr", term, ops);
136 }
137
138 public void test1(){
139 try{
140 testGood("1 + 2 ...", "(1+2)");
141 }
142 catch(ParserException e){
143 fail(e.getMessage());
144 throw e;
145 }
146 }
147 public void test1a(){
148 testGood("1 2", "(1*2)");
149 }
150 public void test1b(){
151 testGood("a b", "(a*b)");
152 }
153 public void test1c(){
154 testGood("2sin[x,y+cos[2]]", "(2*sin[x, (y+cos[2])])");
155 }
156 public void test2(){
157 try{
158 testGood("1 + 2 * 3 ..", "(1+(2*3))");
159 }
160 catch(ParserException e){
161 fail(e.getMessage());
162 throw e;
163 }
164 }
165 public void test3(){
166 try{
167 testGood("//tesst\n (1 + /*ok*/ 2) * (5-4)", "((1+2)*(5-4))");
168 }
169 catch(ParserException e){
170 fail(e.getMessage());
171 throw e;
172 }
173 }
174 public void test4(){
175 try{
176 testGood("//tesst\n (1 + /*ok*/ 2) * ((5/(4)+3))", "((1+2)*((5/4)+3))");
177 }
178 catch(ParserException e){
179 e.printStackTrace(System.err);
180 fail(e.getMessage());
181 }
182 }
183 public void test5(){
184 try{
185 testGood("--1-+-+5 ", "((-(-1))-(-5))");
186 }
187 catch(ParserException e){
188 e.printStackTrace(System.err);
189 fail(e.getMessage());
190 }
191 }
192 public void testa(){
193 testGood("1\t2", "(1*2)");
194
195 }
196 public void testb(){
197 try{
198 System.out.println(testBad("1.... "));
199 }
200 catch(ParserException e){
201 e.printStackTrace(System.err);
202 fail(e.getMessage());
203 }
204 }
205 private static Parser<String > getParser(){
206 return expr().followedBy(words.getParser(".").some(3).seq(Parsers.eof()));
207 }
208
209 public static Test suite(){
210 return new TestSuite(MathEclipseTestCase.class);
211 }
212 public static void main(String [] args){
213 junit.textui.TestRunner.run(suite());
214 }
215
216 }
217 |
Popular Tags |
Java API By Example, From Geeks To Geeks.