From 86947b4df576f8fac2e19b4e916d3ce93324030f Mon Sep 17 00:00:00 2001 From: Lee Nipper Date: Wed, 10 May 2017 22:51:08 -0500 Subject: [PATCH] bracket-push: create test case generator Generate test case array from the canonical-data.json. Update example solution to pass all the tests. Update test program. Increment testVersion and targetTestVersion. --- exercises/bracket-push/.meta/gen.go | 49 ++++++++++++ exercises/bracket-push/bracket_push_test.go | 44 +---------- exercises/bracket-push/cases_test.go | 83 +++++++++++++++++++++ exercises/bracket-push/example.go | 29 ++++--- 4 files changed, 146 insertions(+), 59 deletions(-) create mode 100644 exercises/bracket-push/.meta/gen.go create mode 100644 exercises/bracket-push/cases_test.go diff --git a/exercises/bracket-push/.meta/gen.go b/exercises/bracket-push/.meta/gen.go new file mode 100644 index 000000000..34f3eefe4 --- /dev/null +++ b/exercises/bracket-push/.meta/gen.go @@ -0,0 +1,49 @@ +// +build ignore + +package main + +import ( + "log" + "text/template" + + "../../../gen" +) + +func main() { + t, err := template.New("").Parse(tmpl) + if err != nil { + log.Fatal(err) + } + var j js + if err := gen.Gen("bracket-push", &j, t); err != nil { + log.Fatal(err) + } +} + +// The JSON structure we expect to be able to unmarshal into +type js struct { + Cases []struct { + Description string + Input string + Expected bool + } +} + +// template applied to above data structure generates the Go test cases +var tmpl = `package brackets + +{{.Header}} + +type bracketTest struct { + input string + expected bool +} + +var testCases = []bracketTest { +{{range .J.Cases}}{ + // {{.Description}} + {{printf "%q" .Input}}, + {{.Expected}}, +}, +{{end}}} +` diff --git a/exercises/bracket-push/bracket_push_test.go b/exercises/bracket-push/bracket_push_test.go index c68866cdf..463b55b49 100644 --- a/exercises/bracket-push/bracket_push_test.go +++ b/exercises/bracket-push/bracket_push_test.go @@ -4,49 +4,7 @@ import ( "testing" ) -const targetTestVersion = 4 - -var testCases = []struct { - input string - expected bool -}{ - { - input: "", - expected: true, - }, - { - input: "{}", - expected: true, - }, - { - input: "{{", - expected: false, - }, - { - input: "}{", - expected: false, - }, - { - input: "{}[]", - expected: true, - }, - { - input: "{[]}", - expected: true, - }, - { - input: "{[}]", - expected: false, - }, - { - input: "{[)][]}", - expected: false, - }, - { - input: "{[]([()])}", - expected: true, - }, -} +const targetTestVersion = 5 func TestTestVersion(t *testing.T) { if testVersion != targetTestVersion { diff --git a/exercises/bracket-push/cases_test.go b/exercises/bracket-push/cases_test.go new file mode 100644 index 000000000..072e2cafb --- /dev/null +++ b/exercises/bracket-push/cases_test.go @@ -0,0 +1,83 @@ +package brackets + +// Source: exercism/x-common +// Commit: 855c591 bracket-push: add test case (#747) +// x-common version: 1.1.0 + +type bracketTest struct { + input string + expected bool +} + +var testCases = []bracketTest{ + { + // paired square brackets + "[]", + true, + }, + { + // empty string + "", + true, + }, + { + // unpaired brackets + "[[", + false, + }, + { + // wrong ordered brackets + "}{", + false, + }, + { + // wrong closing bracket + "{]", + false, + }, + { + // paired with whitespace + "{ }", + true, + }, + { + // simple nested brackets + "{[]}", + true, + }, + { + // several paired brackets + "{}[]", + true, + }, + { + // paired and nested brackets + "([{}({}[])])", + true, + }, + { + // unopened closing brackets + "{[)][]}", + false, + }, + { + // unpaired and nested brackets + "([{])", + false, + }, + { + // paired and wrong nested brackets + "[({]})", + false, + }, + { + // math expression + "(((185 + 223.85) * 15) - 543)/2", + true, + }, + { + // complex latex expression + "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)", + true, + }, +} diff --git a/exercises/bracket-push/example.go b/exercises/bracket-push/example.go index ce24f7ff3..91fa6a208 100644 --- a/exercises/bracket-push/example.go +++ b/exercises/bracket-push/example.go @@ -1,11 +1,7 @@ package brackets -import ( - "fmt" -) - // testVersion shows the version of the exercise. -const testVersion = 4 +const testVersion = 5 type bracketKind int @@ -13,6 +9,7 @@ const ( kindParen bracketKind = iota kindSquare bracketKind = iota kindBrace bracketKind = iota + kindOther bracketKind = iota ) // Whether a bracket is an opening or closing bracket @@ -33,9 +30,9 @@ type charInfo struct { func Bracket(input string) (bool, error) { var stack []bracketKind for _, char := range input { - ci, err := info(char) - if err != nil { - return false, err + ci := info(char) + if ci.kind == kindOther { + continue } if ci.form == formOpen { stack = append(stack, ci.kind) @@ -52,21 +49,21 @@ func Bracket(input string) (bool, error) { return len(stack) == 0, nil } -func info(char rune) (charInfo, error) { +func info(char rune) charInfo { switch char { case '(': - return charInfo{kind: kindParen, form: formOpen}, nil + return charInfo{kind: kindParen, form: formOpen} case '[': - return charInfo{kind: kindSquare, form: formOpen}, nil + return charInfo{kind: kindSquare, form: formOpen} case '{': - return charInfo{kind: kindBrace, form: formOpen}, nil + return charInfo{kind: kindBrace, form: formOpen} case ')': - return charInfo{kind: kindParen, form: formClose}, nil + return charInfo{kind: kindParen, form: formClose} case ']': - return charInfo{kind: kindSquare, form: formClose}, nil + return charInfo{kind: kindSquare, form: formClose} case '}': - return charInfo{kind: kindBrace, form: formClose}, nil + return charInfo{kind: kindBrace, form: formClose} default: - return charInfo{}, fmt.Errorf("Unknown bracket %v", char) + return charInfo{kind: kindOther} } }