mcs/class/corlib/Test/System.Collections/HashtableTest.cs

   1 // HashtableTest.cs - NUnit Test Cases for the System.Collections.Hashtable class\r
   2 //\r
   3 //\r
   4 // (C) Ximian, Inc.  http://www.ximian.com\r
   5 // \r
   6 \r
   7 \r
   8 using System;\r
   9 using System.Collections;\r
  10 \r
  11 using System.IO;\r
  12 using System.Runtime.Serialization;\r
  13 using System.Runtime.Serialization.Formatters;\r
  14 using System.Runtime.Serialization.Formatters.Binary;\r
  15 \r
  16 using NUnit.Framework;\r
  17 \r
  18 \r
  19 \r
  20 namespace MonoTests.System.Collections {\r
  21 \r
  22 \r
  23 /// <summary>Hashtable test.</summary>\r
  24 [TestFixture]\r
  25 public class HashtableTest : Assertion {\r
  26 \r
  27         [Test]\r
  28         public void TestCtor1() {\r
  29                 Hashtable h = new Hashtable();\r
  30                 AssertNotNull("No hash table", h);\r
  31         }\r
  32 \r
  33         [Test]\r
  34         public void TestCtor2() {\r
  35                 {\r
  36                         bool errorThrown = false;\r
  37                         try {\r
  38                                 Hashtable h = new Hashtable((IDictionary) null);\r
  39                         } catch (ArgumentNullException) {\r
  40                                 errorThrown = true;\r
  41                         }\r
  42                         Assert("null hashtable error not thrown", \r
  43                                errorThrown);\r
  44                 }\r
  45                 {\r
  46                         string[] keys = {"this", "is", "a", "test"};\r
  47                         char[] values = {'a', 'b', 'c', 'd'};\r
  48                         Hashtable h1 = new Hashtable();\r
  49                         for (int i = 0; i < keys.Length; i++) {\r
  50                                 h1[keys[i]] = values[i];\r
  51                         }\r
  52                         Hashtable h2 = new Hashtable(h1);\r
  53                         for (int i = 0; i < keys.Length; i++) {\r
  54                                 AssertEquals("No match for key " + keys[i],\r
  55                                              values[i], h2[keys[i]]);\r
  56                         }\r
  57                 }\r
  58         }\r
  59 \r
  60         [Test]\r
  61         [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
  62         public void TestCtor3 ()\r
  63         {\r
  64                 Hashtable h = new Hashtable ();\r
  65                 Hashtable hh = new Hashtable (h, Single.NaN);\r
  66         }\r
  67 \r
  68         [Test]\r
  69         [ExpectedException (typeof (ArgumentException))]\r
  70         public void TestCtor4 ()\r
  71         {\r
  72                 Hashtable ht = new Hashtable (Int32.MaxValue, 0.1f, null, null);\r
  73         }\r
  74 \r
  75         [Test]\r
  76         public void TestCtor5 ()\r
  77         {\r
  78                 // tests if negative capacity throws exception\r
  79                 try {\r
  80                         Hashtable ht = new Hashtable (-10, 0.1f, null, null);\r
  81                         Assert("must throw ArgumentOutOfRange exception, param: capacity", false);\r
  82                 } catch (ArgumentOutOfRangeException e) {\r
  83                         Assert("ParamName is not capacity", e.ParamName == "capacity");\r
  84                 }\r
  85 \r
  86                 // tests if loadFactor out of range throws exception (low)\r
  87                 try {\r
  88                         Hashtable ht = new Hashtable (100, 0.01f, null, null);\r
  89                         Assert("must throw ArgumentOutOfRange exception, param: loadFactor, too low value", false);\r
  90                 }       catch (ArgumentOutOfRangeException e) \r
  91                 {\r
  92                         Assert("ParamName is not loadFactor",e.ParamName == "loadFactor");\r
  93                 }\r
  94 \r
  95                 // tests if loadFactor out of range throws exception (high)\r
  96                 try \r
  97                 {\r
  98                         Hashtable ht = new Hashtable (100, 2f, null, null);\r
  99                         Assert("must throw ArgumentOutOfRange exception, param: loadFactor, too high value", false);\r
 100                 }       \r
 101                 catch (ArgumentOutOfRangeException e) \r
 102                 {\r
 103                         Assert("ParamName is not loadFactor", e.ParamName == "loadFactor");\r
 104                 }\r
 105 \r
 106         }\r
 107 \r
 108         // TODO - Ctors for capacity and load (how to test? any access?)\r
 109         // TODO - Ctors with IComparer, IHashCodeProvider, Serialization\r
 110 \r
 111         [Test]  \r
 112         public void TestCount() {\r
 113                 Hashtable h = new Hashtable();\r
 114                 AssertEquals("new table - count zero", 0, h.Count);\r
 115                 int max = 100;\r
 116                 for (int i = 1; i <= max; i++) {\r
 117                         h[i] = i;\r
 118                         AssertEquals("Count wrong for " + i,\r
 119                                      i, h.Count);\r
 120                 }\r
 121                 for (int i = 1; i <= max; i++) {\r
 122                         h[i] = i * 2;\r
 123                         AssertEquals("Count shouldn't change at " + i,\r
 124                                      max, h.Count);\r
 125                 }\r
 126         }\r
 127 \r
 128         [Test]        \r
 129         public void TestIsFixedSize() {\r
 130                 Hashtable h = new Hashtable();\r
 131                 AssertEquals("hashtable not fixed by default",\r
 132                              false, h.IsFixedSize);\r
 133                 // TODO - any way to get a fixed-size hashtable?\r
 134         }\r
 135 \r
 136         public void TestIsReadOnly() {\r
 137                 Hashtable h = new Hashtable();\r
 138                 AssertEquals("hashtable not read-only by default",\r
 139                              false, h.IsReadOnly);\r
 140                 // TODO - any way to get a read-only hashtable?\r
 141         }\r
 142 \r
 143         [Test]        \r
 144         public void TestIsSynchronized ()\r
 145         {\r
 146                 Hashtable h = new Hashtable ();\r
 147                 Assert ("hashtable not synched by default", !h.IsSynchronized);\r
 148 \r
 149                 Hashtable h2 = Hashtable.Synchronized (h);\r
 150                 Assert ("hashtable should by synched", h2.IsSynchronized);\r
 151 \r
 152                 Hashtable h3 = (Hashtable) h2.Clone ();\r
 153                 Assert ("Cloned Hashtable should by synched", h3.IsSynchronized);\r
 154         }\r
 155 \r
 156         [Test]\r
 157         public void TestItem() {\r
 158                 {\r
 159                         bool errorThrown = false;\r
 160                         try {\r
 161                                 Hashtable h = new Hashtable();\r
 162                                 Object o = h[null];\r
 163                         } catch (ArgumentNullException e) {\r
 164                                 errorThrown = true;\r
 165                                 AssertEquals("ParamName is not \"key\"", "key", e.ParamName);\r
 166                         }\r
 167                         Assert("null hashtable error not thrown", \r
 168                                errorThrown);\r
 169                 }\r
 170                 // TODO - if read-only and/or fixed-size is possible,\r
 171                 //        test 'NotSupportedException' here\r
 172 \r
 173                 {\r
 174                         Hashtable h = new Hashtable();\r
 175                         int max = 100;\r
 176                         for (int i = 1; i <= max; i++) {\r
 177                                 h[i] = i;\r
 178                                 AssertEquals("value wrong for " + i,\r
 179                                              i, h[i]);\r
 180                         }\r
 181                 }\r
 182         }\r
 183 \r
 184         [Test]\r
 185         public void TestKeys() {\r
 186                 string[] keys = {"this", "is", "a", "test"};\r
 187                 string[] keys2 = {"new", "keys"};\r
 188                 char[] values1 = {'a', 'b', 'c', 'd'};\r
 189                 char[] values2 = {'e', 'f', 'g', 'h'};\r
 190                 ICollection keysReference, keysReference2;\r
 191                 Hashtable h1 = new Hashtable();\r
 192                 for (int i = 0; i < keys.Length; i++) {\r
 193                         h1[keys[i]] = values1[i];\r
 194                 }\r
 195                 AssertEquals("keys wrong size",\r
 196                              keys.Length, h1.Keys.Count);\r
 197                 for (int i = 0; i < keys.Length; i++) {\r
 198                         h1[keys[i]] = values2[i];\r
 199                 }\r
 200                 AssertEquals("keys wrong size 2",\r
 201                              keys.Length, h1.Keys.Count);\r
 202 \r
 203                 // MS .NET Always returns the same reference when calling Keys property\r
 204                 keysReference = h1.Keys;\r
 205             keysReference2 = h1.Keys;\r
 206                 AssertEquals("keys references differ", keysReference, keysReference2);\r
 207 \r
 208                 for (int i = 0; i < keys2.Length; i++) \r
 209                 {\r
 210                         h1[keys2[i]] = values2[i];\r
 211                 }\r
 212                 AssertEquals("keys wrong size 3",\r
 213                         keys.Length+keys2.Length, h1.Keys.Count);\r
 214                 AssertEquals("keys wrong size 4",\r
 215                         keys.Length+keys2.Length, keysReference.Count);\r
 216         }\r
 217 \r
 218         // TODO - SyncRoot\r
 219         [Test]        \r
 220         public void TestValues() {\r
 221                 string[] keys = {"this", "is", "a", "test"};\r
 222                 char[] values1 = {'a', 'b', 'c', 'd'};\r
 223                 char[] values2 = {'e', 'f', 'g', 'h'};\r
 224                 Hashtable h1 = new Hashtable();\r
 225                 for (int i = 0; i < keys.Length; i++) {\r
 226                         h1[keys[i]] = values1[i];\r
 227                 }\r
 228                 AssertEquals("values wrong size",\r
 229                              keys.Length, h1.Values.Count);\r
 230                 for (int i = 0; i < keys.Length; i++) {\r
 231                         h1[keys[i]] = values2[i];\r
 232                 }\r
 233                 AssertEquals("values wrong size 2",\r
 234                              keys.Length, h1.Values.Count);\r
 235 \r
 236                 // MS .NET Always returns the same reference when calling Values property\r
 237                 ICollection valuesReference1 = h1.Values;\r
 238                 ICollection valuesReference2 = h1.Values;\r
 239                 AssertEquals("values references differ", valuesReference1, valuesReference2);\r
 240         }\r
 241 \r
 242         [Test]\r
 243         public void TestAdd() {\r
 244                 {\r
 245                         bool errorThrown = false;\r
 246                         try {\r
 247                                 Hashtable h = new Hashtable();\r
 248                                 h.Add(null, "huh?");\r
 249                         } catch (ArgumentNullException e) {\r
 250                                 errorThrown = true;\r
 251                                 AssertEquals("ParamName is not 'key'", "key", e.ParamName);\r
 252                         }\r
 253                         Assert("null add error not thrown", \r
 254                                errorThrown);\r
 255                 }\r
 256                 {\r
 257                         bool errorThrown = false;\r
 258                         try {\r
 259                                 Hashtable h = new Hashtable();\r
 260                                 h.Add('a', 1);\r
 261                                 h.Add('a', 2);\r
 262                         } catch (ArgumentException) {\r
 263                                 errorThrown = true;\r
 264                         }\r
 265                         Assert("re-add error not thrown", \r
 266                                errorThrown);\r
 267                 }\r
 268                 // TODO - hit NotSupportedException\r
 269                 {\r
 270                         Hashtable h = new Hashtable();\r
 271                         int max = 100;\r
 272                         for (int i = 1; i <= max; i++) {\r
 273                                 h.Add(i, i);\r
 274                                 AssertEquals("value wrong for " + i,\r
 275                                              i, h[i]);\r
 276                         }\r
 277                 }\r
 278         }\r
 279 \r
 280         [Test]\r
 281         public void TestClear() {\r
 282                 // TODO - hit NotSupportedException\r
 283                 Hashtable h = new Hashtable();\r
 284                 AssertEquals("new table - count zero", 0, h.Count);\r
 285                 int max = 100;\r
 286                 for (int i = 1; i <= max; i++) {\r
 287                         h[i] = i;\r
 288                 }\r
 289                 Assert("table don't gots stuff", h.Count > 0);\r
 290                 h.Clear();\r
 291                 AssertEquals("Table should be cleared",\r
 292                              0, h.Count);\r
 293         }\r
 294 \r
 295         [Test]\r
 296         public void TestClone() {\r
 297                 {\r
 298                         char[] c1 = {'a', 'b', 'c'};\r
 299                         char[] c2 = {'d', 'e', 'f'};\r
 300                         Hashtable h1 = new Hashtable();\r
 301                         for (int i = 0; i < c1.Length; i++) {\r
 302                                 h1[c1[i]] = c2[i];\r
 303                         }\r
 304                         Hashtable h2 = (Hashtable)h1.Clone();\r
 305                         AssertNotNull("got no clone!", h2);\r
 306                         AssertNotNull("clone's got nothing!", h2[c1[0]]);\r
 307                         for (int i = 0; i < c1.Length; i++) {\r
 308                                 AssertEquals("Hashtable match", \r
 309                                              h1[c1[i]], h2[c1[i]]);\r
 310                         }\r
 311                 }\r
 312                 {\r
 313                         char[] c1 = {'a', 'b', 'c'};\r
 314                         char[] c20 = {'1', '2'};\r
 315                         char[] c21 = {'3', '4'};\r
 316                         char[] c22 = {'5', '6'};\r
 317                         char[][] c2 = {c20, c21, c22};\r
 318                         Hashtable h1 = new Hashtable();\r
 319                         for (int i = 0; i < c1.Length; i++) {\r
 320                                 h1[c1[i]] = c2[i];\r
 321                         }\r
 322                         Hashtable h2 = (Hashtable)h1.Clone();\r
 323                         AssertNotNull("got no clone!", h2);\r
 324                         AssertNotNull("clone's got nothing!", h2[c1[0]]);\r
 325                         for (int i = 0; i < c1.Length; i++) {\r
 326                                 AssertEquals("Hashtable match", \r
 327                                              h1[c1[i]], h2[c1[i]]);\r
 328                         }\r
 329 \r
 330                         ((char[])h1[c1[0]])[0] = 'z';\r
 331                         AssertEquals("shallow copy", h1[c1[0]], h2[c1[0]]);\r
 332                 }\r
 333         }\r
 334 \r
 335         [Test]\r
 336         public void TestContains() {\r
 337                 {\r
 338                         bool errorThrown = false;\r
 339                         try {\r
 340                                 Hashtable h = new Hashtable();\r
 341                                 bool result = h.Contains(null);\r
 342                         } catch (ArgumentNullException e) {\r
 343                                 errorThrown = true;\r
 344                                 AssertEquals("ParamName is not 'key'", "key", e.ParamName);\r
 345                         }\r
 346                         Assert("null add error not thrown", \r
 347                                errorThrown);\r
 348                 }\r
 349                 {\r
 350                         Hashtable h = new Hashtable();\r
 351                         for (int i = 0; i < 10000; i += 2) \r
 352                         {\r
 353                                 h[i] = i;\r
 354                         }\r
 355                         for (int i = 0; i < 10000; i += 2) \r
 356                         {\r
 357                                 Assert("hashtable must contain"+i.ToString(), h.Contains(i));\r
 358                                 Assert("hashtable does not contain "+((int)(i+1)).ToString(), !h.Contains(i+1));\r
 359                         }\r
 360                 }\r
 361         }\r
 362 \r
 363         [Test]\r
 364         public void TestContainsKey() {\r
 365         {\r
 366                         bool errorThrown = false;\r
 367                         try \r
 368                         {\r
 369                                 Hashtable h = new Hashtable();\r
 370                                 bool result = h.Contains(null);\r
 371                         } \r
 372                         catch (ArgumentNullException e) \r
 373                         {\r
 374                                 errorThrown = true;\r
 375                                 AssertEquals("ParamName is not 'key'", "key", e.ParamName);\r
 376                         }\r
 377                         Assert("null add error not thrown", \r
 378                                 errorThrown);\r
 379                 }\r
 380                 {\r
 381                         Hashtable h = new Hashtable();\r
 382                         for (int i = 0; i < 1000; i += 2) \r
 383                         {\r
 384                                 h[i] = i;\r
 385                         }\r
 386                         for (int i = 0; i < 1000; i += 2) \r
 387                         {\r
 388                                 Assert("hashtable must contain"+i.ToString(), h.Contains(i));\r
 389                                 Assert("hashtable does not contain "+((int)(i+1)).ToString(), !h.Contains(i+1));\r
 390                         }\r
 391                 }\r
 392 \r
 393         }\r
 394 \r
 395         [Test]        \r
 396         public void TestContainsValue() {\r
 397                 {\r
 398                         Hashtable h = new Hashtable();\r
 399                         h['a'] = "blue";\r
 400                         Assert("blue? it's in there!", \r
 401                                h.ContainsValue("blue"));\r
 402                         Assert("green? no way!", \r
 403                                !h.ContainsValue("green"));\r
 404                         Assert("null? no way!", \r
 405                                 !h.ContainsValue(null));\r
 406                         h['b'] = null;\r
 407                         Assert("null? it's in there!", \r
 408                                 h.ContainsValue(null));\r
 409 \r
 410                 }\r
 411         }\r
 412 \r
 413         [Test]\r
 414         public void TestCopyTo() {\r
 415                 {\r
 416                         bool errorThrown = false;\r
 417                         try {\r
 418                                 Hashtable h = new Hashtable();\r
 419                                 h.CopyTo(null, 0);\r
 420                         } catch (ArgumentNullException e) {\r
 421                                 errorThrown = true;\r
 422                                 AssertEquals("ParamName is not \"array\"", "array", e.ParamName); \r
 423                         }\r
 424                         Assert("null hashtable error not thrown", \r
 425                                errorThrown);\r
 426                 }\r
 427                 {\r
 428                         bool errorThrown = false;\r
 429                         try {\r
 430                                 Hashtable h = new Hashtable();\r
 431                                 Object[] o = new Object[1];\r
 432                                 h.CopyTo(o, -1);\r
 433                         } catch (ArgumentOutOfRangeException e) {\r
 434                                 errorThrown = true;\r
 435                                 AssertEquals("ParamName is not \"arrayIndex\"", "arrayIndex", e.ParamName);\r
 436                         }\r
 437                         Assert("out of range error not thrown", \r
 438                                errorThrown);\r
 439                 }\r
 440                 {\r
 441                         bool errorThrown = false;\r
 442                         try {\r
 443                                 Hashtable h = new Hashtable();\r
 444                                 Object[,] o = new Object[1,1];\r
 445                                 h.CopyTo(o, 1);\r
 446                         } catch (ArgumentException) {\r
 447                                 errorThrown = true;\r
 448                         }\r
 449                         Assert("multi-dim array error not thrown", \r
 450                                errorThrown);\r
 451                 }\r
 452                 {\r
 453                         bool errorThrown = false;\r
 454                         try {\r
 455                                 Hashtable h = new Hashtable();\r
 456                                 h['a'] = 1; // no error if table is empty\r
 457                                 Object[] o = new Object[5];\r
 458                                 h.CopyTo(o, 5);\r
 459                         } catch (ArgumentException) {\r
 460                                 errorThrown = true;\r
 461                         }\r
 462                         Assert("no room in array error not thrown", \r
 463                                errorThrown);\r
 464                 }\r
 465                 {\r
 466                         bool errorThrown = false;\r
 467                         try {\r
 468                                 Hashtable h = new Hashtable();\r
 469                                 h['a'] = 1;\r
 470                                 h['b'] = 2;\r
 471                                 h['c'] = 2;\r
 472                                 Object[] o = new Object[2];\r
 473                                 h.CopyTo(o, 0);\r
 474                         } catch (ArgumentException) {\r
 475                                 errorThrown = true;\r
 476                         }\r
 477                         Assert("table too big error not thrown", \r
 478                                errorThrown);\r
 479                 }\r
 480                 {\r
 481                         bool errorThrown = false;\r
 482                         try {\r
 483                                 Hashtable h = new Hashtable();\r
 484                                 h["blue"] = 1;\r
 485                                 h["green"] = 2;\r
 486                                 h["red"] = 3;\r
 487                                 Char[] o = new Char[3];\r
 488                                 h.CopyTo(o, 0);\r
 489                         } catch (InvalidCastException) {\r
 490                                 errorThrown = true;\r
 491                         }\r
 492                         Assert("invalid cast error not thrown", \r
 493                                errorThrown);\r
 494                 }\r
 495 \r
 496                 {\r
 497                         Hashtable h = new Hashtable();\r
 498                         h['a'] = 1;\r
 499                         h['b'] = 2;\r
 500                         DictionaryEntry[] o = new DictionaryEntry[2];\r
 501                         h.CopyTo(o,0);\r
 502 #if TARGET_JVM // Hashtable is not an ordered collection!\r
 503                         if (o[0].Key.Equals('b')) {\r
 504                                 DictionaryEntry v = o[0];\r
 505                                 o[0] = o[1];\r
 506                                 o[1] = v;\r
 507                         }\r
 508 #endif // TARGET_JVM\r
 509                         AssertEquals("first copy fine.", 'a', o[0].Key);\r
 510                         AssertEquals("first copy fine.", 1, o[0].Value);\r
 511                         AssertEquals("second copy fine.", 'b', o[1].Key);\r
 512                         AssertEquals("second copy fine.", 2, o[1].Value);\r
 513                 }\r
 514         }\r
 515 \r
 516         [Test]        \r
 517         public void TestGetEnumerator() {\r
 518                 String[] s1 = {"this", "is", "a", "test"};\r
 519                 Char[] c1 = {'a', 'b', 'c', 'd'};\r
 520                 Hashtable h1 = new Hashtable();\r
 521                 for (int i = 0; i < s1.Length; i++) {\r
 522                         h1[s1[i]] = c1[i];\r
 523                 }\r
 524                 IDictionaryEnumerator en = h1.GetEnumerator();\r
 525                 AssertNotNull("No enumerator", en);\r
 526                 \r
 527                 for (int i = 0; i < s1.Length; i++) {\r
 528                         en.MoveNext();\r
 529                         Assert("Not enumerating for " + en.Key, \r
 530                                Array.IndexOf(s1, en.Key) >= 0);\r
 531                         Assert("Not enumerating for " + en.Value, \r
 532                                Array.IndexOf(c1, en.Value) >= 0);\r
 533                 }\r
 534         }\r
 535 \r
 536         [Test]\r
 537         public void TestSerialization () {\r
 538                 Hashtable table1 = new Hashtable();\r
 539                 Hashtable table2;\r
 540                 Stream str = new MemoryStream ();\r
 541                 BinaryFormatter formatter = new BinaryFormatter();\r
 542 \r
 543                 for (int i = 0; i < 100; i++)\r
 544                         table1[i] = "TestString Key: " + i.ToString();\r
 545                 \r
 546                 formatter.Serialize (str, table1);\r
 547                 str.Position = 0;\r
 548                 table2 = (Hashtable) formatter.Deserialize (str);\r
 549                 \r
 550                 bool result;\r
 551                 foreach (DictionaryEntry de in table1)\r
 552                         AssertEquals (de.Value, table2 [de.Key]);\r
 553         }\r
 554         \r
 555         [Test]\r
 556         [Category ("TargetJvmNotWorking")]\r
 557         public void TestSerialization2 () {\r
 558                 // Test from bug #70570\r
 559                 MemoryStream stream = new MemoryStream();\r
 560                 BinaryFormatter formatter = new BinaryFormatter();\r
 561         \r
 562                 Hashtable table = new Hashtable();\r
 563                 table.Add (new Bug(), "Hello");\r
 564 \r
 565                 formatter.Serialize(stream, table);\r
 566                 stream.Position = 0;\r
 567                 table = (Hashtable) formatter.Deserialize(stream);\r
 568                 AssertEquals ("#1", 1, table.Count);\r
 569         }\r
 570 \r
 571         [Test]        \r
 572         public void TestRemove() {\r
 573                 {\r
 574                         bool errorThrown = false;\r
 575                         try {\r
 576                                 Hashtable h = new Hashtable();\r
 577                                 h.Remove(null);\r
 578                         } catch (ArgumentNullException e) {\r
 579                                 errorThrown = true;\r
 580                                 AssertEquals("ParamName is not \"key\"", "key", e.ParamName);\r
 581                         }\r
 582                         Assert("null hashtable error not thrown", \r
 583                                errorThrown);\r
 584                 }\r
 585                 {\r
 586                         string[] keys = {"this", "is", "a", "test"};\r
 587                         char[] values = {'a', 'b', 'c', 'd'};\r
 588                         Hashtable h = new Hashtable();\r
 589                         for (int i = 0; i < keys.Length; i++) {\r
 590                                 h[keys[i]] = values[i];\r
 591                         }\r
 592                         AssertEquals("not enough in table",\r
 593                                      4, h.Count);\r
 594                         h.Remove("huh?");\r
 595                         AssertEquals("not enough in table",\r
 596                                      4, h.Count);\r
 597                         h.Remove("this");\r
 598                         AssertEquals("Wrong count in table",\r
 599                                      3, h.Count);\r
 600                         h.Remove("this");\r
 601                         AssertEquals("Wrong count in table",\r
 602                                      3, h.Count);\r
 603                 }\r
 604         }\r
 605 \r
 606         [Test]        \r
 607         public void TestSynchronized() {\r
 608                 {\r
 609                         bool errorThrown = false;\r
 610                         try {\r
 611                                 Hashtable h = Hashtable.Synchronized(null);\r
 612                         } catch (ArgumentNullException e) {\r
 613                                 errorThrown = true;\r
 614                                 AssertEquals("ParamName is not \"table\"", "table", e.ParamName);\r
 615                         }\r
 616                         Assert("null hashtable error not thrown", \r
 617                                errorThrown);\r
 618                 }\r
 619                 {\r
 620                         Hashtable h = new Hashtable();\r
 621                         Assert("hashtable not synced by default", \r
 622                                !h.IsSynchronized);\r
 623                         Hashtable h2 = Hashtable.Synchronized(h);\r
 624                         Assert("hashtable should by synced", \r
 625                                h2.IsSynchronized);\r
 626                 }\r
 627         }\r
 628         \r
 629         \r
 630         protected Hashtable ht;\r
 631         private static Random rnd;\r
 632         \r
 633         [SetUp]\r
 634         public void SetUp() {\r
 635                 ht=new Hashtable();\r
 636                 rnd=new Random();\r
 637         }\r
 638         \r
 639         private void SetDefaultData() {\r
 640                 ht.Clear();\r
 641                 ht.Add("k1","another");\r
 642                 ht.Add("k2","yet");\r
 643                 ht.Add("k3","hashtable");\r
 644         }\r
 645         \r
 646         [Test]\r
 647         public void TestAddRemoveClear() {\r
 648                 ht.Clear();\r
 649                 Assert(ht.Count==0);\r
 650                 \r
 651                 SetDefaultData();\r
 652                 Assert(ht.Count==3);\r
 653                 \r
 654                 bool thrown=false;\r
 655                 try {\r
 656                         ht.Add("k2","cool");\r
 657                 } catch (ArgumentException) {thrown=true;}\r
 658                 Assert("Must throw ArgumentException!",thrown);\r
 659                 \r
 660                 ht["k2"]="cool";\r
 661                 Assert(ht.Count==3);\r
 662                 Assert(ht["k2"].Equals("cool"));\r
 663                 \r
 664         }\r
 665 \r
 666         [Test]  \r
 667         public void TestCopyTo2() {\r
 668                 SetDefaultData();\r
 669                 Object[] entries=new Object[ht.Count];\r
 670                 ht.CopyTo(entries,0);\r
 671                 Assert("Not an entry.",entries[0] is DictionaryEntry);\r
 672         }\r
 673 \r
 674         [Test]\r
 675         public void CopyTo_Empty ()\r
 676         {\r
 677                 Hashtable ht = new Hashtable ();\r
 678                 AssertEquals ("Count", 0, ht.Count);\r
 679                 object[] array = new object [ht.Count];\r
 680                 ht.CopyTo (array, 0);\r
 681         }\r
 682         \r
 683         [Test]  \r
 684         public void TestUnderHeavyLoad() {\r
 685                 ht.Clear();\r
 686                 int max=100000;\r
 687                 String[] cache=new String[max*2];\r
 688                 int n=0;\r
 689                 \r
 690                 for (int i=0;i<max;i++) {\r
 691                         int id=rnd.Next()&0xFFFF;\r
 692                         String key=""+id+"-key-"+id;\r
 693                         String val="value-"+id;\r
 694                         if (ht[key]==null) {\r
 695                                 ht[key]=val;\r
 696                                 cache[n]=key;\r
 697                                 cache[n+max]=val;\r
 698                                 n++;\r
 699                         }\r
 700                 }\r
 701                 \r
 702                 Assert(ht.Count==n);\r
 703                 \r
 704                 for (int i=0;i<n;i++) {\r
 705                         String key=cache[i];\r
 706                         String val=ht[key] as String;\r
 707                         String err="ht[\""+key+"\"]=\""+val+\r
 708                                 "\", expected \""+cache[i+max]+"\"";\r
 709                         Assert(err,val!=null && val.Equals(cache[i+max]));\r
 710                 }\r
 711                 \r
 712                 int r1=(n/3);\r
 713                 int r2=r1+(n/5);\r
 714                 \r
 715                 for (int i=r1;i<r2;i++) {\r
 716                         ht.Remove(cache[i]);\r
 717                 }\r
 718                 \r
 719                 \r
 720                 for (int i=0;i<n;i++) {\r
 721                         if (i>=r1 && i<r2) {\r
 722                                 Assert(ht[cache[i]]==null);\r
 723                         } else {\r
 724                                 String key=cache[i];\r
 725                                 String val=ht[key] as String;\r
 726                                 String err="ht[\""+key+"\"]=\""+val+\r
 727                                         "\", expected \""+cache[i+max]+"\"";\r
 728                                 Assert(err,val!=null && val.Equals(cache[i+max]));\r
 729                         }\r
 730                 }\r
 731                 \r
 732                 ICollection keys=ht.Keys;\r
 733                 int nKeys=0;\r
 734                 foreach (Object key in keys) {\r
 735                         Assert((key as String) != null);\r
 736                         nKeys++;\r
 737                 }\r
 738                 Assert(nKeys==ht.Count);\r
 739 \r
 740                 \r
 741                 ICollection vals=ht.Values;\r
 742                 int nVals=0;\r
 743                 foreach (Object val in vals) {\r
 744                         Assert((val as String) != null);\r
 745                         nVals++;\r
 746                 }\r
 747                 Assert(nVals==ht.Count);\r
 748                 \r
 749         }\r
 750 \r
 751         \r
 752         /// <summary>\r
 753         ///  Test hashtable with CaseInsensitiveHashCodeProvider\r
 754         ///  and CaseInsensitive comparer.\r
 755         /// </summary>\r
 756         [Test]        \r
 757         public void TestCaseInsensitive ()\r
 758         {\r
 759                 // Not very meaningfull test, just to make\r
 760                 // sure that hcp is set properly set.\r
 761                 Hashtable ciHashtable = new Hashtable(11,1.0f,CaseInsensitiveHashCodeProvider.Default,CaseInsensitiveComparer.Default);\r
 762                 ciHashtable ["key1"] = "value";\r
 763                 ciHashtable ["key2"] = "VALUE";\r
 764                 Assert(ciHashtable ["key1"].Equals ("value"));\r
 765                 Assert(ciHashtable ["key2"].Equals ("VALUE"));\r
 766 \r
 767                 ciHashtable ["KEY1"] = "new_value";\r
 768                 Assert(ciHashtable ["key1"].Equals ("new_value"));\r
 769 \r
 770         }\r
 771 \r
 772         [Test]\r
 773         public void TestCopyConstructor ()\r
 774         {\r
 775                 SetDefaultData ();\r
 776 \r
 777                 Hashtable htCopy = new Hashtable (ht);\r
 778 \r
 779                 Assert(ht.Count == htCopy.Count);\r
 780         }\r
 781 \r
 782         [Test]\r
 783         public void TestEnumerator ()\r
 784         {\r
 785                 SetDefaultData ();\r
 786 \r
 787                 IEnumerator e = ht.GetEnumerator ();\r
 788 \r
 789                 while (e.MoveNext ()) {}\r
 790 \r
 791                 Assert (!e.MoveNext ());\r
 792 \r
 793         }\r
 794 \r
 795         [Test]\r
 796         [ExpectedException (typeof (ArgumentNullException))]\r
 797         public void GetObjectData_NullSerializationInfo () \r
 798         {\r
 799                 SetDefaultData ();\r
 800                 ht.GetObjectData (null, new StreamingContext ());\r
 801         }\r
 802 \r
 803         // bug #75790\r
 804         [Test]\r
 805         [Category ("NotDotNet")] // .NET raises InvalidOperationException.\r
 806         public void SyncHashtable_ICollectionsGetEnumerator ()\r
 807         {\r
 808                 Hashtable hashtable = Hashtable.Synchronized (new Hashtable ());\r
 809                 hashtable["a"] = 1;\r
 810                 //IEnumerator e = (hashtable.Clone() as\r
 811                 IEnumerator e = (hashtable as ICollection).GetEnumerator ();\r
 812                 //e.Reset();\r
 813                 e.MoveNext ();\r
 814                 DictionaryEntry de = (DictionaryEntry) e.Current;\r
 815         }\r
 816 \r
 817         [Test]\r
 818         public void SerializableSubClasses ()\r
 819         {\r
 820                 Hashtable ht = new Hashtable ();\r
 821                 // see bug #76300\r
 822                 Assert ("Keys.IsSerializable", ht.Keys.GetType ().IsSerializable);\r
 823                 Assert ("Values.IsSerializable", ht.Values.GetType ().IsSerializable);\r
 824                 Assert ("GetEnumerator.IsSerializable", ht.GetEnumerator ().GetType ().IsSerializable);\r
 825                 Assert ("Synchronized.IsSerializable", Hashtable.Synchronized (ht).GetType ().IsSerializable);\r
 826         }\r
 827 }\r
 828 \r
 829 [Serializable]\r
 830 public class Bug :ISerializable {\r
 831 \r
 832         [Serializable]\r
 833         private sealed class InnerClassSerializationHelper : IObjectReference {\r
 834                 public object GetRealObject( StreamingContext context )\r
 835                 {\r
 836                         return new Bug();\r
 837                 }\r
 838         };\r
 839 \r
 840         void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context )\r
 841         {\r
 842                 info.SetType( typeof(InnerClassSerializationHelper) );\r
 843         }\r
 844 };\r
 845 \r
 846 \r
 847 }\r