You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2016/11/10 11:33:13 UTC
[02/58] [abbrv] lucenenet git commit: Added TreeSet and
TreeDictionary from C5 to the Support namespace
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5f198526/src/Lucene.Net.Tests/core/Support/TestTreeDictionary.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Support/TestTreeDictionary.cs b/src/Lucene.Net.Tests/core/Support/TestTreeDictionary.cs
new file mode 100644
index 0000000..2ea7c90
--- /dev/null
+++ b/src/Lucene.Net.Tests/core/Support/TestTreeDictionary.cs
@@ -0,0 +1,522 @@
+\ufeff/*
+ 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.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;
+ }
+ }
+ }
+}
+