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

   1 //\r
   2 // System.Collections.DictionaryBase\r
   3 // Test suite for System.Collections.DictionaryBase\r
   4 //\r
   5 // Authors:\r
   6 //      Carlos Alberto Barcenilla (barce@frlp.utn.edu.ar)\r
   7 //\r
   8 \r
   9 using System;\r
  10 using System.Collections;\r
  11 using NUnit.Framework;\r
  12 \r
  13 namespace MonoTests.System.Collections \r
  14 {\r
  15 \r
  16         [TestFixture]\r
  17         public class DictionaryBaseTest: Assertion\r
  18         {\r
  19                 static void Main(string[] args)\r
  20                 {\r
  21                 }\r
  22 \r
  23                 public class ConcreteDictionary : DictionaryBase\r
  24                 {\r
  25                         public bool onInsertFired;\r
  26                         public bool onInsertCompleteFired;\r
  27                         public bool onValidateFired;\r
  28                         public bool onRemoveFired;\r
  29                         public bool onRemoveCompleteFired;\r
  30                         public bool onClearFired;\r
  31                         public bool onClearCompleteFired;\r
  32                         public bool onSetFired;\r
  33                         public bool onSetCompleteFired;\r
  34                         public bool onGetFired;\r
  35 \r
  36                         public bool onInsertMustThrowException;\r
  37                         public bool onInsertCompleteMustThrowException;\r
  38                         public bool onValidateMustThrowException;\r
  39                         public bool onRemoveMustThrowException;\r
  40                         public bool onRemoveCompleteMustThrowException;\r
  41                         public bool onClearMustThrowException;\r
  42                         public bool onClearCompleteMustThrowException;\r
  43                         public bool onSetMustThrowException;\r
  44                         public bool onSetCompleteMustThrowException;\r
  45                         public bool onGetMustThrowException;\r
  46 \r
  47                         public ConcreteDictionary() \r
  48                         {\r
  49                         }\r
  50 \r
  51                         public ConcreteDictionary(int i) \r
  52                         {\r
  53                                 for (int j = 0; j < i; j++) \r
  54                                 {\r
  55                                         ((IDictionary) this).Add(j, j*2);\r
  56                                 }\r
  57 \r
  58                                 ClearFlags();\r
  59                         }\r
  60 \r
  61             public IDictionary BaseDictionary \r
  62                         {\r
  63                                 get { return this.Dictionary; }\r
  64                         }\r
  65 \r
  66                         public void ClearFlags() \r
  67                         {\r
  68                                 onInsertFired = false;\r
  69                                 onInsertCompleteFired = false;\r
  70                                 onValidateFired = false;\r
  71                                 onRemoveFired = false;\r
  72                                 onRemoveCompleteFired = false;\r
  73                                 onClearFired = false;\r
  74                                 onClearCompleteFired = false;\r
  75                                 onSetFired = false;\r
  76                                 onSetCompleteFired = false;\r
  77                                 onGetFired = false;\r
  78                         }\r
  79 \r
  80                         protected override void OnValidate(object key, object value)\r
  81                         {\r
  82                                 onValidateFired = true;\r
  83                                 if (onValidateMustThrowException)\r
  84                                         throw new Exception();\r
  85                                 base.OnValidate (key, value);\r
  86                         }\r
  87 \r
  88                         protected override void OnInsert(object key, object value)\r
  89                         {\r
  90                                 onInsertFired = true;\r
  91                                 if (onInsertMustThrowException)\r
  92                                         throw new Exception();\r
  93                                 base.OnInsert (key, value);\r
  94                         }\r
  95 \r
  96                         protected override void OnInsertComplete(object key, object value)\r
  97                         {\r
  98                                 onInsertCompleteFired = true;\r
  99                                 if (onInsertCompleteMustThrowException)\r
 100                                         throw new Exception();\r
 101                                 base.OnInsertComplete (key, value);\r
 102                         }\r
 103 \r
 104                         protected override void OnRemove(object key, object value)\r
 105                         {\r
 106                                 onRemoveFired = true;\r
 107                                 if (onRemoveMustThrowException)\r
 108                                         throw new Exception();\r
 109                                 base.OnRemove (key, value);\r
 110                         }\r
 111 \r
 112                         protected override void OnRemoveComplete(object key, object value)\r
 113                         {\r
 114                                 onRemoveCompleteFired = true;\r
 115                                 if (onRemoveCompleteMustThrowException)\r
 116                                         throw new Exception();\r
 117                                 base.OnRemoveComplete (key, value);\r
 118                         }\r
 119 \r
 120 \r
 121                         protected override void OnClear()\r
 122                         {\r
 123                                 onClearFired = true;\r
 124                                 if (onClearMustThrowException)\r
 125                                         throw new Exception();\r
 126                                 base.OnClear ();\r
 127                         }\r
 128 \r
 129                         protected override void OnClearComplete()\r
 130                         {\r
 131                                 onClearCompleteFired = true;\r
 132                                 if (onClearCompleteMustThrowException)\r
 133                                         throw new Exception();\r
 134                                 base.OnClearComplete ();\r
 135                         }\r
 136 \r
 137                         protected override object OnGet(object key, object currentValue)\r
 138                         {\r
 139                                 onGetFired = true;\r
 140                                 if (onGetMustThrowException)\r
 141                                         throw new Exception();\r
 142                                 return base.OnGet (key, currentValue);\r
 143                         }\r
 144 \r
 145                         protected override void OnSet(object key, object oldValue, object newValue)\r
 146                         {\r
 147                                 onSetFired = true;\r
 148                                 if (onSetMustThrowException)\r
 149                                         throw new Exception();\r
 150                                 base.OnSet (key, oldValue, newValue);\r
 151                         }\r
 152 \r
 153                         protected override void OnSetComplete(object key, object oldValue, object newValue)\r
 154                         {\r
 155                                 onSetCompleteFired = true;\r
 156                                 if (onSetCompleteMustThrowException)\r
 157                                         throw new Exception();\r
 158                                 base.OnSetComplete (key, oldValue, newValue);\r
 159                         }\r
 160                 }\r
 161 \r
 162                 [Test]\r
 163                 public void Add() \r
 164                 {\r
 165                         ConcreteDictionary myDictionary = new ConcreteDictionary(10);\r
 166                         myDictionary.BaseDictionary.Add(100, 1);\r
 167 \r
 168                         Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 169                         Assert("OnInsert must be fired", myDictionary.onInsertFired);\r
 170                         Assert("OnInsertComplete must be fired", myDictionary.onInsertCompleteFired);\r
 171                         AssertEquals("Count", 11, myDictionary.Count);\r
 172                         AssertEquals(1, myDictionary.BaseDictionary[100]);\r
 173                 }\r
 174 \r
 175                 [Test]\r
 176                 public void AddOnValidateExcept() \r
 177                 {\r
 178                         bool exceptionThrown = false;\r
 179 \r
 180                         ConcreteDictionary myDictionary = new ConcreteDictionary(30);\r
 181                         myDictionary.onValidateMustThrowException = true;\r
 182 \r
 183                         try {\r
 184                                 myDictionary.BaseDictionary.Add(111,222);\r
 185                         } catch {\r
 186                                 exceptionThrown = true;\r
 187                         } finally {\r
 188                                 Assert("Exception must be thrown", exceptionThrown);\r
 189                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 190                                 Assert("OnInsert must not be fired", !myDictionary.onInsertFired);\r
 191                                 Assert("OnInsertComplete must not be fired", !myDictionary.onInsertCompleteFired);\r
 192                                 AssertEquals("Count", 30, myDictionary.Count);\r
 193                         }\r
 194 \r
 195                 }\r
 196 \r
 197                 [Test]\r
 198                 public void AddOnInsertExcept() \r
 199                 {\r
 200                         bool exceptionThrown = false;\r
 201 \r
 202                         ConcreteDictionary myDictionary = new ConcreteDictionary(30);\r
 203                         myDictionary.onInsertMustThrowException = true;\r
 204 \r
 205                         try {\r
 206                                 myDictionary.BaseDictionary.Add(666,222);\r
 207                         } catch {\r
 208                                 exceptionThrown = true;\r
 209                         } finally {\r
 210                                 Assert("Exception must be thrown", exceptionThrown);\r
 211                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 212                                 Assert("OnInsert must be fired", myDictionary.onInsertFired);\r
 213                                 Assert("OnInsertComplete must not be fired", !myDictionary.onInsertCompleteFired);\r
 214                                 AssertEquals("Count", 30, myDictionary.Count);\r
 215                         }\r
 216 \r
 217                 }\r
 218 \r
 219                 [Test]\r
 220                 public void AddOnInsertCompleteExcept() \r
 221                 {\r
 222                         bool exceptionThrown = false;\r
 223 \r
 224                         ConcreteDictionary myDictionary = new ConcreteDictionary(5);\r
 225                         myDictionary.onInsertCompleteMustThrowException = true;\r
 226 \r
 227                         try {\r
 228                                 myDictionary.BaseDictionary.Add(888,999);\r
 229                         } catch {\r
 230                                 exceptionThrown = true;\r
 231                         } finally {\r
 232                                 Assert("Exception must be thrown", exceptionThrown);\r
 233                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 234                                 Assert("OnInsert must be fired", myDictionary.onInsertFired);\r
 235                                 Assert("OnInsertComplete must be fired", myDictionary.onInsertCompleteFired);\r
 236                                 AssertEquals("Count", 5, myDictionary.Count);\r
 237                         }\r
 238 \r
 239                 }\r
 240 \r
 241                 [Test]\r
 242                 public void AddNullKey() \r
 243                 {\r
 244                         bool exceptionThrown = false;\r
 245 \r
 246                         ConcreteDictionary myDictionary = new ConcreteDictionary();\r
 247                         try {\r
 248                                 myDictionary.BaseDictionary.Add(null, 11);\r
 249                         } catch (ArgumentNullException) {\r
 250                                 exceptionThrown = true;\r
 251                         } finally {\r
 252                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 253                                 Assert("OnInsert must be fired", myDictionary.onInsertFired);\r
 254                                 Assert("OnInsertComplete must not be fired", !myDictionary.onInsertCompleteFired);\r
 255                                 Assert("ArgumentNullException must be thrown", exceptionThrown);\r
 256                         }\r
 257                 }\r
 258 \r
 259                 [Test]\r
 260                 public void Clear() \r
 261                 {\r
 262                         ConcreteDictionary myDictionary = new ConcreteDictionary(30);\r
 263                         myDictionary.Clear();\r
 264 \r
 265                         Assert("OnClear must be fired", myDictionary.onClearFired);\r
 266                         Assert("OnClearComplete must be fired", myDictionary.onClearCompleteFired);\r
 267                         AssertEquals("Count", 0, myDictionary.Count);\r
 268                 }\r
 269 \r
 270                 [Test]\r
 271                 public void ClearOnClearExcept() \r
 272                 {\r
 273                         bool exceptionThrown = false;\r
 274 \r
 275                         ConcreteDictionary myDictionary = new ConcreteDictionary(30);\r
 276                         myDictionary.onClearMustThrowException = true;\r
 277 \r
 278                         try {\r
 279                                 myDictionary.Clear();\r
 280                         } catch {\r
 281                                 exceptionThrown = true;\r
 282                         } finally {\r
 283                                 Assert("Exception must be thrown", exceptionThrown);\r
 284                                 Assert("OnClear must be fired", myDictionary.onClearFired);\r
 285                                 Assert("OnClearComplete must not be fired", !myDictionary.onClearCompleteFired);\r
 286                                 AssertEquals("Count", 30, myDictionary.Count);\r
 287                         }\r
 288 \r
 289                 }\r
 290 \r
 291                 [Test]\r
 292                 public void ClearOnClearCompleteExcept() \r
 293                 {\r
 294                         bool exceptionThrown = false;\r
 295 \r
 296                         ConcreteDictionary myDictionary = new ConcreteDictionary(30);\r
 297                         myDictionary.onClearCompleteMustThrowException = true;\r
 298 \r
 299                         try {\r
 300                                 myDictionary.Clear();\r
 301                         } catch {\r
 302                                 exceptionThrown = true;\r
 303                         } finally {\r
 304                                 Assert("Exception must be thrown", exceptionThrown);\r
 305                                 Assert("OnClear must be fired", myDictionary.onClearFired);\r
 306                                 Assert("OnClearComplete must be fired", myDictionary.onClearCompleteFired);\r
 307                                 AssertEquals("Count", 0, myDictionary.Count);\r
 308                         }\r
 309 \r
 310                 }\r
 311 \r
 312                 [Test]\r
 313                 public void Count() \r
 314                 {\r
 315                         ConcreteDictionary myDictionary = new ConcreteDictionary(19);\r
 316                         AssertEquals(19, myDictionary.Count);\r
 317                 }\r
 318 \r
 319                 [Test]\r
 320                 public void Remove() \r
 321                 {\r
 322                         ConcreteDictionary myDictionary = new ConcreteDictionary(8);\r
 323                         myDictionary.BaseDictionary.Remove(5);\r
 324 \r
 325                         Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 326                         Assert("OnRemove must be fired", myDictionary.onRemoveFired);\r
 327                         Assert("OnRemoveComplete must be fired", myDictionary.onRemoveCompleteFired);\r
 328                         AssertEquals("Count", 7, myDictionary.Count);\r
 329                         AssertEquals(null, myDictionary.BaseDictionary[5]);\r
 330                 }\r
 331 \r
 332                 [Test]\r
 333                 public void RemoveOnValidateExcept() \r
 334                 {\r
 335                         bool exceptionThrown = false;\r
 336 \r
 337                         ConcreteDictionary myDictionary = new ConcreteDictionary(28);\r
 338                         myDictionary.onValidateMustThrowException = true;\r
 339 \r
 340                         try {\r
 341                                 myDictionary.BaseDictionary.Remove(11);\r
 342                         } catch {\r
 343                                 exceptionThrown = true;\r
 344                         } finally {\r
 345                                 Assert("Exception must be thrown in this test", exceptionThrown);\r
 346                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 347                                 Assert("OnRemove must not be fired", !myDictionary.onRemoveFired);\r
 348                                 Assert("OnRemoveComplete must not be fired", !myDictionary.onRemoveCompleteFired);\r
 349                                 AssertEquals("Count", 28, myDictionary.Count);\r
 350                                 AssertEquals(22, myDictionary.BaseDictionary[11]);\r
 351                         }\r
 352 \r
 353                 }\r
 354 \r
 355                 [Test]\r
 356                 public void RemoveOnRemoveExcept() \r
 357                 {\r
 358                         bool exceptionThrown = false;\r
 359 \r
 360                         ConcreteDictionary myDictionary = new ConcreteDictionary(28);\r
 361                         myDictionary.onRemoveMustThrowException = true;\r
 362 \r
 363                         try {\r
 364                                 myDictionary.BaseDictionary.Remove(11);\r
 365                         } catch {\r
 366                                 exceptionThrown = true;\r
 367                         } finally {\r
 368                                 Assert("Exception must be thrown", exceptionThrown);\r
 369                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 370                                 Assert("OnRemove must be fired", myDictionary.onRemoveFired);\r
 371                                 Assert("OnRemoveComplete must not be fired", !myDictionary.onRemoveCompleteFired);\r
 372                                 AssertEquals("Count", 28, myDictionary.Count);\r
 373                                 AssertEquals(22, myDictionary.BaseDictionary[11]);\r
 374                         }\r
 375 \r
 376                 }\r
 377 \r
 378                 [Test]\r
 379                 public void RemoveOnRemoveCompleteExcept() \r
 380                 {\r
 381                         bool exceptionThrown = false;\r
 382 \r
 383                         ConcreteDictionary myDictionary = new ConcreteDictionary(28);\r
 384                         myDictionary.onRemoveCompleteMustThrowException = true;\r
 385 \r
 386                         try \r
 387                         {\r
 388                                 myDictionary.BaseDictionary.Remove(11);\r
 389                         } \r
 390                         catch \r
 391                         {\r
 392                                 exceptionThrown = true;\r
 393                         } \r
 394                         finally \r
 395                         {\r
 396                                 Assert("Exception must be thrown", exceptionThrown);\r
 397                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 398                                 Assert("OnRemove must be fired", myDictionary.onRemoveFired);\r
 399                                 Assert("OnRemoveComplete must be fired", myDictionary.onRemoveCompleteFired);\r
 400                                 AssertEquals("Count", 27, myDictionary.Count);\r
 401                                 AssertEquals(null, myDictionary.BaseDictionary[11]);\r
 402                         }\r
 403 \r
 404                 }\r
 405 \r
 406                 [Test]\r
 407                 public void RemoveKeyNotInDictionary() \r
 408                 {\r
 409                 \r
 410                         ConcreteDictionary myDictionary = new ConcreteDictionary(28);\r
 411 \r
 412                         myDictionary.BaseDictionary.Remove(80);\r
 413                         Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 414                         Assert("OnRemove must be fired", myDictionary.onRemoveFired);\r
 415                         Assert("OnRemoveComplete must be fired", myDictionary.onRemoveCompleteFired);\r
 416                 }\r
 417 \r
 418                 [Test]\r
 419                 public void Items() \r
 420                 {\r
 421                         ConcreteDictionary myDictionary = new ConcreteDictionary(19);\r
 422                         for (int i = 0; i < 19; i++) \r
 423                         {\r
 424                                 AssertEquals(i*2, (int) myDictionary.BaseDictionary[i]);\r
 425                         }\r
 426                 }\r
 427 \r
 428                 [Test]\r
 429                 public void Contains() \r
 430                 {\r
 431                         ConcreteDictionary myDictionary = new ConcreteDictionary(14);\r
 432                         for (int i = 0; i < 14; i++) \r
 433                         {\r
 434                                 Assert("Must contain " + i, myDictionary.BaseDictionary.Contains(i));\r
 435                         }\r
 436                         for (int i = 14; i < 34; i++) \r
 437                         {\r
 438                                 Assert("Must not contain " + i, !myDictionary.BaseDictionary.Contains(i));\r
 439                         }\r
 440                 }\r
 441 \r
 442                 [Test]\r
 443                 public void GetEnumerator() \r
 444                 {\r
 445                         ConcreteDictionary myDictionary = new ConcreteDictionary(4);\r
 446                         \r
 447                         AssertNotNull(myDictionary.GetEnumerator());\r
 448                 }\r
 449 \r
 450                 [Test]\r
 451                 public void Keys() \r
 452                 {\r
 453                         ConcreteDictionary myDictionary = new ConcreteDictionary(5);\r
 454                         ICollection keys = myDictionary.BaseDictionary.Keys;\r
 455 \r
 456                         int total = 0;\r
 457                         foreach (int i in keys) \r
 458                                 total += i;\r
 459                         AssertEquals(10, total);\r
 460                         AssertEquals(5, keys.Count);\r
 461                 }\r
 462 \r
 463                 [Test]\r
 464                 public void Values() \r
 465                 {\r
 466                         ConcreteDictionary myDictionary = new ConcreteDictionary(5);\r
 467                         ICollection values = myDictionary.BaseDictionary.Values;\r
 468 \r
 469                         int total = 0;\r
 470                         foreach (int i in values) \r
 471                                 total += i;\r
 472                         AssertEquals(20, total);\r
 473                         AssertEquals(5, values.Count);\r
 474                 }\r
 475 \r
 476                 [Test]\r
 477                 public void Get() \r
 478                 {\r
 479                         ConcreteDictionary myDictionary = new ConcreteDictionary(18);\r
 480                         int v = (int) myDictionary.BaseDictionary[10];\r
 481 \r
 482                         Assert("OnGet must be fired", myDictionary.onGetFired);\r
 483                         AssertEquals(v, 20);\r
 484                 }\r
 485 \r
 486                 [Test]\r
 487                 public void GetOnGetExcept() \r
 488                 {\r
 489                         bool exceptionThrown = false;\r
 490 \r
 491                         ConcreteDictionary myDictionary = new ConcreteDictionary(18);\r
 492                         myDictionary.onGetMustThrowException = true;\r
 493 \r
 494                         try {\r
 495                                 int v = (int) myDictionary.BaseDictionary[10];\r
 496                         } catch {\r
 497                                 exceptionThrown = true;\r
 498                         } finally {\r
 499                                 Assert("Exception must be thrown", exceptionThrown);\r
 500                                 Assert("OnGet must be fired", myDictionary.onGetFired);\r
 501                         }\r
 502                 }\r
 503 \r
 504                 [Test]\r
 505                 public void GetNoKey() \r
 506                 {\r
 507                         ConcreteDictionary myDictionary = new ConcreteDictionary(18);\r
 508                         AssertNull(myDictionary.BaseDictionary[100]);\r
 509                 }\r
 510 \r
 511                 [Test]\r
 512                 public void Set() \r
 513                 {\r
 514                         ConcreteDictionary myDictionary = new ConcreteDictionary(18);\r
 515                         myDictionary.BaseDictionary[10] = 50;\r
 516 \r
 517                         Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 518                         Assert("OnSet must be fired", myDictionary.onSetFired);\r
 519                         Assert("OnSetComplete must be fired", myDictionary.onSetCompleteFired);\r
 520                         AssertEquals(50, myDictionary.BaseDictionary[10]);\r
 521                 }\r
 522 \r
 523                 [Test]\r
 524                 public void SetNewKey() \r
 525                 {\r
 526                         ConcreteDictionary myDictionary = new ConcreteDictionary(18);\r
 527                         myDictionary.BaseDictionary[111] = 222;\r
 528 \r
 529                         Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 530                         Assert("OnSet must be fired", myDictionary.onSetFired);\r
 531                         Assert("OnSetComplete must be fired", myDictionary.onSetCompleteFired);\r
 532                         Assert("OnInsert must not be fired", !myDictionary.onInsertFired);\r
 533                         Assert("OnInsertComplete must not be fired", !myDictionary.onInsertCompleteFired);\r
 534                         AssertEquals(222, myDictionary.BaseDictionary[111]);\r
 535                         AssertEquals(19, myDictionary.Count);\r
 536                 }\r
 537 \r
 538                 [Test]\r
 539                 public void SetOnValidateExcept() \r
 540                 {\r
 541                         bool exceptionThrown = false;\r
 542 \r
 543                         ConcreteDictionary myDictionary = new ConcreteDictionary(18);\r
 544                         myDictionary.onValidateMustThrowException = true;\r
 545                         \r
 546                         try {\r
 547                                 myDictionary.BaseDictionary[10] = 50;\r
 548                         } catch {\r
 549                                 exceptionThrown = true;\r
 550                         } finally {\r
 551                                 Assert("Exception must be thrown", exceptionThrown);\r
 552                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 553                                 Assert("OnSet must not be fired", !myDictionary.onSetFired);\r
 554                                 Assert("OnSetComplete not must be fired", !myDictionary.onSetCompleteFired);\r
 555                                 AssertEquals(20, myDictionary.BaseDictionary[10]);\r
 556                         }\r
 557                 }\r
 558 \r
 559                 [Test]\r
 560                 public void SetOnSetExcept() \r
 561                 {\r
 562                         bool exceptionThrown = false;\r
 563 \r
 564                         ConcreteDictionary myDictionary = new ConcreteDictionary(18);\r
 565                         myDictionary.onSetMustThrowException = true;\r
 566                         \r
 567                         try {\r
 568                                 myDictionary.BaseDictionary[10] = 50;\r
 569                         } catch {\r
 570                                 exceptionThrown = true;\r
 571                         } finally {\r
 572                                 Assert("Exception must be thrown", exceptionThrown);\r
 573                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 574                                 Assert("OnSet must be fired", myDictionary.onSetFired);\r
 575                                 Assert("OnSetComplete must not be fired", !myDictionary.onSetCompleteFired);\r
 576                                 AssertEquals(20, myDictionary.BaseDictionary[10]);\r
 577                         }\r
 578                 }\r
 579 \r
 580                 [Test]\r
 581                 public void SetOnSetCompleteExcept() \r
 582                 {\r
 583                         bool exceptionThrown = false;\r
 584 \r
 585                         ConcreteDictionary myDictionary = new ConcreteDictionary(18);\r
 586                         myDictionary.onSetCompleteMustThrowException = true;\r
 587                         \r
 588                         try {\r
 589                                 myDictionary.BaseDictionary[10] = 50;\r
 590                         } catch {\r
 591                                 exceptionThrown = true;\r
 592                         } finally {\r
 593                                 Assert("Exception must be thrown", exceptionThrown);\r
 594                                 Assert("OnValidate must be fired", myDictionary.onValidateFired);\r
 595                                 Assert("OnSet must be fired", myDictionary.onSetFired);\r
 596                                 Assert("OnSetComplete must be fired", myDictionary.onSetCompleteFired);\r
 597                                 AssertEquals(20, myDictionary.BaseDictionary[10]);\r
 598                         }\r
 599                 }\r
 600 \r
 601                 [Test]\r
 602                 public void IsReadOnly() \r
 603                 {\r
 604                         ConcreteDictionary myDictionary = new ConcreteDictionary(1);\r
 605                         Assert(!myDictionary.BaseDictionary.IsReadOnly);\r
 606                 }\r
 607 \r
 608                 [Test]\r
 609                 public void IsFixedSize() \r
 610                 {\r
 611                         ConcreteDictionary myDictionary = new ConcreteDictionary(1);\r
 612                         Assert(!myDictionary.BaseDictionary.IsFixedSize);\r
 613                 }\r
 614 \r
 615                 [Test]\r
 616                 public void DictionaryProperty()\r
 617                 {\r
 618                         ConcreteDictionary myDictionary = new ConcreteDictionary(1);\r
 619                         AssertEquals(myDictionary, myDictionary.BaseDictionary);\r
 620                 }\r
 621         }\r
 622 }\r