2017-07-29 21:49:36 -07:00
|
|
|
package org.nwapw.abacus.tests;
|
|
|
|
|
2017-07-29 23:48:01 -07:00
|
|
|
import org.junit.Assert;
|
|
|
|
import org.junit.Test;
|
2017-07-29 21:49:36 -07:00
|
|
|
import org.nwapw.abacus.lexing.Lexer;
|
2017-07-29 23:48:01 -07:00
|
|
|
import org.nwapw.abacus.lexing.pattern.Match;
|
|
|
|
|
|
|
|
import java.util.List;
|
2017-07-29 21:49:36 -07:00
|
|
|
|
|
|
|
public class LexerTests {
|
|
|
|
|
2017-07-29 23:48:01 -07:00
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testBasicSuccess() {
|
2017-07-29 23:48:01 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("abc", 0);
|
|
|
|
lexer.register("def", 1);
|
|
|
|
List<Match<Integer>> matchedIntegers = lexer.lexAll("abcdefabc", 0, Integer::compare);
|
2017-07-30 14:12:17 -07:00
|
|
|
Assert.assertNotNull(matchedIntegers);
|
2017-07-29 23:48:01 -07:00
|
|
|
Assert.assertEquals(matchedIntegers.get(0).getType(), Integer.valueOf(0));
|
|
|
|
Assert.assertEquals(matchedIntegers.get(1).getType(), Integer.valueOf(1));
|
|
|
|
Assert.assertEquals(matchedIntegers.get(2).getType(), Integer.valueOf(0));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testBasicFailure() {
|
2017-07-29 23:48:01 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("abc", 0);
|
|
|
|
lexer.register("def", 1);
|
|
|
|
Assert.assertNull(lexer.lexAll("abcdefabcz", 0, Integer::compare));
|
|
|
|
}
|
2017-07-29 21:49:36 -07:00
|
|
|
|
2017-07-30 00:46:42 -07:00
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testNoPatterns() {
|
2017-07-30 00:46:42 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
Assert.assertNull(lexer.lexAll("abcdefabc", 0, Integer::compare));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testEmptyMatches() {
|
2017-07-30 00:46:42 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("a?", 0);
|
|
|
|
Assert.assertNull(lexer.lexAll("", 0, Integer::compare));
|
|
|
|
}
|
2017-07-30 14:12:17 -07:00
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testOneOrMore() {
|
2017-07-30 14:12:17 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("a+", 0);
|
|
|
|
List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
|
|
|
|
Assert.assertNotNull(tokens);
|
|
|
|
Assert.assertEquals(tokens.size(), 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testZeroOrMore() {
|
2017-07-30 14:12:17 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("a*", 0);
|
|
|
|
List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
|
|
|
|
Assert.assertNotNull(tokens);
|
|
|
|
Assert.assertEquals(tokens.size(), 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testZeroOrOne() {
|
2017-07-30 14:12:17 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("a?", 0);
|
|
|
|
List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
|
|
|
|
Assert.assertNotNull(tokens);
|
|
|
|
Assert.assertEquals(tokens.size(), 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testGreedyMatching() {
|
2017-07-30 14:12:17 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("a*a", 0);
|
|
|
|
List<Match<Integer>> tokens = lexer.lexAll("aaaa", 0, Integer::compare);
|
|
|
|
Assert.assertNotNull(tokens);
|
|
|
|
Assert.assertEquals(tokens.size(), 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testAnyCharacter() {
|
2017-07-30 14:12:17 -07:00
|
|
|
String testString = "abcdef";
|
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register(".", 0);
|
|
|
|
List<Match<Integer>> tokens = lexer.lexAll(testString, 0, Integer::compare);
|
|
|
|
Assert.assertNotNull(tokens);
|
|
|
|
Assert.assertEquals(tokens.size(), testString.length());
|
2017-07-30 21:11:32 -07:00
|
|
|
for (int i = 0; i < tokens.size(); i++) {
|
2017-07-30 14:12:17 -07:00
|
|
|
Assert.assertEquals(testString.substring(i, i + 1), tokens.get(i).getContent());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testBasicGroup() {
|
2017-07-30 14:12:17 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("(abc)", 0);
|
|
|
|
List<Match<Integer>> tokens = lexer.lexAll("abc", 0, Integer::compare);
|
|
|
|
Assert.assertNotNull(tokens);
|
|
|
|
Assert.assertEquals(tokens.size(), 1);
|
|
|
|
Assert.assertEquals(tokens.get(0).getContent(), "abc");
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testBasicRangeSuccess() {
|
2017-07-30 14:12:17 -07:00
|
|
|
String testString = "abcdef";
|
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("[a-f]", 0);
|
|
|
|
List<Match<Integer>> tokens = lexer.lexAll(testString, 0, Integer::compare);
|
|
|
|
Assert.assertNotNull(tokens);
|
|
|
|
Assert.assertEquals(testString.length(), tokens.size());
|
2017-07-30 21:11:32 -07:00
|
|
|
for (int i = 0; i < tokens.size(); i++) {
|
2017-07-30 14:12:17 -07:00
|
|
|
Assert.assertEquals(testString.substring(i, i + 1), tokens.get(i).getContent());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testBasicRangeFailure() {
|
2017-07-30 14:12:17 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("[a-f]", 0);
|
|
|
|
Assert.assertNull(lexer.lexAll("g", 0, Integer::compare));
|
|
|
|
}
|
2017-07-30 21:11:32 -07:00
|
|
|
|
2017-07-30 14:12:17 -07:00
|
|
|
@Test
|
2017-07-30 21:11:32 -07:00
|
|
|
public void testGroupAndOperator() {
|
2017-07-30 14:12:17 -07:00
|
|
|
Lexer<Integer> lexer = new Lexer<>();
|
|
|
|
lexer.register("(abc)+", 0);
|
|
|
|
List<Match<Integer>> tokens = lexer.lexAll("abcabc", 0, Integer::compare);
|
|
|
|
Assert.assertNotNull(tokens);
|
|
|
|
Assert.assertEquals(tokens.size(), 1);
|
|
|
|
}
|
|
|
|
|
2017-07-29 21:49:36 -07:00
|
|
|
}
|