104 lines
2.7 KiB
Go
104 lines
2.7 KiB
Go
package toml
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
|
|
"git.makaay.nl/mauricem/go-parsekit/parse"
|
|
)
|
|
|
|
type statesT struct {
|
|
name string
|
|
in string
|
|
out interface{}
|
|
err string
|
|
}
|
|
|
|
type parseTest struct {
|
|
input interface{}
|
|
expected []string
|
|
}
|
|
|
|
func testParseHandler(t *testing.T, p *parser, handler parse.Handler, test parseTest) {
|
|
var err error
|
|
defer func() {
|
|
recovered := recover()
|
|
results := []string{}
|
|
for _, item := range p.Items {
|
|
results = append(results, item.String())
|
|
}
|
|
if err != nil {
|
|
results = append(results, fmt.Sprintf("Error: %s", err))
|
|
}
|
|
if recovered != nil {
|
|
results = append(results, fmt.Sprintf("Panic: %s", recovered.(string)))
|
|
}
|
|
|
|
for i, e := range test.expected {
|
|
if i > len(results)-1 {
|
|
t.Errorf("No result at index %d for input %q, expected: %s", i, test.input, e)
|
|
continue
|
|
}
|
|
r := results[i]
|
|
if e != r {
|
|
t.Errorf("Unexpected result at index %d for input %q:\nexpected: %s\nactual: %s\n", i, test.input, e, r)
|
|
}
|
|
}
|
|
if len(results) > len(test.expected) {
|
|
t.Errorf("Got more results than expected for input %q, surplus result(s):\n", test.input)
|
|
for i := len(test.expected); i < len(results); i++ {
|
|
t.Errorf("[%d] %s", i, results[i])
|
|
}
|
|
}
|
|
}()
|
|
err = parse.New(handler)(test.input)
|
|
}
|
|
|
|
func testAST(t *testing.T, code func() (error, *parser), expectedError string, expectedData string) {
|
|
err, p := code()
|
|
if expectedError == "" {
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error: %s", err)
|
|
}
|
|
} else {
|
|
if err == nil {
|
|
t.Fatalf("An error was expected, but no error was returned")
|
|
} else if err.Error() != expectedError {
|
|
t.Fatalf("Unexpected error:\nexpected: %s\nactual: %s\n", expectedError, err.Error())
|
|
}
|
|
}
|
|
if expectedData == "" {
|
|
return
|
|
}
|
|
if expectedData != p.Root.String() {
|
|
t.Fatalf("Unexpected data after parsing:\nexpected: %s\nactual: %s\n", expectedData, p.Root.String())
|
|
}
|
|
}
|
|
|
|
type parseToASTTest struct {
|
|
input interface{}
|
|
expected string
|
|
expectedError string
|
|
}
|
|
|
|
func testParseToAST(t *testing.T, p *parser, handler parse.Handler, test parseToASTTest) {
|
|
var err error
|
|
defer func() {
|
|
recovered := recover()
|
|
if recovered != nil {
|
|
err = fmt.Errorf("Panic: %s", recovered.(string))
|
|
}
|
|
if err != nil && test.expectedError == "" {
|
|
t.Errorf("Unexpected error for input %q: %s", test.input, err)
|
|
} else if err != nil && test.expectedError != err.Error() {
|
|
t.Errorf("Unexpected error for input %q:\nexpected: %s\nactual: %s\n", test.input, test.expectedError, err.Error())
|
|
} else {
|
|
result := p.Root.String()
|
|
if test.expected != result {
|
|
t.Errorf("Unexpected result for input %q:\nexpected: %s\nactual: %s\n", test.input, test.expected, result)
|
|
}
|
|
}
|
|
}()
|
|
err = parse.New(handler)(test.input)
|
|
}
|