public void CanReadThroughAsDictionary() { RedBlackTree <int, string> tree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ReadOnlyRedBlackTree <int, string> wrapper = new ReadOnlyRedBlackTree <int, string>(tree); IDictionary <int, string> dictionary = wrapper.AsDictionary(); Assert.That(dictionary[2], Is.EqualTo("2")); Assert.That(dictionary.Count, Is.EqualTo(5)); Assert.That(dictionary.Contains(new KeyValuePair <int, string>(2, "2")), Is.True); Assert.That(dictionary.Contains(new KeyValuePair <int, string>(2, "6")), Is.False); Assert.That(dictionary.Contains(new KeyValuePair <int, string>(6, "2")), Is.False); Assert.That(dictionary.Contains(new KeyValuePair <int, string>(6, "6")), Is.False); Assert.That(dictionary.Contains(new KeyValuePair <int, string>(2, null)), Is.False); Assert.That(dictionary.ContainsKey(2), Is.True); Assert.That(dictionary.ContainsKey(6), Is.False); Assert.That(dictionary.IsReadOnly, Is.True); Assert.That(dictionary.TryGetValue(2, out string value), Is.True); Assert.That(value, Is.EqualTo("2")); Assert.That(dictionary.TryGetValue(6, out value), Is.False); }
public void CanReadValuesAndNodesThroughAReadOnlyWrapper() { RedBlackTree <int, string> tree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ReadOnlyRedBlackTree <int, string> wrapper = new ReadOnlyRedBlackTree <int, string>(tree); Assert.That(wrapper[2], Is.EqualTo("2")); Assert.That(wrapper.ContainsKey(2), Is.True); Assert.That(wrapper.Find(2), Is.EqualTo(tree.Find(2))); Assert.That(wrapper.Contains(tree.Find(2)), Is.True); Assert.That(wrapper.TryGetValue(2, out string value), Is.True); Assert.That(value, Is.EqualTo("2")); Assert.That(wrapper.FindOrInsert(2, null, out RedBlackTreeNode <int, string> node), Is.False); Assert.That(node, Is.EqualTo(tree.Find(2))); Assert.That(wrapper.ContainsKey(6), Is.False); Assert.That(wrapper.TryGetValue(6, out value), Is.False); Assert.That(wrapper.Contains(tree.Find(6)), Is.False); }
public void CanReadTheWholeCollectionThroughAReadOnlyWrapper() { RedBlackTree <int, string> tree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ReadOnlyRedBlackTree <int, string> wrapper = new ReadOnlyRedBlackTree <int, string>(tree); CollectionAssert.AreEquivalent(wrapper.ToDictionary(), new Dictionary <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }); RedBlackTreeNode <int, string>[] array = new RedBlackTreeNode <int, string> [5]; wrapper.CopyTo(array, 0); CollectionAssert.AreEqual(array.Select(n => n.Key), new[] { 1, 2, 3, 4, 5 }); array = new RedBlackTreeNode <int, string> [5]; int index = 0; IEnumerator <RedBlackTreeNode <int, string> > enumerator = tree.GetEnumerator(); while (enumerator.MoveNext()) { array[index++] = enumerator.Current; } CollectionAssert.AreEqual(array.Select(n => n.Key), new[] { 1, 2, 3, 4, 5 }); array = new RedBlackTreeNode <int, string> [5]; index = 0; IEnumerator enumerator2 = ((IEnumerable)tree).GetEnumerator(); while (enumerator2.MoveNext()) { array[index++] = (RedBlackTreeNode <int, string>)enumerator2.Current; } CollectionAssert.AreEqual(array.Select(n => n.Key), new[] { 1, 2, 3, 4, 5 }); }
public void CanReadAsCollectionThroughAsDictionary() { RedBlackTree <int, string> tree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ReadOnlyRedBlackTree <int, string> wrapper = new ReadOnlyRedBlackTree <int, string>(tree); IDictionary <int, string> dictionary = wrapper.AsDictionary(); KeyValuePair <int, string>[] array = new KeyValuePair <int, string> [5]; dictionary.CopyTo(array, 0); CollectionAssert.AreEquivalent(array, new[] { new KeyValuePair <int, string>(1, "1"), new KeyValuePair <int, string>(2, "2"), new KeyValuePair <int, string>(3, "3"), new KeyValuePair <int, string>(4, "4"), new KeyValuePair <int, string>(5, "5"), }); CollectionAssert.AreEquivalent(dictionary.Keys, new[] { 1, 2, 3, 4, 5 }); CollectionAssert.AreEquivalent(dictionary.Values, new[] { "1", "2", "3", "4", "5" }); int index = 0; array = new KeyValuePair <int, string> [5]; foreach (KeyValuePair <int, string> pair in dictionary) { array[index++] = pair; } CollectionAssert.AreEquivalent(array, new[] { new KeyValuePair <int, string>(1, "1"), new KeyValuePair <int, string>(2, "2"), new KeyValuePair <int, string>(3, "3"), new KeyValuePair <int, string>(4, "4"), new KeyValuePair <int, string>(5, "5"), }); }
public void ReadOnlyShouldMirrorTheUnderlyingCollection() { RedBlackTree <int, string> redBlackTree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ICollection <int> keys = redBlackTree.Keys; Assert.That(keys.IsReadOnly, Is.False); ReadOnlyRedBlackTree <int, string> readOnlyTree = new ReadOnlyRedBlackTree <int, string>(redBlackTree); keys = readOnlyTree.Keys; Assert.That(keys.IsReadOnly, Is.True); }
public void CanConstructAReadOnlyRedBlackTreeWrapper() { RedBlackTree <int, string> tree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ReadOnlyRedBlackTree <int, string> wrapper = new ReadOnlyRedBlackTree <int, string>(tree); Assert.That(wrapper, Is.Not.Null); Assert.That(wrapper.Compare, Is.EqualTo(tree.Compare)); Assert.That(wrapper.Root, Is.EqualTo(tree.Root)); Assert.That(wrapper.Count, Is.EqualTo(5)); Assert.That(wrapper.MinimumNode.Key, Is.EqualTo(1)); Assert.That(wrapper.MaximumNode.Key, Is.EqualTo(5)); }
public void ValueCollectionsShouldAlwaysBeReadOnly() { RedBlackTree <int, string> redBlackTree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ICollection <string> values = redBlackTree.Values; Assert.That(values.IsReadOnly, Is.True); ReadOnlyRedBlackTree <int, string> readOnlyTree = new ReadOnlyRedBlackTree <int, string>(redBlackTree); values = readOnlyTree.Values; Assert.That(values.IsReadOnly, Is.True); }
public void CannotMutateThroughAsDictionary() { RedBlackTree <int, string> tree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ReadOnlyRedBlackTree <int, string> wrapper = new ReadOnlyRedBlackTree <int, string>(tree); IDictionary <int, string> dictionary = wrapper.AsDictionary(); Assert.Throws <ImmutableException>(() => dictionary[3] = "foo"); Assert.Throws <ImmutableException>(() => dictionary.Add(6, "6")); Assert.Throws <ImmutableException>(() => dictionary.Add(new KeyValuePair <int, string>(6, "6"))); Assert.Throws <ImmutableException>(() => dictionary.Clear()); Assert.Throws <ImmutableException>(() => dictionary.Remove(3)); Assert.Throws <ImmutableException>(() => dictionary.Remove(new KeyValuePair <int, string>(3, "3"))); Assert.Throws <ImmutableException>(() => dictionary.Keys.Add(6)); Assert.Throws <ImmutableException>(() => dictionary.Values.Add("bar")); }
public void CanPerformRangeQueriesThroughAReadOnlyWrapper() { RedBlackTree <int, string> tree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ReadOnlyRedBlackTree <int, string> wrapper = new ReadOnlyRedBlackTree <int, string>(tree); Assert.That(wrapper.GreatestBefore(3).Value, Is.EqualTo("2")); Assert.That(wrapper.GreatestBeforeOrEqualTo(3).Value, Is.EqualTo("3")); Assert.That(wrapper.GreatestBeforeOrEqualTo(6).Value, Is.EqualTo("5")); Assert.That(wrapper.GreatestInRange(2, 4).Value, Is.EqualTo("4")); Assert.That(wrapper.LeastAfter(3).Value, Is.EqualTo("4")); Assert.That(wrapper.LeastAfterOrEqualTo(3).Value, Is.EqualTo("3")); Assert.That(wrapper.LeastAfterOrEqualTo(0).Value, Is.EqualTo("1")); Assert.That(wrapper.LeastInRange(2, 4).Value, Is.EqualTo("2")); }
public void CannotMutateTheTreeThroughAReadOnlyWrapper() { RedBlackTree <int, string> tree = new RedBlackTree <int, string> { { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, }; ReadOnlyRedBlackTree <int, string> wrapper = new ReadOnlyRedBlackTree <int, string>(tree); Assert.Throws <ImmutableException>(() => wrapper.Add(6, "6")); Assert.Throws <ImmutableException>(() => wrapper.Add(new RedBlackTreeNode <int, string>(6, "6"))); Assert.Throws <ImmutableException>(() => wrapper.Clear()); Assert.Throws <ImmutableException>(() => wrapper.DeleteNode(wrapper.MinimumNode)); Assert.Throws <ImmutableException>(() => wrapper.FindOrInsert(6, "6", out RedBlackTreeNode <int, string> newNode)); Assert.Throws <ImmutableException>(() => wrapper.Remove(5)); Assert.Throws <ImmutableException>(() => wrapper.Remove(wrapper.MinimumNode)); Assert.Throws <ImmutableException>(() => wrapper.RemoveRange(1, 3)); Assert.Throws <ImmutableException>(() => wrapper[2] = "foo"); Assert.Throws <ImmutableException>(() => wrapper[6] = "bar"); }