| /* |
| Copyright (c) 2003-2016 Niels Kokholm, Peter Sestoft, and Rasmus Lystrøm |
| Permission is hereby granted, free of charge, to any person obtaining a copy |
| of this software and associated documentation files (the "Software"), to deal |
| in the Software without restriction, including without limitation the rights |
| to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the Software is |
| furnished to do so, subject to the following conditions: |
| |
| The above copyright notice and this permission notice shall be included in |
| all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| SOFTWARE. |
| */ |
| |
| using System; |
| using Lucene.Net.Attributes; |
| using Lucene.Net.Support.C5; |
| using NUnit.Framework; |
| using SCG = System.Collections.Generic; |
| |
| |
| namespace Lucene.Net.Support.C5.RBDictionary |
| { |
| using DictionaryIntToInt = TreeDictionary<int, int>; |
| |
| static class Factory |
| { |
| public static IDictionary<K, V> New<K, V>() { return new TreeDictionary<K, V>(); } |
| } |
| |
| //[TestFixture] |
| //public class GenericTesters |
| //{ |
| // [Test, LuceneNetSpecific] |
| // public void TestSerialize() |
| // { |
| // C5UnitTests.Templates.Extensible.Serialization.DTester<DictionaryIntToInt>(); |
| // } |
| //} |
| |
| |
| [TestFixture] |
| public class Formatting |
| { |
| IDictionary<int, int> coll; |
| IFormatProvider rad16; |
| [SetUp] |
| public void Init() { coll = Factory.New<int, int>(); rad16 = new RadixFormatProvider(16); } |
| [TearDown] |
| public void Dispose() { coll = null; rad16 = null; } |
| [Test, LuceneNetSpecific] |
| public void Format() |
| { |
| Assert.AreEqual("[ ]", coll.ToString()); |
| coll.Add(23, 67); coll.Add(45, 89); |
| Assert.AreEqual("[ 23 => 67, 45 => 89 ]", coll.ToString()); |
| Assert.AreEqual("[ 17 => 43, 2D => 59 ]", coll.ToString(null, rad16)); |
| Assert.AreEqual("[ 23 => 67, ... ]", coll.ToString("L14", null)); |
| Assert.AreEqual("[ 17 => 43, ... ]", coll.ToString("L14", rad16)); |
| } |
| } |
| |
| [TestFixture] |
| public class RBDict |
| { |
| private TreeDictionary<string, string> dict; |
| |
| |
| [SetUp] |
| public void Init() { dict = new TreeDictionary<string, string>(new SC()); } |
| |
| |
| [TearDown] |
| public void Dispose() { dict = null; } |
| |
| [Test, LuceneNetSpecific] |
| public void NullEqualityComparerinConstructor1() |
| { |
| Assert.Throws<NullReferenceException>(() => new TreeDictionary<int, int>(null)); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void Choose() |
| { |
| dict.Add("YES", "NO"); |
| Assert.AreEqual(new KeyValuePair<string, string>("YES", "NO"), dict.Choose()); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void BadChoose() |
| { |
| Assert.Throws<NoSuchItemException>(() => dict.Choose()); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void Pred1() |
| { |
| dict.Add("A", "1"); |
| dict.Add("C", "2"); |
| dict.Add("E", "3"); |
| Assert.AreEqual("1", dict.Predecessor("B").Value); |
| Assert.AreEqual("1", dict.Predecessor("C").Value); |
| Assert.AreEqual("1", dict.WeakPredecessor("B").Value); |
| Assert.AreEqual("2", dict.WeakPredecessor("C").Value); |
| Assert.AreEqual("2", dict.Successor("B").Value); |
| Assert.AreEqual("3", dict.Successor("C").Value); |
| Assert.AreEqual("2", dict.WeakSuccessor("B").Value); |
| Assert.AreEqual("2", dict.WeakSuccessor("C").Value); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void Pred2() |
| { |
| dict.Add("A", "1"); |
| dict.Add("C", "2"); |
| dict.Add("E", "3"); |
| KeyValuePair<String, String> res; |
| Assert.IsTrue(dict.TryPredecessor("B", out res)); |
| Assert.AreEqual("1", res.Value); |
| Assert.IsTrue(dict.TryPredecessor("C", out res)); |
| Assert.AreEqual("1", res.Value); |
| Assert.IsTrue(dict.TryWeakPredecessor("B", out res)); |
| Assert.AreEqual("1", res.Value); |
| Assert.IsTrue(dict.TryWeakPredecessor("C", out res)); |
| Assert.AreEqual("2", res.Value); |
| Assert.IsTrue(dict.TrySuccessor("B", out res)); |
| Assert.AreEqual("2", res.Value); |
| Assert.IsTrue(dict.TrySuccessor("C", out res)); |
| Assert.AreEqual("3", res.Value); |
| Assert.IsTrue(dict.TryWeakSuccessor("B", out res)); |
| Assert.AreEqual("2", res.Value); |
| Assert.IsTrue(dict.TryWeakSuccessor("C", out res)); |
| Assert.AreEqual("2", res.Value); |
| |
| Assert.IsFalse(dict.TryPredecessor("A", out res)); |
| Assert.AreEqual(null, res.Key); |
| Assert.AreEqual(null, res.Value); |
| |
| Assert.IsFalse(dict.TryWeakPredecessor("@", out res)); |
| Assert.AreEqual(null, res.Key); |
| Assert.AreEqual(null, res.Value); |
| |
| Assert.IsFalse(dict.TrySuccessor("E", out res)); |
| Assert.AreEqual(null, res.Key); |
| Assert.AreEqual(null, res.Value); |
| |
| Assert.IsFalse(dict.TryWeakSuccessor("F", out res)); |
| Assert.AreEqual(null, res.Key); |
| Assert.AreEqual(null, res.Value); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void Initial() |
| { |
| bool res; |
| Assert.IsFalse(dict.IsReadOnly); |
| |
| Assert.AreEqual(dict.Count, 0, "new dict should be empty"); |
| dict.Add("A", "B"); |
| Assert.AreEqual(dict.Count, 1, "bad count"); |
| Assert.AreEqual(dict["A"], "B", "Wrong value for dict[A]"); |
| dict.Add("C", "D"); |
| Assert.AreEqual(dict.Count, 2, "bad count"); |
| Assert.AreEqual(dict["A"], "B", "Wrong value"); |
| Assert.AreEqual(dict["C"], "D", "Wrong value"); |
| res = dict.Remove("A"); |
| Assert.IsTrue(res, "bad return value from Remove(A)"); |
| Assert.IsTrue(dict.Check()); |
| Assert.AreEqual(dict.Count, 1, "bad count"); |
| Assert.AreEqual(dict["C"], "D", "Wrong value of dict[C]"); |
| res = dict.Remove("Z"); |
| Assert.IsFalse(res, "bad return value from Remove(Z)"); |
| Assert.AreEqual(dict.Count, 1, "bad count"); |
| Assert.AreEqual(dict["C"], "D", "Wrong value of dict[C] (2)"); |
| dict.Clear(); |
| Assert.AreEqual(dict.Count, 0, "dict should be empty"); |
| } |
| [Test, LuceneNetSpecific] |
| public void Contains() |
| { |
| dict.Add("C", "D"); |
| Assert.IsTrue(dict.Contains("C")); |
| Assert.IsFalse(dict.Contains("D")); |
| } |
| |
| |
| [Test, LuceneNetSpecific] |
| public void IllegalAdd() |
| { |
| dict.Add("A", "B"); |
| |
| var exception = Assert.Throws<DuplicateNotAllowedException>(() => dict.Add("A", "B")); |
| Assert.AreEqual("Key being added: 'A'", exception.Message); |
| } |
| |
| |
| [Test, LuceneNetSpecific] |
| public void GettingNonExisting() |
| { |
| Assert.Throws<NoSuchItemException>(() => Console.WriteLine(dict["R"])); |
| } |
| |
| |
| [Test, LuceneNetSpecific] |
| public void Setter() |
| { |
| dict["R"] = "UYGUY"; |
| Assert.AreEqual(dict["R"], "UYGUY"); |
| dict["R"] = "UIII"; |
| Assert.AreEqual(dict["R"], "UIII"); |
| dict["S"] = "VVV"; |
| Assert.AreEqual(dict["R"], "UIII"); |
| Assert.AreEqual(dict["S"], "VVV"); |
| //dict.dump(); |
| } |
| } |
| |
| [TestFixture] |
| public class GuardedSortedDictionaryTest |
| { |
| private GuardedSortedDictionary<string, string> dict; |
| |
| [SetUp] |
| public void Init() |
| { |
| ISortedDictionary<string, string> dict = new TreeDictionary<string, string>(new SC()); |
| dict.Add("A", "1"); |
| dict.Add("C", "2"); |
| dict.Add("E", "3"); |
| this.dict = new GuardedSortedDictionary<string, string>(dict); |
| } |
| |
| [TearDown] |
| public void Dispose() { dict = null; } |
| |
| [Test, LuceneNetSpecific] |
| public void Pred1() |
| { |
| Assert.AreEqual("1", dict.Predecessor("B").Value); |
| Assert.AreEqual("1", dict.Predecessor("C").Value); |
| Assert.AreEqual("1", dict.WeakPredecessor("B").Value); |
| Assert.AreEqual("2", dict.WeakPredecessor("C").Value); |
| Assert.AreEqual("2", dict.Successor("B").Value); |
| Assert.AreEqual("3", dict.Successor("C").Value); |
| Assert.AreEqual("2", dict.WeakSuccessor("B").Value); |
| Assert.AreEqual("2", dict.WeakSuccessor("C").Value); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void Pred2() |
| { |
| KeyValuePair<String, String> res; |
| Assert.IsTrue(dict.TryPredecessor("B", out res)); |
| Assert.AreEqual("1", res.Value); |
| Assert.IsTrue(dict.TryPredecessor("C", out res)); |
| Assert.AreEqual("1", res.Value); |
| Assert.IsTrue(dict.TryWeakPredecessor("B", out res)); |
| Assert.AreEqual("1", res.Value); |
| Assert.IsTrue(dict.TryWeakPredecessor("C", out res)); |
| Assert.AreEqual("2", res.Value); |
| Assert.IsTrue(dict.TrySuccessor("B", out res)); |
| Assert.AreEqual("2", res.Value); |
| Assert.IsTrue(dict.TrySuccessor("C", out res)); |
| Assert.AreEqual("3", res.Value); |
| Assert.IsTrue(dict.TryWeakSuccessor("B", out res)); |
| Assert.AreEqual("2", res.Value); |
| Assert.IsTrue(dict.TryWeakSuccessor("C", out res)); |
| Assert.AreEqual("2", res.Value); |
| |
| Assert.IsFalse(dict.TryPredecessor("A", out res)); |
| Assert.AreEqual(null, res.Key); |
| Assert.AreEqual(null, res.Value); |
| |
| Assert.IsFalse(dict.TryWeakPredecessor("@", out res)); |
| Assert.AreEqual(null, res.Key); |
| Assert.AreEqual(null, res.Value); |
| |
| Assert.IsFalse(dict.TrySuccessor("E", out res)); |
| Assert.AreEqual(null, res.Key); |
| Assert.AreEqual(null, res.Value); |
| |
| Assert.IsFalse(dict.TryWeakSuccessor("F", out res)); |
| Assert.AreEqual(null, res.Key); |
| Assert.AreEqual(null, res.Value); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void Initial() |
| { |
| Assert.IsTrue(dict.IsReadOnly); |
| |
| Assert.AreEqual(3, dict.Count); |
| Assert.AreEqual("1", dict["A"]); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void Contains() |
| { |
| Assert.IsTrue(dict.Contains("A")); |
| Assert.IsFalse(dict.Contains("1")); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void IllegalAdd() |
| { |
| Assert.Throws<ReadOnlyCollectionException>(() => dict.Add("Q", "7")); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void IllegalClear() |
| { |
| Assert.Throws<ReadOnlyCollectionException>(() => dict.Clear()); |
| } |
| [Test, LuceneNetSpecific] |
| |
| public void IllegalSet() |
| { |
| Assert.Throws<ReadOnlyCollectionException>(() => dict["A"] = "8"); |
| } |
| |
| public void IllegalRemove() |
| { |
| Assert.Throws<ReadOnlyCollectionException>(() => dict.Remove("A")); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void GettingNonExisting() |
| { |
| Assert.Throws<NoSuchItemException>(() => Console.WriteLine(dict["R"])); |
| } |
| } |
| |
| [TestFixture] |
| public class Enumerators |
| { |
| private TreeDictionary<string, string> dict; |
| |
| private SCG.IEnumerator<KeyValuePair<string, string>> dictenum; |
| |
| |
| [SetUp] |
| public void Init() |
| { |
| dict = new TreeDictionary<string, string>(new SC()); |
| dict["S"] = "A"; |
| dict["T"] = "B"; |
| dict["R"] = "C"; |
| dictenum = dict.GetEnumerator(); |
| } |
| |
| |
| [TearDown] |
| public void Dispose() |
| { |
| dictenum = null; |
| dict = null; |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void KeysEnumerator() |
| { |
| SCG.IEnumerator<string> keys = dict.Keys.GetEnumerator(); |
| Assert.AreEqual(3, dict.Keys.Count); |
| Assert.IsTrue(keys.MoveNext()); |
| Assert.AreEqual("R", keys.Current); |
| Assert.IsTrue(keys.MoveNext()); |
| Assert.AreEqual("S", keys.Current); |
| Assert.IsTrue(keys.MoveNext()); |
| Assert.AreEqual("T", keys.Current); |
| Assert.IsFalse(keys.MoveNext()); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void KeysISorted() |
| { |
| ISorted<string> keys = dict.Keys; |
| Assert.IsTrue(keys.IsReadOnly); |
| Assert.AreEqual("R", keys.FindMin()); |
| Assert.AreEqual("T", keys.FindMax()); |
| Assert.IsTrue(keys.Contains("S")); |
| Assert.AreEqual(3, keys.Count); |
| // This doesn't hold, maybe because the dict uses a special key comparer? |
| // Assert.IsTrue(keys.SequencedEquals(new WrappedArray<string>(new string[] { "R", "S", "T" }))); |
| Assert.IsTrue(keys.UniqueItems().All(delegate (String s) { return s == "R" || s == "S" || s == "T"; })); |
| Assert.IsTrue(keys.All(delegate (String s) { return s == "R" || s == "S" || s == "T"; })); |
| Assert.IsFalse(keys.Exists(delegate (String s) { return s != "R" && s != "S" && s != "T"; })); |
| String res; |
| Assert.IsTrue(keys.Find(delegate (String s) { return s == "R"; }, out res)); |
| Assert.AreEqual("R", res); |
| Assert.IsFalse(keys.Find(delegate (String s) { return s == "Q"; }, out res)); |
| Assert.AreEqual(null, res); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void KeysISortedPred() |
| { |
| ISorted<string> keys = dict.Keys; |
| String res; |
| Assert.IsTrue(keys.TryPredecessor("S", out res)); |
| Assert.AreEqual("R", res); |
| Assert.IsTrue(keys.TryWeakPredecessor("R", out res)); |
| Assert.AreEqual("R", res); |
| Assert.IsTrue(keys.TrySuccessor("S", out res)); |
| Assert.AreEqual("T", res); |
| Assert.IsTrue(keys.TryWeakSuccessor("T", out res)); |
| Assert.AreEqual("T", res); |
| Assert.IsFalse(keys.TryPredecessor("R", out res)); |
| Assert.AreEqual(null, res); |
| Assert.IsFalse(keys.TryWeakPredecessor("P", out res)); |
| Assert.AreEqual(null, res); |
| Assert.IsFalse(keys.TrySuccessor("T", out res)); |
| Assert.AreEqual(null, res); |
| Assert.IsFalse(keys.TryWeakSuccessor("U", out res)); |
| Assert.AreEqual(null, res); |
| |
| Assert.AreEqual("R", keys.Predecessor("S")); |
| Assert.AreEqual("R", keys.WeakPredecessor("R")); |
| Assert.AreEqual("T", keys.Successor("S")); |
| Assert.AreEqual("T", keys.WeakSuccessor("T")); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void ValuesEnumerator() |
| { |
| SCG.IEnumerator<string> values = dict.Values.GetEnumerator(); |
| Assert.AreEqual(3, dict.Values.Count); |
| Assert.IsTrue(values.MoveNext()); |
| Assert.AreEqual("C", values.Current); |
| Assert.IsTrue(values.MoveNext()); |
| Assert.AreEqual("A", values.Current); |
| Assert.IsTrue(values.MoveNext()); |
| Assert.AreEqual("B", values.Current); |
| Assert.IsFalse(values.MoveNext()); |
| } |
| |
| [Test, LuceneNetSpecific] |
| public void Fun() |
| { |
| Assert.AreEqual("B", dict.Func("T")); |
| } |
| |
| |
| [Test, LuceneNetSpecific] |
| public void NormalUse() |
| { |
| Assert.IsTrue(dictenum.MoveNext()); |
| Assert.AreEqual(dictenum.Current, new KeyValuePair<string, string>("R", "C")); |
| Assert.IsTrue(dictenum.MoveNext()); |
| Assert.AreEqual(dictenum.Current, new KeyValuePair<string, string>("S", "A")); |
| Assert.IsTrue(dictenum.MoveNext()); |
| Assert.AreEqual(dictenum.Current, new KeyValuePair<string, string>("T", "B")); |
| Assert.IsFalse(dictenum.MoveNext()); |
| } |
| } |
| |
| |
| namespace PathCopyPersistence |
| { |
| [TestFixture] |
| public class Simple |
| { |
| private TreeDictionary<string, string> dict; |
| |
| private TreeDictionary<string, string> snap; |
| |
| |
| [SetUp] |
| public void Init() |
| { |
| dict = new TreeDictionary<string, string>(new SC()); |
| dict["S"] = "A"; |
| dict["T"] = "B"; |
| dict["R"] = "C"; |
| dict["V"] = "G"; |
| snap = (TreeDictionary<string, string>)dict.Snapshot(); |
| } |
| |
| |
| [Test, LuceneNetSpecific] |
| public void Test() |
| { |
| dict["SS"] = "D"; |
| Assert.AreEqual(5, dict.Count); |
| Assert.AreEqual(4, snap.Count); |
| dict["T"] = "bb"; |
| Assert.AreEqual(5, dict.Count); |
| Assert.AreEqual(4, snap.Count); |
| Assert.AreEqual("B", snap["T"]); |
| Assert.AreEqual("bb", dict["T"]); |
| Assert.IsFalse(dict.IsReadOnly); |
| Assert.IsTrue(snap.IsReadOnly); |
| //Finally, update of root node: |
| TreeDictionary<string, string> snap2 = (TreeDictionary<string, string>)dict.Snapshot(); |
| dict["S"] = "abe"; |
| Assert.AreEqual("abe", dict["S"]); |
| } |
| |
| |
| [Test, LuceneNetSpecific] |
| public void UpdateSnap() |
| { |
| Assert.Throws<ReadOnlyCollectionException>(() => snap["Y"] = "J"); |
| } |
| |
| |
| [TearDown] |
| public void Dispose() |
| { |
| dict = null; |
| snap = null; |
| } |
| } |
| } |
| } |
| |