trackler 2.2.1.56 → 2.2.1.57

data/tracks/go/config/maintainers.json

@@ -51,9 +51,9 @@
       "show_on_website": false
     },
     {
-      "alumnus": false,
+      "alumnus": true,
       "avatar_url": null,
-      "bio": "I used to be an artist, and am now a software engineer, using Go to build tools for network engineers. Maintaining Exercism's Go track has opened up the world of open source to me.",
+      "bio": "I used to be an artist, and am now a software engineer, using Go for forensics monitoring. Exercism's Go track opened up the world of open source to me.",
       "github_username": "robphoenix",
       "link_text": "robphoenix.com",
       "link_url": "https://blog.robphoenix.com/",

data/tracks/go/docs/TESTS.md

@@ -9,21 +9,6 @@ $ go test
 
 Most exercises contain benchmarks, that you can use to determine how changes to your solution affect its performance. To run the benchmarks for an exercise use the command `go test -bench .` inside the exercise directory.
 
-### The `testVersion` constant
-
-Some exercises require you to define a testVersion constant in your package.
-There are sometimes problems where tests change and solutions which worked for
-the old version no longer work. The testVersion system makes it obvious when
-this happens.
-
-To avoid compilation warnings due to testVersion not being defined
-just add `const testVersion = VERSION` (where VERSION should be replaced by the
-value of `targetTestVersion` in the test file) to your submission file.
-
-Should the tests change in a way that old submissions will or could no longer
-work the test writer should increase the `targetTestVersion` value which will cause
-the tests to fail with a clear message when an old submission is run with them.
-
 ### Testable examples
 
 [Example tests](https://blog.golang.org/examples) are used in some exercises and

data/tracks/go/exercises/accumulate/accumulate_test.go

@@ -6,8 +6,6 @@ import (
 	"testing"
 )
 
-const targetTestVersion = 1
-
 func echo(c string) string {
 	return c
 }
@@ -28,12 +26,6 @@ var tests = []struct {
 	{[]string{"HELLO", "WORLD"}, []string{"hello", "world"}, strings.ToUpper, "strings.ToUpper"},
 }
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func TestAccumulate(t *testing.T) {
 	for _, test := range tests {
 		actual := Accumulate(test.given, test.converter)

data/tracks/go/exercises/accumulate/example.go

@@ -1,7 +1,5 @@
 package accumulate
 
-const testVersion = 1
-
 func Accumulate(s []string, f func(st string) string) (result []string) {
 	for _, v := range s {
 		result = append(result, []string{f(v)}...)

data/tracks/go/exercises/acronym/acronym.go

@@ -1,5 +1,17 @@
-package acronym
+// This is a "stub" file.  It's a little start on your solution.
+// It's not a complete solution though; you have to write some code.
 
-const testVersion = 3
+// Package acronym should have a package comment that summarizes what it's about.
+// https://golang.org/doc/effective_go.html#commentary
+package acronym
 
 func Abbreviate(string) string
+
+// Abbreviate should have a comment documenting it.
+func Abbreviate(s string) string {
+	// Write some code here to pass the test suite.
+	// Then remove all the stock comments.
+	// They're here to help you get started but they only clutter a finished solution.
+	// If you leave them in, reviewers may protest!
+	return ""
+}

data/tracks/go/exercises/acronym/acronym_test.go

@@ -4,14 +4,6 @@ import (
 	"testing"
 )
 
-const targetTestVersion = 3
-
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
-	}
-}
-
 func TestAcronym(t *testing.T) {
 	for _, test := range stringTestCases {
 		actual := Abbreviate(test.input)

data/tracks/go/exercises/acronym/cases_test.go

@@ -1,8 +1,8 @@
 package acronym
 
-// Source: exercism/x-common
+// Source: exercism/problem-specifications
 // Commit: cae7ae1 acronym: remove test case with mixed-case phrase (#788)
-// x-common version: 1.1.0
+// Problem Specifications Version: 1.1.0
 
 type acronymTest struct {
 	input    string

data/tracks/go/exercises/acronym/example.go

@@ -6,8 +6,6 @@ import (
 	"strings"
 )
 
-const testVersion = 3
-
 func Abbreviate(s string) string {
 	regex := regexp.MustCompile("[A-Z]+[a-z]*|[a-z]+")
 	words := regex.FindAllString(s, -1)

data/tracks/go/exercises/all-your-base/all_your_base_test.go

@@ -2,8 +2,6 @@ package allyourbase
 
 import "testing"
 
-const targetTestVersion = 1
-
 // Note: ConvertToBase should accept leading zeroes in its input,
 // but never emit leading zeroes in its output.
 // Exception: If the value of the output is zero, represent it with a single zero.
@@ -156,12 +154,6 @@ func digitsEqual(a, b []uint64) bool {
 	return true
 }
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
-	}
-}
-
 func TestConvertToBase(t *testing.T) {
 	for _, c := range testCases {
 		output, err := ConvertToBase(c.inputBase, c.inputDigits, c.outputBase)

data/tracks/go/exercises/all-your-base/example.go

@@ -5,8 +5,6 @@ import (
 	"math"
 )
 
-const testVersion = 1
-
 var (
 	ErrInvalidBase  = errors.New("invalid base given")
 	ErrInvalidDigit = errors.New("invalid digit given")

data/tracks/go/exercises/allergies/allergies_test.go

@@ -6,8 +6,6 @@ import (
 	"testing"
 )
 
-const targetTestVersion = 1
-
 var allergiesTests = []struct {
 	expected []string
 	input    uint
@@ -23,12 +21,6 @@ var allergiesTests = []struct {
 	{[]string{"eggs", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats"}, 509},
 }
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func TestAllergies(t *testing.T) {
 	for _, test := range allergiesTests {
 		actual := Allergies(test.input)

data/tracks/go/exercises/allergies/example.go

@@ -2,8 +2,6 @@ package allergies
 
 import "math"
 
-const testVersion = 1
-
 var allergens = []string{"eggs", "peanuts", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats"}
 
 func Allergies(i uint) (result []string) {

data/tracks/go/exercises/anagram/.meta/gen.go

@@ -0,0 +1,55 @@
+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("anagram", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Exercise string
+	Version  string
+	Comments []string
+	Cases    []OneCase
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type OneCase struct {
+	Description string
+	Subject     string
+	Candidates  []string
+	Expected    []string
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package anagram
+
+{{.Header}}
+
+var testCases = []struct {
+	description string
+	subject     string
+	candidates  []string
+	expected    []string
+}{ {{range .J.Cases}}
+{
+	description: {{printf "%q"   .Description}},
+	subject: {{printf "%q"   .Subject}},
+	candidates: []string { {{range $line := .Candidates}}{{printf "\n%q," $line}}{{end}}},
+	expected: []string { {{range $line := .Expected}}{{printf "\n%q," $line}}{{end}}},
+	},{{end}}
+}
+`

data/tracks/go/exercises/anagram/anagram_test.go

@@ -6,130 +6,6 @@ import (
 	"testing"
 )
 
-const targetTestVersion = 2
-
-var testCases = []struct {
-	subject     string
-	candidates  []string
-	expected    []string
-	description string
-}{
-	{
-		subject: "diaper",
-		candidates: []string{
-			"hello",
-			"world",
-			"zombies",
-			"pants",
-		},
-		expected:    []string{},
-		description: "no matches",
-	},
-	{
-		subject: "ant",
-		candidates: []string{
-			"tan",
-			"stand",
-			"at",
-		},
-		expected:    []string{"tan"},
-		description: "simple anagram",
-	},
-	{
-		subject: "listen",
-		candidates: []string{
-			"enlists",
-			"google",
-			"inlets",
-			"banana",
-		},
-		expected:    []string{"inlets"},
-		description: "another simple anagram",
-	},
-	{
-		subject: "master",
-		candidates: []string{
-			"stream",
-			"pigeon",
-			"maters",
-		},
-		expected:    []string{"maters", "stream"},
-		description: "multiple anagrams",
-	},
-	{
-		subject: "allergy",
-		candidates: []string{
-			"gallery",
-			"ballerina",
-			"regally",
-			"clergy",
-			"largely",
-			"leading",
-		},
-		expected:    []string{"gallery", "largely", "regally"},
-		description: "multiple anagrams (again)",
-	},
-	{
-		subject: "galea",
-		candidates: []string{
-			"eagle",
-		},
-		expected:    []string{},
-		description: "does not confuse different duplicates",
-	},
-	{
-		subject: "corn",
-		candidates: []string{
-			"corn",
-			"dark",
-			"Corn",
-			"rank",
-			"CORN",
-			"cron",
-			"park",
-		},
-		expected:    []string{"cron"},
-		description: "identical word is not anagram",
-	},
-	{
-		subject: "mass",
-		candidates: []string{
-			"last",
-		},
-		expected:    []string{},
-		description: "eliminate anagrams with same checksum",
-	},
-	{
-		subject: "good",
-		candidates: []string{
-			"dog",
-			"goody",
-		},
-		expected:    []string{},
-		description: "eliminate anagram subsets",
-	},
-	{
-		subject: "Orchestra",
-		candidates: []string{
-			"cashregiser",
-			"carthorse",
-			"radishes",
-		},
-		expected:    []string{"carthorse"},
-		description: "subjects are case insensitive",
-	},
-	{
-		subject: "orchestra",
-		candidates: []string{
-			"cashregiser",
-			"Carthorse",
-			"radishes",
-		},
-		expected:    []string{"Carthorse"},
-		description: "candidates are case insensitive",
-	},
-}
-
 func equal(a []string, b []string) bool {
 	if len(b) != len(a) {
 		return false
@@ -140,12 +16,6 @@ func equal(a []string, b []string) bool {
 	return fmt.Sprintf("%v", a) == fmt.Sprintf("%v", b)
 }
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
-	}
-}
-
 func TestDetectAnagrams(t *testing.T) {
 	for _, tt := range testCases {
 		actual := Detect(tt.subject, tt.candidates)

data/tracks/go/exercises/anagram/cases_test.go

@@ -0,0 +1,164 @@
+package anagram
+
+// Source: exercism/problem-specifications
+// Commit: 196fc1a anagram: Rename duplicated test case description (#671)
+// Problem Specifications Version: 1.0.1
+
+var testCases = []struct {
+	description string
+	subject     string
+	candidates  []string
+	expected    []string
+}{
+	{
+		description: "no matches",
+		subject:     "diaper",
+		candidates: []string{
+			"hello",
+			"world",
+			"zombies",
+			"pants"},
+		expected: []string{},
+	},
+	{
+		description: "detects simple anagram",
+		subject:     "ant",
+		candidates: []string{
+			"tan",
+			"stand",
+			"at"},
+		expected: []string{
+			"tan"},
+	},
+	{
+		description: "does not detect false positives",
+		subject:     "galea",
+		candidates: []string{
+			"eagle"},
+		expected: []string{},
+	},
+	{
+		description: "detects two anagrams",
+		subject:     "master",
+		candidates: []string{
+			"stream",
+			"pigeon",
+			"maters"},
+		expected: []string{
+			"stream",
+			"maters"},
+	},
+	{
+		description: "does not detect anagram subsets",
+		subject:     "good",
+		candidates: []string{
+			"dog",
+			"goody"},
+		expected: []string{},
+	},
+	{
+		description: "detects anagram",
+		subject:     "listen",
+		candidates: []string{
+			"enlists",
+			"google",
+			"inlets",
+			"banana"},
+		expected: []string{
+			"inlets"},
+	},
+	{
+		description: "detects three anagrams",
+		subject:     "allergy",
+		candidates: []string{
+			"gallery",
+			"ballerina",
+			"regally",
+			"clergy",
+			"largely",
+			"leading"},
+		expected: []string{
+			"gallery",
+			"regally",
+			"largely"},
+	},
+	{
+		description: "does not detect identical words",
+		subject:     "corn",
+		candidates: []string{
+			"corn",
+			"dark",
+			"Corn",
+			"rank",
+			"CORN",
+			"cron",
+			"park"},
+		expected: []string{
+			"cron"},
+	},
+	{
+		description: "does not detect non-anagrams with identical checksum",
+		subject:     "mass",
+		candidates: []string{
+			"last"},
+		expected: []string{},
+	},
+	{
+		description: "detects anagrams case-insensitively",
+		subject:     "Orchestra",
+		candidates: []string{
+			"cashregister",
+			"Carthorse",
+			"radishes"},
+		expected: []string{
+			"Carthorse"},
+	},
+	{
+		description: "detects anagrams using case-insensitive subject",
+		subject:     "Orchestra",
+		candidates: []string{
+			"cashregister",
+			"carthorse",
+			"radishes"},
+		expected: []string{
+			"carthorse"},
+	},
+	{
+		description: "detects anagrams using case-insensitive possible matches",
+		subject:     "orchestra",
+		candidates: []string{
+			"cashregister",
+			"Carthorse",
+			"radishes"},
+		expected: []string{
+			"Carthorse"},
+	},
+	{
+		description: "does not detect a word as its own anagram",
+		subject:     "banana",
+		candidates: []string{
+			"Banana"},
+		expected: []string{},
+	},
+	{
+		description: "does not detect a anagram if the original word is repeated",
+		subject:     "go",
+		candidates: []string{
+			"go Go GO"},
+		expected: []string{},
+	},
+	{
+		description: "anagrams must use all letters exactly once",
+		subject:     "tapper",
+		candidates: []string{
+			"patter"},
+		expected: []string{},
+	},
+	{
+		description: "capital word is not own anagram",
+		subject:     "BANANA",
+		candidates: []string{
+			"Banana"},
+		expected: []string{},
+	},
+}