trackler 2.0.8.43 → 2.0.8.44

data/tracks/go/exercises/forth/cases_test.go

@@ -1,246 +1,269 @@
 package forth
 
 // Source: exercism/x-common
-// Commit: 8804a76 Remove non-ASCII characters tests from forth exercise
+// Commit: 0d6f5b7 forth: Fix canonical-data.json formatting
+// x-common version: 1.0.0
 
-var parsingGroup = []testCase{
-	{
-		"empty input results in empty stack",
-		[]string{},
-		[]int{},
-	},
-	{
-		"numbers just get pushed onto the stack",
-		[]string{"1 2 3 4 5"},
-		[]int{1, 2, 3, 4, 5},
-	},
-	{
-		"all non-word characters are separators",
-		[]string{"1\x002\x133\n4\r5 6\t7"},
-		[]int{1, 2, 3, 4, 5, 6, 7},
-	},
-}
-
-var additionGroup = []testCase{
-	{
-		"can add two numbers",
-		[]string{"1 2 +"},
-		[]int{3},
-	},
-	{
-		"errors if there is nothing on the stack",
-		[]string{"+"},
-		[]int(nil),
-	},
-	{
-		"errors if there is only one value on the stack",
-		[]string{"1 +"},
-		[]int(nil),
-	},
-}
-
-var subtractionGroup = []testCase{
-	{
-		"can subtract two numbers",
-		[]string{"3 4 -"},
-		[]int{-1},
-	},
-	{
-		"errors if there is nothing on the stack",
-		[]string{"-"},
-		[]int(nil),
-	},
-	{
-		"errors if there is only one value on the stack",
-		[]string{"1 -"},
-		[]int(nil),
-	},
-}
-
-var multiplicationGroup = []testCase{
-	{
-		"can multiply two numbers",
-		[]string{"2 4 *"},
-		[]int{8},
-	},
-	{
-		"errors if there is nothing on the stack",
-		[]string{"*"},
-		[]int(nil),
-	},
-	{
-		"errors if there is only one value on the stack",
-		[]string{"1 *"},
-		[]int(nil),
-	},
-}
-
-var divisionGroup = []testCase{
-	{
-		"can divide two numbers",
-		[]string{"12 3 /"},
-		[]int{4},
-	},
-	{
-		"performs integer division",
-		[]string{"8 3 /"},
-		[]int{2},
-	},
-	{
-		"errors if dividing by zero",
-		[]string{"4 0 /"},
-		[]int(nil),
-	},
-	{
-		"errors if there is nothing on the stack",
-		[]string{"/"},
-		[]int(nil),
-	},
-	{
-		"errors if there is only one value on the stack",
-		[]string{"1 /"},
-		[]int(nil),
-	},
+type testGroup struct {
+	group string
+	tests []testCase
 }
 
-var arithmeticGroup = []testCase{
-	{
-		"addition and subtraction",
-		[]string{"1 2 + 4 -"},
-		[]int{-1},
-	},
-	{
-		"multiplication and division",
-		[]string{"2 4 * 3 /"},
-		[]int{2},
-	},
+type testCase struct {
+	description string
+	input       []string
+	expected    []int // nil slice indicates error expected.
 }
 
-var dupGroup = []testCase{
-	{
-		"copies the top value on the stack",
-		[]string{"1 DUP"},
-		[]int{1, 1},
+var testGroups = []testGroup{
+	{
+		group: "parsing and numbers",
+		tests: []testCase{
+			{
+				"empty input results in empty stack",
+				[]string{},
+				[]int{},
+			},
+			{
+				"numbers just get pushed onto the stack",
+				[]string{"1 2 3 4 5"},
+				[]int{1, 2, 3, 4, 5},
+			},
+			{
+				"all non-word characters are separators",
+				[]string{"1\x002\x133\n4\r5 6\t7"},
+				[]int{1, 2, 3, 4, 5, 6, 7},
+			},
+		},
+	},
+	{
+		group: "addition",
+		tests: []testCase{
+			{
+				"can add two numbers",
+				[]string{"1 2 +"},
+				[]int{3},
+			},
+			{
+				"errors if there is nothing on the stack",
+				[]string{"+"},
+				[]int(nil),
+			},
+			{
+				"errors if there is only one value on the stack",
+				[]string{"1 +"},
+				[]int(nil),
+			},
+		},
+	},
+	{
+		group: "subtraction",
+		tests: []testCase{
+			{
+				"can subtract two numbers",
+				[]string{"3 4 -"},
+				[]int{-1},
+			},
+			{
+				"errors if there is nothing on the stack",
+				[]string{"-"},
+				[]int(nil),
+			},
+			{
+				"errors if there is only one value on the stack",
+				[]string{"1 -"},
+				[]int(nil),
+			},
+		},
+	},
+	{
+		group: "multiplication",
+		tests: []testCase{
+			{
+				"can multiply two numbers",
+				[]string{"2 4 *"},
+				[]int{8},
+			},
+			{
+				"errors if there is nothing on the stack",
+				[]string{"*"},
+				[]int(nil),
+			},
+			{
+				"errors if there is only one value on the stack",
+				[]string{"1 *"},
+				[]int(nil),
+			},
+		},
+	},
+	{
+		group: "division",
+		tests: []testCase{
+			{
+				"can divide two numbers",
+				[]string{"12 3 /"},
+				[]int{4},
+			},
+			{
+				"performs integer division",
+				[]string{"8 3 /"},
+				[]int{2},
+			},
+			{
+				"errors if dividing by zero",
+				[]string{"4 0 /"},
+				[]int(nil),
+			},
+			{
+				"errors if there is nothing on the stack",
+				[]string{"/"},
+				[]int(nil),
+			},
+			{
+				"errors if there is only one value on the stack",
+				[]string{"1 /"},
+				[]int(nil),
+			},
+		},
+	},
+	{
+		group: "combined arithmetic",
+		tests: []testCase{
+			{
+				"addition and subtraction",
+				[]string{"1 2 + 4 -"},
+				[]int{-1},
+			},
+			{
+				"multiplication and division",
+				[]string{"2 4 * 3 /"},
+				[]int{2},
+			},
+		},
+	},
+	{
+		group: "dup",
+		tests: []testCase{
+			{
+				"copies the top value on the stack",
+				[]string{"1 DUP"},
+				[]int{1, 1},
+			},
+			{
+				"is case-insensitive",
+				[]string{"1 2 Dup"},
+				[]int{1, 2, 2},
+			},
+			{
+				"errors if there is nothing on the stack",
+				[]string{"dup"},
+				[]int(nil),
+			},
+		},
+	},
+	{
+		group: "drop",
+		tests: []testCase{
+			{
+				"removes the top value on the stack if it is the only one",
+				[]string{"1 drop"},
+				[]int{},
+			},
+			{
+				"removes the top value on the stack if it is not the only one",
+				[]string{"1 2 drop"},
+				[]int{1},
+			},
+			{
+				"errors if there is nothing on the stack",
+				[]string{"drop"},
+				[]int(nil),
+			},
+		},
+	},
+	{
+		group: "swap",
+		tests: []testCase{
+			{
+				"swaps the top two values on the stack if they are the only ones",
+				[]string{"1 2 swap"},
+				[]int{2, 1},
+			},
+			{
+				"swaps the top two values on the stack if they are not the only ones",
+				[]string{"1 2 3 swap"},
+				[]int{1, 3, 2},
+			},
+			{
+				"errors if there is nothing on the stack",
+				[]string{"swap"},
+				[]int(nil),
+			},
+			{
+				"errors if there is only one value on the stack",
+				[]string{"1 swap"},
+				[]int(nil),
+			},
+		},
+	},
+	{
+		group: "over",
+		tests: []testCase{
+			{
+				"copies the second element if there are only two",
+				[]string{"1 2 over"},
+				[]int{1, 2, 1},
+			},
+			{
+				"copies the second element if there are more than two",
+				[]string{"1 2 3 over"},
+				[]int{1, 2, 3, 2},
+			},
+			{
+				"errors if there is nothing on the stack",
+				[]string{"over"},
+				[]int(nil),
+			},
+			{
+				"errors if there is only one value on the stack",
+				[]string{"1 over"},
+				[]int(nil),
+			},
+		},
+	},
+	{
+		group: "user-defined words",
+		tests: []testCase{
+			{
+				"can consist of built-in words",
+				[]string{": dup-twice dup dup ;", "1 dup-twice"},
+				[]int{1, 1, 1},
+			},
+			{
+				"execute in the right order",
+				[]string{": countup 1 2 3 ;", "countup"},
+				[]int{1, 2, 3},
+			},
+			{
+				"can override other user-defined words",
+				[]string{": foo dup ;", ": foo dup dup ;", "1 foo"},
+				[]int{1, 1, 1},
+			},
+			{
+				"can override built-in words",
+				[]string{": swap dup ;", "1 swap"},
+				[]int{1, 1},
+			},
+			{
+				"cannot redefine numbers",
+				[]string{": 1 2 ;"},
+				[]int(nil),
+			},
+			{
+				"errors if executing a non-existent word",
+				[]string{"foo"},
+				[]int(nil),
+			},
+		},
 	},
-	{
-		"is case-insensitive",
-		[]string{"1 2 Dup"},
-		[]int{1, 2, 2},
-	},
-	{
-		"errors if there is nothing on the stack",
-		[]string{"dup"},
-		[]int(nil),
-	},
-}
-
-var dropGroup = []testCase{
-	{
-		"removes the top value on the stack if it is the only one",
-		[]string{"1 drop"},
-		[]int{},
-	},
-	{
-		"removes the top value on the stack if it is not the only one",
-		[]string{"1 2 drop"},
-		[]int{1},
-	},
-	{
-		"errors if there is nothing on the stack",
-		[]string{"drop"},
-		[]int(nil),
-	},
-}
-
-var swapGroup = []testCase{
-	{
-		"swaps the top two values on the stack if they are the only ones",
-		[]string{"1 2 swap"},
-		[]int{2, 1},
-	},
-	{
-		"swaps the top two values on the stack if they are not the only ones",
-		[]string{"1 2 3 swap"},
-		[]int{1, 3, 2},
-	},
-	{
-		"errors if there is nothing on the stack",
-		[]string{"swap"},
-		[]int(nil),
-	},
-	{
-		"errors if there is only one value on the stack",
-		[]string{"1 swap"},
-		[]int(nil),
-	},
-}
-
-var overGroup = []testCase{
-	{
-		"copies the second element if there are only two",
-		[]string{"1 2 over"},
-		[]int{1, 2, 1},
-	},
-	{
-		"copies the second element if there are more than two",
-		[]string{"1 2 3 over"},
-		[]int{1, 2, 3, 2},
-	},
-	{
-		"errors if there is nothing on the stack",
-		[]string{"over"},
-		[]int(nil),
-	},
-	{
-		"errors if there is only one value on the stack",
-		[]string{"1 over"},
-		[]int(nil),
-	},
-}
-
-var userdefinedGroup = []testCase{
-	{
-		"can consist of built-in words",
-		[]string{": dup-twice dup dup ;", "1 dup-twice"},
-		[]int{1, 1, 1},
-	},
-	{
-		"execute in the right order",
-		[]string{": countup 1 2 3 ;", "countup"},
-		[]int{1, 2, 3},
-	},
-	{
-		"can override other user-defined words",
-		[]string{": foo dup ;", ": foo dup dup ;", "1 foo"},
-		[]int{1, 1, 1},
-	},
-	{
-		"can override built-in words",
-		[]string{": swap dup ;", "1 swap"},
-		[]int{1, 1},
-	},
-	{
-		"cannot redefine numbers",
-		[]string{": 1 2 ;"},
-		[]int(nil),
-	},
-	{
-		"errors if executing a non-existent word",
-		[]string{"foo"},
-		[]int(nil),
-	},
-}
-
-var testSections = []testcaseSection{
-	{"parsing", parsingGroup},
-	{"addition(+)", additionGroup},
-	{"subtraction(-)", subtractionGroup},
-	{"multiplication(*)", multiplicationGroup},
-	{"division(/)", divisionGroup},
-	{"arithmetic", arithmeticGroup},
-	{"dup", dupGroup},
-	{"drop", dropGroup},
-	{"swap", swapGroup},
-	{"over", overGroup},
-	{"user-defined", userdefinedGroup},
 }

data/tracks/go/exercises/forth/forth_test.go

@@ -11,53 +11,38 @@ import (
 
 const targetTestVersion = 1
 
-type testCase struct {
-	description string
-	input       []string
-	expected    []int // nil slice indicates error expected.
-}
-
-type testcaseSection struct {
-	name  string
-	tests []testCase
-}
-
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
 }
 
-func runTestCases(t *testing.T, sectionName string, testCases []testCase) {
-	for _, tc := range testCases {
-		description := sectionName + " - " + tc.description
-		if v, err := Forth(tc.input); err == nil {
-			var _ error = err
-			if tc.expected == nil {
-				t.Fatalf("%s\n\tForth(%#v) expected an error, got %v",
-					description, tc.input, v)
-			} else if !reflect.DeepEqual(v, tc.expected) {
-				t.Fatalf("%s\n\tForth(%#v) expected %v, got %v",
-					description, tc.input, tc.expected, v)
+func TestForth(t *testing.T) {
+	for _, tg := range testGroups {
+		for _, tc := range tg.tests {
+			if v, err := Forth(tc.input); err == nil {
+				var _ error = err
+				if tc.expected == nil {
+					t.Fatalf("FAIL: %s | %s\n\tForth(%#v) expected an error, got %v",
+						tg.group, tc.description, tc.input, v)
+				} else if !reflect.DeepEqual(v, tc.expected) {
+					t.Fatalf("FAIL: %s | %s\n\tForth(%#v) expected %v, got %v",
+						tg.group, tc.description, tc.input, tc.expected, v)
+				}
+			} else if tc.expected != nil {
+				t.Fatalf("FAIL: %s | %s\n\tForth(%#v) expected %v, got an error: %q",
+					tg.group, tc.description, tc.input, tc.expected, err)
 			}
-		} else if tc.expected != nil {
-			t.Fatalf("%s\n\tForth(%#v) expected %v, got an error: %q",
-				description, tc.input, tc.expected, err)
+			t.Logf("PASS: %s | %s", tg.group, tc.description)
 		}
 	}
 }
 
-func TestForth(t *testing.T) {
-	for _, testSection := range testSections {
-		runTestCases(t, testSection.name, testSection.tests)
-	}
-}
-
 func BenchmarkForth(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		for _, testSection := range testSections {
-			for _, test := range testSection.tests {
-				Forth(test.input)
+		for _, tg := range testGroups {
+			for _, tc := range tg.tests {
+				Forth(tc.input)
 			}
 		}
 	}

data/tracks/go/exercises/gigasecond/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/hamming/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/largest-series-product/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/leap/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/luhn/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/meetup/{example_gen.go → .meta/gen.go}

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/raindrops/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/rna-transcription/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/roman-numerals/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/transpose/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {

data/tracks/go/exercises/word-count/{example_gen.go → .meta/gen.go}

@@ -6,7 +6,7 @@ import (
 	"log"
 	"text/template"
 
-	"../../gen"
+	"../../../gen"
 )
 
 func main() {