209 lines
7.6 KiB
Go
209 lines
7.6 KiB
Go
package parsekit_test
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"git.makaay.nl/mauricem/go-parsekit"
|
|
)
|
|
|
|
func ExampleMatchAnyRune() {
|
|
parser := parsekit.New(
|
|
func(p *parsekit.P) {
|
|
p.Expects("Any valid rune")
|
|
if p.On(a.AnyRune).Accept().End() {
|
|
p.EmitLiteral(TestItem)
|
|
}
|
|
})
|
|
run := parser.Parse("¡Any / valid / character will dö!")
|
|
match, _, ok := run.Next()
|
|
if ok {
|
|
fmt.Printf("Match = %q\n", match)
|
|
}
|
|
}
|
|
|
|
func TestCombinators(t *testing.T) {
|
|
RunMatcherTests(t, []MatcherTest{
|
|
{"xxx", c.Rune('x'), true, "x"},
|
|
{"x ", c.Rune(' '), false, ""},
|
|
{"aa", c.RuneRange('b', 'e'), false, ""},
|
|
{"bb", c.RuneRange('b', 'e'), true, "b"},
|
|
{"cc", c.RuneRange('b', 'e'), true, "c"},
|
|
{"dd", c.RuneRange('b', 'e'), true, "d"},
|
|
{"ee", c.RuneRange('b', 'e'), true, "e"},
|
|
{"ff", c.RuneRange('b', 'e'), false, ""},
|
|
{"Hello, world!", c.Str("Hello"), true, "Hello"},
|
|
{"HellÖ, world!", c.StrNoCase("hellö"), true, "HellÖ"},
|
|
{"+X", c.Runes('+', '-', '*', '/'), true, "+"},
|
|
{"-X", c.Runes('+', '-', '*', '/'), true, "-"},
|
|
{"*X", c.Runes('+', '-', '*', '/'), true, "*"},
|
|
{"/X", c.Runes('+', '-', '*', '/'), true, "/"},
|
|
{"!X", c.Runes('+', '-', '*', '/'), false, ""},
|
|
{"abc", c.Not(c.Rune('b')), true, "a"},
|
|
{"bcd", c.Not(c.Rune('b')), false, ""},
|
|
{"bcd", c.Not(c.Rune('b')), false, ""},
|
|
{"1010", c.Not(c.Seq(c.Rune('2'), c.Rune('0'))), true, "1"},
|
|
{"2020", c.Not(c.Seq(c.Rune('2'), c.Rune('0'))), false, ""},
|
|
{"abc", c.Any(c.Rune('a'), c.Rune('b')), true, "a"},
|
|
{"bcd", c.Any(c.Rune('a'), c.Rune('b')), true, "b"},
|
|
{"cde", c.Any(c.Rune('a'), c.Rune('b')), false, ""},
|
|
{"ababc", c.Rep(4, c.Runes('a', 'b')), true, "abab"},
|
|
{"ababc", c.Rep(5, c.Runes('a', 'b')), false, ""},
|
|
{"", c.Min(0, c.Rune('a')), true, ""},
|
|
{"a", c.Min(0, c.Rune('a')), true, "a"},
|
|
{"aaaaa", c.Min(4, c.Rune('a')), true, "aaaaa"},
|
|
{"aaaaa", c.Min(5, c.Rune('a')), true, "aaaaa"},
|
|
{"aaaaa", c.Min(6, c.Rune('a')), false, ""},
|
|
{"", c.Max(4, c.Rune('b')), true, ""},
|
|
{"X", c.Max(4, c.Rune('b')), true, ""},
|
|
{"bbbbbX", c.Max(4, c.Rune('b')), true, "bbbb"},
|
|
{"bbbbbX", c.Max(5, c.Rune('b')), true, "bbbbb"},
|
|
{"bbbbbX", c.Max(6, c.Rune('b')), true, "bbbbb"},
|
|
{"", c.MinMax(0, 0, c.Rune('c')), true, ""},
|
|
{"X", c.MinMax(0, 0, c.Rune('c')), true, ""},
|
|
{"cccccX", c.MinMax(0, 0, c.Rune('c')), true, ""},
|
|
{"cccccX", c.MinMax(0, 1, c.Rune('c')), true, "c"},
|
|
{"cccccX", c.MinMax(0, 5, c.Rune('c')), true, "ccccc"},
|
|
{"cccccX", c.MinMax(0, 6, c.Rune('c')), true, "ccccc"},
|
|
{"cccccX", c.MinMax(1, 1, c.Rune('c')), true, "c"},
|
|
{"", c.MinMax(1, 1, c.Rune('c')), false, ""},
|
|
{"X", c.MinMax(1, 1, c.Rune('c')), false, ""},
|
|
{"cccccX", c.MinMax(1, 3, c.Rune('c')), true, "ccc"},
|
|
{"cccccX", c.MinMax(1, 6, c.Rune('c')), true, "ccccc"},
|
|
{"cccccX", c.MinMax(3, 4, c.Rune('c')), true, "cccc"},
|
|
{"", c.OneOrMore(c.Rune('d')), false, ""},
|
|
{"X", c.OneOrMore(c.Rune('d')), false, ""},
|
|
{"dX", c.OneOrMore(c.Rune('d')), true, "d"},
|
|
{"dddddX", c.OneOrMore(c.Rune('d')), true, "ddddd"},
|
|
{"", c.ZeroOrMore(c.Rune('e')), true, ""},
|
|
{"X", c.ZeroOrMore(c.Rune('e')), true, ""},
|
|
{"eX", c.ZeroOrMore(c.Rune('e')), true, "e"},
|
|
{"eeeeeX", c.ZeroOrMore(c.Rune('e')), true, "eeeee"},
|
|
{"Hello, world!X", c.Seq(c.Str("Hello"), a.Comma, a.Space, c.Str("world"), a.Excl), true, "Hello, world!"},
|
|
{"101010123", c.OneOrMore(c.Seq(c.Rune('1'), c.Rune('0'))), true, "101010"},
|
|
{"", c.Opt(c.OneOrMore(c.Rune('f'))), true, ""},
|
|
{"ghijkl", c.Opt(c.Rune('h')), true, ""},
|
|
{"ghijkl", c.Opt(c.Rune('g')), true, "g"},
|
|
{"fffffX", c.Opt(c.OneOrMore(c.Rune('f'))), true, "fffff"},
|
|
{"1,2,3,b,c", c.Separated(a.Digit, a.Comma), true, "1,2,3"},
|
|
{`\x9a\x01\xF0\xfCAndSomeMoreStuff`, c.OneOrMore(c.Seq(a.Backslash, c.Rune('x'), c.Rep(2, a.HexDigit))), true, `\x9a\x01\xF0\xfC`},
|
|
{" ", m.Trim(c.OneOrMore(a.AnyRune), " "), true, ""},
|
|
{" ", m.TrimLeft(c.OneOrMore(a.AnyRune), " "), true, ""},
|
|
{" ", m.TrimRight(c.OneOrMore(a.AnyRune), " "), true, ""},
|
|
})
|
|
}
|
|
|
|
func TestModifiers(t *testing.T) {
|
|
RunMatcherTests(t, []MatcherTest{
|
|
{" trim ", m.Trim(c.OneOrMore(a.AnyRune), " "), true, "trim"},
|
|
{" \t trim \t ", m.Trim(c.OneOrMore(a.AnyRune), " \t"), true, "trim"},
|
|
{" trim ", m.TrimLeft(c.OneOrMore(a.AnyRune), " "), true, "trim "},
|
|
{" trim ", m.TrimRight(c.OneOrMore(a.AnyRune), " "), true, " trim"},
|
|
{" \t trim \t ", m.TrimRight(c.OneOrMore(a.AnyRune), " \t"), true, " \t trim"},
|
|
{"--cool", c.Seq(m.Drop(c.OneOrMore(a.Minus)), c.Str("cool")), true, "cool"},
|
|
})
|
|
}
|
|
|
|
func TestAtoms(t *testing.T) {
|
|
RunMatcherTests(t, []MatcherTest{
|
|
{"", a.EndOfFile, true, ""},
|
|
{"⌘", a.AnyRune, true, "⌘"},
|
|
{"\xbc", a.AnyRune, false, ""}, // invalid UTF8 rune
|
|
{"", a.AnyRune, false, ""}, // end of file
|
|
{" ", a.Space, true, " "},
|
|
{"X", a.Space, false, ""},
|
|
{"\t", a.Tab, true, "\t"},
|
|
{"\r", a.CR, true, "\r"},
|
|
{"\n", a.LF, true, "\n"},
|
|
{"!", a.Excl, true, "!"},
|
|
{"\"", a.DoubleQuote, true, "\""},
|
|
{"#", a.Hash, true, "#"},
|
|
{"$", a.Dollar, true, "$"},
|
|
{"%", a.Percent, true, "%"},
|
|
{"&", a.Amp, true, "&"},
|
|
{"'", a.SingleQuote, true, "'"},
|
|
{"(", a.RoundOpen, true, "("},
|
|
{")", a.RoundClose, true, ")"},
|
|
{"*", a.Asterisk, true, "*"},
|
|
{"+", a.Plus, true, "+"},
|
|
{",", a.Comma, true, ","},
|
|
{"-", a.Minus, true, "-"},
|
|
{".", a.Dot, true, "."},
|
|
{"/", a.Slash, true, "/"},
|
|
{":", a.Colon, true, ":"},
|
|
{";", a.Semicolon, true, ";"},
|
|
{"<", a.AngleOpen, true, "<"},
|
|
{"=", a.Equal, true, "="},
|
|
{">", a.AngleClose, true, ">"},
|
|
{"?", a.Question, true, "?"},
|
|
{"@", a.At, true, "@"},
|
|
{"[", a.SquareOpen, true, "["},
|
|
{"\\", a.Backslash, true, "\\"},
|
|
{"]", a.SquareClose, true, "]"},
|
|
{"^", a.Caret, true, "^"},
|
|
{"_", a.Underscore, true, "_"},
|
|
{"`", a.Backquote, true, "`"},
|
|
{"{", a.CurlyOpen, true, "{"},
|
|
{"|", a.Pipe, true, "|"},
|
|
{"}", a.CurlyClose, true, "}"},
|
|
{"~", a.Tilde, true, "~"},
|
|
{" \t \t \r\n", a.Whitespace, true, " \t \t "},
|
|
{"\r", a.WhitespaceAndNewlines, false, ""},
|
|
{" \t\r\n \r", a.WhitespaceAndNewlines, true, " \t\r\n "},
|
|
{"", a.EndOfLine, true, ""},
|
|
{"\r\n", a.EndOfLine, true, "\r\n"},
|
|
{"\n", a.EndOfLine, true, "\n"},
|
|
{"0", a.Digit, true, "0"},
|
|
{"1", a.Digit, true, "1"},
|
|
{"2", a.Digit, true, "2"},
|
|
{"3", a.Digit, true, "3"},
|
|
{"4", a.Digit, true, "4"},
|
|
{"5", a.Digit, true, "5"},
|
|
{"6", a.Digit, true, "6"},
|
|
{"7", a.Digit, true, "7"},
|
|
{"8", a.Digit, true, "8"},
|
|
{"9", a.Digit, true, "9"},
|
|
{"X", a.Digit, false, ""},
|
|
{"a", a.ASCIILower, true, "a"},
|
|
{"z", a.ASCIILower, true, "z"},
|
|
{"A", a.ASCIILower, false, ""},
|
|
{"Z", a.ASCIILower, false, ""},
|
|
{"A", a.ASCIIUpper, true, "A"},
|
|
{"Z", a.ASCIIUpper, true, "Z"},
|
|
{"a", a.ASCIIUpper, false, ""},
|
|
{"z", a.ASCIIUpper, false, ""},
|
|
{"0", a.HexDigit, true, "0"},
|
|
{"9", a.HexDigit, true, "9"},
|
|
{"a", a.HexDigit, true, "a"},
|
|
{"f", a.HexDigit, true, "f"},
|
|
{"A", a.HexDigit, true, "A"},
|
|
{"F", a.HexDigit, true, "F"},
|
|
{"g", a.HexDigit, false, "g"},
|
|
{"G", a.HexDigit, false, "G"},
|
|
})
|
|
}
|
|
|
|
func TestSequenceOfRunes(t *testing.T) {
|
|
sequence := c.Seq(
|
|
a.Hash, a.Dollar, a.Percent, a.Amp, a.SingleQuote, a.RoundOpen,
|
|
a.RoundClose, a.Asterisk, a.Plus, a.Comma, a.Minus, a.Dot, a.Slash,
|
|
a.Colon, a.Semicolon, a.AngleOpen, a.Equal, a.AngleClose, a.Question,
|
|
a.At, a.SquareOpen, a.Backslash, a.SquareClose, a.Caret, a.Underscore,
|
|
a.Backquote, a.CurlyOpen, a.Pipe, a.CurlyClose, a.Tilde,
|
|
)
|
|
input := "#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
|
|
parser := parsekit.New(func(p *parsekit.P) {
|
|
p.Expects("Sequence of runes")
|
|
if p.On(sequence).Accept().End() {
|
|
p.EmitLiteral(TestItem)
|
|
}
|
|
})
|
|
item, err, ok := parser.Parse(input).Next()
|
|
if !ok {
|
|
t.Fatalf("Parsing failed: %s", err)
|
|
}
|
|
if item.Value != input {
|
|
t.Fatalf("Unexpected output from parser:\nexpected: %s\nactual: %s\n", input, item.Value)
|
|
}
|
|
}
|