static void Main()
{
StringSet ss = new StringSet();
// Check the interface methods first.
ISet <string> s = ss;
checkThat(s.Count == 0, "is initially empty");
checkThat(!s.Contains("key"), "doesn't contain inexistent element");
checkThat(!s.Remove("key"), "returns false when removing inexistent element");
checkThat(s.Add("key"), "returns true when adding a new element");
checkThat(!s.Add("key"), "returns false when adding an existing element");
checkThat(s.Contains("key"), "contains the just added element");
checkThat(s.Remove("key"), "returns true when removing an existing element");
checkThat(s.Count == 0, "is empty again");
checkThat(s.Add("key1"), "Add(key1) returns true");
checkThat(s.Add("key2"), "Add(key2) returns true");
checkThat(s.Add("key3"), "Add(key3) returns true");
// Also check a different interface, providing a different Add() (sic!).
ICollection <string> coll = ss;
coll.Add("key");
checkThat(ss.Count == 4, "contains 4 elements");
// Now use object-specific methods, mimicking HashSet<>.
string val;
checkThat(ss.TryGetValue("key1", out val), "could retrieve existing item");
checkThat(val.Equals("key1"), "value was returned correctly by TryGetValue()");
checkThat(!ss.TryGetValue("no-such-key", out val), "couldn't retrieve inexistent item");
checkThat(val == null, "value was reset after failed TryGetValue()");
IList <string> list = new List <string>();
foreach (string str in ss)
{
list.Add(str);
}
checkThat(list.Count == 4, "copy contains 4 elements");
ss.Clear();
checkThat(ss.Count == 0, "is empty after Clear()");
// Check set-theoretic methods.
checkThat(new StringSet().SetEquals(new StringSet()), "SetEquals() works for empty sets");
checkThat(new StringSet {
"foo"
}.SetEquals(new StringSet {
"foo"
}), "SetEquals() works for non-empty sets");
checkThat(!new StringSet {
"foo"
}.SetEquals(new[] { "bar" }), "SetEquals() doesn't always return true");
ss = new StringSet {
"foo", "bar", "baz"
};
ss.ExceptWith(new[] { "baz", "quux" });
checkThat(ss.SetEquals(new[] { "foo", "bar" }), "ExceptWith works");
ss = new StringSet {
"foo", "bar", "baz"
};
ss.IntersectWith(new[] { "baz", "quux" });
checkThat(ss.SetEquals(new[] { "baz" }), "IntersectWith works");
checkThat(ss.IsProperSubsetOf(new[] { "bar", "baz" }), "IsProperSubsetOf works");
checkThat(!ss.IsProperSubsetOf(new[] { "baz" }), "!IsProperSubsetOf works");
checkThat(ss.IsSubsetOf(new[] { "bar", "baz" }), "IsSubsetOf works");
checkThat(!ss.IsSubsetOf(new[] { "bar" }), "!IsSubsetOf works");
ss = new StringSet {
"foo", "bar", "baz"
};
checkThat(ss.IsProperSupersetOf(new[] { "bar" }), "IsProperSupersetOf works");
checkThat(!ss.IsProperSupersetOf(new[] { "quux" }), "IsProperSupersetOf works");
checkThat(ss.IsSupersetOf(new[] { "foo", "bar", "baz" }), "IsProperSupersetOf works");
checkThat(!ss.IsSupersetOf(new[] { "foo", "bar", "baz", "quux" }), "IsProperSupersetOf works");
checkThat(ss.Overlaps(new[] { "foo" }), "Overlaps works");
checkThat(!ss.Overlaps(new[] { "moo" }), "!Overlaps works");
ss.SymmetricExceptWith(new[] { "baz", "quux" });
checkThat(ss.SetEquals(new[] { "foo", "bar", "quux" }), "SymmetricExceptWith works");
ss = new StringSet {
"foo", "bar", "baz"
};
ss.UnionWith(new[] { "baz", "quux" });
checkThat(ss.SetEquals(new[] { "foo", "bar", "baz", "quux" }), "UnionWith works");
// Check a set of another type.
FooSet fooSet = new FooSet();
ISet <Foo> fooISet = fooSet;
checkThat(fooISet.Count == 0, "is initially empty");
checkThat(fooISet.Add(new Foo(17)), "added successfully");
checkThat(fooISet.Count == 1, "is not empty any more");
// And a set of primitive type.
IntSet intSet = new IntSet();
checkThat(intSet.Count == 0, "is initially empty");
checkThat(intSet.Add(17), "17 added successfully");
checkThat(!intSet.Add(17), "17 not added again");
checkThat(intSet.Count == 1, "not empty any more");
checkThat(intSet.Add(289), "289 added successfully");
checkThat(intSet.Count == 2, "even less empty now");
}