testeval.java

用编译原理方法计算表达式的值,例如(2+3)*84+3这样的复杂表达式 深入体现了面向对象的方法,代码可以很容易进行overwrite

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import junit.framework.TestCase;

/**
 * 
 * Course - CS601 OO Programming
 * Instructor - Terence Parr
 * Assignment - 4
 *
 * Test Harness for EvalParser
 * 
 */
public class TestEval extends TestCase {
	
	public void testparenthesis() throws IOException {
		
		StringReader s = new StringReader("1234");
		
		int read = -1;
		while ((read = s.read()) != -1) {
			System.out.print((char)read);
		}
		
		String expression = "(1+1)*2"; 
		assertEquals(4, eval(expression));
		
		expression = "((1+1)*2+3)*2+1";
		assertEquals(15, eval(expression));
		
		expression = "1+(3+4)*5+2";
		assertEquals(38, eval(expression));
		
		expression="12+34*(3+7)";
		assertEquals(352,eval(expression));
		
		expression="12*(3+34*(39+46))+235";
		assertEquals(34951,eval(expression));
	}
	
	public void testMultiplications() {
		String expression = "0*0";  // this should return 0
		assertEquals(0, eval(expression));

		expression = "10*0";  
		assertEquals(0, eval(expression));

		expression = "10*10";  
		assertEquals(100, eval(expression));

		expression = "10*9*8*7*6*5*4*3*2*1";  
		assertEquals(3628800, eval(expression));
	}
	public void testLess(){
		String expression="1<2";
		assertEquals(1,eval(expression));
		
		expression="12<349";
		assertEquals(1,eval(expression));
		
		expression="(2+2)<7*3";
		assertEquals(1,eval(expression));
		
		expression="(1+3)*20<100";
		assertEquals(1,eval(expression));
		
		expression="(2+3)<3";
		assertEquals(0,eval(expression));
		
		expression="23*34+45<6";
		assertEquals(0,eval(expression));
		
		expression="2+3*4<(4+6)*5";
		assertEquals(1,eval(expression));
		
		expression="2*6   <7";
		assertEquals(0,eval(expression));
		
		expression="2+6<9";
		assertEquals(1,eval(expression));
		
		expression="2<  9";
		assertEquals(1,eval(expression));
		
		expression="2+6\n \r<9";
		assertEquals(1,eval(expression));
		
	}

	private void failifExceptionNotThrown(String expression) {
		try {
			eval(expression);
			fail("Error should have been thrown");
		} catch (IllegalArgumentException ex) {
			// ok
		}
	}
	
	public void testBadInput() {
		String expression = "(9";  // this should return throw an error
		failifExceptionNotThrown(expression);
		
		expression = "12*3+ad";
		failifExceptionNotThrown(expression);

		expression = "+12*3+5";
		failifExceptionNotThrown(expression);

		expression = "12+4++3 +5";
		failifExceptionNotThrown(expression);

		expression = "1+2 4";
		failifExceptionNotThrown(expression);

		expression = "1+2\n\r4";
		failifExceptionNotThrown(expression);
		
		expression="(1+3\n\r  ";
		failifExceptionNotThrown(expression);
		
		expression="(1+3))3\n+3";
		failifExceptionNotThrown(expression);
		
		expression="(2+45)*4<(1000";
		failifExceptionNotThrown(expression);
		
		expression="2+3   4<40";
		failifExceptionNotThrown(expression);
		
		expression="7<(23+34)*32  8";
		failifExceptionNotThrown(expression);
		
		expression="7<23<30";
		failifExceptionNotThrown(expression);
		
		expression="7<2  8";
		failifExceptionNotThrown(expression);
		
		expression="7<8  9";
		failifExceptionNotThrown(expression);
		
		expression="dyuedjuoi6782739$%^";
		failifExceptionNotThrown(expression);
		
	}
	
	public void testOperatorPrecedence() {
		String expression = "5+5*5";  // this should be 125 not 50
		assertEquals(30, eval(expression));
		
		expression = "5*8+5+5*(2*(2+4)+4)";
		assertEquals(125, eval(expression));
		
		expression = "5*8+5*8+5+5+5*8+5*8";
		assertEquals(170, eval(expression));
		
	}
	
	public void testValidWhiteSpace() {
		String expression = "\n\r\n\n\n\n5 \n*\n             4  + \r5\n  \n\r";
		assertEquals(25, eval(expression));
	    expression="(\n\r\n5  +\n\r4\n )";
		assertEquals(9,eval(expression));
		expression="(\n\r4  +\n5)<\n\r   46";
		assertEquals(1,eval(expression));
		expression="34\n   <2*56";
		assertEquals(1,eval(expression));
	}
	
	public void testTooLargeInput() {
		String expression = "2147483647+1";
		failifExceptionNotThrown(expression);
		
		expression = "2147483647*2147483647";
		failifExceptionNotThrown(expression);
		
		expression = "2147483647+0";
		// verify no exception is thrown(test will fail if so)
		eval(expression);
	}
	
	public int eval(String expression) {
		Reader r = new BufferedReader(new StringReader(expression));
		EvalParser p = new EvalParser(new TokenBuffer(new Lexer(r, 4), 4));
		return p.expression();
	}
	
}