trackler 2.0.6.16 → 2.0.6.17

data/tracks/go/exercises/custom-set/custom_set_test.go

@@ -6,20 +6,16 @@ package stringset
 //
 // New() Set
 // NewFromSlice([]string) Set
-// (s Set) Add(string)         // modify s
-// (s Set) Delete(string)      // modify s
-// (s Set) Has(string) bool
-// (s Set) IsEmpty() bool
-// (s Set) Len() int
-// (s Set) Slice() []string
 // (s Set) String() string
-// Equal(s1, s2 Set) bool
-// Subset(s1, s2 Set) bool     // return s1 ⊆ s2
+// (s Set) IsEmpty() bool
+// (s Set) Has(string) bool
+// Subset(s1, s2 Set) bool
 // Disjoint(s1, s2 Set) bool
+// Equal(s1, s2 Set) bool
+// (s Set) Add(string)
 // Intersection(s1, s2 Set) Set
+// Difference(s1, s2 Set) Set
 // Union(s1, s2 Set) Set
-// Difference(s1, s2 Set) Set  // return s1 ∖ s2
-// SymmetricDifference(s1, s2 Set) Set
 //
 // For Set.String, use '{' and '}', output elements as double-quoted strings
 // safely escaped with Go syntax, and use a comma and a single space between
@@ -28,12 +24,11 @@ package stringset
 
 import (
 	"math/rand"
-	"reflect"
 	"strconv"
 	"testing"
 )
 
-const targetTestVersion = 3
+const targetTestVersion = 4
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
@@ -79,65 +74,36 @@ func TestNewFromSlice(t *testing.T) {
 	}
 }
 
-func TestSlice(t *testing.T) {
-	// empty set should produce empty slice
-	s := New()
-	if l := s.Slice(); len(l) != 0 {
-		t.Fatalf(`s.Slice() = %q, want []`, l)
-	}
-
-	// one element:
-	want := []string{"a"}
-	s = NewFromSlice(want)
-	got := s.Slice()
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf(`%v Slice = %q, want %q`, s, got, want)
-	}
-
-	// two elements:
-	w1 := []string{"a", "b"}
-	w2 := []string{"b", "a"}
-	s = NewFromSlice(w1)
-	got = s.Slice()
-	if !reflect.DeepEqual(got, w1) && !reflect.DeepEqual(got, w2) {
-		t.Fatalf(`%v Slice = %q, want %q`, s, got, w1)
-	}
-}
-
 // Trusting NewFromSlice now, remaining tests are table driven, taking data
 // from cases_test.go and building sets with NewFromSlice.
 
 // test case types used in cases_test.go
+
 type (
-	// binary function, bool result (Equal, Subset, Disjoint)
-	binBoolCase struct {
-		set1 []string
-		set2 []string
-		want bool
-	}
 	// unary function, bool result (IsEmpty)
 	unaryBoolCase struct {
 		set  []string
 		want bool
 	}
-	// unary function, int result (Len)
-	unaryIntCase struct {
-		set  []string
-		want int
-	}
 	// set-element function, bool result (Has)
 	eleBoolCase struct {
 		set  []string
 		ele  string
 		want bool
 	}
-	// set-element operator (Add, Delete)
+	// binary function, bool result (Subset, Disjoint, Equal)
+	binBoolCase struct {
+		set1 []string
+		set2 []string
+		want bool
+	}
+	// set-element operator (Add)
 	eleOpCase struct {
 		set  []string
 		ele  string
 		want []string
 	}
-	// set-set operator (Union, Intersection, Difference, Symmetric-Difference)
+	// set-set operator (Intersection, Difference, Union)
 	binOpCase struct {
 		set1 []string
 		set2 []string
@@ -145,45 +111,16 @@ type (
 	}
 )
 
-// helper for testing Equal, Subset, Disjoint
-func testBinBool(name string, f func(Set, Set) bool, cases []binBoolCase, t *testing.T) {
-	for _, tc := range cases {
-		s1 := NewFromSlice(tc.set1)
-		s2 := NewFromSlice(tc.set2)
-		got := f(s1, s2)
-		if got != tc.want {
-			t.Fatalf("%s(%v, %v) = %t, want %t", name, s1, s2, got, tc.want)
-		}
-	}
-}
-
-func TestEqual(t *testing.T) {
-	testBinBool("Equal", Equal, eqCases, t)
-}
-
-// With Equal tested, remaining tests use it to judge correctness.
-
-// helper for testing Add, Delete
-func testEleOp(name string, op func(Set, string), cases []eleOpCase, t *testing.T) {
-	for _, tc := range cases {
+func TestIsEmpty(t *testing.T) {
+	for _, tc := range emptyCases {
 		s := NewFromSlice(tc.set)
-		op(s, tc.ele)
-		want := NewFromSlice(tc.want)
-		if !Equal(s, want) {
-			t.Fatalf("%v %s %q = %v, want %v",
-				NewFromSlice(tc.set), name, tc.ele, s, want)
+		got := s.IsEmpty()
+		if got != tc.want {
+			t.Fatalf("%v IsEmpty = %t, want %t", s, got, tc.want)
 		}
 	}
 }
 
-func TestAdd(t *testing.T) {
-	testEleOp("Add", Set.Add, addCases, t)
-}
-
-func TestDelete(t *testing.T) {
-	testEleOp("Delete", Set.Delete, delCases, t)
-}
-
 func TestHas(t *testing.T) {
 	for _, tc := range hasCases {
 		s := NewFromSlice(tc.set)
@@ -194,22 +131,14 @@ func TestHas(t *testing.T) {
 	}
 }
 
-func TestIsEmpty(t *testing.T) {
-	for _, tc := range emptyCases {
-		s := NewFromSlice(tc.set)
-		got := s.IsEmpty()
-		if got != tc.want {
-			t.Fatalf("%v IsEmpty = %t, want %t", s, got, tc.want)
-		}
-	}
-}
-
-func TestLen(t *testing.T) {
-	for _, tc := range lenCases {
-		s := NewFromSlice(tc.set)
-		got := s.Len()
+// helper for testing Subset, Disjoint, Equal
+func testBinBool(name string, f func(Set, Set) bool, cases []binBoolCase, t *testing.T) {
+	for _, tc := range cases {
+		s1 := NewFromSlice(tc.set1)
+		s2 := NewFromSlice(tc.set2)
+		got := f(s1, s2)
 		if got != tc.want {
-			t.Fatalf("%v Len = %d, want %d", s, got, tc.want)
+			t.Fatalf("%s(%v, %v) = %t, want %t", name, s1, s2, got, tc.want)
 		}
 	}
 }
@@ -222,7 +151,22 @@ func TestDisjoint(t *testing.T) {
 	testBinBool("Disjoint", Disjoint, disjointCases, t)
 }
 
-// helper for testing Union, Intersection, Difference, SymmetricDifference
+func TestEqual(t *testing.T) {
+	testBinBool("Equal", Equal, eqCases, t)
+}
+
+func TestAdd(t *testing.T) {
+	for _, tc := range addCases {
+		s := NewFromSlice(tc.set)
+		s.Add(tc.ele)
+		want := NewFromSlice(tc.want)
+		if !Equal(s, want) {
+			t.Fatalf("%v Add %q = %v, want %v", NewFromSlice(tc.set), tc.ele, s, want)
+		}
+	}
+}
+
+// helper for testing Intersection, Difference, Union
 func testBinOp(name string, f func(Set, Set) Set, cases []binOpCase, t *testing.T) {
 	for _, tc := range cases {
 		s1 := NewFromSlice(tc.set1)
@@ -235,10 +179,6 @@ func testBinOp(name string, f func(Set, Set) Set, cases []binOpCase, t *testing.
 	}
 }
 
-func TestUnion(t *testing.T) {
-	testBinOp("Union", Union, unionCases, t)
-}
-
 func TestIntersection(t *testing.T) {
 	testBinOp("Intersection", Intersection, intersectionCases, t)
 }
@@ -247,8 +187,8 @@ func TestDifference(t *testing.T) {
 	testBinOp("Difference", Difference, differenceCases, t)
 }
 
-func TestSymmetricDifference(t *testing.T) {
-	testBinOp("SymmetricDifference", SymmetricDifference, symmetricDifferenceCases, t)
+func TestUnion(t *testing.T) {
+	testBinOp("Union", Union, unionCases, t)
 }
 
 func BenchmarkNewFromSlice1e1(b *testing.B) { bench(1e1, b) }

data/tracks/go/exercises/custom-set/example.go

@@ -2,12 +2,9 @@
 
 package stringset
 
-import (
-	"fmt"
-	"reflect"
-)
+import "fmt"
 
-const testVersion = 3
+const testVersion = 4
 
 // Set represents some properties of a mathematical set.
 // Sets are finite and all elements are unique string values.
@@ -27,23 +24,18 @@ func NewFromSlice(l []string) Set {
 	return s
 }
 
-// Add adds element e to Set s.
-//
-// If e is already in s, s is unchanged.
-func (s Set) Add(e string) {
-	s[e] = true
-}
-
-// Delete deletes element e from Set s.
-//
-// If e is not in s, Delete has no effect.
-func (s Set) Delete(e string) {
-	delete(s, e)
-}
-
-// Has returns true if e is an element of s.
-func (s Set) Has(e string) bool {
-	return s[e]
+// String returns a printable representation of s.
+func (s Set) String() string {
+	r := "{"
+	i := 0
+	for e := range s {
+		if i > 0 {
+			r += ", "
+		}
+		r += fmt.Sprintf("%q", e)
+		i++
+	}
+	return r + "}"
 }
 
 // IsEmpty returns true if s represents the empty set.
@@ -51,44 +43,40 @@ func (s Set) IsEmpty() bool {
 	return len(s) == 0
 }
 
-// Len returns the cardinality, or number of elements in s.
-func (s Set) Len() int {
-	return len(s)
+// Has returns true if e is an element of s.
+func (s Set) Has(e string) bool {
+	return s[e]
 }
 
-// Slice constructs a slice populated with the elements of s.
-func (s Set) Slice() []string {
-	l := make([]string, len(s))
-	i := 0
-	for e := range s {
-		l[i] = e
-		i++
-	}
-	return l
+// Add adds element e to Set s.
+// If e is already in s, s is unchanged.
+func (s Set) Add(e string) {
+	s[e] = true
 }
 
-// String returns a printable representation of s.
-func (s Set) String() string {
-	r := "{"
-	i := 0
-	for e := range s {
-		if i > 0 {
-			r += ", "
+// Subset returns true if all elements of s1 are also in s2.
+func Subset(s1, s2 Set) bool {
+	for e := range s1 {
+		if !s2[e] {
+			return false
 		}
-		r += fmt.Sprintf("%q", e)
-		i++
 	}
-	return r + "}"
+	return true
 }
 
 // Disjoint returns true if s1 and s2 have no elements in common.
 func Disjoint(s1, s2 Set) bool {
-	return len(Intersection(s1, s2)) == 0
+	for e := range s1 {
+		if s2[e] {
+			return false
+		}
+	}
+	return true
 }
 
 // Equal returns true if s1 and s2 contain the same elements.
 func Equal(s1, s2 Set) bool {
-	return reflect.DeepEqual(s1, s2)
+	return Subset(s1, s2) && Subset(s2, s1)
 }
 
 // Intersection constructs a new Set populated with the elements common to
@@ -103,19 +91,6 @@ func Intersection(s1, s2 Set) Set {
 	return r
 }
 
-// Union constructs a new Set populated with elements that appear in s1, s2,
-// or both.
-func Union(s1, s2 Set) Set {
-	r := Set{}
-	for e := range s1 {
-		r[e] = true
-	}
-	for e := range s2 {
-		r[e] = true
-	}
-	return r
-}
-
 // Difference returns a new Set populated with elements that appear in s1
 // but not in s2.
 func Difference(s1, s2 Set) Set {
@@ -128,29 +103,15 @@ func Difference(s1, s2 Set) Set {
 	return r
 }
 
-// Subset returns true if all elements of s1 are also in s2.
-func Subset(s1, s2 Set) bool {
-	for e := range s1 {
-		if !s2[e] {
-			return false
-		}
-	}
-	return true
-}
-
-// SymmetricDifference constructs a new set populated with elements that are
-// members of s1 or s2 but not both.
-func SymmetricDifference(s1, s2 Set) Set {
+// Union constructs a new Set populated with elements that appear in s1, s2,
+// or both.
+func Union(s1, s2 Set) Set {
 	r := Set{}
 	for e := range s1 {
-		if !s2[e] {
-			r[e] = true
-		}
+		r[e] = true
 	}
 	for e := range s2 {
-		if !s1[e] {
-			r[e] = true
-		}
+		r[e] = true
 	}
 	return r
 }

data/tracks/go/exercises/custom-set/example_gen.go

@@ -42,70 +42,58 @@ func strSlice(ns []int) []string {
 
 // The JSON structure we expect to be able to unmarshal into
 type js struct {
-	Equal               binaryBool // binary function, boolean result
-	Add                 eleOp      // set-element operator
-	Delete              eleOp      // ...
-	IsEmpty             unaryBool  `json:"is-empty"`
-	Size                unaryInt   // Set.Len
-	Element             eleBool    // Set.Has
-	Subset              binaryBool
-	Disjoint            binaryBool
-	Union               binaryOp // set-set operator
-	Intersection        binaryOp
-	Difference          binaryOp
-	SymmetricDifference binaryOp `json:"symmetric-difference"`
+	IsEmpty      unaryBool `json:"empty"`
+	Contains     eleBool
+	Subset       binaryBool
+	Disjoint     binaryBool
+	Equal        binaryBool
+	Add          eleOp
+	Intersection binaryOp
+	Difference   binaryOp
+	Union        binaryOp
 }
 
-type binaryBool struct {
-	Description []string
+type unaryBool struct {
+	Description string
 	Cases       []struct {
 		Description string
-		Set1        []int
-		Set2        []int
+		Set         []int
 		Expected    bool
 	}
 }
 
-type eleOp struct {
-	Description []string
+type eleBool struct {
+	Description string
 	Cases       []struct {
 		Description string
 		Set         []int
 		Element     int
-		Expected    []int
-	}
-}
-
-type unaryBool struct {
-	Description []string
-	Cases       []struct {
-		Description string
-		Set         []int
 		Expected    bool
 	}
 }
 
-type unaryInt struct {
-	Description []string
+type binaryBool struct {
+	Description string
 	Cases       []struct {
 		Description string
-		Set         []int
-		Expected    int
+		Set1        []int
+		Set2        []int
+		Expected    bool
 	}
 }
 
-type eleBool struct {
-	Description []string
+type eleOp struct {
+	Description string
 	Cases       []struct {
 		Description string
 		Set         []int
 		Element     int
-		Expected    bool
+		Expected    []int
 	}
 }
 
 type binaryOp struct {
-	Description []string
+	Description string
 	Cases       []struct {
 		Description string
 		Set1        []int
@@ -122,9 +110,6 @@ type binaryOp struct {
 var tmpl = `
 {{/* nested templates for repeated stuff */}}
 
-{{define "cmts"}}{{range .}}// {{.}}
-{{end}}{{end}}
-
 {{define "binaryBool"}} = []binBoolCase{
 {{range .}}{ // {{.Description}}
 	{{strs .Set1 | printf "%#v"}},
@@ -156,46 +141,41 @@ package stringset
 {{if .Commit}}// Commit: {{.Commit}}
 {{end}}
 
-{{template "cmts" .J.Equal.Description}}var eqCases{{template "binaryBool" .J.Equal.Cases}}
-
-{{template "cmts" .J.Add.Description}}var addCases{{template "eleOp" .J.Add.Cases}}
-
-{{template "cmts" .J.Delete.Description}}var delCases{{template "eleOp" .J.Delete.Cases}}
-
-{{range .J.IsEmpty.Description}}// {{.}}
-{{end}}var emptyCases = []unaryBoolCase{
+// {{.J.IsEmpty.Description}}
+var emptyCases = []unaryBoolCase{
 {{range .J.IsEmpty.Cases}}{ // {{.Description}}
 	{{strs .Set | printf "%#v"}},
 	{{.Expected}},
 },
 {{end}}}
 
-{{range .J.Size.Description}}// {{.}}
-{{end}}var lenCases = []unaryIntCase{
-{{range .J.Size.Cases}}{ // {{.Description}}
-	{{strs .Set | printf "%#v"}},
-	{{.Expected}},
-},
-{{end}}}
-
-{{range .J.Element.Description}}// {{.}}
-{{end}}var hasCases = []eleBoolCase{
-{{range .J.Element.Cases}}{ // {{.Description}}
+// {{.J.Contains.Description}}
+var hasCases = []eleBoolCase{
+{{range .J.Contains.Cases}}{ // {{.Description}}
 	{{strs .Set | printf "%#v"}},
 	{{str .Element | printf "%q"}},
 	{{.Expected}},
 },
 {{end}}}
 
-{{template "cmts" .J.Subset.Description}}var subsetCases{{template "binaryBool" .J.Subset.Cases}}
+// {{.J.Subset.Description}}
+var subsetCases{{template "binaryBool" .J.Subset.Cases}}
+
+// {{.J.Disjoint.Description}}
+var disjointCases{{template "binaryBool" .J.Disjoint.Cases}}
 
-{{template "cmts" .J.Disjoint.Description}}var disjointCases{{template "binaryBool" .J.Disjoint.Cases}}
+// {{.J.Equal.Description}}
+var eqCases{{template "binaryBool" .J.Equal.Cases}}
 
-{{template "cmts" .J.Union.Description}}var unionCases{{template "binaryOp" .J.Union.Cases}}
+// {{.J.Add.Description}}
+var addCases{{template "eleOp" .J.Add.Cases}}
 
-{{template "cmts" .J.Intersection.Description}}var intersectionCases{{template "binaryOp" .J.Intersection.Cases}}
+// {{.J.Intersection.Description}}
+var intersectionCases{{template "binaryOp" .J.Intersection.Cases}}
 
-{{template "cmts" .J.Difference.Description}}var differenceCases{{template "binaryOp" .J.Difference.Cases}}
+// {{.J.Difference.Description}}
+var differenceCases{{template "binaryOp" .J.Difference.Cases}}
 
-{{template "cmts" .J.SymmetricDifference.Description}}var symmetricDifferenceCases{{template "binaryOp" .J.SymmetricDifference.Cases}}
+// {{.J.Union.Description}}
+var unionCases{{template "binaryOp" .J.Union.Cases}}
 `