mcs/class/Mono.C5/current/Test/trees/Dictionary.cs

   1 /*\r
   2  Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft\r
   3  Permission is hereby granted, free of charge, to any person obtaining a copy\r
   4  of this software and associated documentation files (the "Software"), to deal\r
   5  in the Software without restriction, including without limitation the rights\r
   6  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   7  copies of the Software, and to permit persons to whom the Software is\r
   8  furnished to do so, subject to the following conditions:\r
   9  \r
  10  The above copyright notice and this permission notice shall be included in\r
  11  all copies or substantial portions of the Software.\r
  12  \r
  13  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  14  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  15  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  16  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  17  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  18  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
  19  SOFTWARE.\r
  20 */\r
  21 \r
  22 using System;\r
  23 using C5;\r
  24 using NUnit.Framework;\r
  25 using SCG=System.Collections.Generic;\r
  26 \r
  27 \r
  28 namespace C5UnitTests.trees.RBDictionary\r
  29 {\r
  30   static class Factory\r
  31   {\r
  32     public static IDictionary<K,V> New<K,V>() { return new TreeDictionary<K,V>(); }\r
  33   }\r
  34 \r
  35 \r
  36   [TestFixture]\r
  37   public class Formatting\r
  38   {\r
  39     IDictionary<int,int> coll;\r
  40     IFormatProvider rad16;\r
  41     [SetUp]\r
  42     public void Init() { coll = Factory.New<int,int>(); rad16 = new RadixFormatProvider(16); }\r
  43     [TearDown]\r
  44     public void Dispose() { coll = null; rad16 = null; }\r
  45     [Test]\r
  46     public void Format()\r
  47     {\r
  48       Assert.AreEqual("[  ]", coll.ToString());\r
  49       coll.Add(23, 67); coll.Add(45, 89);\r
  50       Assert.AreEqual("[ 23 => 67, 45 => 89 ]", coll.ToString());\r
  51       Assert.AreEqual("[ 17 => 43, 2D => 59 ]", coll.ToString(null, rad16));\r
  52       Assert.AreEqual("[ 23 => 67, ... ]", coll.ToString("L14", null));\r
  53       Assert.AreEqual("[ 17 => 43, ... ]", coll.ToString("L14", rad16));\r
  54     }\r
  55   }\r
  56 \r
  57   [TestFixture]\r
  58   public class RBDict\r
  59         {\r
  60                 private TreeDictionary<string,string> dict;\r
  61 \r
  62 \r
  63                 [SetUp]\r
  64                 public void Init() { dict = new TreeDictionary<string,string>(new SC()); }\r
  65 \r
  66 \r
  67                 [TearDown]\r
  68                 public void Dispose() { dict = null; }\r
  69 \r
  70     [Test]\r
  71     [ExpectedException(typeof(NullReferenceException))]\r
  72     public void NullEqualityComparerinConstructor1()\r
  73     {\r
  74       new TreeDictionary<int,int>(null);\r
  75     }\r
  76 \r
  77     [Test]\r
  78     public void Choose()\r
  79     {\r
  80       dict.Add("YES","NO");\r
  81       Assert.AreEqual(new KeyValuePair<string,string>("YES","NO"), dict.Choose());\r
  82     }\r
  83 \r
  84     [Test]\r
  85     [ExpectedException(typeof(NoSuchItemException))]\r
  86     public void BadChoose()\r
  87     {\r
  88       dict.Choose();\r
  89     }\r
  90 \r
  91                 [Test]\r
  92                 public void Pred()\r
  93                 {\r
  94                         dict.Add("A", "1");\r
  95                         dict.Add("C", "2");\r
  96                         dict.Add("E", "3");\r
  97                         Assert.AreEqual("1", dict.Predecessor("B").Value);\r
  98                         Assert.AreEqual("1", dict.Predecessor("C").Value);\r
  99                         Assert.AreEqual("1", dict.WeakPredecessor("B").Value);\r
 100                         Assert.AreEqual("2", dict.WeakPredecessor("C").Value);\r
 101                         Assert.AreEqual("2", dict.Successor("B").Value);\r
 102                         Assert.AreEqual("3", dict.Successor("C").Value);\r
 103                         Assert.AreEqual("2", dict.WeakSuccessor("B").Value);\r
 104                         Assert.AreEqual("2", dict.WeakSuccessor("C").Value);\r
 105                 }\r
 106 \r
 107 \r
 108                 [Test]\r
 109                 public void Initial()\r
 110                 {\r
 111                         bool res;\r
 112                         Assert.IsFalse(dict.IsReadOnly);\r
 113 \r
 114                         Assert.AreEqual(dict.Count, 0, "new dict should be empty");\r
 115                         dict.Add("A", "B");\r
 116                         Assert.AreEqual(dict.Count, 1, "bad count");\r
 117                         Assert.AreEqual(dict["A"], "B", "Wrong value for dict[A]");\r
 118                         dict.Add("C", "D");\r
 119                         Assert.AreEqual(dict.Count, 2, "bad count");\r
 120                         Assert.AreEqual(dict["A"], "B", "Wrong value");\r
 121                         Assert.AreEqual(dict["C"], "D", "Wrong value");\r
 122                         res = dict.Remove("A");\r
 123                         Assert.IsTrue(res, "bad return value from Remove(A)");\r
 124                         Assert.IsTrue(dict.Check());\r
 125                         Assert.AreEqual(dict.Count, 1, "bad count");\r
 126                         Assert.AreEqual(dict["C"], "D", "Wrong value of dict[C]");\r
 127                         res = dict.Remove("Z");\r
 128                         Assert.IsFalse(res, "bad return value from Remove(Z)");\r
 129                         Assert.AreEqual(dict.Count, 1, "bad count");\r
 130                         Assert.AreEqual(dict["C"], "D", "Wrong value of dict[C] (2)");\r
 131                         dict.Clear();\r
 132                         Assert.AreEqual(dict.Count, 0, "dict should be empty");\r
 133                 }\r
 134                 [Test]\r
 135                 public void Contains()\r
 136                 {\r
 137                         dict.Add("C", "D");\r
 138                         Assert.IsTrue(dict.Contains("C"));\r
 139                         Assert.IsFalse(dict.Contains("D"));\r
 140                 }\r
 141 \r
 142 \r
 143                 [Test]\r
 144                 [ExpectedException(typeof(DuplicateNotAllowedException), "Key being added: 'A'")]\r
 145                 public void IllegalAdd()\r
 146                 {\r
 147                         dict.Add("A", "B");\r
 148                         dict.Add("A", "B");\r
 149                 }\r
 150 \r
 151 \r
 152                 [Test]\r
 153     [ExpectedException(typeof(NoSuchItemException))]\r
 154     public void GettingNonExisting()\r
 155                 {\r
 156                         Console.WriteLine(dict["R"]);\r
 157                 }\r
 158 \r
 159 \r
 160                 [Test]\r
 161                 public void Setter()\r
 162                 {\r
 163                         dict["R"] = "UYGUY";\r
 164                         Assert.AreEqual(dict["R"], "UYGUY");\r
 165                         dict["R"] = "UIII";\r
 166                         Assert.AreEqual(dict["R"], "UIII");\r
 167                         dict["S"] = "VVV";\r
 168                         Assert.AreEqual(dict["R"], "UIII");\r
 169                         Assert.AreEqual(dict["S"], "VVV");\r
 170                         //dict.dump();\r
 171                 }\r
 172         }\r
 173 \r
 174         [TestFixture]\r
 175         public class Enumerators\r
 176         {\r
 177                 private TreeDictionary<string,string> dict;\r
 178 \r
 179                 private SCG.IEnumerator<KeyValuePair<string,string>> dictenum;\r
 180 \r
 181 \r
 182                 [SetUp]\r
 183                 public void Init()\r
 184                 {\r
 185                         dict = new TreeDictionary<string,string>(new SC());\r
 186                         dict["S"] = "A";\r
 187                         dict["T"] = "B";\r
 188                         dict["R"] = "C";\r
 189                         dictenum = dict.GetEnumerator();\r
 190                 }\r
 191 \r
 192 \r
 193                 [TearDown]\r
 194                 public void Dispose()\r
 195                 {\r
 196                         dictenum = null;\r
 197                         dict = null;\r
 198                 }\r
 199 \r
 200 \r
 201 \r
 202                 [Test]\r
 203                 public void Keys()\r
 204                 {\r
 205                         SCG.IEnumerator<string> keys = dict.Keys.GetEnumerator();\r
 206                         Assert.AreEqual(3, dict.Keys.Count);\r
 207                         Assert.IsTrue(keys.MoveNext());\r
 208                         Assert.AreEqual("R",keys.Current);\r
 209                         Assert.IsTrue(keys.MoveNext());\r
 210                         Assert.AreEqual("S",keys.Current);\r
 211                         Assert.IsTrue(keys.MoveNext());\r
 212                         Assert.AreEqual("T",keys.Current);\r
 213                         Assert.IsFalse(keys.MoveNext());\r
 214                 }\r
 215 \r
 216                 [Test]\r
 217                 public void Values()\r
 218                 {\r
 219                         SCG.IEnumerator<string> values = dict.Values.GetEnumerator();\r
 220                         Assert.AreEqual(3, dict.Values.Count);\r
 221                         Assert.IsTrue(values.MoveNext());\r
 222                         Assert.AreEqual("C",values.Current);\r
 223                         Assert.IsTrue(values.MoveNext());\r
 224                         Assert.AreEqual("A",values.Current);\r
 225                         Assert.IsTrue(values.MoveNext());\r
 226                         Assert.AreEqual("B",values.Current);\r
 227                         Assert.IsFalse(values.MoveNext());\r
 228                 }\r
 229 \r
 230     [Test]\r
 231     public void Fun()\r
 232     {\r
 233       Assert.AreEqual("B", dict.Fun("T"));\r
 234     }\r
 235 \r
 236 \r
 237                 [Test]\r
 238                 public void NormalUse()\r
 239                 {\r
 240                         Assert.IsTrue(dictenum.MoveNext());\r
 241                         Assert.AreEqual(dictenum.Current, new KeyValuePair<string,string>("R", "C"));\r
 242                         Assert.IsTrue(dictenum.MoveNext());\r
 243                         Assert.AreEqual(dictenum.Current, new KeyValuePair<string,string>("S", "A"));\r
 244                         Assert.IsTrue(dictenum.MoveNext());\r
 245                         Assert.AreEqual(dictenum.Current, new KeyValuePair<string,string>("T", "B"));\r
 246                         Assert.IsFalse(dictenum.MoveNext());\r
 247                 }\r
 248         }\r
 249 \r
 250 \r
 251 \r
 252 \r
 253         namespace PathCopyPersistence\r
 254         {\r
 255                 [TestFixture]\r
 256                 public class Simple\r
 257                 {\r
 258                         private TreeDictionary<string,string> dict;\r
 259 \r
 260                         private TreeDictionary<string,string> snap;\r
 261 \r
 262 \r
 263                         [SetUp]\r
 264                         public void Init()\r
 265                         {\r
 266                                 dict = new TreeDictionary<string,string>(new SC());\r
 267                                 dict["S"] = "A";\r
 268                                 dict["T"] = "B";\r
 269                                 dict["R"] = "C";\r
 270                                 dict["V"] = "G";\r
 271                                 snap = (TreeDictionary<string,string>)dict.Snapshot();\r
 272                         }\r
 273 \r
 274 \r
 275                         [Test]\r
 276                         public void Test()\r
 277                         {\r
 278                                 dict["SS"] = "D";\r
 279                                 Assert.AreEqual(5, dict.Count);\r
 280                                 Assert.AreEqual(4, snap.Count);\r
 281                                 dict["T"] = "bb";\r
 282                                 Assert.AreEqual(5, dict.Count);\r
 283                                 Assert.AreEqual(4, snap.Count);\r
 284                                 Assert.AreEqual("B", snap["T"]);\r
 285                                 Assert.AreEqual("bb", dict["T"]);\r
 286                                 Assert.IsFalse(dict.IsReadOnly);\r
 287                                 Assert.IsTrue(snap.IsReadOnly);\r
 288                                 //Finally, update of root node:\r
 289                                 TreeDictionary<string,string> snap2 = (TreeDictionary<string,string>)dict.Snapshot();\r
 290                                 dict["S"] = "abe";\r
 291                                 Assert.AreEqual("abe", dict["S"]);\r
 292                         }\r
 293 \r
 294 \r
 295                         [Test]\r
 296                         [ExpectedException(typeof(ReadOnlyCollectionException))]\r
 297                         public void UpdateSnap()\r
 298                         {\r
 299                                 snap["Y"] = "J";\r
 300                         }\r
 301 \r
 302 \r
 303                         [TearDown]\r
 304                         public void Dispose()\r
 305                         {\r
 306                                 dict = null;\r
 307                                 snap = null;\r
 308                         }\r
 309                 }\r
 310         }\r
 311 }\r