func TestLex(t *testing.T) {
l := New([]lex.Lex{
trie.New("tag1", "foo", "foots"),
trie.New("tag2", "foo", "fool"),
})
tests := []struct {
input rune
match bool
tag tag.Tag
err bool
}{
{'f', false, nil, false},
{'o', false, nil, false},
{'o', true, tag.New("tag1"), false},
{'l', true, tag.New("tag2"), false},
{'s', false, nil, true},
}
for i, test := range tests {
l.Next(test.input)
if l.Match() != test.match {
t.Errorf("match not equal on input %d: expected %v, got %v", i, test.match, l.Match())
}
if !tag.Equal(l.Tag(), test.tag) {
t.Errorf("tag not equal on input %d: expected %v, got %v", i, test.tag, l.Tag())
}
if l.Error() != test.err {
t.Errorf("error not equal on input %d: expected %v, got %v", i, test.err, l.Error())
}
}
}
func TestBufferParens(t *testing.T) {
taker := SimpleTaker([]Match{})
b := Buffer{
Taker: &taker,
Lex: trie.New("tag", "{", "}"),
}
expected := SimpleTaker{
Match{0, "{", tag.New("tag")},
Match{1, "}", tag.New("tag")},
Match{2, "{", tag.New("tag")},
Match{3, "}", tag.New("tag")},
}
n, err := b.Read([]byte("{}{}"))
if err == nil {
err = b.Close()
}
if err != nil {
t.Errorf("expected err == nil, got %v", err)
}
if n != 4 {
t.Errorf("expected n == 4, got %d", n)
}
if len(taker) != 4 {
t.Errorf("expected 4 matches, got %d", len(taker))
}
for i, m := range taker {
if m.Index != expected[i].Index || m.Str != expected[i].Str || !tag.Equal(m.Tag, expected[i].Tag) {
t.Errorf("taker[%d] != %v, got %v", i, expected[i], m)
}
}
}
func TestParens(t *testing.T) {
tests := []struct {
str string
ok bool
}{
{"{}", true},
{"{}{}", true},
{"{{}}", true},
{"{}}{", false},
{"{{}}{}", true},
{"}{", false},
}
for _, test := range tests {
parser := parse.New()
parens := &Parens{parser}
parser.States["parens"] = parens
parser.Push("parens")
b := lex.Buffer{
Taker: parser,
Lex: trie.New("trie", "{", "}"),
}
n, err := b.Read([]byte(test.str))
if (n == len(test.str) && err == nil) != test.ok {
if test.ok {
t.Errorf("Expected no error on %s: %d read, error %s", test.str, n, err)
} else {
t.Errorf("Expected error on %s", test.str)
}
}
fmt.Println("Done test!")
}
}
func TestBuffer(t *testing.T) {
taker := SimpleTaker([]Match{})
b := Buffer{
Taker: &taker,
Lex: trie.New("tag", "abc", "abcdef", "abcdefgh", "ggg"),
}
expected := SimpleTaker{
Match{0, "abcdef", tag.New("tag")},
Match{6, "ggg", tag.New("tag")},
}
n, err := b.Read([]byte("abcde"))
if n != 5 {
t.Errorf("expected n == 5, got %d", n)
}
if err != nil {
t.Errorf("expected err == nil, got %v", err)
}
n, err = b.Read([]byte("fggg"))
if err == nil {
err = b.Close()
}
if n != 4 {
t.Errorf("expected n == 4, got %d", n)
}
if err != nil {
t.Errorf("expected err == nil, got %v", err)
}
if len(taker) != len(expected) {
t.Errorf("expected len(taker) == %d, got %d", len(expected), len(taker))
}
for i, m := range taker {
if m.Index != expected[i].Index || m.Str != expected[i].Str || !tag.Equal(m.Tag, expected[i].Tag) {
t.Errorf("taker[%d] != %v, got %v", i, expected[i], m)
}
}
n, err = b.Read([]byte("xyz"))
if n != 3 {
t.Errorf("expected n == 3, got %d", n)
}
if err == nil {
t.Error("expected err != nil, got nil")
}
}
func TestStack(t *testing.T) {
tests := []struct {
str string
ok bool
}{
{"()", true},
{"()()", true},
{"(())", true},
{"())(", false},
{"(())()", true},
{")(", false},
}
for _, test := range tests {
t.Logf("Running test on %s", test.str)
p := &parens{}
s := New(p)
b := lex.Buffer{
Taker: s,
Lex: trie.New("trie", "(", ")"),
}
n, err := b.Read([]byte(test.str))
if err == nil {
err = b.Close()
}
if test.ok {
if n != len(test.str) || err != nil {
t.Fatalf("expected no error on %s: %d read, error %s", test.str, n, err)
}
if len(s.Stack) != 1 {
t.Fatalf("expected stack size one on %s, got %d", test.str, len(s.Stack))
} else if s.Stack[0].(*parens).String() != test.str {
t.Fatalf("expected parse as %s, got %s", test.str, s.Stack[0].(*parens).String())
}
} else if n == len(test.str) && err == nil {
t.Fatalf("expected error on input %s", test.str)
}
}
}