summaryrefslogtreecommitdiff
path: root/go/custom-set/cases_test.go
diff options
context:
space:
mode:
authorDimitri Sokolyuk <demon@dim13.org>2016-08-30 01:33:25 +0200
committerDimitri Sokolyuk <demon@dim13.org>2016-08-30 01:33:25 +0200
commitbfb81139b65cd99b4a231e42a810214388194ec7 (patch)
treefe4595faf9da496a420455c4f379d98b64a0403c /go/custom-set/cases_test.go
parentd7411d8e5a0a5f974c2a8a5fe52d4265c4b951b8 (diff)
Solve set
Diffstat (limited to 'go/custom-set/cases_test.go')
-rw-r--r--go/custom-set/cases_test.go368
1 files changed, 368 insertions, 0 deletions
diff --git a/go/custom-set/cases_test.go b/go/custom-set/cases_test.go
new file mode 100644
index 0000000..90523b8
--- /dev/null
+++ b/go/custom-set/cases_test.go
@@ -0,0 +1,368 @@
+package stringset
+
+// Source: exercism/x-common
+// Commit: 269f498 Merge pull request #48 from soniakeys/custom-set-json
+
+// Test two sets for equality.
+var eqCases = []binBoolCase{
+ { // order doesn't matter
+ []string{"a", "c"},
+ []string{"c", "a"},
+ true,
+ },
+ { // dupicates don't matter
+ []string{"a", "a"},
+ []string{"a"},
+ true,
+ },
+ { // empty sets are equal
+ []string{},
+ []string{},
+ true,
+ },
+ { // set with single element is equal to itself
+ []string{"a"},
+ []string{"a"},
+ true,
+ },
+ { // different sets are not equal
+ []string{"a", "b", "c"},
+ []string{"c", "d", "e"},
+ false,
+ },
+ { // empty set is not equal to non-empty set
+ []string{},
+ []string{"a", "b", "c"},
+ false,
+ },
+ { // non-empty set is not equal to empty set
+ []string{"a", "b", "c"},
+ []string{},
+ false,
+ },
+ { // having most in common is not good enough
+ []string{"a", "b", "c", "d"},
+ []string{"b", "c", "d", "e"},
+ false,
+ },
+}
+
+// Add an element to a set.
+var addCases = []eleOpCase{
+ { // add to empty set
+ []string{},
+ "c",
+ []string{"c"},
+ },
+ { // add to non-empty set
+ []string{"a", "b", "d"},
+ "c",
+ []string{"a", "b", "c", "d"},
+ },
+ { // add existing element
+ []string{"a", "b", "c"},
+ "c",
+ []string{"a", "b", "c"},
+ },
+}
+
+// Delete an element from a set.
+var delCases = []eleOpCase{
+ { // delete an element
+ []string{"c", "b", "a"},
+ "b",
+ []string{"a", "c"},
+ },
+ { // delete an element not in set
+ []string{"c", "b", "a"},
+ "d",
+ []string{"a", "b", "c"},
+ },
+}
+
+// Test if is a set is empty.
+var emptyCases = []unaryBoolCase{
+ { // empty
+ []string{},
+ true,
+ },
+ { // single element
+ []string{"a"},
+ false,
+ },
+ { // a few elements
+ []string{"a", "b", "c", "b"},
+ false,
+ },
+}
+
+// Return the cardinality of a set.
+var lenCases = []unaryIntCase{
+ { // empty set
+ []string{},
+ 0,
+ },
+ { // non-empty set
+ []string{"a", "b", "c"},
+ 3,
+ },
+ { // duplicate element
+ []string{"a", "b", "c", "b"},
+ 3,
+ },
+}
+
+// Test if a value is an element of a set.
+var hasCases = []eleBoolCase{
+ { // nothing is an element of the empty set
+ []string{},
+ "a",
+ false,
+ },
+ { // 1 is in the set
+ []string{"a", "b", "c", "b"},
+ "a",
+ true,
+ },
+ { // 2 is in the set
+ []string{"a", "b", "c", "b"},
+ "b",
+ true,
+ },
+ { // 3 is in the set
+ []string{"a", "b", "c", "b"},
+ "c",
+ true,
+ },
+ { // 4 not in the set
+ []string{"a", "b", "c", "b"},
+ "d",
+ false,
+ },
+}
+
+// Test if set1 is a subset of set2.
+var subsetCases = []binBoolCase{
+ { // empty set is subset of itself
+ []string{},
+ []string{},
+ true,
+ },
+ { // empty set is subset of non-empty set
+ []string{},
+ []string{"a"},
+ true,
+ },
+ { // non-empty set is not subset of empty set
+ []string{"a"},
+ []string{},
+ false,
+ },
+ { // non-empty set is subset of itself
+ []string{"a", "b", "c"},
+ []string{"a", "b", "c"},
+ true,
+ },
+ { // proper subset
+ []string{"a", "b", "c"},
+ []string{"d", "a", "b", "c"},
+ true,
+ },
+ { // same number of elements
+ []string{"a", "b", "c"},
+ []string{"d", "a", "c"},
+ false,
+ },
+ { // superset
+ []string{"a", "b", "c", "d", "e"},
+ []string{"b", "c", "d"},
+ false,
+ },
+ { // fewer elements but not a subset
+ []string{"a", "b", "c", "k"},
+ []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"},
+ false,
+ },
+}
+
+// Test if two sets are disjoint.
+var disjointCases = []binBoolCase{
+ { // the empty set is disjoint with itself
+ []string{},
+ []string{},
+ true,
+ },
+ { // empty set disjoint with non-empty set
+ []string{},
+ []string{"a"},
+ true,
+ },
+ { // non-empty set disjoint with empty set
+ []string{"a"},
+ []string{},
+ true,
+ },
+ { // one element in common
+ []string{"a", "b"},
+ []string{"b", "c"},
+ false,
+ },
+ { // no elements in common
+ []string{"a", "b"},
+ []string{"c", "d"},
+ true,
+ },
+}
+
+// Produce the union of two sets.
+var unionCases = []binOpCase{
+ { // union of empty sets
+ []string{},
+ []string{},
+ []string{},
+ },
+ { // union of empty set with set of one element
+ []string{},
+ []string{"b"},
+ []string{"b"},
+ },
+ { // union of empty set with non-empty set
+ []string{},
+ []string{"c", "b", "e"},
+ []string{"b", "c", "e"},
+ },
+ { // union of non-empty set with empty set
+ []string{"a", "c"},
+ []string{},
+ []string{"a", "c"},
+ },
+ { // union of a set with itself
+ []string{"a", "c"},
+ []string{"c", "a"},
+ []string{"a", "c"},
+ },
+ { // union with one element
+ []string{"a", "c"},
+ []string{"b"},
+ []string{"a", "b", "c"},
+ },
+ { // one element in common, one different
+ []string{"a", "c"},
+ []string{"b", "c"},
+ []string{"c", "b", "a"},
+ },
+ { // two elements in common
+ []string{"a", "b", "c", "d"},
+ []string{"c", "b", "e"},
+ []string{"a", "b", "c", "d", "e"},
+ },
+}
+
+// Intersect two sets.
+var intersectionCases = []binOpCase{
+ { // intersect empty sets
+ []string{},
+ []string{},
+ []string{},
+ },
+ { // intersect empty set with non-empty set
+ []string{},
+ []string{"c", "b", "e"},
+ []string{},
+ },
+ { // intersect non-empty set with empty set
+ []string{"a", "b", "c", "d"},
+ []string{},
+ []string{},
+ },
+ { // intersect one element with itself
+ []string{"c"},
+ []string{"c"},
+ []string{"c"},
+ },
+ { // one element in common, extra elements in both sets
+ []string{"a", "b", "c"},
+ []string{"c", "e", "d"},
+ []string{"c"},
+ },
+ { // two elements in common, extras in both sets
+ []string{"a", "b", "c", "d"},
+ []string{"c", "b", "e"},
+ []string{"b", "c"},
+ },
+ { // intersect with subset
+ []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"},
+ []string{"e", "f", "g", "h", "i", "j"},
+ []string{"e", "f", "g", "h", "i", "j"},
+ },
+ { // nothing in common
+ []string{"a", "b", "c"},
+ []string{"d", "e", "f"},
+ []string{},
+ },
+}
+
+// Produce the set difference (set1 - set2)
+// or more specifically, (set1 ∖ set2)
+var differenceCases = []binOpCase{
+ { // difference of two empty sets
+ []string{},
+ []string{},
+ []string{},
+ },
+ { // difference of empty set and non-empty set
+ []string{},
+ []string{"c", "b", "e"},
+ []string{},
+ },
+ { // difference of non-empty set and empty set
+ []string{"a", "b", "c", "d"},
+ []string{},
+ []string{"a", "b", "c", "d"},
+ },
+ { // no elements in common
+ []string{"a", "b", "c"},
+ []string{"d"},
+ []string{"a", "b", "c"},
+ },
+ { // one element in common, one extra
+ []string{"c", "b", "a"},
+ []string{"b", "d"},
+ []string{"a", "c"},
+ },
+ { // two elements in common, one extra
+ []string{"a", "b", "c", "d"},
+ []string{"c", "b", "e"},
+ []string{"a", "d"},
+ },
+}
+
+// Produce the symmetric difference of two sets. The symmetric
+// difference consists of elements in one or the other but not both.
+var symmetricDifferenceCases = []binOpCase{
+ { // two empty sets
+ []string{},
+ []string{},
+ []string{},
+ },
+ { // empty set and non-empty set
+ []string{},
+ []string{"c", "b", "e"},
+ []string{"c", "b", "e"},
+ },
+ { // non-empty set and empty set
+ []string{"a", "b", "c", "d"},
+ []string{},
+ []string{"a", "b", "c", "d"},
+ },
+ { // no elements in common
+ []string{"a", "b", "c"},
+ []string{"d"},
+ []string{"a", "b", "c", "d"},
+ },
+ { // one element in common
+ []string{"c", "b", "a"},
+ []string{"b", "d"},
+ []string{"a", "c", "d"},
+ },
+}