public static Model makeReminderModel(){ List<Rule> rules = new LinkedList<>(); rules.addAll(Rules.BASE); rules.addAll(Rules.fromFile("model/reminders.rules")); rules.addAll(DateTimeAnnotator.rules()); List<Annotator> annotators = Arrays.asList( TokenAnnotator.INSTANCE, PhraseAnnotator.INSTANCE, NumberAnnotator.INSTANCE, DateTimeAnnotator.INSTANCE ); Grammar grammar = new Grammar(rules, "$ROOT"); Parser parser = new Parser(grammar, new BasicTokenizer(), annotators); return new Model(parser); }
@Test void getBinaryRules() { List<Rule> rules = Collections.singletonList(new Rule("$A", "$B $C")); Grammar grammar = new Grammar(rules, "$ROOT"); assertEquals(rules.get(0), grammar.getBinaryRules("$B", "$C").get(0)); assertEquals(0, grammar.getLexicalRules(Arrays.asList("$B", "$C")).size()); assertEquals(0, grammar.getUnaryRules("$B").size()); } }
@Test void getUnaryRules() { List<Rule> rules = Collections.singletonList(new Rule("$A", "$B")); Grammar grammar = new Grammar(rules, "$ROOT"); assertEquals(rules.get(0), grammar.getUnaryRules("$B").get(0)); assertEquals(0, grammar.getBinaryRules("$B", "$C").size()); assertEquals(0, grammar.getLexicalRules(Arrays.asList("$B", "$C")).size()); }
@Test void getLexicalRules() { List<Rule> rules = Collections.singletonList(new Rule("$A", "B C")); Grammar grammar = new Grammar(rules, "$ROOT"); assertEquals(rules.get(0), grammar.getLexicalRules(Arrays.asList("B", "C")).get(0)); assertEquals(0, grammar.getBinaryRules("$B", "$C").size()); assertEquals(0, grammar.getUnaryRules("$B").size()); }
@Test void applyLexicalRules() { List<Rule> rules = Collections.singletonList(new Rule("$A", "B C")); Grammar grammar = new Grammar(rules, "$ROOT"); Parser p = new Parser(grammar, null, null); Parser.Chart chart = p.new Chart(10); List<String> tokens = Arrays.asList("A", "B", "C"); p.applyLexicalRules(chart, tokens, 1, 3); assertEquals(rules.get(0), chart.getDerivations(1, 3).get(0).rule); }
@Test void shouldSplitNaryRule() { Rule[] rules = { new Rule("$A", "$B $C $D") }; Grammar g = new Grammar(Arrays.asList(rules), null); assertTrue(g.binaryRules.containsKey(new StringTuple("$C $D"))); assertTrue(g.binaryRules.containsKey(new StringTuple("$B $A_$B"))); assertEquals(g.binaryRules.get(new StringTuple("$C $D")).get(0).getLHS(), "$A_$B"); assertEquals(g.binaryRules.get(new StringTuple("$B $A_$B")).get(0).getLHS(), "$A"); }
@Test void parseSyntactic() { Rule r1 = new Rule("$A", "a"); Rule r2 = new Rule("$B", "b"); Rule r3 = new Rule("$C", "$A $B"); Grammar grammar = new Grammar(Arrays.asList(r1, r2, r3), "$C"); Parser p = new Parser(grammar, s -> Arrays.asList(s.split(" ")), Collections.emptyList()); Derivation dc1 = new Derivation(r1, null); Derivation dc2 = new Derivation(r2, null); Derivation expected = new Derivation(r3, Arrays.asList(dc1, dc2)); Derivation actual = p.parseSyntactic("a b").get(0); assertEquals(expected.rule, actual.rule); assertEquals(expected.children.get(0).rule, actual.children.get(0).rule); assertEquals(expected.children.get(1).rule, actual.children.get(1).rule); }
@Test void shouldSplitOptionals() { Rule[] rules = { new Rule("$A", "?$B $C") }; Grammar g = new Grammar(Arrays.asList(rules), null); assertTrue(g.binaryRules.containsKey(new StringTuple("$B $C"))); assertTrue(g.unaryRules.containsKey(new StringTuple("$C"))); assertEquals(g.binaryRules.get(new StringTuple("$B $C")).get(0).getLHS(), "$A"); assertEquals(g.unaryRules.get(new StringTuple("$C")).get(0).getLHS(), "$A"); }
@Test void parse() { List<Rule> rules = Arrays.asList( new Rule("$A", "a"), new Rule("$B", "b"), new Rule("$C", "$A $B", "{e:@first, f:@last}") ); Grammar grammar = new Grammar(rules, "$C"); Parser p = new Parser(grammar, s -> Arrays.asList(s.split(" ")), Collections.emptyList()); Map<String, Object> expected = new HashMap<String, Object>(){{ put("e", "a"); put("f", "b"); }}; List<LogicalForm> actual = p.parse("a b"); assertEquals(1, actual.size()); assertEquals(expected, actual.get(0).getMap()); }
@Test void applyUnaryRules() { List<Rule> rules = Arrays.asList( new Rule("$F", "$E"), new Rule("$E", "$D")); Grammar grammar = new Grammar(rules, "$ROOT"); Parser p = new Parser(grammar, null, null); Parser.Chart chart = p.new Chart(10); chart.addDerivation(1, 3, new Derivation(new Rule("$D", "$B $C"), null)); p.applyUnaryRules(chart, 1, 3); assertEquals(3, chart.getDerivations(1, 3).size()); assertEquals(rules.get(0), chart.getDerivations(1, 3).get(2).rule); assertEquals(rules.get(1), chart.getDerivations(1, 3).get(1).rule); }
@Test void applyBinaryRules() { List<Rule> rules = Collections.singletonList( new Rule("$C", "$A $B")); Grammar grammar = new Grammar(rules, "$ROOT"); Parser p = new Parser(grammar, null, null); Parser.Chart chart = p.new Chart(10); chart.addDerivation(0, 1, new Derivation(new Rule("$A", "A"), null)); chart.addDerivation(1, 2, new Derivation(new Rule("$B", "B"), null)); p.applyBinaryRules(chart, 0, 2); assertEquals(rules.get(0), chart.getDerivations(0, 2).get(0).rule); } }