| using System; |
| using System.Collections.Generic; |
| using li_std_setNamespace; |
| |
| public class runme |
| { |
| static void checkThat(bool mustBeTrue, string message) |
| { |
| if (!mustBeTrue) |
| throw new Exception("Test that the set " + message + " failed"); |
| } |
| |
| 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"); |
| } |
| } |