diff options
Diffstat (limited to 'tests/unit/driver/parser/semantic_action_test.go')
| -rw-r--r-- | tests/unit/driver/parser/semantic_action_test.go | 227 |
1 files changed, 227 insertions, 0 deletions
diff --git a/tests/unit/driver/parser/semantic_action_test.go b/tests/unit/driver/parser/semantic_action_test.go new file mode 100644 index 0000000..cb3ee70 --- /dev/null +++ b/tests/unit/driver/parser/semantic_action_test.go @@ -0,0 +1,227 @@ +package parser + +import ( + "fmt" + "strings" + "testing" + + "urubu/grammar" + spec "urubu/spec/grammar" + "urubu/spec/grammar/parser" +) + +type testSemAct struct { + gram *spec.CompiledGrammar + actLog []string +} + +func (a *testSemAct) Shift(tok VToken, recovered bool) { + t := a.gram.Syntactic.Terminals[tok.TerminalID()] + if recovered { + a.actLog = append(a.actLog, fmt.Sprintf("shift/%v/recovered", t)) + } else { + a.actLog = append(a.actLog, fmt.Sprintf("shift/%v", t)) + } +} + +func (a *testSemAct) Reduce(prodNum int, recovered bool) { + lhsSym := a.gram.Syntactic.LHSSymbols[prodNum] + lhsText := a.gram.Syntactic.NonTerminals[lhsSym] + if recovered { + a.actLog = append(a.actLog, fmt.Sprintf("reduce/%v/recovered", lhsText)) + } else { + a.actLog = append(a.actLog, fmt.Sprintf("reduce/%v", lhsText)) + } +} + +func (a *testSemAct) Accept() { + a.actLog = append(a.actLog, "accept") +} + +func (a *testSemAct) TrapAndShiftError(cause VToken, popped int) { + a.actLog = append(a.actLog, fmt.Sprintf("trap/%v/shift/error", popped)) +} + +func (a *testSemAct) MissError(cause VToken) { + a.actLog = append(a.actLog, "miss") +} + +func TestParserWithSemanticAction(t *testing.T) { + specSrcWithErrorProd := ` +#name test; + +seq + : seq elem semicolon + | elem semicolon + | error star star semicolon + | error semicolon #recover + ; +elem + : char char char + ; + +ws #skip + : "[\u{0009}\u{0020}]+"; +semicolon + : ';'; +star + : '*'; +char + : "[a-z]"; +` + + specSrcWithoutErrorProd := ` +#name test; + +seq + : seq elem semicolon + | elem semicolon + ; +elem + : char char char + ; + +ws #skip + : "[\u{0009}\u{0020}]+"; +semicolon + : ';'; +char + : "[a-z]"; +` + + tests := []struct { + caption string + specSrc string + src string + actLog []string + }{ + { + caption: "when an input contains no syntax error, the driver calls `Shift`, `Reduce`, and `Accept`.", + specSrc: specSrcWithErrorProd, + src: `a b c; d e f;`, + actLog: []string{ + "shift/char", + "shift/char", + "shift/char", + "reduce/elem", + "shift/semicolon", + "reduce/seq", + + "shift/char", + "shift/char", + "shift/char", + "reduce/elem", + "shift/semicolon", + "reduce/seq", + + "accept", + }, + }, + { + caption: "when a grammar has `error` symbol, the driver calls `TrapAndShiftError`.", + specSrc: specSrcWithErrorProd, + src: `a; b !; c d !; e ! * *; h i j;`, + actLog: []string{ + "shift/char", + "trap/1/shift/error", + "shift/semicolon", + "reduce/seq/recovered", + + "shift/char", + "trap/2/shift/error", + "shift/semicolon", + "reduce/seq/recovered", + + "shift/char", + "shift/char", + "trap/3/shift/error", + "shift/semicolon", + "reduce/seq/recovered", + + "shift/char", + "trap/2/shift/error", + "shift/star", + "shift/star", + // When the driver shifts three times, it recovers from an error. + "shift/semicolon/recovered", + "reduce/seq", + + "shift/char", + "shift/char", + "shift/char", + "reduce/elem", + "shift/semicolon", + "reduce/seq", + + // Even if the input contains syntax errors, the driver calls `Accept` when the input is accepted + // according to the error production. + "accept", + }, + }, + { + caption: "when the input doesn't meet the error production, the driver calls `MissError`.", + specSrc: specSrcWithErrorProd, + src: `a !`, + actLog: []string{ + "shift/char", + "trap/1/shift/error", + + "miss", + }, + }, + { + caption: "when a syntax error isn't trapped, the driver calls `MissError`.", + specSrc: specSrcWithoutErrorProd, + src: `a !`, + actLog: []string{ + "shift/char", + + "miss", + }, + }, + } + for _, tt := range tests { + t.Run(tt.caption, func(t *testing.T) { + ast, err := parser.Parse(strings.NewReader(tt.specSrc)) + if err != nil { + t.Fatal(err) + } + + b := grammar.GrammarBuilder{ + AST: ast, + } + gram, _, err := b.Build() + if err != nil { + t.Fatal(err) + } + + toks, err := NewTokenStream(gram, strings.NewReader(tt.src)) + if err != nil { + t.Fatal(err) + } + + semAct := &testSemAct{ + gram: gram, + } + p, err := NewParser(toks, NewGrammar(gram), SemanticAction(semAct)) + if err != nil { + t.Fatal(err) + } + + err = p.Parse() + if err != nil { + t.Fatal(err) + } + + if len(semAct.actLog) != len(tt.actLog) { + t.Fatalf("unexpected action log; want: %+v, got: %+v", tt.actLog, semAct.actLog) + } + + for i, e := range tt.actLog { + if semAct.actLog[i] != e { + t.Fatalf("unexpected action log; want: %+v, got: %+v", tt.actLog, semAct.actLog) + } + } + }) + } +} |