diff --git a/ast/ast_optimize_test.go b/ast/ast_optimize_test.go index 3acc357e..3a3f0d23 100644 --- a/ast/ast_optimize_test.go +++ b/ast/ast_optimize_test.go @@ -1,6 +1,7 @@ package ast import ( + "fmt" "reflect" "testing" // "github.com/pmezard/go-difflib/difflib" @@ -340,25 +341,27 @@ var cases = []struct { func TestOptimize(t *testing.T) { for i := range cases { - Optimize(cases[i].in) - if !reflect.DeepEqual(cases[i].in, cases[i].out) { - t.Errorf("%d: not equal", i) - // dumpin := goon.Sdump(cases[i].in) - // dumpout := goon.Sdump(cases[i].out) - // fmt.Println("=== want:") - // fmt.Println(dumpout) - // fmt.Println("=== got:") - // fmt.Println(dumpin) - // fmt.Println("=== diff:") - // diff := difflib.UnifiedDiff{ - // A: difflib.SplitLines(dumpout), - // B: difflib.SplitLines(dumpin), - // FromFile: "want", - // ToFile: "got", - // Context: 3, - // } - // text, _ := difflib.GetUnifiedDiffString(diff) - // fmt.Println(text) - } + t.Run(fmt.Sprint(i), func(t *testing.T) { + Optimize(cases[i].in) + if !reflect.DeepEqual(cases[i].in, cases[i].out) { + t.Errorf("%d: not equal", i) + // dumpin := goon.Sdump(cases[i].in) + // dumpout := goon.Sdump(cases[i].out) + // fmt.Println("=== want:") + // fmt.Println(dumpout) + // fmt.Println("=== got:") + // fmt.Println(dumpin) + // fmt.Println("=== diff:") + // diff := difflib.UnifiedDiff{ + // A: difflib.SplitLines(dumpout), + // B: difflib.SplitLines(dumpin), + // FromFile: "want", + // ToFile: "got", + // Context: 3, + // } + // text, _ := difflib.GetUnifiedDiffString(diff) + // fmt.Println(text) + } + }) } } diff --git a/ast/ast_test.go b/ast/ast_test.go index 767e9a1d..336bccfd 100644 --- a/ast/ast_test.go +++ b/ast/ast_test.go @@ -69,39 +69,41 @@ var expRanges = []string{ func TestCharClassParse(t *testing.T) { for i, c := range charClasses { - m := NewCharClassMatcher(Pos{}, c) + t.Run(c, func(t *testing.T) { + m := NewCharClassMatcher(Pos{}, c) - ic := strings.HasSuffix(c, "i") - if m.IgnoreCase != ic { - t.Errorf("%q: want ignore case: %t, got %t", c, ic, m.IgnoreCase) - } - iv := c[1] == '^' - if m.Inverted != iv { - t.Errorf("%q: want inverted: %t, got %t", c, iv, m.Inverted) - } + ic := strings.HasSuffix(c, "i") + if m.IgnoreCase != ic { + t.Errorf("%q: want ignore case: %t, got %t", c, ic, m.IgnoreCase) + } + iv := c[1] == '^' + if m.Inverted != iv { + t.Errorf("%q: want inverted: %t, got %t", c, iv, m.Inverted) + } - if n := utf8.RuneCountInString(expChars[i]); len(m.Chars) != n { - t.Errorf("%q: want %d chars, got %d", c, n, len(m.Chars)) - } else if string(m.Chars) != expChars[i] { - t.Errorf("%q: want %q, got %q", c, expChars[i], string(m.Chars)) - } + if n := utf8.RuneCountInString(expChars[i]); len(m.Chars) != n { + t.Errorf("%q: want %d chars, got %d", c, n, len(m.Chars)) + } else if string(m.Chars) != expChars[i] { + t.Errorf("%q: want %q, got %q", c, expChars[i], string(m.Chars)) + } - if n := utf8.RuneCountInString(expRanges[i]); len(m.Ranges) != n { - t.Errorf("%q: want %d chars, got %d", c, n, len(m.Ranges)) - } else if string(m.Ranges) != expRanges[i] { - t.Errorf("%q: want %q, got %q", c, expRanges[i], string(m.Ranges)) - } + if n := utf8.RuneCountInString(expRanges[i]); len(m.Ranges) != n { + t.Errorf("%q: want %d chars, got %d", c, n, len(m.Ranges)) + } else if string(m.Ranges) != expRanges[i] { + t.Errorf("%q: want %q, got %q", c, expRanges[i], string(m.Ranges)) + } - if n := len(expUnicodeClasses[i]); len(m.UnicodeClasses) != n { - t.Errorf("%q: want %d Unicode classes, got %d", c, n, len(m.UnicodeClasses)) - } else if n > 0 { - want := expUnicodeClasses[i] - got := m.UnicodeClasses - for j, wantClass := range want { - if wantClass != got[j] { - t.Errorf("%q: range table %d: want %v, got %v", c, j, wantClass, got[j]) + if n := len(expUnicodeClasses[i]); len(m.UnicodeClasses) != n { + t.Errorf("%q: want %d Unicode classes, got %d", c, n, len(m.UnicodeClasses)) + } else if n > 0 { + want := expUnicodeClasses[i] + got := m.UnicodeClasses + for j, wantClass := range want { + if wantClass != got[j] { + t.Errorf("%q: range table %d: want %v, got %v", c, j, wantClass, got[j]) + } } } - } + }) } } diff --git a/bootstrap/parser_test.go b/bootstrap/parser_test.go index 07b94db8..4cdd5ee9 100644 --- a/bootstrap/parser_test.go +++ b/bootstrap/parser_test.go @@ -53,17 +53,19 @@ var parseExpRes = []string{ func TestParseValid(t *testing.T) { p := NewParser() for i, c := range parseValidCases { - g, err := p.Parse("", strings.NewReader(c)) - if err != nil { - t.Errorf("%d: got error %v", i, err) - continue - } + t.Run(c, func(t *testing.T) { + g, err := p.Parse("", strings.NewReader(c)) + if err != nil { + t.Errorf("%d: got error %v", i, err) + return + } - want := parseExpRes[i] - got := g.String() - if want != got { - t.Errorf("%d: want \n%s\n, got \n%s\n", i, want, got) - } + want := parseExpRes[i] + got := g.String() + if want != got { + t.Errorf("%d: want \n%s\n, got \n%s\n", i, want, got) + } + }) } } @@ -80,18 +82,20 @@ var parseExpErrs = [][]string{ func TestParseInvalid(t *testing.T) { p := NewParser() for i, c := range parseInvalidCases { - _, err := p.Parse("", strings.NewReader(c)) - el := *(err.(*errList)) - if len(el) != len(parseExpErrs[i]) { - t.Errorf("%d: want %d errors, got %d", i, len(parseExpErrs[i]), len(el)) - continue - } - for j, err := range el { - want := parseExpErrs[i][j] - got := err.Error() - if want != got { - t.Errorf("%d: error %d: want %q, got %q", i, j, want, got) + t.Run(c, func(t *testing.T) { + _, err := p.Parse("", strings.NewReader(c)) + el := *(err.(*errList)) + if len(el) != len(parseExpErrs[i]) { + t.Errorf("%d: want %d errors, got %d", i, len(parseExpErrs[i]), len(el)) + return + } + for j, err := range el { + want := parseExpErrs[i][j] + got := err.Error() + if want != got { + t.Errorf("%d: error %d: want %q, got %q", i, j, want, got) + } } - } + }) } } diff --git a/bootstrap/scan_test.go b/bootstrap/scan_test.go index c5b89a6c..f50a4f9e 100644 --- a/bootstrap/scan_test.go +++ b/bootstrap/scan_test.go @@ -218,33 +218,35 @@ func TestScanValid(t *testing.T) { var s Scanner var errh errsink for i, c := range scanValidCases { - errh.reset() - s.Init("", strings.NewReader(c), errh.add) + t.Run(c, func(t *testing.T) { + errh.reset() + s.Init("", strings.NewReader(c), errh.add) - j := 0 - for { - tok, ok := s.Scan() - if j < len(scanExpTokens[i]) { - got := tok.String() - want := scanExpTokens[i][j] - if got != want { - t.Errorf("%d: token %d: want %q, got %q", i, j, want, got) + j := 0 + for { + tok, ok := s.Scan() + if j < len(scanExpTokens[i]) { + got := tok.String() + want := scanExpTokens[i][j] + if got != want { + t.Errorf("%d: token %d: want %q, got %q", i, j, want, got) + } + } else { + t.Errorf("%d: want %d tokens, got #%d", i, len(scanExpTokens[i]), j+1) } - } else { - t.Errorf("%d: want %d tokens, got #%d", i, len(scanExpTokens[i]), j+1) - } - if !ok { - if j < len(scanExpTokens[i])-1 { - t.Errorf("%d: wand %d tokens, got only %d", i, len(scanExpTokens[i]), j+1) + if !ok { + if j < len(scanExpTokens[i])-1 { + t.Errorf("%d: wand %d tokens, got only %d", i, len(scanExpTokens[i]), j+1) + } + break } - break + j++ + } + if len(errh.errs) != 0 { + t.Errorf("%d: want no error, got %d", i, len(errh.errs)) + t.Log(errh.errs) } - j++ - } - if len(errh.errs) != 0 { - t.Errorf("%d: want no error, got %d", i, len(errh.errs)) - t.Log(errh.errs) - } + }) } } @@ -336,23 +338,25 @@ func TestScanInvalid(t *testing.T) { var s Scanner var errh errsink for i, c := range scanInvalidCases { - errh.reset() - s.Init("", strings.NewReader(c), errh.add) - for { - if _, ok := s.Scan(); !ok { - break + t.Run(c, func(t *testing.T) { + errh.reset() + s.Init("", strings.NewReader(c), errh.add) + for { + if _, ok := s.Scan(); !ok { + break + } } - } - if len(errh.errs) != len(scanExpErrs[i]) { - t.Errorf("%d: want %d errors, got %d", i, len(scanExpErrs[i]), len(errh.errs)) - continue - } - for j := range errh.errs { - want := scanExpErrs[i][j] - got := errh.StringAt(j) - if want != got { - t.Errorf("%d: error %d: want %q, got %q", i, j, want, got) + if len(errh.errs) != len(scanExpErrs[i]) { + t.Errorf("%d: want %d errors, got %d", i, len(scanExpErrs[i]), len(errh.errs)) + return + } + for j := range errh.errs { + want := scanExpErrs[i][j] + got := errh.StringAt(j) + if want != got { + t.Errorf("%d: error %d: want %q, got %q", i, j, want, got) + } } - } + }) } } diff --git a/examples/calculator/calculator_test.go b/examples/calculator/calculator_test.go index 1af22105..8e059510 100644 --- a/examples/calculator/calculator_test.go +++ b/examples/calculator/calculator_test.go @@ -48,19 +48,21 @@ var validCases = map[string]int{ func TestValidCases(t *testing.T) { for tc, exp := range validCases { - got, err := Parse("", []byte(tc)) - if err != nil { - t.Errorf("%q: want no error, got %v", tc, err) - continue - } - goti, ok := got.(int) - if !ok { - t.Errorf("%q: want type %T, got %T", tc, exp, got) - continue - } - if exp != goti { - t.Errorf("%q: want %d, got %d", tc, exp, goti) - } + t.Run(tc, func(t *testing.T) { + got, err := Parse("", []byte(tc)) + if err != nil { + t.Errorf("%q: want no error, got %v", tc, err) + return + } + goti, ok := got.(int) + if !ok { + t.Errorf("%q: want type %T, got %T", tc, exp, got) + return + } + if exp != goti { + t.Errorf("%q: want %d, got %d", tc, exp, goti) + } + }) } } @@ -88,24 +90,26 @@ var invalidCases = map[string]string{ func TestInvalidCases(t *testing.T) { for tc, exp := range invalidCases { - got, err := Parse("", []byte(tc)) - if err == nil { - t.Errorf("%q: want error, got none (%v)", tc, got) - continue - } - el, ok := err.(errList) - if !ok { - t.Errorf("%q: want error type %T, got %T", tc, &errList{}, err) - continue - } - for _, e := range el { - if _, ok := e.(*parserError); !ok { - t.Errorf("%q: want all individual errors to be %T, got %T (%[3]v)", tc, &parserError{}, e) + t.Run(tc, func(t *testing.T) { + got, err := Parse("", []byte(tc)) + if err == nil { + t.Errorf("%q: want error, got none (%v)", tc, got) + return } - } - if exp != err.Error() { - t.Errorf("%q: want \n%s\n, got \n%s\n", tc, exp, err) - } + el, ok := err.(errList) + if !ok { + t.Errorf("%q: want error type %T, got %T", tc, &errList{}, err) + return + } + for _, e := range el { + if _, ok := e.(*parserError); !ok { + t.Errorf("%q: want all individual errors to be %T, got %T (%[3]v)", tc, &parserError{}, e) + } + } + if exp != err.Error() { + t.Errorf("%q: want \n%s\n, got \n%s\n", tc, exp, err) + } + }) } } diff --git a/examples/json/cmd/json-parser/exporterror_test.go b/examples/json/cmd/json-parser/exporterror_test.go index a57414ba..9cd811e2 100644 --- a/examples/json/cmd/json-parser/exporterror_test.go +++ b/examples/json/cmd/json-parser/exporterror_test.go @@ -1,6 +1,7 @@ package main import ( + "fmt" "reflect" "testing" @@ -51,29 +52,31 @@ var invalidCases = []struct { } func TestInvalidCases(t *testing.T) { - for _, test := range invalidCases { - got, err := json.Parse("", []byte(test.input)) - if err == nil { - t.Errorf("%q: want error, got none (%v)", test.input, got) - continue - } - el, ok := err.(json.ErrorLister) - if !ok { - t.Errorf("%q: want error to implement ErrorLister, got: %T", test.input, err) - continue - } - for _, e := range el.Errors() { - parserErr, ok := e.(json.ParserError) - if !ok { - t.Errorf("%q: want all individual errors to implement ParserError, got: %T", test.input, e) + for i, test := range invalidCases { + t.Run(fmt.Sprint(i), func(t *testing.T) { + got, err := json.Parse("", []byte(test.input)) + if err == nil { + t.Errorf("%q: want error, got none (%v)", test.input, got) + return } - if !reflect.DeepEqual(test.expected, parserErr.Expected()) { - t.Errorf("%q: want: %v, got: %v", test.input, test.expected, parserErr.Expected()) + el, ok := err.(json.ErrorLister) + if !ok { + t.Errorf("%q: want error to implement ErrorLister, got: %T", test.input, err) + return } - if !strings.Contains(parserErr.Error(), test.err) { - t.Errorf("%q: want prefix \n%s\n, got \n%s\n", test.input, test.err, parserErr.Error()) + for _, e := range el.Errors() { + parserErr, ok := e.(json.ParserError) + if !ok { + t.Errorf("%q: want all individual errors to implement ParserError, got: %T", test.input, e) + } + if !reflect.DeepEqual(test.expected, parserErr.Expected()) { + t.Errorf("%q: want: %v, got: %v", test.input, test.expected, parserErr.Expected()) + } + if !strings.Contains(parserErr.Error(), test.err) { + t.Errorf("%q: want prefix \n%s\n, got \n%s\n", test.input, test.err, parserErr.Error()) + } } - } + }) } } @@ -129,15 +132,17 @@ var caretCases = []struct { } func TestCaretCases(t *testing.T) { - for _, test := range caretCases { - got, err := json.Parse("", []byte(test.input)) - if err == nil { - t.Errorf("%q: want error, got none (%v)", test.input, got) - continue - } - caret := caretError(err, test.input) - if test.expected != caret { - t.Errorf("%q: want:\n%s\ngot:\n%s\n", test.input, test.expected, caret) - } + for i, test := range caretCases { + t.Run(fmt.Sprint(i), func(t *testing.T) { + got, err := json.Parse("", []byte(test.input)) + if err == nil { + t.Errorf("%q: want error, got none (%v)", test.input, got) + return + } + caret := caretError(err, test.input) + if test.expected != caret { + t.Errorf("%q: want:\n%s\ngot:\n%s\n", test.input, test.expected, caret) + } + }) } } diff --git a/examples/json/json_test.go b/examples/json/json_test.go index 9e92b713..bc506eca 100644 --- a/examples/json/json_test.go +++ b/examples/json/json_test.go @@ -14,49 +14,51 @@ import ( func TestCmpStdlib(t *testing.T) { files := testJSONFiles(t) for _, file := range files { - pgot, err := ParseFile(file) - if err != nil { - t.Errorf("%s: pigeon.ParseFile: %v", file, err) - continue - } - - pogot, err := optimized.ParseFile(file) - if err != nil { - t.Errorf("%s: optimized.ParseFile: %v", file, err) - continue - } - - poggot, err := optimizedgrammar.ParseFile(file) - if err != nil { - t.Errorf("%s: optimizedgrammar.ParseFile: %v", file, err) - continue - } - - b, err := ioutil.ReadFile(file) - if err != nil { - t.Errorf("%s: ioutil.ReadAll: %v", file, err) - continue - } - var jgot interface{} - if err := json.Unmarshal(b, &jgot); err != nil { - t.Errorf("%s: json.Unmarshal: %v", file, err) - continue - } - - if !reflect.DeepEqual(pgot, jgot) { - t.Errorf("%s: not equal", file) - continue - } - - if !reflect.DeepEqual(pogot, jgot) { - t.Errorf("%s: optimized not equal", file) - continue - } - - if !reflect.DeepEqual(poggot, jgot) { - t.Errorf("%s: optimized grammar not equal", file) - continue - } + t.Run(file, func(t *testing.T) { + pgot, err := ParseFile(file) + if err != nil { + t.Errorf("%s: pigeon.ParseFile: %v", file, err) + return + } + + pogot, err := optimized.ParseFile(file) + if err != nil { + t.Errorf("%s: optimized.ParseFile: %v", file, err) + return + } + + poggot, err := optimizedgrammar.ParseFile(file) + if err != nil { + t.Errorf("%s: optimizedgrammar.ParseFile: %v", file, err) + return + } + + b, err := ioutil.ReadFile(file) + if err != nil { + t.Errorf("%s: ioutil.ReadAll: %v", file, err) + return + } + var jgot interface{} + if err := json.Unmarshal(b, &jgot); err != nil { + t.Errorf("%s: json.Unmarshal: %v", file, err) + return + } + + if !reflect.DeepEqual(pgot, jgot) { + t.Errorf("%s: not equal", file) + return + } + + if !reflect.DeepEqual(pogot, jgot) { + t.Errorf("%s: optimized not equal", file) + return + } + + if !reflect.DeepEqual(poggot, jgot) { + t.Errorf("%s: optimized grammar not equal", file) + return + } + }) } } @@ -69,19 +71,23 @@ func testJSONFiles(t *testing.T) []string { } files := make([]string, 0, len(fis)) for _, fi := range fis { - if filepath.Ext(fi.Name()) == ".json" { - files = append(files, filepath.Join(rootDir, fi.Name())) - } + t.Run(fi.Name(), func(t *testing.T) { + if filepath.Ext(fi.Name()) == ".json" { + files = append(files, filepath.Join(rootDir, fi.Name())) + } + }) } return files } func TestChoiceAltStatistics(t *testing.T) { cases := []struct { + name string json string expectedStats map[string]map[string]int }{ { + name: "empty json", json: `{}`, expectedStats: map[string]map[string]int{ "Bool 92:8": { @@ -97,6 +103,7 @@ func TestChoiceAltStatistics(t *testing.T) { }, }, { + name: "simple json", json: `{ "string": "string", "number": 123 }`, expectedStats: map[string]map[string]int{ "Integer 68:11": { @@ -121,14 +128,16 @@ func TestChoiceAltStatistics(t *testing.T) { } for _, test := range cases { - stats := Stats{} - _, err := Parse("TestStatistics", []byte(test.json), Statistics(&stats, "no match")) - if err != nil { - t.Fatalf("Expected to parse %s without error, got: %v", test.json, err) - } - if !reflect.DeepEqual(test.expectedStats, stats.ChoiceAltCnt) { - t.Fatalf("Expected stats to equal %#v, got %#v", test.expectedStats, stats.ChoiceAltCnt) - } + t.Run(test.name, func(t *testing.T) { + stats := Stats{} + _, err := Parse("TestStatistics", []byte(test.json), Statistics(&stats, "no match")) + if err != nil { + t.Fatalf("Expected to parse %s without error, got: %v", test.json, err) + } + if !reflect.DeepEqual(test.expectedStats, stats.ChoiceAltCnt) { + t.Fatalf("Expected stats to equal %#v, got %#v", test.expectedStats, stats.ChoiceAltCnt) + } + }) } } diff --git a/test/alternate_entrypoint/altentry_test.go b/test/alternate_entrypoint/altentry_test.go index c776804b..b53ea471 100644 --- a/test/alternate_entrypoint/altentry_test.go +++ b/test/alternate_entrypoint/altentry_test.go @@ -17,15 +17,17 @@ func TestValidEntrypoints(t *testing.T) { } for _, c := range cases { - v, err := Parse("", []byte(c.in), Entrypoint(c.entrypoint)) - if err != nil { - t.Errorf("%s:%s: got error %s", c.entrypoint, c.in, err) - } + t.Run(c.in, func(t *testing.T) { + v, err := Parse("", []byte(c.in), Entrypoint(c.entrypoint)) + if err != nil { + t.Errorf("%s:%s: got error %s", c.entrypoint, c.in, err) + } - got := string(v.([]byte)) - if got != c.in { - t.Errorf("%s:%s: got %s", c.entrypoint, c.in, got) - } + got := string(v.([]byte)) + if got != c.in { + t.Errorf("%s:%s: got %s", c.entrypoint, c.in, got) + } + }) } } @@ -48,12 +50,14 @@ func TestInvalidEntrypoints(t *testing.T) { } for _, c := range cases { - _, err := Parse("", []byte(c.in), Entrypoint(c.entrypoint)) - if err == nil { - t.Errorf("%s:%s: want error, got none", c.entrypoint, c.in) - } - if !strings.Contains(err.Error(), c.errMsg) { - t.Errorf("%s:%s: want %s, got %s", c.entrypoint, c.in, c.errMsg, err) - } + t.Run(c.in, func(t *testing.T) { + _, err := Parse("", []byte(c.in), Entrypoint(c.entrypoint)) + if err == nil { + t.Errorf("%s:%s: want error, got none", c.entrypoint, c.in) + } + if !strings.Contains(err.Error(), c.errMsg) { + t.Errorf("%s:%s: want %s, got %s", c.entrypoint, c.in, c.errMsg, err) + } + }) } } diff --git a/test/andnot/andnot_test.go b/test/andnot/andnot_test.go index 34e8bb23..1ec70c8b 100644 --- a/test/andnot/andnot_test.go +++ b/test/andnot/andnot_test.go @@ -24,13 +24,15 @@ var cases = map[string]string{ func TestAndNot(t *testing.T) { for tc, exp := range cases { - _, err := Parse("", []byte(tc)) - var got string - if err != nil { - got = err.Error() - } - if got != exp { - t.Errorf("%q: want %v, got %v", tc, exp, got) - } + t.Run(tc, func(t *testing.T) { + _, err := Parse("", []byte(tc)) + var got string + if err != nil { + got = err.Error() + } + if got != exp { + t.Errorf("%q: want %v, got %v", tc, exp, got) + } + }) } } diff --git a/test/errorpos/errorpos_test.go b/test/errorpos/errorpos_test.go index 24ea795f..14774132 100644 --- a/test/errorpos/errorpos_test.go +++ b/test/errorpos/errorpos_test.go @@ -41,14 +41,16 @@ var cases = map[string]string{ func TestErrorPos(t *testing.T) { for tc, exp := range cases { - _, err := Parse("", []byte(tc)) - var got string - if err != nil { - got = err.Error() - } - if got != exp { - _, _ = Parse("", []byte(tc), Debug(true)) - t.Errorf("%q: want %v, got %v", tc, exp, got) - } + t.Run(tc, func(t *testing.T) { + _, err := Parse("", []byte(tc)) + var got string + if err != nil { + got = err.Error() + } + if got != exp { + _, _ = Parse("", []byte(tc), Debug(true)) + t.Errorf("%q: want %v, got %v", tc, exp, got) + } + }) } } diff --git a/test/global_store/global_store_test.go b/test/global_store/global_store_test.go index 9ca7de3d..f29a33ec 100644 --- a/test/global_store/global_store_test.go +++ b/test/global_store/global_store_test.go @@ -28,13 +28,15 @@ func TestGlobalStore(t *testing.T) { }, } for _, test := range cases { - got, err := Parse("", []byte(test.input), GlobalStore("initial", test.initial)) - if err != nil { - t.Fatalf("for input %q got error: %s", test.input, err) - } - goti := got.(int) - if goti != test.expected { - t.Errorf("for input %q want %d, got %d", test.input, test.expected, goti) - } + t.Run(test.input, func(t *testing.T) { + got, err := Parse("", []byte(test.input), GlobalStore("initial", test.initial)) + if err != nil { + t.Fatalf("for input %q got error: %s", test.input, err) + } + goti := got.(int) + if goti != test.expected { + t.Errorf("for input %q want %d, got %d", test.input, test.expected, goti) + } + }) } } diff --git a/test/goto/goto_test.go b/test/goto/goto_test.go index 72e0ea1a..563adcfc 100644 --- a/test/goto/goto_test.go +++ b/test/goto/goto_test.go @@ -95,22 +95,24 @@ multidefined: noop`, } for _, test := range cases { - ll := make(labelLookup) - got, err := Parse("", []byte(test.input), GlobalStore("labelLookup", ll)) - if err != nil { - if !strings.Contains(err.Error(), test.err) { - t.Fatalf("Parse error did not match, expected: %s, got %s, input:\n%s\n", test.err, err, test.input) + t.Run(test.input, func(t *testing.T) { + ll := make(labelLookup) + got, err := Parse("", []byte(test.input), GlobalStore("labelLookup", ll)) + if err != nil { + if !strings.Contains(err.Error(), test.err) { + t.Fatalf("Parse error did not match, expected: %s, got %s, input:\n%s\n", test.err, err, test.input) + } + } else { + instr := got.([]Instruction) + result := "" + for _, inst := range instr { + result += inst.Assemble() + "\n" + } + result = strings.Trim(result, "\n") + if result != test.expected { + t.Fatalf("Parse did not provide expected result, expected:\n%s\n\nOutput:\n%s\n", test.expected, result) + } } - } else { - instr := got.([]Instruction) - result := "" - for _, inst := range instr { - result += inst.Assemble() + "\n" - } - result = strings.Trim(result, "\n") - if result != test.expected { - t.Fatalf("Parse did not provide expected result, expected:\n%s\n\nOutput:\n%s\n", test.expected, result) - } - } + }) } } diff --git a/test/goto_state/goto_state_test.go b/test/goto_state/goto_state_test.go index 94cd3289..81bde54a 100644 --- a/test/goto_state/goto_state_test.go +++ b/test/goto_state/goto_state_test.go @@ -95,22 +95,24 @@ multidefined: noop`, } for _, test := range cases { - ll := make(labelLookup) - got, err := Parse("", []byte(test.input), InitState("labelLookup", ll)) - if err != nil { - if !strings.Contains(err.Error(), test.err) { - t.Fatalf("Parse error did not match, expected: %s, got %s, input:\n%s\n", test.err, err, test.input) + t.Run(test.input, func(t *testing.T) { + ll := make(labelLookup) + got, err := Parse("", []byte(test.input), InitState("labelLookup", ll)) + if err != nil { + if !strings.Contains(err.Error(), test.err) { + t.Fatalf("Parse error did not match, expected: %s, got %s, input:\n%s\n", test.err, err, test.input) + } + } else { + instr := got.([]Instruction) + result := "" + for _, inst := range instr { + result += inst.Assemble() + "\n" + } + result = strings.Trim(result, "\n") + if result != test.expected { + t.Fatalf("Parse did not provide expected result, expected:\n%s\n\nOutput:\n%s\n", test.expected, result) + } } - } else { - instr := got.([]Instruction) - result := "" - for _, inst := range instr { - result += inst.Assemble() + "\n" - } - result = strings.Trim(result, "\n") - if result != test.expected { - t.Fatalf("Parse did not provide expected result, expected:\n%s\n\nOutput:\n%s\n", test.expected, result) - } - } + }) } } diff --git a/test/issue_18/issue_18_test.go b/test/issue_18/issue_18_test.go index 4d563207..48eb1bac 100644 --- a/test/issue_18/issue_18_test.go +++ b/test/issue_18/issue_18_test.go @@ -2,9 +2,18 @@ package issue18 import "testing" -var cases = map[string]string{ - `123455`: ``, - ` +var cases = []struct { + name string + in string + exp string +}{ + { + name: "numbers", + in: `123455`, + exp: ``, + }, { + name: "numbers with whitespace", + in: ` 1 @@ -12,28 +21,34 @@ var cases = map[string]string{ 3 - `: ``, - ` + `, + exp: ``, + }, { + name: "unexpected character", + in: ` 1 2 x - `: `7:5 (20): no match found, expected: [ \t\r\n], [0-9] or EOF`, + `, + exp: `7:5 (20): no match found, expected: [ \t\r\n], [0-9] or EOF`, + }, } func TestErrorReporting(t *testing.T) { - for tc, exp := range cases { - _, err := Parse("", []byte(tc)) - var got string - if err != nil { - got = err.Error() - } - - if got != exp { - t.Errorf("%q: want %v, got %v", tc, exp, got) - } - + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + _, err := Parse("", []byte(tc.in)) + var got string + if err != nil { + got = err.Error() + } + + if got != tc.exp { + t.Errorf("%q: want %v, got %v", tc.name, tc.exp, got) + } + }) } } diff --git a/test/labeled_failures/labeled_failures_test.go b/test/labeled_failures/labeled_failures_test.go index 365f6ff9..7c187f18 100644 --- a/test/labeled_failures/labeled_failures_test.go +++ b/test/labeled_failures/labeled_failures_test.go @@ -70,33 +70,35 @@ func TestLabeledFailures(t *testing.T) { }, } for _, test := range cases { - got, err := Parse("", []byte(test.input)) - if test.errors == nil && err != nil { - t.Fatalf("for input %q got error: %s, but expect to parse without errors", test.input, err) - } - if !reflect.DeepEqual(got, test.captures) { - t.Errorf("for input %q want %s, got %s", test.input, test.captures, got) - } - if err != nil { - list := err.(errList) - if len(list) != len(test.errors) { - t.Errorf("for input %q want %d error(s), got %d", test.input, len(test.errors), len(list)) - t.Logf("expected errors:\n") - for _, ee := range test.errors { - t.Logf("- %s\n", ee) - } - t.Logf("got errors:\n") - for _, ee := range list { - t.Logf("- %s\n", ee) - } - t.FailNow() + t.Run(test.input, func(t *testing.T) { + got, err := Parse("", []byte(test.input)) + if test.errors == nil && err != nil { + t.Fatalf("for input %q got error: %s, but expect to parse without errors", test.input, err) } - for i, err := range list { - pe := err.(*parserError) - if pe.Error() != test.errors[i] { - t.Errorf("for input %q want %dth error to be %s, got %s", test.input, i+1, test.errors[i], pe) + if !reflect.DeepEqual(got, test.captures) { + t.Errorf("for input %q want %s, got %s", test.input, test.captures, got) + } + if err != nil { + list := err.(errList) + if len(list) != len(test.errors) { + t.Errorf("for input %q want %d error(s), got %d", test.input, len(test.errors), len(list)) + t.Logf("expected errors:\n") + for _, ee := range test.errors { + t.Logf("- %s\n", ee) + } + t.Logf("got errors:\n") + for _, ee := range list { + t.Logf("- %s\n", ee) + } + t.FailNow() + } + for i, err := range list { + pe := err.(*parserError) + if pe.Error() != test.errors[i] { + t.Errorf("for input %q want %dth error to be %s, got %s", test.input, i+1, test.errors[i], pe) + } } } - } + }) } } diff --git a/test/linear/linear_test.go b/test/linear/linear_test.go index 355c5aee..e623906c 100644 --- a/test/linear/linear_test.go +++ b/test/linear/linear_test.go @@ -4,6 +4,7 @@ import ( "bytes" "crypto/rand" "encoding/base64" + "fmt" "io" "testing" "time" @@ -20,18 +21,20 @@ func TestLinearTime(t *testing.T) { //1 << 20, } for _, sz := range sizes { - r := io.LimitReader(rand.Reader, sz) - enc := base64.NewEncoder(base64.StdEncoding, &buf) - _, err := io.Copy(enc, r) - if err != nil { - t.Fatal(err) - } - _ = enc.Close() + t.Run(fmt.Sprint(sz), func(t *testing.T) { + r := io.LimitReader(rand.Reader, sz) + enc := base64.NewEncoder(base64.StdEncoding, &buf) + _, err := io.Copy(enc, r) + if err != nil { + t.Fatal(err) + } + _ = enc.Close() - start := time.Now() - if _, err := Parse("", buf.Bytes(), Memoize(true)); err != nil { - t.Fatal(err) - } - t.Log(time.Since(start)) + start := time.Now() + if _, err := Parse("", buf.Bytes(), Memoize(true)); err != nil { + t.Fatal(err) + } + t.Log(time.Since(start)) + }) } } diff --git a/test/state/state_test.go b/test/state/state_test.go index 34735c31..665ad232 100644 --- a/test/state/state_test.go +++ b/test/state/state_test.go @@ -12,13 +12,15 @@ var cases = map[string]int{ func TestState(t *testing.T) { for tc, exp := range cases { - got, err := Parse("", []byte(tc), Memoize(false), InitState("countCs", 10)) + t.Run(tc, func(t *testing.T) { + got, err := Parse("", []byte(tc), Memoize(false), InitState("countCs", 10)) - if err != nil { - t.Errorf(err.Error()) - } - if got != exp { - t.Errorf("%q: want %v, got %v", tc, exp, got) - } + if err != nil { + t.Errorf(err.Error()) + } + if got != exp { + t.Errorf("%q: want %v, got %v", tc, exp, got) + } + }) } } diff --git a/test/stateclone/stateclone_test.go b/test/stateclone/stateclone_test.go index 7e188cfd..91d60ed9 100644 --- a/test/stateclone/stateclone_test.go +++ b/test/stateclone/stateclone_test.go @@ -12,20 +12,22 @@ var cases = map[string]int{ func TestState(t *testing.T) { for tc, exp := range cases { - vals := make(values, 1) - vals[0] = 10 - got, err := Parse("", []byte(tc), Memoize(false), InitState("vals", vals)) + t.Run(tc, func(t *testing.T) { + vals := make(values, 1) + vals[0] = 10 + got, err := Parse("", []byte(tc), Memoize(false), InitState("vals", vals)) - if err != nil { - t.Errorf(err.Error()) - } - vals = got.(values) - res := 0 - for _, v := range vals { - res += v - } - if res != exp { - t.Errorf("%q: want %v, got %v", tc, exp, got) - } + if err != nil { + t.Errorf(err.Error()) + } + vals = got.(values) + res := 0 + for _, v := range vals { + res += v + } + if res != exp { + t.Errorf("%q: want %v, got %v", tc, exp, got) + } + }) } } diff --git a/test/statereadonly/statereadonly_test.go b/test/statereadonly/statereadonly_test.go index 860d45bd..ecfd49dc 100644 --- a/test/statereadonly/statereadonly_test.go +++ b/test/statereadonly/statereadonly_test.go @@ -12,13 +12,15 @@ var cases = map[string]int{ func TestStateReadonly(t *testing.T) { for tc, exp := range cases { - got, err := Parse("", []byte(tc), Memoize(false)) + t.Run(tc, func(t *testing.T) { + got, err := Parse("", []byte(tc), Memoize(false)) - if err != nil { - t.Errorf(err.Error()) - } - if got != exp { - t.Errorf("%q: want %v, got %v", tc, exp, got) - } + if err != nil { + t.Errorf(err.Error()) + } + if got != exp { + t.Errorf("%q: want %v, got %v", tc, exp, got) + } + }) } } diff --git a/test/staterestore/optimized/staterestore_test.go b/test/staterestore/optimized/staterestore_test.go index 1848533a..8ea404db 100644 --- a/test/staterestore/optimized/staterestore_test.go +++ b/test/staterestore/optimized/staterestore_test.go @@ -15,13 +15,15 @@ var cases = []struct { func TestStateRestore(t *testing.T) { for _, c := range cases { - got, err := Parse("", []byte(c.input), Entrypoint(c.rule)) - if err != nil { - t.Errorf("%s:%q: %v", c.rule, c.input, err) - continue - } - if got != c.want { - t.Errorf("%s:%q: want %v, got %v", c.rule, c.input, c.want, got) - } + t.Run(c.rule, func(t *testing.T) { + got, err := Parse("", []byte(c.input), Entrypoint(c.rule)) + if err != nil { + t.Errorf("%s:%q: %v", c.rule, c.input, err) + return + } + if got != c.want { + t.Errorf("%s:%q: want %v, got %v", c.rule, c.input, c.want, got) + } + }) } } diff --git a/test/staterestore/standard/staterestore_test.go b/test/staterestore/standard/staterestore_test.go index 1848533a..8ea404db 100644 --- a/test/staterestore/standard/staterestore_test.go +++ b/test/staterestore/standard/staterestore_test.go @@ -15,13 +15,15 @@ var cases = []struct { func TestStateRestore(t *testing.T) { for _, c := range cases { - got, err := Parse("", []byte(c.input), Entrypoint(c.rule)) - if err != nil { - t.Errorf("%s:%q: %v", c.rule, c.input, err) - continue - } - if got != c.want { - t.Errorf("%s:%q: want %v, got %v", c.rule, c.input, c.want, got) - } + t.Run(c.rule, func(t *testing.T) { + got, err := Parse("", []byte(c.input), Entrypoint(c.rule)) + if err != nil { + t.Errorf("%s:%q: %v", c.rule, c.input, err) + return + } + if got != c.want { + t.Errorf("%s:%q: want %v, got %v", c.rule, c.input, c.want, got) + } + }) } } diff --git a/test/thrownrecover/thrownrecover_test.go b/test/thrownrecover/thrownrecover_test.go index 3b4d8fde..7ed63f88 100644 --- a/test/thrownrecover/thrownrecover_test.go +++ b/test/thrownrecover/thrownrecover_test.go @@ -95,36 +95,38 @@ func TestThrowAndRecover(t *testing.T) { }, } for _, test := range cases { - got, err := Parse("", []byte(test.input)) - if test.errors == nil && err != nil { - t.Fatalf("for input %q got error: %s, but expect to parse without errors", test.input, err) - } - if test.errors != nil && err == nil { - t.Fatalf("for input %q got no error, but expect to parse with errors: %s", test.input, test.errors) - } - if !reflect.DeepEqual(got, test.captures) { - t.Errorf("for input %q want %s, got %s", test.input, test.captures, got) - } - if err != nil { - list := err.(errList) - if len(list) != len(test.errors) { - t.Errorf("for input %q want %d error(s), got %d", test.input, len(test.errors), len(list)) - t.Logf("expected errors:\n") - for _, ee := range test.errors { - t.Logf("- %s\n", ee) - } - t.Logf("got errors:\n") - for _, ee := range list { - t.Logf("- %s\n", ee) - } - t.FailNow() + t.Run(test.input, func(t *testing.T) { + got, err := Parse("", []byte(test.input)) + if test.errors == nil && err != nil { + t.Fatalf("for input %q got error: %s, but expect to parse without errors", test.input, err) + } + if test.errors != nil && err == nil { + t.Fatalf("for input %q got no error, but expect to parse with errors: %s", test.input, test.errors) } - for i, err := range list { - pe := err.(*parserError) - if pe.Error() != test.errors[i] { - t.Errorf("for input %q want %dth error to be %s, got %s", test.input, i+1, test.errors[i], pe) + if !reflect.DeepEqual(got, test.captures) { + t.Errorf("for input %q want %s, got %s", test.input, test.captures, got) + } + if err != nil { + list := err.(errList) + if len(list) != len(test.errors) { + t.Errorf("for input %q want %d error(s), got %d", test.input, len(test.errors), len(list)) + t.Logf("expected errors:\n") + for _, ee := range test.errors { + t.Logf("- %s\n", ee) + } + t.Logf("got errors:\n") + for _, ee := range list { + t.Logf("- %s\n", ee) + } + t.FailNow() + } + for i, err := range list { + pe := err.(*parserError) + if pe.Error() != test.errors[i] { + t.Errorf("for input %q want %dth error to be %s, got %s", test.input, i+1, test.errors[i], pe) + } } } - } + }) } }