Update tokenizer

src/edu/ucsb/cs56/pconrad/parsing/tokenizer/TokenFactory.java

@@ -83,4 +83,48 @@ public interface TokenFactory {
     */
 
     public Token makeDivideToken();
+
+    /** make a token that represents an equality operator <code>==</code> 
+	@return an appropriate token
+    */
+
+    public Token makeEqualsToken();
+
+    /** make a token that represents a not equals operator <code>!=</code> 
+	@return an appropriate token
+    */
+
+    public Token makeNotEqualsToken();
+
+
+    /** make a token that represents a less than operator <code>&lt;</code> 
+	@return an appropriate token
+    */
+
+    public Token makeLessThanToken();
+
+    /** make a token that represents a less than or equals operator <code>&lt;=</code> 
+	@return an appropriate token
+    */
+
+    public Token makeLessThanOrEqualsToken();
+
+    /** make a token that represents a greater than operator <code>&gt;</code> 
+	@return an appropriate token
+    */
+
+    public Token makeGreaterThanToken();
+
+    /** make a token that represents a greater than or equals operator <code>&gt;=</code> 
+	@return an appropriate token
+    */
+
+    public Token makeGreaterThanOrEqualsToken();
+
+    /** make a token that represents an exponent operator <code>**</code> 
+	@return an appropriate token
+    */
+
+    public Token makeExponentOperatorToken();
+
 }

src/edu/ucsb/cs56/pconrad/parsing/tokenizer/TokenizerAddonsTest.java

@@ -0,0 +1,148 @@
+package edu.ucsb.cs56.pconrad.parsing.tokenizer;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.fail;
+import org.junit.Test;
+
+public class TokenizerAddonsTest {
+
+    private TokenFactory tf = new DefaultTokenFactory();
+
+    @Test
+    public void testOneEqualsToken() {
+        assertArrayEquals(new Token[] { tf.makeEqualsToken() },
+                          Tokenizer.tokenizeToArray("=="));
+    }
+
+
+    @Test
+    public void testTwoEqualsTokensWithWhiteSpace() {
+        assertArrayEquals(new Token[] {
+		tf.makeEqualsToken(),
+		tf.makeEqualsToken()
+	    },
+                          Tokenizer.tokenizeToArray("== =="));
+    }
+
+    @Test
+    public void testTwoEqualsTokensNoWhiteSpace() {
+        assertArrayEquals(new Token[] {
+		tf.makeEqualsToken(),
+		tf.makeEqualsToken()
+	    },
+                          Tokenizer.tokenizeToArray("===="));
+    }
+
+
+    @Test
+    public void testOneEqualsTokensOneErrorEqualToken() {
+        assertArrayEquals(new Token[] {
+		tf.makeEqualsToken(),
+		tf.makeErrorToken("=")
+	    },
+	    Tokenizer.tokenizeToArray("==="));
+    }
+
+    @Test
+    public void testEqualsExpression() {
+	assertArrayEquals(new Token[] { tf.makeIntToken("12"),
+					tf.makeEqualsToken(),
+					tf.makeIntToken("13") },
+	    Tokenizer.tokenizeToArray("12 == 13"));
+    }
+
+    @Test
+    public void testNotEqualsToken() {
+	assertArrayEquals(new Token[] { tf.makeNotEqualsToken() },
+			  Tokenizer.tokenizeToArray("!="));
+    }
+
+    @Test
+    public void testNotEqualsExpression() {
+	assertArrayEquals(new Token[] { tf.makeIntToken("12"),
+					tf.makeNotEqualsToken(),
+					tf.makeIntToken("13") },
+	    Tokenizer.tokenizeToArray("12 != 13"));
+    }
+
+    @Test
+    public void testLeExpression() {
+	assertArrayEquals(new Token[] { tf.makeIntToken("12"),
+					tf.makeLessThanOrEqualsToken(),
+					tf.makeIntToken("13") },
+	    Tokenizer.tokenizeToArray("12 <= 13"));
+    }
+
+    @Test
+    public void testLtExpression() {
+	assertArrayEquals(new Token[] { tf.makeIntToken("1"),
+					tf.makePlusToken(),
+					tf.makeIntToken("2"),
+					tf.makeLessThanToken(),
+					tf.makeIntToken("3"),
+					tf.makeTimesToken(),
+					tf.makeIntToken("4")
+	    },
+	    Tokenizer.tokenizeToArray("1+2<3*4"));
+    }
+
+
+    @Test
+    public void testGtExpression() {
+	assertArrayEquals(new Token[] { tf.makeIntToken("12"),
+					tf.makeGreaterThanToken(),
+					tf.makeIntToken("13") },
+	    Tokenizer.tokenizeToArray("12 > 13"));
+    }
+
+    @Test
+    public void testGeExpression() {
+	assertArrayEquals(new Token[] { tf.makeLParenToken(),
+					tf.makeIntToken("78"),
+					tf.makeMinusToken(),
+					tf.makeIntToken("90"),
+					tf.makeRParenToken(),
+					tf.makeGreaterThanOrEqualsToken(),
+					tf.makeIntToken("13"),
+					tf.makeDivideToken(),
+					tf.makeIntToken("4")
+	    },
+	    Tokenizer.tokenizeToArray("(78-90)>=13/4"));
+    }
+
+
+    public void testExponentOperator() {
+	assertArrayEquals(new Token[] {
+		tf.makeIntToken("2"),
+		tf.makeExponentOperatorToken(),
+		tf.makeIntToken("16"),
+	    },
+	    Tokenizer.tokenizeToArray("2**16"));
+    }
+
+    public void testInequalityOperators() {
+	assertArrayEquals(new Token[] {
+		tf.makeLessThanToken(),
+		tf.makeLessThanOrEqualsToken(),
+		tf.makeLessThanToken(),
+		tf.makeGreaterThanToken(),
+		tf.makeLessThanOrEqualsToken(),
+	    },
+	    Tokenizer.tokenizeToArray("<<=<>>="));
+    }
+
+    public void brokenInequalityOperators() {
+	assertArrayEquals(new Token[] {
+		tf.makeLessThanToken(),
+		tf.makeErrorToken("="),
+		tf.makeGreaterThanToken(),
+		tf.makeErrorToken("="),
+		tf.makeEqualsToken(),
+		tf.makeErrorToken("="),
+		tf.makeErrorToken("="),		
+	    },
+	    Tokenizer.tokenizeToArray("< = > = == = = "));
+    }
+
+}