mcs/class/System/Test/System.Collections.Specialized/NameValueCollectionTest.cs

   1 // created on 7/21/2001 at 2:36 PM
   2 //
   3 // Authors:
   4 //      Martin Willemoes Hansen (mwh@sysrq.dk)
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2003 Martin Willemoes Hansen
   8 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
   9 //
  10
  11 using System;
  12 using System.Collections;
  13 using System.Collections.Specialized;
  14 using System.Text;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.System.Collections.Specialized {
  19
  20         [TestFixture]
  21         public class NameValueCollectionTest : Assertion {
  22
  23                 [Test]
  24                 public void GetValues ()
  25                 {
  26                         NameValueCollection col = new NameValueCollection ();
  27                         col.Add ("foo1", "bar1");
  28                         AssertEquals ("#1", null, col.GetValues (null));
  29                         AssertEquals ("#2", null, col.GetValues (""));
  30                         AssertEquals ("#3", null, col.GetValues ("NotExistent"));
  31                         AssertEquals ("#4", 1, col.GetValues (0).Length);
  32                 }
  33
  34                 [Test]
  35                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
  36                 public void GetValues_OutOfRange ()
  37                 {
  38                         NameValueCollection c = new NameValueCollection ();
  39                         c.Add ("foo1", "bar1");
  40                         AssertEquals ("#5", null, c.GetValues (1));
  41                 }
  42
  43                 [Test]
  44                 public void Get ()
  45                 {
  46                         NameValueCollection col = new NameValueCollection (5);
  47                         col.Add ("foo1", "bar1");
  48                         AssertEquals ("#1", null, col.Get (null));
  49                         AssertEquals ("#2", null, col.Get (""));
  50                         AssertEquals ("#3", null, col.Get ("NotExistent"));
  51                         AssertEquals ("#4", "bar1", col.Get ("foo1"));
  52                         AssertEquals ("#5", "bar1", col.Get (0));
  53                 }
  54
  55                 [Test]
  56                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
  57                 public void Get_OutOfRange ()
  58                 {
  59                         NameValueCollection c = new NameValueCollection ();
  60                         c.Add ("foo1", "bar1");
  61                         AssertEquals ("#6", null, c.Get (1));
  62                 }
  63
  64                 [Test]
  65                 public void GetKey ()
  66                 {
  67                         NameValueCollection c = new NameValueCollection (CaseInsensitiveHashCodeProvider.DefaultInvariant, CaseInsensitiveComparer.DefaultInvariant);
  68                         c.Add ("foo1", "bar1");
  69                         AssertEquals ("#1", "foo1", c.GetKey (0));
  70                 }
  71
  72                 [Test]
  73                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
  74                 public void GetKey_OutOfRange ()
  75                 {
  76                         NameValueCollection c = new NameValueCollection ();
  77                         c.Add ("foo1", "bar1");
  78                         AssertEquals ("#2", null, c.GetKey (1));
  79                 }
  80
  81                 [Test]
  82                 public void HasKeys ()
  83                 {
  84                         NameValueCollection c = new NameValueCollection (5, CaseInsensitiveHashCodeProvider.DefaultInvariant, CaseInsensitiveComparer.DefaultInvariant);
  85                         Assert ("#1", !c.HasKeys ());
  86                         c.Add ("foo1", "bar1");
  87                         Assert ("#2", c.HasKeys ());
  88                 }
  89
  90                 [Test]
  91                 public void Clear ()
  92                 {
  93                         NameValueCollection c = new NameValueCollection ();
  94                         AssertEquals ("#1", 0, c.Count);
  95                         c.Add ("foo1", "bar1");
  96                         AssertEquals ("#2", 1, c.Count);
  97                         c.Clear ();
  98                         AssertEquals ("#3", 0, c.Count);
  99                 }
 100
 101                 [Test]
 102                 public void Add ()
 103                 {
 104                         NameValueCollection c = new NameValueCollection ();
 105                         c.Add ("mono", "mono");
 106                         c.Add ("!mono", null);
 107                         c.Add (null, "mono!");
 108                         AssertEquals ("Count", 3, c.Count);
 109                         AssertEquals ("mono", "mono", c ["mono"]);
 110                         AssertNull ("!mono", c ["!mono"]);
 111                         AssertEquals ("mono!", "mono!", c [null]);
 112                 }
 113
 114                 [Test]
 115                 public void Add_Multiples ()
 116                 {
 117                         NameValueCollection c = new NameValueCollection ();
 118                         c.Add ("mono", "mono");
 119                         c.Add ("mono", "mono");
 120                         c.Add ("mono", "mono");
 121                         AssertEquals ("Count", 1, c.Count);
 122                         AssertEquals ("mono", "mono,mono,mono", c ["mono"]);
 123                 }
 124
 125                 [Test]
 126                 public void Add_Multiples_Null ()
 127                 {
 128                         NameValueCollection c = new NameValueCollection ();
 129                         c.Add ("mono", "mono");
 130                         c.Add ("mono", null);
 131                         c.Add ("mono", "mono");
 132                         AssertEquals ("Count", 1, c.Count);
 133                         AssertEquals ("mono", "mono,mono", c ["mono"]);
 134                 }
 135
 136                 [Test]
 137                 public void Add_NVC ()
 138                 {
 139                         NameValueCollection c1 = new NameValueCollection ();
 140                         NameValueCollection c2 = new NameValueCollection (c1);
 141
 142                         c2.Add (c1);
 143                         AssertEquals ("c1.Count", 0, c1.Count);
 144                         AssertEquals ("c2.Count", 0, c2.Count);
 145
 146                         c1.Add ("foo", "bar");
 147                         c2.Add ("bar", "foo");
 148
 149                         AssertEquals ("c1.Count", 1, c1.Count);
 150                         AssertEquals ("c2.Count", 1, c2.Count);
 151
 152                         c2.Add (c1);
 153                         AssertEquals ("c1.Count", 1, c1.Count);
 154                         AssertEquals ("c2.Count", 2, c2.Count);
 155                 }
 156
 157                 [Test]
 158 #if NET_2_0
 159                 [ExpectedException (typeof (ArgumentNullException))]
 160 #else
 161                 [ExpectedException (typeof (NullReferenceException))]
 162 #endif
 163                 public void Add_NVC_Null ()
 164                 {
 165                         new NameValueCollection ().Add (null);
 166                 }
 167
 168                 [Test]
 169                 public void Add_NVC_Null2 ()
 170                 {
 171                         NameValueCollection a = new NameValueCollection ();
 172                         NameValueCollection b = new NameValueCollection ();
 173
 174                         b.Add ("Test", null);
 175                         a.Add (b);
 176                         AssertEquals ("Count", 1, a.Count);
 177                 }
 178
 179                 [Test]
 180                 public void Set_New ()
 181                 {
 182                         NameValueCollection c = new NameValueCollection ();
 183                         c.Set ("mono", "mono");
 184                         c.Set ("!mono", null);
 185                         c.Set (null, "mono!");
 186                         AssertEquals ("Count", 3, c.Count);
 187                         AssertEquals ("mono", "mono", c ["mono"]);
 188                         AssertNull ("!mono", c ["!mono"]);
 189                         AssertEquals ("mono!", "mono!", c [null]);
 190                 }
 191
 192                 [Test]
 193                 public void Set_Replace ()
 194                 {
 195                         NameValueCollection c = new NameValueCollection ();
 196                         c.Add ("mono", "mono");
 197                         c.Add ("!mono", "!mono");
 198                         c.Add ("mono!", "mono!");
 199                         AssertEquals ("Count", 3, c.Count);
 200                         AssertEquals ("mono", "mono", c ["mono"]);
 201                         AssertEquals ("!mono", "!mono", c ["!mono"]);
 202                         AssertEquals ("mono!", "mono!", c ["mono!"]);
 203
 204                         c.Set ("mono", "nomo");
 205                         c.Set ("!mono", null);
 206                         c.Set (null, "mono!");
 207                         AssertEquals ("Count", 4, c.Count); // mono! isn't removed
 208                         AssertEquals ("mono", "nomo", c ["mono"]);
 209                         AssertNull ("!mono", c ["!mono"]);
 210                         AssertEquals ("mono!1", "mono!", c ["mono!"]);
 211                         AssertEquals ("mono!2", "mono!", c [null]);
 212                 }
 213
 214                 [Test]
 215                 public void CaseInsensitive ()
 216                 {
 217                         // default constructor is case insensitive
 218                         NameValueCollection c = new NameValueCollection ();
 219                         c.Add ("mono", "mono");
 220                         c.Add ("MoNo", "MoNo");
 221                         c.Add ("mOnO", "mOnO");
 222                         c.Add ("MONO", "MONO");
 223                         AssertEquals ("Count", 1, c.Count);
 224                 }
 225
 226                 [Test]
 227                 public void CopyTo ()
 228                 {
 229                         string [] array = new string [4];
 230                         NameValueCollection c = new NameValueCollection ();
 231                         c.Add ("1", "mono");
 232                         c.Add ("2", "MoNo");
 233                         c.Add ("3", "mOnO");
 234                         c.Add ("4", "MONO");
 235                         c.CopyTo (array, 0);
 236                 }
 237
 238                 [Test]
 239                 [ExpectedException (typeof (ArgumentNullException))]
 240                 public void CopyTo_Null ()
 241                 {
 242                         NameValueCollection c = new NameValueCollection ();
 243                         c.CopyTo (null, 0);
 244                 }
 245
 246                 [Test]
 247                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 248                 public void CopyTo_NegativeIndex ()
 249                 {
 250                         string [] array = new string [4];
 251                         NameValueCollection c = new NameValueCollection ();
 252                         c.Add ("1", "mono");
 253                         c.Add ("2", "MoNo");
 254                         c.Add ("3", "mOnO");
 255                         c.Add ("4", "MONO");
 256                         c.CopyTo (array, -1);
 257                 }
 258
 259                 [Test]
 260                 [ExpectedException (typeof (ArgumentException))]
 261                 public void CopyTo_NotEnoughSpace ()
 262                 {
 263                         string [] array = new string [4];
 264                         NameValueCollection c = new NameValueCollection ();
 265                         c.Add ("1", "mono");
 266                         c.Add ("2", "MoNo");
 267                         c.Add ("3", "mOnO");
 268                         c.Add ("4", "MONO");
 269                         c.CopyTo (array, 2);
 270                 }
 271
 272                 [Test]
 273                 // Note: not a RankException
 274                 [ExpectedException (typeof (ArgumentException))]
 275                 public void CopyTo_MultipleDimensionStringArray ()
 276                 {
 277                         string [,,] matrix = new string [2,3,4];
 278                         NameValueCollection c = new NameValueCollection ();
 279                         c.Add ("1", "mono");
 280                         c.Add ("2", "MoNo");
 281                         c.Add ("3", "mOnO");
 282                         c.Add ("4", "MONO");
 283                         c.CopyTo (matrix, 0);
 284                 }
 285
 286                 [Test]
 287                 // Note: not a RankException
 288                 [ExpectedException (typeof (ArgumentException))]
 289                 public void CopyTo_MultipleDimensionArray ()
 290                 {
 291                         Array a = Array.CreateInstance (typeof (string), 1, 2, 3);
 292                         NameValueCollection c = new NameValueCollection ();
 293                         c.CopyTo (a, 0);
 294                 }
 295
 296                 [Test]
 297                 public void Remove ()
 298                 {
 299                         string[] items = { "mono", "MoNo", "mOnO", "MONO" };
 300                         // default constructor is case insensitive
 301                         NameValueCollection c = new NameValueCollection ();
 302                         for (int i=0; i < items.Length; i++) {
 303                                 string add = "Add-" + i.ToString () + "-Count";
 304
 305                                 c.Add (items [i], add);
 306                                 AssertEquals (add, 1, c.Count);
 307                                 c.Remove (items [0]);
 308                                 AssertEquals ("Remove-0-Count", 0, c.Count);
 309
 310                                 c.Add (items [i], add);
 311                                 AssertEquals (add, 1, c.Count);
 312                                 c.Remove (items [1]);
 313                                 AssertEquals ("Remove-1-Count", 0, c.Count);
 314
 315                                 c.Add (items [i], add);
 316                                 AssertEquals (add, 1, c.Count);
 317                                 c.Remove (items [2]);
 318                                 AssertEquals ("Remove-2-Count", 0, c.Count);
 319
 320                                 c.Add (items [i], add);
 321                                 AssertEquals (add , 1, c.Count);
 322                                 c.Remove (items [3]);
 323                                 AssertEquals ("Remove-3-Count", 0, c.Count);
 324                         }
 325                 }
 326 #if NET_2_0
 327                 [Test]
 328                 public void Constructor_IEqualityComparer ()
 329                 {
 330                         NameValueCollection coll = new NameValueCollection (new EqualityComparer ());
 331                         coll.Add ("a", "1");
 332                         AssertEquals ("#1", 1, coll.Count);
 333                 }
 334
 335                 [Test]
 336                 public void Constructor_Int_IEqualityComparer ()
 337                 {
 338                         NameValueCollection coll = new NameValueCollection (5, new EqualityComparer ());
 339                         coll.Add ("a", "1");
 340                         AssertEquals ("#1", 1, coll.Count);
 341                 }
 342
 343                 [Test]
 344                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 345                 public void Constructor_IntNegative_IEqualityComparer ()
 346                 {
 347                         new NameValueCollection (-1, new EqualityComparer ());
 348                 }
 349 #endif
 350         }
 351 }