From bfb81139b65cd99b4a231e42a810214388194ec7 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 30 Aug 2016 01:33:25 +0200 Subject: Solve set --- go/custom-set/cases_test.go | 368 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 368 insertions(+) create mode 100644 go/custom-set/cases_test.go (limited to 'go/custom-set/cases_test.go') 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"}, + }, +} -- cgit v1.2.3