mcs/class/System.Data/Test/System.Data.Common/DbConnectionStringBuilderTest.cs

   1 // DbConnectionStringBuilderTest.cs - NUnit Test Cases for Testing the
   2 // DbConnectionStringBuilder class
   3 //
   4 // Author:
   5 //      Sureshkumar T (tsureshkumar@novell.com)
   6 //      Daniel Morgan (monodanmorg@yahoo.com)
   7 //      Gert Driesen (drieseng@users.sourceforge.net
   8 //
   9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  10 // Copyright (C) 2008 Daniel Morgan
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 #if NET_2_0
  33
  34 #region Using directives
  35
  36 using System;
  37 using System.Collections;
  38 using System.Collections.Generic;
  39 using System.Collections.Specialized;
  40 using System.ComponentModel;
  41 using System.Data;
  42 using System.Data.Common;
  43 using System.Data.SqlClient;
  44 using System.Reflection;
  45 using System.Text;
  46
  47 using NUnit.Framework;
  48
  49 #endregion
  50
  51 namespace MonoTests.System.Data.Common
  52 {
  53         [TestFixture]
  54         public class DbConnectionStringBuilderTest
  55         {
  56                 private DbConnectionStringBuilder builder = null;
  57                 private const string SERVER = "SERVER";
  58                 private const string SERVER_VALUE = "localhost";
  59
  60                 [SetUp]
  61                 public void SetUp ()
  62                 {
  63                         builder = new DbConnectionStringBuilder ();
  64                 }
  65
  66                 [Test]
  67                 public void Add ()
  68                 {
  69                         builder.Add ("driverid", "420");
  70                         builder.Add ("driverid", "560");
  71                         builder.Add ("DriverID", "840");
  72                         Assert.AreEqual ("840", builder ["driverId"], "#A1");
  73                         Assert.IsTrue (builder.ContainsKey ("driverId"), "#A2");
  74                         builder.Add ("Driver", "OdbcDriver");
  75                         Assert.AreEqual ("OdbcDriver", builder ["Driver"], "#B1");
  76                         Assert.IsTrue (builder.ContainsKey ("Driver"), "#B2");
  77                         builder.Add ("Driver", "{OdbcDriver");
  78                         Assert.AreEqual ("{OdbcDriver", builder ["Driver"], "#C1");
  79                         Assert.IsTrue (builder.ContainsKey ("Driver"), "#C2");
  80                         builder.Add ("Dsn", "MyDsn");
  81                         Assert.AreEqual ("MyDsn", builder ["Dsn"], "#D1");
  82                         Assert.IsTrue (builder.ContainsKey ("Dsn"), "#D2");
  83                         builder.Add ("dsN", "MyDsn2");
  84                         Assert.AreEqual ("MyDsn2", builder ["Dsn"], "#E1");
  85                         Assert.IsTrue (builder.ContainsKey ("Dsn"), "#E2");
  86                 }
  87
  88                 [Test]
  89                 public void Add_Keyword_Invalid ()
  90                 {
  91                         string [] invalid_keywords = new string [] {
  92                                 string.Empty,
  93                                 " ",
  94                                 " abc",
  95                                 "abc ",
  96                                 "\r",
  97                                 "ab\rc",
  98                                 ";abc",
  99                                 "a\0b"
 100                                 };
 101
 102                         for (int i = 0; i < invalid_keywords.Length; i++) {
 103                                 string keyword = invalid_keywords [i];
 104                                 try {
 105                                         builder.Add (keyword, "abc");
 106                                         Assert.Fail ("#1:" + i);
 107                                 } catch (ArgumentException ex) {
 108                                         // Invalid keyword, contain one or more of 'no characters',
 109                                         // 'control characters', 'leading or trailing whitespace'
 110                                         // or 'leading semicolons'
 111                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:"+ i);
 112                                         Assert.IsNull (ex.InnerException, "#3:" + i);
 113                                         Assert.IsNotNull (ex.Message, "#4:" + i);
 114                                         Assert.IsTrue (ex.Message.IndexOf ("'" + keyword + "'") == -1, "#5:" + i);
 115                                         Assert.AreEqual (keyword, ex.ParamName, "#6:" + i);
 116                                 }
 117                         }
 118                 }
 119
 120                 [Test]
 121                 public void Add_Keyword_Null ()
 122                 {
 123                         try {
 124                                 builder.Add (null, "abc");
 125                                 Assert.Fail ("#1");
 126                         } catch (ArgumentNullException ex) {
 127                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 128                                 Assert.IsNull (ex.InnerException, "#3");
 129                                 Assert.IsNotNull (ex.Message, "#4");
 130                                 Assert.AreEqual ("keyword", ex.ParamName, "#5");
 131                         }
 132                 }
 133
 134                 [Test]
 135                 public void ConnectionString ()
 136                 {
 137                         DbConnectionStringBuilder sb;
 138
 139                         sb = new DbConnectionStringBuilder ();
 140                         sb.ConnectionString = "A=B";
 141                         Assert.IsTrue (sb.ContainsKey ("A"), "#A1");
 142                         Assert.AreEqual ("a=B", sb.ConnectionString, "#A2");
 143                         Assert.AreEqual (1, sb.Count, "#A3");
 144                         Assert.AreEqual (1, sb.Keys.Count, "#A4");
 145
 146                         sb.ConnectionString = null;
 147                         Assert.IsFalse (sb.ContainsKey ("A"), "#B1");
 148                         Assert.AreEqual (string.Empty, sb.ConnectionString, "#B2");
 149                         Assert.AreEqual (0, sb.Count, "#B3");
 150                         Assert.AreEqual (0, sb.Keys.Count, "#B4");
 151
 152                         sb = new DbConnectionStringBuilder ();
 153                         sb.ConnectionString = "A=B";
 154                         sb.ConnectionString = string.Empty;
 155                         Assert.IsFalse (sb.ContainsKey ("A"), "#C1");
 156                         Assert.AreEqual (string.Empty, sb.ConnectionString, "#C2");
 157                         Assert.AreEqual (0, sb.Count, "#C3");
 158                         Assert.AreEqual (0, sb.Keys.Count, "#C4");
 159
 160                         sb = new DbConnectionStringBuilder ();
 161                         sb.ConnectionString = "A=B";
 162                         sb.ConnectionString = "\r ";
 163                         Assert.IsFalse (sb.ContainsKey ("A"), "#D1");
 164                         Assert.AreEqual (string.Empty, sb.ConnectionString, "#D2");
 165                         Assert.AreEqual (0, sb.Count, "#D3");
 166                         Assert.AreEqual (0, sb.Keys.Count, "#D4");
 167                 }
 168
 169                 [Test]
 170                 public void ConnectionString_Value_Empty ()
 171                 {
 172                         DbConnectionStringBuilder [] sbs = new DbConnectionStringBuilder [] {
 173                                 new DbConnectionStringBuilder (),
 174                                 new DbConnectionStringBuilder (false),
 175                                 new DbConnectionStringBuilder (true)
 176                                 };
 177
 178                         foreach (DbConnectionStringBuilder sb in sbs) {
 179                                 sb.ConnectionString = "A=";
 180                                 Assert.IsFalse (sb.ContainsKey ("A"), "#1");
 181                                 Assert.AreEqual (string.Empty, sb.ConnectionString, "#2");
 182                                 Assert.AreEqual (0, sb.Count, "#3");
 183                         }
 184                 }
 185
 186                 [Test]
 187                 public void Clear ()
 188                 {
 189                         DbConnectionStringBuilder [] sbs = new DbConnectionStringBuilder [] {
 190                                 new DbConnectionStringBuilder (),
 191                                 new DbConnectionStringBuilder (false),
 192                                 new DbConnectionStringBuilder (true)
 193                                 };
 194
 195                         foreach (DbConnectionStringBuilder sb in sbs) {
 196                                 sb ["Dbq"] = "C:\\Data.xls";
 197                                 sb ["Driver"] = "790";
 198                                 sb.Add ("Port", "56");
 199                                 sb.Clear ();
 200                                 Assert.AreEqual (string.Empty, sb.ConnectionString, "#1");
 201                                 Assert.IsFalse (sb.ContainsKey ("Dbq"), "#2");
 202                                 Assert.IsFalse (sb.ContainsKey ("Driver"), "#3");
 203                                 Assert.IsFalse (sb.ContainsKey ("Port"), "#4");
 204                                 Assert.AreEqual (0, sb.Count, "#5");
 205                                 Assert.AreEqual (0, sb.Keys.Count, "#6");
 206                                 Assert.AreEqual (0, sb.Values.Count, "#7");
 207                         }
 208                 }
 209
 210                 [Test]
 211                 public void AddDuplicateTest ()
 212                 {
 213                         builder.Add (SERVER, SERVER_VALUE);
 214                         builder.Add (SERVER, SERVER_VALUE);
 215                         // should allow duplicate addition. rather, it should re-assign
 216                         Assert.AreEqual (SERVER + "=" + SERVER_VALUE, builder.ConnectionString,
 217                                          "Duplicates addition does not change the value!");
 218                 }
 219
 220                 [Test]
 221                 public void Indexer ()
 222                 {
 223                         builder ["abc Def"] = "xa 34";
 224                         Assert.AreEqual ("xa 34", builder ["abc def"], "#A1");
 225                         Assert.AreEqual ("abc Def=\"xa 34\"", builder.ConnectionString, "#A2");
 226                         builder ["na;"] = "abc;";
 227                         Assert.AreEqual ("abc;", builder ["na;"], "#B1");
 228                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"abc;\"", builder.ConnectionString, "#B2");
 229                         builder ["Na;"] = "de\rfg";
 230                         Assert.AreEqual ("de\rfg", builder ["na;"], "#C1");
 231                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\"", builder.ConnectionString, "#C2");
 232                         builder ["val"] = ";xyz";
 233                         Assert.AreEqual (";xyz", builder ["val"], "#D1");
 234                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\"", builder.ConnectionString, "#D2");
 235                         builder ["name"] = string.Empty;
 236                         Assert.AreEqual (string.Empty, builder ["name"], "#E1");
 237                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\";name=", builder.ConnectionString, "#E2");
 238                         builder ["name"] = " ";
 239                         Assert.AreEqual (" ", builder ["name"], "#F1");
 240                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\";name=\" \"", builder.ConnectionString, "#F2");
 241
 242                         builder = new DbConnectionStringBuilder (false);
 243                         builder ["abc Def"] = "xa 34";
 244                         Assert.AreEqual ("xa 34", builder ["abc def"], "#A1");
 245                         Assert.AreEqual ("abc Def=\"xa 34\"", builder.ConnectionString, "#A2");
 246                         builder ["na;"] = "abc;";
 247                         Assert.AreEqual ("abc;", builder ["na;"], "#B1");
 248                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"abc;\"", builder.ConnectionString, "#B2");
 249                         builder ["Na;"] = "de\rfg";
 250                         Assert.AreEqual ("de\rfg", builder ["na;"], "#C1");
 251                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\"", builder.ConnectionString, "#C2");
 252                         builder ["val"] = ";xyz";
 253                         Assert.AreEqual (";xyz", builder ["val"], "#D1");
 254                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\"", builder.ConnectionString, "#D2");
 255                         builder ["name"] = string.Empty;
 256                         Assert.AreEqual (string.Empty, builder ["name"], "#E1");
 257                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\";name=", builder.ConnectionString, "#E2");
 258                         builder ["name"] = " ";
 259                         Assert.AreEqual (" ", builder ["name"], "#F1");
 260                         Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\";name=\" \"", builder.ConnectionString, "#F2");
 261
 262                         builder = new DbConnectionStringBuilder (true);
 263                         builder ["abc Def"] = "xa 34";
 264                         Assert.AreEqual ("xa 34", builder ["abc def"], "#A1");
 265                         Assert.AreEqual ("abc Def=xa 34", builder.ConnectionString, "#A2");
 266                         builder ["na;"] = "abc;";
 267                         Assert.AreEqual ("abc;", builder ["na;"], "#B1");
 268                         Assert.AreEqual ("abc Def=xa 34;na;={abc;}", builder.ConnectionString, "#B2");
 269                         builder ["Na;"] = "de\rfg";
 270                         Assert.AreEqual ("de\rfg", builder ["na;"], "#C1");
 271                         Assert.AreEqual ("abc Def=xa 34;na;=de\rfg", builder.ConnectionString, "#C2");
 272                         builder ["val"] = ";xyz";
 273                         Assert.AreEqual (";xyz", builder ["val"], "#D1");
 274                         Assert.AreEqual ("abc Def=xa 34;na;=de\rfg;val={;xyz}", builder.ConnectionString, "#D2");
 275                         builder ["name"] = string.Empty;
 276                         Assert.AreEqual (string.Empty, builder ["name"], "#E1");
 277                         Assert.AreEqual ("abc Def=xa 34;na;=de\rfg;val={;xyz};name=", builder.ConnectionString, "#E2");
 278                         builder ["name"] = " ";
 279                         Assert.AreEqual (" ", builder ["name"], "#F1");
 280                         Assert.AreEqual ("abc Def=xa 34;na;=de\rfg;val={;xyz};name= ", builder.ConnectionString, "#F2");
 281                 }
 282
 283                 [Test]
 284                 public void Indexer_Keyword_Invalid ()
 285                 {
 286                         string [] invalid_keywords = new string [] {
 287                                 string.Empty,
 288                                 " ",
 289                                 " abc",
 290                                 "abc ",
 291                                 "\r",
 292                                 "ab\rc",
 293                                 ";abc",
 294                                 "a\0b"
 295                                 };
 296
 297                         for (int i = 0; i < invalid_keywords.Length; i++) {
 298                                 string keyword = invalid_keywords [i];
 299                                 try {
 300                                         builder [keyword] = "abc";
 301                                         Assert.Fail ("#A1:" + i);
 302                                 } catch (ArgumentException ex) {
 303                                         // Invalid keyword, contain one or more of 'no characters',
 304                                         // 'control characters', 'leading or trailing whitespace'
 305                                         // or 'leading semicolons'
 306                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2:"+ i);
 307                                         Assert.IsNull (ex.InnerException, "#A3:" + i);
 308                                         Assert.IsNotNull (ex.Message, "#A4:" + i);
 309                                         Assert.IsTrue (ex.Message.IndexOf ("'" + keyword + "'") == -1, "#A5:" + i);
 310                                         Assert.AreEqual (keyword, ex.ParamName, "#A6:" + i);
 311                                 }
 312
 313                                 builder [keyword] = null;
 314                                 Assert.IsFalse (builder.ContainsKey (keyword), "#B");
 315
 316                                 try {
 317                                         object value = builder [keyword];
 318                                         Assert.Fail ("#C1:" + i);
 319                                 } catch (ArgumentException ex) {
 320                                         // Keyword not supported: '...'
 321                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2:"+ i);
 322                                         Assert.IsNull (ex.InnerException, "#C3:" + i);
 323                                         Assert.IsNotNull (ex.Message, "#C4:" + i);
 324                                         Assert.IsTrue (ex.Message.IndexOf ("'" + keyword + "'") != -1, "#C5:" + i);
 325                                         Assert.IsNull (ex.ParamName, "#C6:" + i);
 326                                 }
 327                         }
 328                 }
 329
 330                 [Test]
 331                 public void Indexer_Keyword_NotSupported ()
 332                 {
 333                         try {
 334                                 object value = builder ["abc"];
 335                                 Assert.Fail ("#1");
 336                         } catch (ArgumentException ex) {
 337                                 // Keyword not supported: 'abc'
 338                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 339                                 Assert.IsNull (ex.InnerException, "#3");
 340                                 Assert.IsNotNull (ex.Message, "#4");
 341                                 Assert.IsTrue (ex.Message.IndexOf ("'abc'") != -1, "#5");
 342                                 Assert.IsNull (ex.ParamName, "#6");
 343                         }
 344                 }
 345
 346                 [Test]
 347                 public void Indexer_Keyword_Null ()
 348                 {
 349                         try {
 350                                 builder [null] = "abc";
 351                                 Assert.Fail ("#A1");
 352                         } catch (ArgumentNullException ex) {
 353                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 354                                 Assert.IsNull (ex.InnerException, "#A3");
 355                                 Assert.IsNotNull (ex.Message, "#A4");
 356                                 Assert.AreEqual ("keyword", ex.ParamName, "#A5");
 357                         }
 358
 359                         try {
 360                                 builder [null] = null;
 361                                 Assert.Fail ("#B1");
 362                         } catch (ArgumentNullException ex) {
 363                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 364                                 Assert.IsNull (ex.InnerException, "#B3");
 365                                 Assert.IsNotNull (ex.Message, "#B4");
 366                                 Assert.AreEqual ("keyword", ex.ParamName, "#B5");
 367                         }
 368
 369                         try {
 370                                 object value = builder [null];
 371                                 Assert.Fail ("#C1");
 372                         } catch (ArgumentNullException ex) {
 373                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
 374                                 Assert.IsNull (ex.InnerException, "#C3");
 375                                 Assert.IsNotNull (ex.Message, "#C4");
 376                                 Assert.AreEqual ("keyword", ex.ParamName, "#C5");
 377                         }
 378                 }
 379
 380                 [Test]
 381                 public void Indexer_Value_Null ()
 382                 {
 383                         builder ["DriverID"] = null;
 384                         Assert.AreEqual (string.Empty, builder.ConnectionString, "#A1");
 385                         try {
 386                                 object value = builder ["DriverID"];
 387                                 Assert.Fail ("#A2:" + value);
 388                         } catch (ArgumentException ex) {
 389                                 // Keyword not supported: 'DriverID'
 390                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A3");
 391                                 Assert.IsNull (ex.InnerException, "#A4");
 392                                 Assert.IsNotNull (ex.Message, "#A5");
 393                                 Assert.IsTrue (ex.Message.IndexOf ("'DriverID'") != -1, "#A6:" + ex.Message);
 394                                 Assert.IsNull (ex.ParamName, "#A7");
 395                         }
 396                         Assert.IsFalse (builder.ContainsKey ("DriverID"), "#A8");
 397                         Assert.AreEqual (string.Empty, builder.ConnectionString, "#A9");
 398
 399                         builder ["DriverID"] = "A";
 400                         Assert.AreEqual ("DriverID=A", builder.ConnectionString, "#B1");
 401                         builder ["DriverID"] = null;
 402                         Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B2");
 403                         Assert.AreEqual (string.Empty, builder.ConnectionString, "#B3");
 404                 }
 405
 406                 [Test]
 407                 public void Remove ()
 408                 {
 409                         Assert.IsFalse (builder.Remove ("Dsn"), "#A1");
 410                         Assert.IsFalse (builder.Remove ("Driver"), "#A2");
 411                         builder.Add ("DriverID", "790");
 412                         builder ["DefaultDir"] = "C:\\";
 413                         Assert.IsTrue (builder.Remove ("DriverID"), "#B1");
 414                         Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B2");
 415                         Assert.IsFalse (builder.Remove ("DriverID"), "#B3");
 416                         Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B4");
 417                         Assert.IsTrue (builder.Remove ("defaulTdIr"), "#B5");
 418                         Assert.IsFalse (builder.ContainsKey ("DefaultDir"), "#B6");
 419                         Assert.IsFalse (builder.Remove ("defaulTdIr"), "#B7");
 420                         Assert.IsFalse (builder.Remove ("userid"), "#B8");
 421                         Assert.IsFalse (builder.Remove (string.Empty), "#B9");
 422                         Assert.IsFalse (builder.Remove ("\r"), "#B10");
 423                         Assert.IsFalse (builder.Remove ("a;"), "#B11");
 424                         builder ["Dsn"] = "myDsn";
 425                         Assert.IsTrue (builder.Remove ("Dsn"), "#C1");
 426                         Assert.IsFalse (builder.ContainsKey ("Dsn"), "#C2");
 427                         Assert.IsFalse (builder.Remove ("Dsn"), "#C3");
 428                         builder ["Driver"] = "SQL Server";
 429                         Assert.IsTrue (builder.Remove ("Driver"), "#D1");
 430                         Assert.IsFalse (builder.ContainsKey ("Driver"), "#D2");
 431                         Assert.IsFalse (builder.Remove ("Driver"), "#D3");
 432
 433                         builder = new DbConnectionStringBuilder (false);
 434                         Assert.IsFalse (builder.Remove ("Dsn"), "#A1");
 435                         Assert.IsFalse (builder.Remove ("Driver"), "#A2");
 436                         builder.Add ("DriverID", "790");
 437                         builder ["DefaultDir"] = "C:\\";
 438                         Assert.IsTrue (builder.Remove ("DriverID"), "#B1");
 439                         Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B2");
 440                         Assert.IsFalse (builder.Remove ("DriverID"), "#B3");
 441                         Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B4");
 442                         Assert.IsTrue (builder.Remove ("defaulTdIr"), "#B5");
 443                         Assert.IsFalse (builder.ContainsKey ("DefaultDir"), "#B6");
 444                         Assert.IsFalse (builder.Remove ("defaulTdIr"), "#B7");
 445                         Assert.IsFalse (builder.Remove ("userid"), "#B8");
 446                         Assert.IsFalse (builder.Remove (string.Empty), "#B9");
 447                         Assert.IsFalse (builder.Remove ("\r"), "#B10");
 448                         Assert.IsFalse (builder.Remove ("a;"), "#B11");
 449                         builder ["Dsn"] = "myDsn";
 450                         Assert.IsTrue (builder.Remove ("Dsn"), "#C1");
 451                         Assert.IsFalse (builder.ContainsKey ("Dsn"), "#C2");
 452                         Assert.IsFalse (builder.Remove ("Dsn"), "#C3");
 453                         builder ["Driver"] = "SQL Server";
 454                         Assert.IsTrue (builder.Remove ("Driver"), "#D1");
 455                         Assert.IsFalse (builder.ContainsKey ("Driver"), "#D2");
 456                         Assert.IsFalse (builder.Remove ("Driver"), "#D3");
 457
 458                         builder = new DbConnectionStringBuilder (true);
 459                         Assert.IsFalse (builder.Remove ("Dsn"), "#A1");
 460                         Assert.IsFalse (builder.Remove ("Driver"), "#A2");
 461                         builder.Add ("DriverID", "790");
 462                         builder ["DefaultDir"] = "C:\\";
 463                         Assert.IsTrue (builder.Remove ("DriverID"), "#B1");
 464                         Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B2");
 465                         Assert.IsFalse (builder.Remove ("DriverID"), "#B3");
 466                         Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B4");
 467                         Assert.IsTrue (builder.Remove ("defaulTdIr"), "#B5");
 468                         Assert.IsFalse (builder.ContainsKey ("DefaultDir"), "#B6");
 469                         Assert.IsFalse (builder.Remove ("defaulTdIr"), "#B7");
 470                         Assert.IsFalse (builder.Remove ("userid"), "#B8");
 471                         Assert.IsFalse (builder.Remove (string.Empty), "#B9");
 472                         Assert.IsFalse (builder.Remove ("\r"), "#B10");
 473                         Assert.IsFalse (builder.Remove ("a;"), "#B11");
 474                         builder ["Dsn"] = "myDsn";
 475                         Assert.IsTrue (builder.Remove ("Dsn"), "#C1");
 476                         Assert.IsFalse (builder.ContainsKey ("Dsn"), "#C2");
 477                         Assert.IsFalse (builder.Remove ("Dsn"), "#C3");
 478                         builder ["Driver"] = "SQL Server";
 479                         Assert.IsTrue (builder.Remove ("Driver"), "#D1");
 480                         Assert.IsFalse (builder.ContainsKey ("Driver"), "#D2");
 481                         Assert.IsFalse (builder.Remove ("Driver"), "#D3");
 482                 }
 483
 484                 [Test]
 485                 public void Remove_Keyword_Null ()
 486                 {
 487                         try {
 488                                 builder.Remove (null);
 489                                 Assert.Fail ("#1");
 490                         } catch (ArgumentNullException ex) {
 491                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 492                                 Assert.IsNull (ex.InnerException, "#3");
 493                                 Assert.IsNotNull (ex.Message, "#4");
 494                                 Assert.AreEqual ("keyword", ex.ParamName, "#5");
 495                         }
 496                 }
 497
 498                 [Test]
 499                 public void ContainsKey ()
 500                 {
 501                         builder ["SourceType"] = "DBC";
 502                         builder.Add ("Port", "56");
 503                         Assert.IsTrue (builder.ContainsKey ("SourceType"), "#A1");
 504                         Assert.IsTrue (builder.ContainsKey ("Port"), "#A2");
 505                         Assert.IsFalse (builder.ContainsKey ("Dsn"), "#A3");
 506                         Assert.IsFalse (builder.ContainsKey ("Driver"), "#A4");
 507                         Assert.IsFalse (builder.ContainsKey ("xyz"), "#A5");
 508                         builder ["Dsn"] = "myDsn";
 509                         Assert.IsTrue (builder.ContainsKey ("Dsn"), "#A6");
 510                         builder ["Driver"] = "SQL Server";
 511                         Assert.IsTrue (builder.ContainsKey ("Driver"), "#A7");
 512                         builder ["abc"] = "pqr";
 513                         Assert.IsTrue (builder.ContainsKey ("ABC"), "#A8");
 514                         Assert.IsFalse (builder.ContainsKey (string.Empty), "#A9");
 515
 516                         builder = new DbConnectionStringBuilder (false);
 517                         builder ["SourceType"] = "DBC";
 518                         builder.Add ("Port", "56");
 519                         Assert.IsTrue (builder.ContainsKey ("SourceType"), "#A1");
 520                         Assert.IsTrue (builder.ContainsKey ("Port"), "#A2");
 521                         Assert.IsFalse (builder.ContainsKey ("Dsn"), "#A3");
 522                         Assert.IsFalse (builder.ContainsKey ("Driver"), "#A4");
 523                         Assert.IsFalse (builder.ContainsKey ("xyz"), "#A5");
 524                         builder ["Dsn"] = "myDsn";
 525                         Assert.IsTrue (builder.ContainsKey ("Dsn"), "#A6");
 526                         builder ["Driver"] = "SQL Server";
 527                         Assert.IsTrue (builder.ContainsKey ("Driver"), "#A7");
 528                         builder ["abc"] = "pqr";
 529                         Assert.IsTrue (builder.ContainsKey ("ABC"), "#A8");
 530                         Assert.IsFalse (builder.ContainsKey (string.Empty), "#A9");
 531
 532                         builder = new DbConnectionStringBuilder (true);
 533                         builder ["SourceType"] = "DBC";
 534                         builder.Add ("Port", "56");
 535                         Assert.IsTrue (builder.ContainsKey ("SourceType"), "#A1");
 536                         Assert.IsTrue (builder.ContainsKey ("Port"), "#A2");
 537                         Assert.IsFalse (builder.ContainsKey ("Dsn"), "#A3");
 538                         Assert.IsFalse (builder.ContainsKey ("Driver"), "#A4");
 539                         Assert.IsFalse (builder.ContainsKey ("xyz"), "#A5");
 540                         builder ["Dsn"] = "myDsn";
 541                         Assert.IsTrue (builder.ContainsKey ("Dsn"), "#A6");
 542                         builder ["Driver"] = "SQL Server";
 543                         Assert.IsTrue (builder.ContainsKey ("Driver"), "#A7");
 544                         builder ["abc"] = "pqr";
 545                         Assert.IsTrue (builder.ContainsKey ("ABC"), "#A8");
 546                         Assert.IsFalse (builder.ContainsKey (string.Empty), "#A9");
 547                 }
 548
 549                 [Test]
 550                 public void ContainsKey_Keyword_Null ()
 551                 {
 552                         builder ["SourceType"] = "DBC";
 553                         try {
 554                                 builder.ContainsKey (null);
 555                                 Assert.Fail ("#1");
 556                         } catch (ArgumentNullException ex) {
 557                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 558                                 Assert.IsNull (ex.InnerException, "#3");
 559                                 Assert.IsNotNull (ex.Message, "#4");
 560                                 Assert.AreEqual ("keyword", ex.ParamName, "#5");
 561                         }
 562                 }
 563
 564                 [Test]
 565                 public void EquivalentToTest ()
 566                 {
 567                         builder.Add (SERVER, SERVER_VALUE);
 568                         DbConnectionStringBuilder sb2 = new DbConnectionStringBuilder ();
 569                         sb2.Add (SERVER, SERVER_VALUE);
 570                         bool value = builder.EquivalentTo (sb2);
 571                         Assert.IsTrue (value, "builder comparision does not work!");
 572
 573                         // negative tests
 574                         sb2.Add (SERVER + "1", SERVER_VALUE);
 575                         value = builder.EquivalentTo (sb2);
 576                         Assert.IsFalse (value, "builder comparision does not work for not equivalent strings!");
 577                 }
 578
 579                 [Test] // AppendKeyValuePair (StringBuilder, String, String)
 580                 public void AppendKeyValuePair1 ()
 581                 {
 582                         StringBuilder sb = new StringBuilder ();
 583                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure");
 584                         Assert.AreEqual ("Database=Adventure", sb.ToString (), "#A1");
 585                         sb.Length = 0;
 586                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture");
 587                         Assert.AreEqual ("Database=\"Adven'ture\"", sb.ToString (), "#A2");
 588                         sb.Length = 0;
 589                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture");
 590                         Assert.AreEqual ("Database='Adven\"ture'", sb.ToString (), "#A3");
 591                         sb.Length = 0;
 592                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure\"");
 593                         Assert.AreEqual ("Database='\"Adventure\"'", sb.ToString (), "#A4");
 594                         sb.Length = 0;
 595                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture\"");
 596                         Assert.AreEqual ("Database=\"\"\"Adven'ture\"\"\"", sb.ToString (), "#A5");
 597                         sb.Length = 0;
 598
 599                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture");
 600                         Assert.AreEqual ("Database=\"Adven;ture\"", sb.ToString (), "#B1");
 601                         sb.Length = 0;
 602                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure;");
 603                         Assert.AreEqual ("Database=\"Adventure;\"", sb.ToString (), "#B2");
 604                         sb.Length = 0;
 605                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure");
 606                         Assert.AreEqual ("Database=\";Adventure\"", sb.ToString (), "#B3");
 607                         sb.Length = 0;
 608                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture");
 609                         Assert.AreEqual ("Database=\"Adv'en;ture\"", sb.ToString (), "#B4");
 610                         sb.Length = 0;
 611                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture");
 612                         Assert.AreEqual ("Database='Adv\"en;ture'", sb.ToString (), "#B5");
 613                         sb.Length = 0;
 614                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture");
 615                         Assert.AreEqual ("Database=\"A'dv\"\"en;ture\"", sb.ToString (), "#B6");
 616                         sb.Length = 0;
 617                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture\"");
 618                         Assert.AreEqual ("Database='\"Adven;ture\"'", sb.ToString (), "#B7");
 619                         sb.Length = 0;
 620
 621                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture");
 622                         Assert.AreEqual ("Database=\"Adven=ture\"", sb.ToString (), "#C1");
 623                         sb.Length = 0;
 624                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture");
 625                         Assert.AreEqual ("Database=\"Adv'en=ture\"", sb.ToString (), "#C2");
 626                         sb.Length = 0;
 627                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture");
 628                         Assert.AreEqual ("Database='Adv\"en=ture'", sb.ToString (), "#C3");
 629                         sb.Length = 0;
 630                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture");
 631                         Assert.AreEqual ("Database=\"A'dv\"\"en=ture\"", sb.ToString (), "#C4");
 632                         sb.Length = 0;
 633                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture\"");
 634                         Assert.AreEqual ("Database='\"Adven=ture\"'", sb.ToString (), "#C5");
 635                         sb.Length = 0;
 636
 637                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture");
 638                         Assert.AreEqual ("Database=Adven{ture", sb.ToString (), "#D1");
 639                         sb.Length = 0;
 640                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture");
 641                         Assert.AreEqual ("Database=Adven}ture", sb.ToString (), "#D2");
 642                         sb.Length = 0;
 643                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure");
 644                         Assert.AreEqual ("Database={Adventure", sb.ToString (), "#D3");
 645                         sb.Length = 0;
 646                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure");
 647                         Assert.AreEqual ("Database=}Adventure", sb.ToString (), "#D4");
 648                         sb.Length = 0;
 649                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure{");
 650                         Assert.AreEqual ("Database=Adventure{", sb.ToString (), "#D5");
 651                         sb.Length = 0;
 652                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure}");
 653                         Assert.AreEqual ("Database=Adventure}", sb.ToString (), "#D6");
 654                         sb.Length = 0;
 655                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture");
 656                         Assert.AreEqual ("Database=\"Adv'en{ture\"", sb.ToString (), "#D7");
 657                         sb.Length = 0;
 658                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture");
 659                         Assert.AreEqual ("Database=\"Adv'en}ture\"", sb.ToString (), "#D8");
 660                         sb.Length = 0;
 661                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture");
 662                         Assert.AreEqual ("Database='Adv\"en{ture'", sb.ToString (), "#D9");
 663                         sb.Length = 0;
 664                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture");
 665                         Assert.AreEqual ("Database='Adv\"en}ture'", sb.ToString (), "#D10");
 666                         sb.Length = 0;
 667                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture");
 668                         Assert.AreEqual ("Database=\"A'dv\"\"en{ture\"", sb.ToString (), "#D11");
 669                         sb.Length = 0;
 670                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture");
 671                         Assert.AreEqual ("Database=\"A'dv\"\"en}ture\"", sb.ToString (), "#D12");
 672                         sb.Length = 0;
 673                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture\"");
 674                         Assert.AreEqual ("Database='\"Adven{ture\"'", sb.ToString (), "#D13");
 675                         sb.Length = 0;
 676                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture\"");
 677                         Assert.AreEqual ("Database='\"Adven}ture\"'", sb.ToString (), "#D14");
 678                         sb.Length = 0;
 679
 680                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure");
 681                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost");
 682                         Assert.AreEqual ("Database=Adventure;Server=localhost", sb.ToString (), "#E1");
 683                         sb.Length = 0;
 684                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", string.Empty);
 685                         Assert.AreEqual ("Database=", sb.ToString (), "#E2");
 686                         sb.Length = 0;
 687                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", null);
 688                         Assert.AreEqual ("Database=", sb.ToString (), "#E3");
 689                         sb.Length = 0;
 690
 691                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Datab=ase", "Adven=ture", false);
 692                         Assert.AreEqual ("Datab==ase=\"Adven=ture\"", sb.ToString (), "#F1");
 693                 }
 694
 695                 [Test] // AppendKeyValuePair (StringBuilder, String, String)
 696                 public void AppendKeyValuePair1_Builder_Null ()
 697                 {
 698                         try {
 699                                 DbConnectionStringBuilder.AppendKeyValuePair (
 700                                         (StringBuilder) null, "Server",
 701                                         "localhost");
 702                                 Assert.Fail ("#1");
 703                         } catch (ArgumentNullException ex) {
 704                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 705                                 Assert.IsNull (ex.InnerException, "#3");
 706                                 Assert.IsNotNull (ex.Message, "#4");
 707                                 Assert.AreEqual ("builder", ex.ParamName, "#5");
 708                         }
 709                 }
 710
 711                 [Test] // AppendKeyValuePair (StringBuilder, String, String)
 712                 public void AppendKeyValuePair1_Keyword_Empty ()
 713                 {
 714                         StringBuilder sb = new StringBuilder ();
 715                         try {
 716                                 DbConnectionStringBuilder.AppendKeyValuePair (
 717                                         sb, string.Empty, "localhost");
 718                                 Assert.Fail ("#1");
 719                         } catch (ArgumentException ex) {
 720                                 // Expecting non-empty string for 'keyName'
 721                                 // parameter
 722                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 723                                 Assert.IsNull (ex.InnerException, "#3");
 724                                 Assert.IsNotNull (ex.Message, "#4");
 725                                 Assert.IsNull (ex.ParamName, "#5");
 726                         }
 727                 }
 728
 729                 [Test] // AppendKeyValuePair (StringBuilder, String, String)
 730                 public void AppendKeyValuePair1_Keyword_Null ()
 731                 {
 732                         StringBuilder sb = new StringBuilder ();
 733                         try {
 734                                 DbConnectionStringBuilder.AppendKeyValuePair (
 735                                         sb, (string) null, "localhost");
 736                                 Assert.Fail ("#1");
 737                         } catch (ArgumentNullException ex) {
 738                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 739                                 Assert.IsNull (ex.InnerException, "#3");
 740                                 Assert.IsNotNull (ex.Message, "#4");
 741                                 Assert.AreEqual ("keyName", ex.ParamName, "#5");
 742                         }
 743                 }
 744
 745                 [Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
 746                 public void AppendKeyValuePair2_UseOdbcRules_False ()
 747                 {
 748                         StringBuilder sb = new StringBuilder ();
 749                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works", false);
 750                         Assert.AreEqual ("Database=\"Adventure Works\"", sb.ToString (), "#A1");
 751                         sb.Length = 0;
 752                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure", false);
 753                         Assert.AreEqual ("Database=Adventure", sb.ToString (), "#A2");
 754                         sb.Length = 0;
 755                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture Works", false);
 756                         Assert.AreEqual ("Database=\"Adven'ture Works\"", sb.ToString (), "#A3");
 757                         sb.Length = 0;
 758                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture", false);
 759                         Assert.AreEqual ("Database=\"Adven'ture\"", sb.ToString (), "#A4");
 760                         sb.Length = 0;
 761                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture Works", false);
 762                         Assert.AreEqual ("Database='Adven\"ture Works'", sb.ToString (), "#A5");
 763                         sb.Length = 0;
 764                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture", false);
 765                         Assert.AreEqual ("Database='Adven\"ture'", sb.ToString (), "#A6");
 766                         sb.Length = 0;
 767                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure Works\"", false);
 768                         Assert.AreEqual ("Database='\"Adventure Works\"'", sb.ToString (), "#A7");
 769                         sb.Length = 0;
 770                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure\"", false);
 771                         Assert.AreEqual ("Database='\"Adventure\"'", sb.ToString (), "#A8");
 772                         sb.Length = 0;
 773                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture Works\"", false);
 774                         Assert.AreEqual ("Database=\"\"\"Adven'ture Works\"\"\"", sb.ToString (), "#A9");
 775                         sb.Length = 0;
 776                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture\"", false);
 777                         Assert.AreEqual ("Database=\"\"\"Adven'ture\"\"\"", sb.ToString (), "#A10");
 778                         sb.Length = 0;
 779
 780                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture Works", false);
 781                         Assert.AreEqual ("Database=\"Adven;ture Works\"", sb.ToString (), "#B1");
 782                         sb.Length = 0;
 783                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture", false);
 784                         Assert.AreEqual ("Database=\"Adven;ture\"", sb.ToString (), "#B2");
 785                         sb.Length = 0;
 786                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works;", false);
 787                         Assert.AreEqual ("Database=\"Adventure Works;\"", sb.ToString (), "#B3");
 788                         sb.Length = 0;
 789                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure;", false);
 790                         Assert.AreEqual ("Database=\"Adventure;\"", sb.ToString (), "#B4");
 791                         sb.Length = 0;
 792                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure Works", false);
 793                         Assert.AreEqual ("Database=\";Adventure Works\"", sb.ToString (), "#B5");
 794                         sb.Length = 0;
 795                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure", false);
 796                         Assert.AreEqual ("Database=\";Adventure\"", sb.ToString (), "#B6");
 797                         sb.Length = 0;
 798                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture Works", false);
 799                         Assert.AreEqual ("Database=\"Adv'en;ture Works\"", sb.ToString (), "#B7");
 800                         sb.Length = 0;
 801                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture", false);
 802                         Assert.AreEqual ("Database=\"Adv'en;ture\"", sb.ToString (), "#B8");
 803                         sb.Length = 0;
 804                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture Works", false);
 805                         Assert.AreEqual ("Database='Adv\"en;ture Works'", sb.ToString (), "#B9");
 806                         sb.Length = 0;
 807                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture", false);
 808                         Assert.AreEqual ("Database='Adv\"en;ture'", sb.ToString (), "#B10");
 809                         sb.Length = 0;
 810                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture Works", false);
 811                         Assert.AreEqual ("Database=\"A'dv\"\"en;ture Works\"", sb.ToString (), "#B11");
 812                         sb.Length = 0;
 813                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture", false);
 814                         Assert.AreEqual ("Database=\"A'dv\"\"en;ture\"", sb.ToString (), "#B12");
 815                         sb.Length = 0;
 816                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture Works\"", false);
 817                         Assert.AreEqual ("Database='\"Adven;ture Works\"'", sb.ToString (), "#B13");
 818                         sb.Length = 0;
 819                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture\"", false);
 820                         Assert.AreEqual ("Database='\"Adven;ture\"'", sb.ToString (), "#B14");
 821                         sb.Length = 0;
 822
 823                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture Works", false);
 824                         Assert.AreEqual ("Database=\"Adven=ture Works\"", sb.ToString (), "#C1");
 825                         sb.Length = 0;
 826                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture", false);
 827                         Assert.AreEqual ("Database=\"Adven=ture\"", sb.ToString (), "#C2");
 828                         sb.Length = 0;
 829                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture Works", false);
 830                         Assert.AreEqual ("Database=\"Adv'en=ture Works\"", sb.ToString (), "#C3");
 831                         sb.Length = 0;
 832                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture", false);
 833                         Assert.AreEqual ("Database=\"Adv'en=ture\"", sb.ToString (), "#C4");
 834                         sb.Length = 0;
 835                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture Works", false);
 836                         Assert.AreEqual ("Database='Adv\"en=ture Works'", sb.ToString (), "#C5");
 837                         sb.Length = 0;
 838                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture", false);
 839                         Assert.AreEqual ("Database='Adv\"en=ture'", sb.ToString (), "#C6");
 840                         sb.Length = 0;
 841                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture Works", false);
 842                         Assert.AreEqual ("Database=\"A'dv\"\"en=ture Works\"", sb.ToString (), "#C7");
 843                         sb.Length = 0;
 844                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture", false);
 845                         Assert.AreEqual ("Database=\"A'dv\"\"en=ture\"", sb.ToString (), "#C8");
 846                         sb.Length = 0;
 847                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture Works\"", false);
 848                         Assert.AreEqual ("Database='\"Adven=ture Works\"'", sb.ToString (), "#C9");
 849                         sb.Length = 0;
 850                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture\"", false);
 851                         Assert.AreEqual ("Database='\"Adven=ture\"'", sb.ToString (), "#C10");
 852                         sb.Length = 0;
 853
 854                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture Works", false);
 855                         Assert.AreEqual ("Database=\"Adven{ture Works\"", sb.ToString (), "#D1");
 856                         sb.Length = 0;
 857                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture", false);
 858                         Assert.AreEqual ("Database=Adven{ture", sb.ToString (), "#D2");
 859                         sb.Length = 0;
 860                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture Works", false);
 861                         Assert.AreEqual ("Database=\"Adven}ture Works\"", sb.ToString (), "#D3");
 862                         sb.Length = 0;
 863                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture", false);
 864                         Assert.AreEqual ("Database=Adven}ture", sb.ToString (), "#D4");
 865                         sb.Length = 0;
 866                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure Works", false);
 867                         Assert.AreEqual ("Database=\"{Adventure Works\"", sb.ToString (), "#D5");
 868                         sb.Length = 0;
 869                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure", false);
 870                         Assert.AreEqual ("Database={Adventure", sb.ToString (), "#D6");
 871                         sb.Length = 0;
 872                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure Works", false);
 873                         Assert.AreEqual ("Database=\"}Adventure Works\"", sb.ToString (), "#D7");
 874                         sb.Length = 0;
 875                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure", false);
 876                         Assert.AreEqual ("Database=}Adventure", sb.ToString (), "#D8");
 877                         sb.Length = 0;
 878                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works{", false);
 879                         Assert.AreEqual ("Database=\"Adventure Works{\"", sb.ToString (), "#D9");
 880                         sb.Length = 0;
 881                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure{", false);
 882                         Assert.AreEqual ("Database=Adventure{", sb.ToString (), "#D10");
 883                         sb.Length = 0;
 884                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works}", false);
 885                         Assert.AreEqual ("Database=\"Adventure Works}\"", sb.ToString (), "#D11");
 886                         sb.Length = 0;
 887                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure}", false);
 888                         Assert.AreEqual ("Database=Adventure}", sb.ToString (), "#D12");
 889                         sb.Length = 0;
 890                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture Works", false);
 891                         Assert.AreEqual ("Database=\"Adv'en{ture Works\"", sb.ToString (), "#D13");
 892                         sb.Length = 0;
 893                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture", false);
 894                         Assert.AreEqual ("Database=\"Adv'en{ture\"", sb.ToString (), "#D14");
 895                         sb.Length = 0;
 896                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture Works", false);
 897                         Assert.AreEqual ("Database=\"Adv'en}ture Works\"", sb.ToString (), "#D15");
 898                         sb.Length = 0;
 899                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture", false);
 900                         Assert.AreEqual ("Database=\"Adv'en}ture\"", sb.ToString (), "#D16");
 901                         sb.Length = 0;
 902                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture Works", false);
 903                         Assert.AreEqual ("Database='Adv\"en{ture Works'", sb.ToString (), "#D17");
 904                         sb.Length = 0;
 905                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture", false);
 906                         Assert.AreEqual ("Database='Adv\"en{ture'", sb.ToString (), "#D18");
 907                         sb.Length = 0;
 908                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture Works", false);
 909                         Assert.AreEqual ("Database='Adv\"en}ture Works'", sb.ToString (), "#D19");
 910                         sb.Length = 0;
 911                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture", false);
 912                         Assert.AreEqual ("Database='Adv\"en}ture'", sb.ToString (), "#D20");
 913                         sb.Length = 0;
 914                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture Works", false);
 915                         Assert.AreEqual ("Database=\"A'dv\"\"en{ture Works\"", sb.ToString (), "#D21");
 916                         sb.Length = 0;
 917                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture", false);
 918                         Assert.AreEqual ("Database=\"A'dv\"\"en{ture\"", sb.ToString (), "#D22");
 919                         sb.Length = 0;
 920                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture Works", false);
 921                         Assert.AreEqual ("Database=\"A'dv\"\"en}ture Works\"", sb.ToString (), "#D23");
 922                         sb.Length = 0;
 923                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture", false);
 924                         Assert.AreEqual ("Database=\"A'dv\"\"en}ture\"", sb.ToString (), "#D24");
 925                         sb.Length = 0;
 926                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture Works\"", false);
 927                         Assert.AreEqual ("Database='\"Adven{ture Works\"'", sb.ToString (), "#D25");
 928                         sb.Length = 0;
 929                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture\"", false);
 930                         Assert.AreEqual ("Database='\"Adven{ture\"'", sb.ToString (), "#D26");
 931                         sb.Length = 0;
 932                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture Works\"", false);
 933                         Assert.AreEqual ("Database='\"Adven}ture Works\"'", sb.ToString (), "#D27");
 934                         sb.Length = 0;
 935                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture\"", false);
 936                         Assert.AreEqual ("Database='\"Adven}ture\"'", sb.ToString (), "#D28");
 937                         sb.Length = 0;
 938                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}}}", false);
 939                         Assert.AreEqual ("Database={{{B}}}", sb.ToString (), "#D33a");
 940                         sb.Length = 0;
 941                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}}}", false);
 942                         Assert.AreEqual ("Driver={{{B}}}", sb.ToString (), "#D33b");
 943                         sb.Length = 0;
 944                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{A{B{C}D}E}", false);
 945                         Assert.AreEqual ("Database={A{B{C}D}E}", sb.ToString (), "#D33c");
 946                         sb.Length = 0;
 947                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{A{B{C}D}E}", false);
 948                         Assert.AreEqual ("Driver={A{B{C}D}E}", sb.ToString (), "#D33d");
 949                         sb.Length = 0;
 950                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}}", false);
 951                         Assert.AreEqual ("Database={{{B}}", sb.ToString (), "#D33e");
 952                         sb.Length = 0;
 953                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}}", false);
 954                         Assert.AreEqual ("Driver={{{B}}", sb.ToString (), "#D33f");
 955                         sb.Length = 0;
 956                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}", false);
 957                         Assert.AreEqual ("Database={{{B}", sb.ToString (), "#D33g");
 958                         sb.Length = 0;
 959                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}", false);
 960                         Assert.AreEqual ("Driver={{{B}", sb.ToString (), "#D33h");
 961                         sb.Length = 0;
 962                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{B}", false);
 963                         Assert.AreEqual ("Database={{B}", sb.ToString (), "#D33i");
 964                         sb.Length = 0;
 965                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{B}", false);
 966                         Assert.AreEqual ("Driver={{B}", sb.ToString (), "#D33j");
 967                         sb.Length = 0;
 968                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{B}}", false);
 969                         Assert.AreEqual ("Database={B}}", sb.ToString (), "#D33k");
 970                         sb.Length = 0;
 971                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{B}}", false);
 972                         Assert.AreEqual ("Driver={B}}", sb.ToString (), "#D33l");
 973                         sb.Length = 0;
 974                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{B}}C", false);
 975                         Assert.AreEqual ("Database={B}}C", sb.ToString (), "#D33k");
 976                         sb.Length = 0;
 977                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{B}}C", false);
 978                         Assert.AreEqual ("Driver={B}}C", sb.ToString (), "#D33l");
 979                         sb.Length = 0;
 980                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A{B}}", false);
 981                         Assert.AreEqual ("Database=A{B}}", sb.ToString (), "#D33k");
 982                         sb.Length = 0;
 983                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A{B}}", false);
 984                         Assert.AreEqual ("Driver=A{B}}", sb.ToString (), "#D33l");
 985                         sb.Length = 0;
 986                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", " {B}} ", false);
 987                         Assert.AreEqual ("Database=\" {B}} \"", sb.ToString (), "#D33k");
 988                         sb.Length = 0;
 989                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", " {B}} ", false);
 990                         Assert.AreEqual ("Driver=\" {B}} \"", sb.ToString (), "#D33l");
 991                         sb.Length = 0;
 992                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{B}}", false);
 993                         Assert.AreEqual ("Database={{B}}", sb.ToString (), "#D33a");
 994                         sb.Length = 0;
 995                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{B}}", false);
 996                         Assert.AreEqual ("Driver={{B}}", sb.ToString (), "#D33b");
 997                         sb.Length = 0;
 998                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}}", false);
 999                         Assert.AreEqual ("Database=}}", sb.ToString (), "#D33a");
1000                         sb.Length = 0;
1001                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}}", false);
1002                         Assert.AreEqual ("Driver=}}", sb.ToString (), "#D33b");
1003                         sb.Length = 0;
1004                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}", false);
1005                         Assert.AreEqual ("Database=}", sb.ToString (), "#D33a");
1006                         sb.Length = 0;
1007                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}", false);
1008                         Assert.AreEqual ("Driver=}", sb.ToString (), "#D33b");
1009                         sb.Length = 0;
1010
1011                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works", false);
1012                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", false);
1013                         Assert.AreEqual ("Database=\"Adventure Works\";Server=localhost", sb.ToString (), "#E1");
1014                         sb.Length = 0;
1015                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure", false);
1016                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", false);
1017                         Assert.AreEqual ("Database=Adventure;Server=localhost", sb.ToString (), "#E2");
1018                         sb.Length = 0;
1019                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", string.Empty, false);
1020                         Assert.AreEqual ("Database=", sb.ToString (), "#E3");
1021                         sb.Length = 0;
1022                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", null, false);
1023                         Assert.AreEqual ("Database=", sb.ToString (), "#E4");
1024                         sb.Length = 0;
1025
1026                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Datab=ase", "Adven=ture", false);
1027                         Assert.AreEqual ("Datab==ase=\"Adven=ture\"", sb.ToString (), "#F1");
1028                 }
1029
1030                 [Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
1031                 public void AppendKeyValuePair2_UseOdbcRules_True ()
1032                 {
1033                         StringBuilder sb = new StringBuilder ();
1034                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works", true);
1035                         Assert.AreEqual ("Database=Adventure Works", sb.ToString (), "#A1a");
1036                         sb.Length = 0;
1037                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works", true);
1038                         Assert.AreEqual ("Driver={Adventure Works}", sb.ToString (), "#A1b");
1039                         sb.Length = 0;
1040                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure", true);
1041                         Assert.AreEqual ("Database=Adventure", sb.ToString (), "#A2a");
1042                         sb.Length = 0;
1043                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure", true);
1044                         Assert.AreEqual ("Driver={Adventure}", sb.ToString (), "#A2b");
1045                         sb.Length = 0;
1046                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture Works", true);
1047                         Assert.AreEqual ("Database=Adven'ture Works", sb.ToString (), "#A3a");
1048                         sb.Length = 0;
1049                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven'ture Works", true);
1050                         Assert.AreEqual ("Driver={Adven'ture Works}", sb.ToString (), "#A3b");
1051                         sb.Length = 0;
1052                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture", true);
1053                         Assert.AreEqual ("Database=Adven'ture", sb.ToString (), "#A4a");
1054                         sb.Length = 0;
1055                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven'ture", true);
1056                         Assert.AreEqual ("Driver={Adven'ture}", sb.ToString (), "#A4b");
1057                         sb.Length = 0;
1058                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture Works", true);
1059                         Assert.AreEqual ("Database=Adven\"ture Works", sb.ToString (), "#A5a");
1060                         sb.Length = 0;
1061                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven\"ture Works", true);
1062                         Assert.AreEqual ("Driver={Adven\"ture Works}", sb.ToString (), "#A5b");
1063                         sb.Length = 0;
1064                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture", true);
1065                         Assert.AreEqual ("Database=Adven\"ture", sb.ToString (), "#A6a");
1066                         sb.Length = 0;
1067                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven\"ture", true);
1068                         Assert.AreEqual ("Driver={Adven\"ture}", sb.ToString (), "#A6b");
1069                         sb.Length = 0;
1070                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure Works\"", true);
1071                         Assert.AreEqual ("Database=\"Adventure Works\"", sb.ToString (), "#A7a");
1072                         sb.Length = 0;
1073                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adventure Works\"", true);
1074                         Assert.AreEqual ("Driver={\"Adventure Works\"}", sb.ToString (), "#A7b");
1075                         sb.Length = 0;
1076                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure\"", true);
1077                         Assert.AreEqual ("Database=\"Adventure\"", sb.ToString (), "#A8a");
1078                         sb.Length = 0;
1079                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adventure\"", true);
1080                         Assert.AreEqual ("Driver={\"Adventure\"}", sb.ToString (), "#A8b");
1081                         sb.Length = 0;
1082                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture Works\"", true);
1083                         Assert.AreEqual ("Database=\"Adven'ture Works\"", sb.ToString (), "#A9a");
1084                         sb.Length = 0;
1085                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven'ture Works\"", true);
1086                         Assert.AreEqual ("Driver={\"Adven'ture Works\"}", sb.ToString (), "#A9b");
1087                         sb.Length = 0;
1088                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture\"", true);
1089                         Assert.AreEqual ("Database=\"Adven'ture\"", sb.ToString (), "#A10a");
1090                         sb.Length = 0;
1091                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven'ture\"", true);
1092                         Assert.AreEqual ("Driver={\"Adven'ture\"}", sb.ToString (), "#A10b");
1093                         sb.Length = 0;
1094
1095                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture Works", true);
1096                         Assert.AreEqual ("Database={Adven;ture Works}", sb.ToString (), "#B1a");
1097                         sb.Length = 0;
1098                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven;ture Works", true);
1099                         Assert.AreEqual ("Driver={Adven;ture Works}", sb.ToString (), "#B1b");
1100                         sb.Length = 0;
1101                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture", true);
1102                         Assert.AreEqual ("Database={Adven;ture}", sb.ToString (), "#B2a");
1103                         sb.Length = 0;
1104                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven;ture", true);
1105                         Assert.AreEqual ("Driver={Adven;ture}", sb.ToString (), "#B2b");
1106                         sb.Length = 0;
1107                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works;", true);
1108                         Assert.AreEqual ("Database={Adventure Works;}", sb.ToString (), "#B3a");
1109                         sb.Length = 0;
1110                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works;", true);
1111                         Assert.AreEqual ("Driver={Adventure Works;}", sb.ToString (), "#B3b");
1112                         sb.Length = 0;
1113                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure;", true);
1114                         Assert.AreEqual ("Database={Adventure;}", sb.ToString (), "#B4a");
1115                         sb.Length = 0;
1116                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure;", true);
1117                         Assert.AreEqual ("Driver={Adventure;}", sb.ToString (), "#B4b");
1118                         sb.Length = 0;
1119                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure Works", true);
1120                         Assert.AreEqual ("Database={;Adventure Works}", sb.ToString (), "#B5a");
1121                         sb.Length = 0;
1122                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", ";Adventure Works", true);
1123                         Assert.AreEqual ("Driver={;Adventure Works}", sb.ToString (), "#B5b");
1124                         sb.Length = 0;
1125                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure", true);
1126                         Assert.AreEqual ("Database={;Adventure}", sb.ToString (), "#B6a");
1127                         sb.Length = 0;
1128                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", ";Adventure", true);
1129                         Assert.AreEqual ("Driver={;Adventure}", sb.ToString (), "#B6b");
1130                         sb.Length = 0;
1131                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture Works", true);
1132                         Assert.AreEqual ("Database={Adv'en;ture Works}", sb.ToString (), "#B7a");
1133                         sb.Length = 0;
1134                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en;ture Works", true);
1135                         Assert.AreEqual ("Driver={Adv'en;ture Works}", sb.ToString (), "#B7b");
1136                         sb.Length = 0;
1137                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture", true);
1138                         Assert.AreEqual ("Database={Adv'en;ture}", sb.ToString (), "#B8a");
1139                         sb.Length = 0;
1140                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en;ture", true);
1141                         Assert.AreEqual ("Driver={Adv'en;ture}", sb.ToString (), "#B8b");
1142                         sb.Length = 0;
1143                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture Works", true);
1144                         Assert.AreEqual ("Database={Adv\"en;ture Works}", sb.ToString (), "#B9A");
1145                         sb.Length = 0;
1146                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en;ture Works", true);
1147                         Assert.AreEqual ("Driver={Adv\"en;ture Works}", sb.ToString (), "#B9b");
1148                         sb.Length = 0;
1149                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture", true);
1150                         Assert.AreEqual ("Database={Adv\"en;ture}", sb.ToString (), "#B10a");
1151                         sb.Length = 0;
1152                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en;ture", true);
1153                         Assert.AreEqual ("Driver={Adv\"en;ture}", sb.ToString (), "#B10b");
1154                         sb.Length = 0;
1155                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture Works", true);
1156                         Assert.AreEqual ("Database={A'dv\"en;ture Works}", sb.ToString (), "#B11a");
1157                         sb.Length = 0;
1158                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en;ture Works", true);
1159                         Assert.AreEqual ("Driver={A'dv\"en;ture Works}", sb.ToString (), "#B11b");
1160                         sb.Length = 0;
1161                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture", true);
1162                         Assert.AreEqual ("Database={A'dv\"en;ture}", sb.ToString (), "#B12a");
1163                         sb.Length = 0;
1164                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en;ture", true);
1165                         Assert.AreEqual ("Driver={A'dv\"en;ture}", sb.ToString (), "#B12b");
1166                         sb.Length = 0;
1167                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture Works\"", true);
1168                         Assert.AreEqual ("Database={\"Adven;ture Works\"}", sb.ToString (), "#B13a");
1169                         sb.Length = 0;
1170                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven;ture Works\"", true);
1171                         Assert.AreEqual ("Driver={\"Adven;ture Works\"}", sb.ToString (), "#B13b");
1172                         sb.Length = 0;
1173                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture\"", true);
1174                         Assert.AreEqual ("Database={\"Adven;ture\"}", sb.ToString (), "#B14a");
1175                         sb.Length = 0;
1176                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven;ture\"", true);
1177                         Assert.AreEqual ("Driver={\"Adven;ture\"}", sb.ToString (), "#B14b");
1178                         sb.Length = 0;
1179
1180                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture Works", true);
1181                         Assert.AreEqual ("Database=Adven=ture Works", sb.ToString (), "#C1a");
1182                         sb.Length = 0;
1183                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven=ture Works", true);
1184                         Assert.AreEqual ("Driver={Adven=ture Works}", sb.ToString (), "#C1b");
1185                         sb.Length = 0;
1186                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture", true);
1187                         Assert.AreEqual ("Database=Adven=ture", sb.ToString (), "#C2a");
1188                         sb.Length = 0;
1189                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven=ture", true);
1190                         Assert.AreEqual ("Driver={Adven=ture}", sb.ToString (), "#C2b");
1191                         sb.Length = 0;
1192                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture Works", true);
1193                         Assert.AreEqual ("Database=Adv'en=ture Works", sb.ToString (), "#C3a");
1194                         sb.Length = 0;
1195                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en=ture Works", true);
1196                         Assert.AreEqual ("Driver={Adv'en=ture Works}", sb.ToString (), "#C3b");
1197                         sb.Length = 0;
1198                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture", true);
1199                         Assert.AreEqual ("Database=Adv'en=ture", sb.ToString (), "#C4a");
1200                         sb.Length = 0;
1201                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en=ture", true);
1202                         Assert.AreEqual ("Driver={Adv'en=ture}", sb.ToString (), "#C4b");
1203                         sb.Length = 0;
1204                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture Works", true);
1205                         Assert.AreEqual ("Database=Adv\"en=ture Works", sb.ToString (), "#C5a");
1206                         sb.Length = 0;
1207                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en=ture Works", true);
1208                         Assert.AreEqual ("Driver={Adv\"en=ture Works}", sb.ToString (), "#C5b");
1209                         sb.Length = 0;
1210                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture", true);
1211                         Assert.AreEqual ("Database=Adv\"en=ture", sb.ToString (), "#C6a");
1212                         sb.Length = 0;
1213                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en=ture", true);
1214                         Assert.AreEqual ("Driver={Adv\"en=ture}", sb.ToString (), "#C6b");
1215                         sb.Length = 0;
1216                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture Works", true);
1217                         Assert.AreEqual ("Database=A'dv\"en=ture Works", sb.ToString (), "#C7a");
1218                         sb.Length = 0;
1219                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en=ture Works", true);
1220                         Assert.AreEqual ("Driver={A'dv\"en=ture Works}", sb.ToString (), "#C7b");
1221                         sb.Length = 0;
1222                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture", true);
1223                         Assert.AreEqual ("Database=A'dv\"en=ture", sb.ToString (), "#C8a");
1224                         sb.Length = 0;
1225                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en=ture", true);
1226                         Assert.AreEqual ("Driver={A'dv\"en=ture}", sb.ToString (), "#C8b");
1227                         sb.Length = 0;
1228                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture Works\"", true);
1229                         Assert.AreEqual ("Database=\"Adven=ture Works\"", sb.ToString (), "#C9a");
1230                         sb.Length = 0;
1231                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven=ture Works\"", true);
1232                         Assert.AreEqual ("Driver={\"Adven=ture Works\"}", sb.ToString (), "#C9b");
1233                         sb.Length = 0;
1234                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture\"", true);
1235                         Assert.AreEqual ("Database=\"Adven=ture\"", sb.ToString (), "#C10a");
1236                         sb.Length = 0;
1237                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven=ture\"", true);
1238                         Assert.AreEqual ("Driver={\"Adven=ture\"}", sb.ToString (), "#C10b");
1239                         sb.Length = 0;
1240
1241                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture Works", true);
1242                         Assert.AreEqual ("Database=Adven{ture Works", sb.ToString (), "#D1a");
1243                         sb.Length = 0;
1244                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven{ture Works", true);
1245                         Assert.AreEqual ("Driver={Adven{ture Works}", sb.ToString (), "#D1b");
1246                         sb.Length = 0;
1247                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{tu}re Works", true);
1248                         Assert.AreEqual ("Database=Adven{tu}re Works", sb.ToString (), "#D1c");
1249                         sb.Length = 0;
1250                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven{tu}re Works", true);
1251                         Assert.AreEqual ("Driver={Adven{tu}}re Works}", sb.ToString (), "#D1d");
1252                         sb.Length = 0;
1253                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture", true);
1254                         Assert.AreEqual ("Database=Adven{ture", sb.ToString (), "#D2a");
1255                         sb.Length = 0;
1256                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven{ture", true);
1257                         Assert.AreEqual ("Driver={Adven{ture}", sb.ToString (), "#D2b");
1258                         sb.Length = 0;
1259                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{tu}re", true);
1260                         Assert.AreEqual ("Database=Adven{tu}re", sb.ToString (), "#D2c");
1261                         sb.Length = 0;
1262                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven{tu}re", true);
1263                         Assert.AreEqual ("Driver={Adven{tu}}re}", sb.ToString (), "#D2d");
1264                         sb.Length = 0;
1265                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture Works", true);
1266                         Assert.AreEqual ("Database=Adven}ture Works", sb.ToString (), "#D3a");
1267                         sb.Length = 0;
1268                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven}ture Works", true);
1269                         Assert.AreEqual ("Driver={Adven}}ture Works}", sb.ToString (), "#D3b");
1270                         sb.Length = 0;
1271                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture", true);
1272                         Assert.AreEqual ("Database=Adven}ture", sb.ToString (), "#D4a");
1273                         sb.Length = 0;
1274                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven}ture", true);
1275                         Assert.AreEqual ("Driver={Adven}}ture}", sb.ToString (), "#D4b");
1276                         sb.Length = 0;
1277                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure Works", true);
1278                         Assert.AreEqual ("Database={{Adventure Works}", sb.ToString (), "#D5a");
1279                         sb.Length = 0;
1280                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure Works", true);
1281                         Assert.AreEqual ("Driver={{Adventure Works}", sb.ToString (), "#D5b");
1282                         sb.Length = 0;
1283                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure", true);
1284                         Assert.AreEqual ("Database={{Adventure}", sb.ToString (), "#D6a");
1285                         sb.Length = 0;
1286                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure", true);
1287                         Assert.AreEqual ("Driver={{Adventure}", sb.ToString (), "#D6b");
1288                         sb.Length = 0;
1289                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure Works}", true);
1290                         Assert.AreEqual ("Database={Adventure Works}", sb.ToString (), "#D7a");
1291                         sb.Length = 0;
1292                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure Works}", true);
1293                         Assert.AreEqual ("Driver={Adventure Works}", sb.ToString (), "#D7b");
1294                         sb.Length = 0;
1295                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventu{re Works}", true);
1296                         Assert.AreEqual ("Database={Adventu{re Works}", sb.ToString (), "#D7c");
1297                         sb.Length = 0;
1298                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventu{re Works}", true);
1299                         Assert.AreEqual ("Driver={Adventu{re Works}", sb.ToString (), "#D7d");
1300                         sb.Length = 0;
1301                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventu}re Works}", true);
1302                         Assert.AreEqual ("Database={{Adventu}}re Works}}}", sb.ToString (), "#D7e");
1303                         sb.Length = 0;
1304                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventu}re Works}", true);
1305                         Assert.AreEqual ("Driver={{Adventu}}re Works}}}", sb.ToString (), "#D7f");
1306                         sb.Length = 0;
1307                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure}", true);
1308                         Assert.AreEqual ("Database={Adventure}", sb.ToString (), "#D8a");
1309                         sb.Length = 0;
1310                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure}", true);
1311                         Assert.AreEqual ("Driver={Adventure}", sb.ToString (), "#D8b");
1312                         sb.Length = 0;
1313                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventu{re}", true);
1314                         Assert.AreEqual ("Database={Adventu{re}", sb.ToString (), "#D8c");
1315                         sb.Length = 0;
1316                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventu{re}", true);
1317                         Assert.AreEqual ("Driver={Adventu{re}", sb.ToString (), "#D8d");
1318                         sb.Length = 0;
1319                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventu}re}", true);
1320                         Assert.AreEqual ("Database={{Adventu}}re}}}", sb.ToString (), "#D8e");
1321                         sb.Length = 0;
1322                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventu}re}", true);
1323                         Assert.AreEqual ("Driver={{Adventu}}re}}}", sb.ToString (), "#D8f");
1324                         sb.Length = 0;
1325                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure }Works", true);
1326                         Assert.AreEqual ("Database={{Adventure }}Works}", sb.ToString (), "#D9a");
1327                         sb.Length = 0;
1328                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure }Works", true);
1329                         Assert.AreEqual ("Driver={{Adventure }}Works}", sb.ToString (), "#D9b");
1330                         sb.Length = 0;
1331                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adven}ture", true);
1332                         Assert.AreEqual ("Database={{Adven}}ture}", sb.ToString (), "#D10a");
1333                         sb.Length = 0;
1334                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adven}ture", true);
1335                         Assert.AreEqual ("Driver={{Adven}}ture}", sb.ToString (), "#D10b");
1336                         sb.Length = 0;
1337                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure Works", true);
1338                         Assert.AreEqual ("Database=}Adventure Works", sb.ToString (), "#D11a");
1339                         sb.Length = 0;
1340                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}Adventure Works", true);
1341                         Assert.AreEqual ("Driver={}}Adventure Works}", sb.ToString (), "#D11b");
1342                         sb.Length = 0;
1343                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure", true);
1344                         Assert.AreEqual ("Database=}Adventure", sb.ToString (), "#D12a");
1345                         sb.Length = 0;
1346                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}Adventure", true);
1347                         Assert.AreEqual ("Driver={}}Adventure}", sb.ToString (), "#D12b");
1348                         sb.Length = 0;
1349                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works{", true);
1350                         Assert.AreEqual ("Database=Adventure Works{", sb.ToString (), "#D13a");
1351                         sb.Length = 0;
1352                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works{", true);
1353                         Assert.AreEqual ("Driver={Adventure Works{}", sb.ToString (), "#D13b");
1354                         sb.Length = 0;
1355                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure{", true);
1356                         Assert.AreEqual ("Database=Adventure{", sb.ToString (), "#D14a");
1357                         sb.Length = 0;
1358                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure{", true);
1359                         Assert.AreEqual ("Driver={Adventure{}", sb.ToString (), "#D14b");
1360                         sb.Length = 0;
1361                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works}", true);
1362                         Assert.AreEqual ("Database=Adventure Works}", sb.ToString (), "#D15a");
1363                         sb.Length = 0;
1364                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works}", true);
1365                         Assert.AreEqual ("Driver={Adventure Works}}}", sb.ToString (), "#D15b");
1366                         sb.Length = 0;
1367                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure}", true);
1368                         Assert.AreEqual ("Database=Adventure}", sb.ToString (), "#D16a");
1369                         sb.Length = 0;
1370                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure}", true);
1371                         Assert.AreEqual ("Driver={Adventure}}}", sb.ToString (), "#D16b");
1372                         sb.Length = 0;
1373                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture Works", true);
1374                         Assert.AreEqual ("Database=Adv'en{ture Works", sb.ToString (), "#D17a");
1375                         sb.Length = 0;
1376                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en{ture Works", true);
1377                         Assert.AreEqual ("Driver={Adv'en{ture Works}", sb.ToString (), "#D17b");
1378                         sb.Length = 0;
1379                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture", true);
1380                         Assert.AreEqual ("Database=Adv'en{ture", sb.ToString (), "#D18a");
1381                         sb.Length = 0;
1382                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en{ture", true);
1383                         Assert.AreEqual ("Driver={Adv'en{ture}", sb.ToString (), "#D18b");
1384                         sb.Length = 0;
1385                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture Works", true);
1386                         Assert.AreEqual ("Database=Adv'en}ture Works", sb.ToString (), "#D19a");
1387                         sb.Length = 0;
1388                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en}ture Works", true);
1389                         Assert.AreEqual ("Driver={Adv'en}}ture Works}", sb.ToString (), "#D19b");
1390                         sb.Length = 0;
1391                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture", true);
1392                         Assert.AreEqual ("Database=Adv'en}ture", sb.ToString (), "#D20a");
1393                         sb.Length = 0;
1394                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en}ture", true);
1395                         Assert.AreEqual ("Driver={Adv'en}}ture}", sb.ToString (), "#D20b");
1396                         sb.Length = 0;
1397                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture Works", true);
1398                         Assert.AreEqual ("Database=Adv\"en{ture Works", sb.ToString (), "#D21a");
1399                         sb.Length = 0;
1400                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en{ture Works", true);
1401                         Assert.AreEqual ("Driver={Adv\"en{ture Works}", sb.ToString (), "#D21b");
1402                         sb.Length = 0;
1403                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture", true);
1404                         Assert.AreEqual ("Database=Adv\"en{ture", sb.ToString (), "#D22a");
1405                         sb.Length = 0;
1406                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en{ture", true);
1407                         Assert.AreEqual ("Driver={Adv\"en{ture}", sb.ToString (), "#D22b");
1408                         sb.Length = 0;
1409                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture Works", true);
1410                         Assert.AreEqual ("Database=Adv\"en}ture Works", sb.ToString (), "#D23a");
1411                         sb.Length = 0;
1412                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en}ture Works", true);
1413                         Assert.AreEqual ("Driver={Adv\"en}}ture Works}", sb.ToString (), "#D23b");
1414                         sb.Length = 0;
1415                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture", true);
1416                         Assert.AreEqual ("Database=Adv\"en}ture", sb.ToString (), "#D24a");
1417                         sb.Length = 0;
1418                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en}ture", true);
1419                         Assert.AreEqual ("Driver={Adv\"en}}ture}", sb.ToString (), "#D24b");
1420                         sb.Length = 0;
1421                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture Works", true);
1422                         Assert.AreEqual ("Database=A'dv\"en{ture Works", sb.ToString (), "#D25a");
1423                         sb.Length = 0;
1424                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en{ture Works", true);
1425                         Assert.AreEqual ("Driver={A'dv\"en{ture Works}", sb.ToString (), "#D25b");
1426                         sb.Length = 0;
1427                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture", true);
1428                         Assert.AreEqual ("Database=A'dv\"en{ture", sb.ToString (), "#D26a");
1429                         sb.Length = 0;
1430                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en{ture", true);
1431                         Assert.AreEqual ("Driver={A'dv\"en{ture}", sb.ToString (), "#D26b");
1432                         sb.Length = 0;
1433                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture Works", true);
1434                         Assert.AreEqual ("Database=A'dv\"en}ture Works", sb.ToString (), "#D27a");
1435                         sb.Length = 0;
1436                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en}ture Works", true);
1437                         Assert.AreEqual ("Driver={A'dv\"en}}ture Works}", sb.ToString (), "#D27b");
1438                         sb.Length = 0;
1439                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture", true);
1440                         Assert.AreEqual ("Database=A'dv\"en}ture", sb.ToString (), "#D28a");
1441                         sb.Length = 0;
1442                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en}ture", true);
1443                         Assert.AreEqual ("Driver={A'dv\"en}}ture}", sb.ToString (), "#D28b");
1444                         sb.Length = 0;
1445                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture Works\"", true);
1446                         Assert.AreEqual ("Database=\"Adven{ture Works\"", sb.ToString (), "#D29a");
1447                         sb.Length = 0;
1448                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven{ture Works\"", true);
1449                         Assert.AreEqual ("Driver={\"Adven{ture Works\"}", sb.ToString (), "#D29b");
1450                         sb.Length = 0;
1451                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture\"", true);
1452                         Assert.AreEqual ("Database=\"Adven{ture\"", sb.ToString (), "#D30a");
1453                         sb.Length = 0;
1454                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven{ture\"", true);
1455                         Assert.AreEqual ("Driver={\"Adven{ture\"}", sb.ToString (), "#D30b");
1456                         sb.Length = 0;
1457                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture Works\"", true);
1458                         Assert.AreEqual ("Database=\"Adven}ture Works\"", sb.ToString (), "#D31a");
1459                         sb.Length = 0;
1460                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven}ture Works\"", true);
1461                         Assert.AreEqual ("Driver={\"Adven}}ture Works\"}", sb.ToString (), "#D31b");
1462                         sb.Length = 0;
1463                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture\"", true);
1464                         Assert.AreEqual ("Database=\"Adven}ture\"", sb.ToString (), "#D32a");
1465                         sb.Length = 0;
1466                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven}ture\"", true);
1467                         Assert.AreEqual ("Driver={\"Adven}}ture\"}", sb.ToString (), "#D32b");
1468                         sb.Length = 0;
1469                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}}}", true);
1470                         Assert.AreEqual ("Database={{{B}}}", sb.ToString (), "#D33a");
1471                         sb.Length = 0;
1472                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}}}", true);
1473                         Assert.AreEqual ("Driver={{{B}}}", sb.ToString (), "#D33b");
1474                         sb.Length = 0;
1475                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{A{B{C}D}E}", true);
1476                         Assert.AreEqual ("Database={{A{B{C}}D}}E}}}", sb.ToString (), "#D33c");
1477                         sb.Length = 0;
1478                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{A{B{C}D}E}", true);
1479                         Assert.AreEqual ("Driver={{A{B{C}}D}}E}}}", sb.ToString (), "#D33d");
1480                         sb.Length = 0;
1481                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}}", true);
1482                         Assert.AreEqual ("Database={{{{B}}}}}", sb.ToString (), "#D33e");
1483                         sb.Length = 0;
1484                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}}", true);
1485                         Assert.AreEqual ("Driver={{{{B}}}}}", sb.ToString (), "#D33f");
1486                         sb.Length = 0;
1487                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}", true);
1488                         Assert.AreEqual ("Database={{{B}", sb.ToString (), "#D33g");
1489                         sb.Length = 0;
1490                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}", true);
1491                         Assert.AreEqual ("Driver={{{B}", sb.ToString (), "#D33h");
1492                         sb.Length = 0;
1493                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{B}", true);
1494                         Assert.AreEqual ("Database={{B}", sb.ToString (), "#D33i");
1495                         sb.Length = 0;
1496                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{B}", true);
1497                         Assert.AreEqual ("Driver={{B}", sb.ToString (), "#D33j");
1498                         sb.Length = 0;
1499                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{B}}", true);
1500                         Assert.AreEqual ("Database={{B}}}}}", sb.ToString (), "#D33k");
1501                         sb.Length = 0;
1502                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{B}}", true);
1503                         Assert.AreEqual ("Driver={{B}}}}}", sb.ToString (), "#D33l");
1504                         sb.Length = 0;
1505                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{B}}C", true);
1506                         Assert.AreEqual ("Database={{B}}}}C}", sb.ToString (), "#D33k");
1507                         sb.Length = 0;
1508                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{B}}C", true);
1509                         Assert.AreEqual ("Driver={{B}}}}C}", sb.ToString (), "#D33l");
1510                         sb.Length = 0;
1511                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A{B}}", true);
1512                         Assert.AreEqual ("Database=A{B}}", sb.ToString (), "#D33k");
1513                         sb.Length = 0;
1514                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A{B}}", true);
1515                         Assert.AreEqual ("Driver={A{B}}}}}", sb.ToString (), "#D33l");
1516                         sb.Length = 0;
1517                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", " {B}} ", true);
1518                         Assert.AreEqual ("Database= {B}} ", sb.ToString (), "#D33k");
1519                         sb.Length = 0;
1520                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", " {B}} ", true);
1521                         Assert.AreEqual ("Driver={ {B}}}} }", sb.ToString (), "#D33l");
1522                         sb.Length = 0;
1523                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{B}}", true);
1524                         Assert.AreEqual ("Database={{{B}}}}}", sb.ToString (), "#D33a");
1525                         sb.Length = 0;
1526                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{B}}", true);
1527                         Assert.AreEqual ("Driver={{{B}}}}}", sb.ToString (), "#D33b");
1528                         sb.Length = 0;
1529                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}}", true);
1530                         Assert.AreEqual ("Database=}}", sb.ToString (), "#D33a");
1531                         sb.Length = 0;
1532                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}}", true);
1533                         Assert.AreEqual ("Driver={}}}}}", sb.ToString (), "#D33b");
1534                         sb.Length = 0;
1535                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}", true);
1536                         Assert.AreEqual ("Database=}", sb.ToString (), "#D33a");
1537                         sb.Length = 0;
1538                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}", true);
1539                         Assert.AreEqual ("Driver={}}}", sb.ToString (), "#D33b");
1540                         sb.Length = 0;
1541
1542                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works", true);
1543                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", true);
1544                         Assert.AreEqual ("Database=Adventure Works;Server=localhost", sb.ToString (), "#E1a", true);
1545                         sb.Length = 0;
1546                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works", true);
1547                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", true);
1548                         Assert.AreEqual ("Driver={Adventure Works};Server=localhost", sb.ToString (), "#E1b", true);
1549                         sb.Length = 0;
1550                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure", true);
1551                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", true);
1552                         Assert.AreEqual ("Database=Adventure;Server=localhost", sb.ToString (), "#E2a", true);
1553                         sb.Length = 0;
1554                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure", true);
1555                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", true);
1556                         Assert.AreEqual ("Driver={Adventure};Server=localhost", sb.ToString (), "#E2b", true);
1557                         sb.Length = 0;
1558                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", string.Empty, true);
1559                         Assert.AreEqual ("Database=", sb.ToString (), "#E3a");
1560                         sb.Length = 0;
1561                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", string.Empty, true);
1562                         Assert.AreEqual ("Driver=", sb.ToString (), "#E3a");
1563                         sb.Length = 0;
1564                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", null, true);
1565                         Assert.AreEqual ("Database=", sb.ToString (), "#E4a");
1566                         sb.Length = 0;
1567                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", null, true);
1568                         Assert.AreEqual ("Driver=", sb.ToString (), "#E4b");
1569                         sb.Length = 0;
1570
1571                         DbConnectionStringBuilder.AppendKeyValuePair (sb, "Datab=ase", "Adven=ture", true);
1572                         Assert.AreEqual ("Datab=ase=Adven=ture", sb.ToString (), "#F1");
1573                 }
1574
1575                 [Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
1576                 public void AppendKeyValuePair2_Builder_Null ()
1577                 {
1578                         try {
1579                                 DbConnectionStringBuilder.AppendKeyValuePair (
1580                                         (StringBuilder) null, "Server",
1581                                         "localhost", true);
1582                                 Assert.Fail ("#A1");
1583                         } catch (ArgumentNullException ex) {
1584                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1585                                 Assert.IsNull (ex.InnerException, "#A3");
1586                                 Assert.IsNotNull (ex.Message, "#A4");
1587                                 Assert.AreEqual ("builder", ex.ParamName, "#A5");
1588                         }
1589
1590                         try {
1591                                 DbConnectionStringBuilder.AppendKeyValuePair (
1592                                         (StringBuilder) null, "Server",
1593                                         "localhost", false);
1594                                 Assert.Fail ("#B1");
1595                         } catch (ArgumentNullException ex) {
1596                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1597                                 Assert.IsNull (ex.InnerException, "#B3");
1598                                 Assert.IsNotNull (ex.Message, "#B4");
1599                                 Assert.AreEqual ("builder", ex.ParamName, "#B5");
1600                         }
1601                 }
1602
1603                 [Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
1604                 public void AppendKeyValuePair2_Keyword_Empty ()
1605                 {
1606                         StringBuilder sb = new StringBuilder ();
1607                         try {
1608                                 DbConnectionStringBuilder.AppendKeyValuePair (
1609                                         sb, string.Empty, "localhost", true);
1610                                 Assert.Fail ("#A1");
1611                         } catch (ArgumentException ex) {
1612                                 // Expecting non-empty string for 'keyName'
1613                                 // parameter
1614                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1615                                 Assert.IsNull (ex.InnerException, "#A3");
1616                                 Assert.IsNotNull (ex.Message, "#A4");
1617                                 Assert.IsNull (ex.ParamName, "#A5");
1618                         }
1619
1620                         try {
1621                                 DbConnectionStringBuilder.AppendKeyValuePair (
1622                                         sb, string.Empty, "localhost", false);
1623                                 Assert.Fail ("#B1");
1624                         } catch (ArgumentException ex) {
1625                                 // Expecting non-empty string for 'keyName'
1626                                 // parameter
1627                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1628                                 Assert.IsNull (ex.InnerException, "#B3");
1629                                 Assert.IsNotNull (ex.Message, "#B4");
1630                                 Assert.IsNull (ex.ParamName, "#B5");
1631                         }
1632                 }
1633
1634                 [Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
1635                 public void AppendKeyValuePair2_Keyword_Null ()
1636                 {
1637                         StringBuilder sb = new StringBuilder ();
1638                         try {
1639                                 DbConnectionStringBuilder.AppendKeyValuePair (
1640                                         sb, (string) null, "localhost", true);
1641                                 Assert.Fail ("#A1");
1642                         } catch (ArgumentNullException ex) {
1643                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1644                                 Assert.IsNull (ex.InnerException, "#A3");
1645                                 Assert.IsNotNull (ex.Message, "#A4");
1646                                 Assert.AreEqual ("keyName", ex.ParamName, "#A5");
1647                         }
1648
1649                         try {
1650                                 DbConnectionStringBuilder.AppendKeyValuePair (
1651                                         sb, (string) null, "localhost", false);
1652                                 Assert.Fail ("#B1");
1653                         } catch (ArgumentNullException ex) {
1654                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1655                                 Assert.IsNull (ex.InnerException, "#B3");
1656                                 Assert.IsNotNull (ex.Message, "#B4");
1657                                 Assert.AreEqual ("keyName", ex.ParamName, "#B5");
1658                         }
1659                 }
1660
1661                 [Test]
1662                 public void ToStringTest ()
1663                 {
1664                         builder.Add (SERVER, SERVER_VALUE);
1665                         string str = builder.ToString ();
1666                         string value = builder.ConnectionString;
1667                         Assert.AreEqual (value, str,
1668                                          "ToString shoud return ConnectionString!");
1669                 }
1670
1671                 [Test]
1672                 public void ItemTest ()
1673                 {
1674                         builder.Add (SERVER, SERVER_VALUE);
1675                         string value = (string) builder [SERVER];
1676                         Assert.AreEqual (SERVER_VALUE, value,
1677                                          "Item indexor does not retrun correct value!");
1678                 }
1679
1680                 [Test]
1681                 public void ICollectionCopyToTest ()
1682                 {
1683                         KeyValuePair<string, object> [] dict = new KeyValuePair<string, object> [2];
1684                         builder.Add (SERVER, SERVER_VALUE);
1685                         builder.Add (SERVER + "1", SERVER_VALUE + "1");
1686
1687                         int i = 0;
1688                         int j = 1;
1689                         ((ICollection) builder).CopyTo (dict, 0);
1690                         Assert.AreEqual (SERVER, dict [i].Key, "not equal");
1691                         Assert.AreEqual (SERVER_VALUE, dict [i].Value, "not equal");
1692                         Assert.AreEqual (SERVER + "1", dict [j].Key, "not equal");
1693                         Assert.AreEqual (SERVER_VALUE + "1", dict [j].Value, "not equal");
1694                 }
1695
1696                 [Test]
1697                 [ExpectedException (typeof (ArgumentException))]
1698                 public void NegICollectionCopyToTest ()
1699                 {
1700                         KeyValuePair<string, object> [] dict = new KeyValuePair<string, object> [1];
1701                         builder.Add (SERVER, SERVER_VALUE);
1702                         builder.Add (SERVER + "1", SERVER_VALUE + "1");
1703                         ((ICollection) builder).CopyTo (dict, 0);
1704                         Assert.Fail ("Exception Destination Array not enough is not thrown!");
1705                 }
1706
1707                 [Test]
1708                 public void TryGetValueTest ()
1709                 {
1710                         object value = null;
1711
1712                         builder ["DriverID"] = "790";
1713                         builder.Add ("Server", "C:\\");
1714                         Assert.IsTrue (builder.TryGetValue ("DriverID", out value), "#A1");
1715                         Assert.AreEqual ("790", value, "#A2");
1716                         Assert.IsTrue (builder.TryGetValue ("SERVER", out value), "#B1");
1717                         Assert.AreEqual ("C:\\", value, "#B2");
1718                         Assert.IsFalse (builder.TryGetValue (string.Empty, out value), "#C1");
1719                         Assert.IsNull (value, "#C2");
1720                         Assert.IsFalse (builder.TryGetValue ("a;", out value), "#D1");
1721                         Assert.IsNull (value, "#D2");
1722                         Assert.IsFalse (builder.TryGetValue ("\r", out value), "#E1");
1723                         Assert.IsNull (value, "#E2");
1724                         Assert.IsFalse (builder.TryGetValue (" ", out value), "#F1");
1725                         Assert.IsNull (value, "#F2");
1726                         Assert.IsFalse (builder.TryGetValue ("doesnotexist", out value), "#G1");
1727                         Assert.IsNull (value, "#G2");
1728                         Assert.IsFalse (builder.TryGetValue ("Driver", out value), "#H1");
1729                         Assert.IsNull (value, "#H2");
1730                         Assert.IsFalse (builder.TryGetValue ("Dsn", out value), "#I1");
1731                         Assert.IsNull (value, "#I2");
1732
1733                         builder = new DbConnectionStringBuilder (false);
1734                         builder ["DriverID"] = "790";
1735                         builder.Add ("Server", "C:\\");
1736                         Assert.IsTrue (builder.TryGetValue ("DriverID", out value), "#A1");
1737                         Assert.AreEqual ("790", value, "#A2");
1738                         Assert.IsTrue (builder.TryGetValue ("SERVER", out value), "#B1");
1739                         Assert.AreEqual ("C:\\", value, "#B2");
1740                         Assert.IsFalse (builder.TryGetValue (string.Empty, out value), "#C1");
1741                         Assert.IsNull (value, "#C2");
1742                         Assert.IsFalse (builder.TryGetValue ("a;", out value), "#D1");
1743                         Assert.IsNull (value, "#D2");
1744                         Assert.IsFalse (builder.TryGetValue ("\r", out value), "#E1");
1745                         Assert.IsNull (value, "#E2");
1746                         Assert.IsFalse (builder.TryGetValue (" ", out value), "#F1");
1747                         Assert.IsNull (value, "#F2");
1748                         Assert.IsFalse (builder.TryGetValue ("doesnotexist", out value), "#G1");
1749                         Assert.IsNull (value, "#G2");
1750                         Assert.IsFalse (builder.TryGetValue ("Driver", out value), "#H1");
1751                         Assert.IsNull (value, "#H2");
1752                         Assert.IsFalse (builder.TryGetValue ("Dsn", out value), "#I1");
1753                         Assert.IsNull (value, "#I2");
1754
1755                         builder = new DbConnectionStringBuilder (true);
1756                         builder ["DriverID"] = "790";
1757                         builder.Add ("Server", "C:\\");
1758                         Assert.IsTrue (builder.TryGetValue ("DriverID", out value), "#A1");
1759                         Assert.AreEqual ("790", value, "#A2");
1760                         Assert.IsTrue (builder.TryGetValue ("SERVER", out value), "#B1");
1761                         Assert.AreEqual ("C:\\", value, "#B2");
1762                         Assert.IsFalse (builder.TryGetValue (string.Empty, out value), "#C1");
1763                         Assert.IsNull (value, "#C2");
1764                         Assert.IsFalse (builder.TryGetValue ("a;", out value), "#D1");
1765                         Assert.IsNull (value, "#D2");
1766                         Assert.IsFalse (builder.TryGetValue ("\r", out value), "#E1");
1767                         Assert.IsNull (value, "#E2");
1768                         Assert.IsFalse (builder.TryGetValue (" ", out value), "#F1");
1769                         Assert.IsNull (value, "#F2");
1770                         Assert.IsFalse (builder.TryGetValue ("doesnotexist", out value), "#G1");
1771                         Assert.IsNull (value, "#G2");
1772                         Assert.IsFalse (builder.TryGetValue ("Driver", out value), "#H1");
1773                         Assert.IsNull (value, "#H2");
1774                         Assert.IsFalse (builder.TryGetValue ("Dsn", out value), "#I1");
1775                         Assert.IsNull (value, "#I2");
1776                 }
1777
1778                 [Test]
1779                 public void TryGetValue_Keyword_Null ()
1780                 {
1781                         object value = null;
1782                         try {
1783                                 builder.TryGetValue (null, out value);
1784                                 Assert.Fail ("#1");
1785                         } catch (ArgumentNullException ex) {
1786                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1787                                 Assert.IsNull (ex.InnerException, "#3");
1788                                 Assert.IsNotNull (ex.Message, "#4");
1789                                 Assert.AreEqual ("keyword", ex.ParamName, "#5");
1790                         }
1791                 }
1792
1793                 [Test]
1794                                 [NUnit.Framework.Category ("MobileNotWorking")] // DefaultMemberAttribute is removed by the tuner, causing #3 to fail
1795                 public void ICTD_GetClassNameTest ()
1796                 {
1797                         ICustomTypeDescriptor ictd = (ICustomTypeDescriptor) builder;
1798                         string className = ictd.GetClassName ();
1799                         Assert.AreEqual (builder.GetType ().ToString (), className, "#1");
1800
1801                         AttributeCollection collection = ictd.GetAttributes ();
1802                         Assert.AreEqual (2, collection.Count, "#2");
1803                         object [] attr = builder.GetType ().GetCustomAttributes (typeof (DefaultMemberAttribute), false);
1804                         if (attr.Length > 0) {
1805                                 DefaultMemberAttribute defAtt = (DefaultMemberAttribute) attr [0];
1806                                 Assert.AreEqual ("Item", defAtt.MemberName, "#3");
1807                         } else
1808                                 Assert.Fail ("#3");
1809
1810                         string compName = ictd.GetComponentName ();
1811                         Assert.IsNull (compName, "#4");
1812
1813                         TypeConverter converter = ictd.GetConverter ();
1814                         Assert.AreEqual (typeof (CollectionConverter), converter.GetType (), "#5");
1815
1816                         EventDescriptor evtDesc = ictd.GetDefaultEvent ();
1817                         Assert.IsNull (evtDesc, "#6");
1818
1819                         PropertyDescriptor property = ictd.GetDefaultProperty ();
1820                         Assert.IsNull (property, "#7");
1821                 }
1822
1823                 [Test]
1824                 public void EmbeddedCharTest1 ()
1825                 {
1826                         // Notice how the keywords show up in the connection string
1827                         //  in the order they were added.
1828                         // And notice the case of the keyword when added is preserved
1829                         //  in the connection string.
1830
1831                         DbConnectionStringBuilder sb = new DbConnectionStringBuilder ();
1832
1833                         sb["Data Source"] = "testdb";
1834                         sb["User ID"] = "someuser";
1835                         sb["Password"] = "abcdef";
1836                         Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=abcdef",
1837                                 sb.ConnectionString, "cs#1");
1838
1839                         sb["Password"] = "abcdef#";
1840                         Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=abcdef#",
1841                                 sb.ConnectionString, "cs#2");
1842
1843                         // an embedded single-quote value will result in the value being delimieted with double quotes
1844                         sb["Password"] = "abc\'def";
1845                         Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=\"abc\'def\"",
1846                                 sb.ConnectionString, "cs#3");
1847
1848                         // an embedded double-quote value will result in the value being delimieted with single quotes
1849                         sb["Password"] = "abc\"def";
1850                         Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=\'abc\"def\'",
1851                                 sb.ConnectionString, "cs#4");
1852
1853                         // an embedded single-quote and double-quote in the value
1854                         // will result in the value being delimited by double-quotes
1855                         // with the embedded double quote being escaped with two double-quotes
1856                         sb["Password"] = "abc\"d\'ef";
1857                         Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=\"abc\"\"d\'ef\"",
1858                                 sb.ConnectionString, "cs#5");
1859
1860                         sb = new DbConnectionStringBuilder ();
1861                         sb["PASSWORD"] = "abcdef1";
1862                         sb["user id"] = "someuser";
1863                         sb["Data Source"] = "testdb";
1864                         Assert.AreEqual ("PASSWORD=abcdef1;user id=someuser;Data Source=testdb",
1865                                 sb.ConnectionString, "cs#6");
1866
1867                         // case is preserved for a keyword that was added the first time
1868                         sb = new DbConnectionStringBuilder ();
1869                         sb["PassWord"] = "abcdef2";
1870                         sb["uSER iD"] = "someuser";
1871                         sb["DaTa SoUrCe"] = "testdb";
1872                         Assert.AreEqual ("PassWord=abcdef2;uSER iD=someuser;DaTa SoUrCe=testdb",
1873                                 sb.ConnectionString, "cs#7");
1874                         sb["passWORD"] = "abc123";
1875                         Assert.AreEqual ("PassWord=abc123;uSER iD=someuser;DaTa SoUrCe=testdb",
1876                                 sb.ConnectionString, "cs#8");
1877
1878                         // embedded equal sign in the value will cause the value to be
1879                         // delimited with double-quotes
1880                         sb = new DbConnectionStringBuilder ();
1881                         sb["Password"] = "abc=def";
1882                         sb["Data Source"] = "testdb";
1883                         sb["User ID"] = "someuser";
1884                         Assert.AreEqual ("Password=\"abc=def\";Data Source=testdb;User ID=someuser",
1885                                 sb.ConnectionString, "cs#9");
1886
1887                         // embedded semicolon in the value will cause the value to be
1888                         // delimited with double-quotes
1889                         sb = new DbConnectionStringBuilder ();
1890                         sb["Password"] = "abc;def";
1891                         sb["Data Source"] = "testdb";
1892                         sb["User ID"] = "someuser";
1893                         Assert.AreEqual ("Password=\"abc;def\";Data Source=testdb;User ID=someuser",
1894                                 sb.ConnectionString, "cs#10");
1895
1896                         // more right parentheses then left parentheses - happily takes it
1897                         sb = new DbConnectionStringBuilder();
1898                         sb.ConnectionString = "Data Source=(((Blah=Something))))))";
1899                         Assert.AreEqual ("data source=\"(((Blah=Something))))))\"",
1900                                 sb.ConnectionString, "cs#11");
1901
1902                         // more left curly braces then right curly braces - happily takes it
1903                         sb = new DbConnectionStringBuilder();
1904                         sb.ConnectionString = "Data Source={{{{Blah=Something}}";
1905                         Assert.AreEqual ("data source=\"{{{{Blah=Something}}\"",
1906                                 sb.ConnectionString, "cs#12");
1907
1908                         // spaces, empty string, null are treated like an empty string
1909                         // and any previous settings is cleared
1910                         sb.ConnectionString = "   ";
1911                         Assert.AreEqual (String.Empty,
1912                                 sb.ConnectionString, "cs#13");
1913
1914                         sb.ConnectionString = " ";
1915                         Assert.AreEqual (String.Empty,
1916                                 sb.ConnectionString, "cs#14");
1917
1918                         sb.ConnectionString = "";
1919                         Assert.AreEqual (String.Empty,
1920                                 sb.ConnectionString, "cs#15");
1921
1922                         sb.ConnectionString = String.Empty;
1923                         Assert.AreEqual (String.Empty,
1924                                 sb.ConnectionString, "cs#16");
1925
1926                         sb.ConnectionString = null;
1927                         Assert.AreEqual (String.Empty,
1928                                 sb.ConnectionString, "cs#17");
1929
1930                         sb = new DbConnectionStringBuilder();
1931                         Assert.AreEqual (String.Empty,
1932                                 sb.ConnectionString, "cs#18");
1933                 }
1934
1935                 [Test]
1936                 public void EmbeddedCharTest2 ()
1937                 {
1938                         DbConnectionStringBuilder sb;
1939
1940                         sb = new DbConnectionStringBuilder ();
1941                         sb.ConnectionString = "Driver={SQL Server};Server=(local host);" +
1942                                 "Trusted_Connection=Yes Or No;Database=Adventure Works;";
1943                         Assert.AreEqual ("{SQL Server}", sb["Driver"], "#A1");
1944                         Assert.AreEqual ("(local host)", sb["Server"], "#A2");
1945                         Assert.AreEqual ("Yes Or No", sb["Trusted_Connection"], "#A3");
1946                         Assert.AreEqual ("driver=\"{SQL Server}\";server=\"(local host)\";" +
1947                                 "trusted_connection=\"Yes Or No\";database=\"Adventure Works\"",
1948                                 sb.ConnectionString, "#A4");
1949
1950                         sb = new DbConnectionStringBuilder ();
1951                         sb.ConnectionString = "Driver={SQLServer};Server=(local);" +
1952                                 "Trusted_Connection=Yes;Database=AdventureWorks;";
1953                         Assert.AreEqual ("{SQLServer}", sb["Driver"], "#B1");
1954                         Assert.AreEqual ("(local)", sb["Server"], "#B2");
1955                         Assert.AreEqual ("Yes", sb["Trusted_Connection"], "#B3");
1956                         Assert.AreEqual ("driver={SQLServer};server=(local);" +
1957                                 "trusted_connection=Yes;database=AdventureWorks",
1958                                 sb.ConnectionString, "#B4");
1959
1960                         sb = new DbConnectionStringBuilder (false);
1961                         sb.ConnectionString = "Driver={SQL Server};Server=(local host);" +
1962                                 "Trusted_Connection=Yes Or No;Database=Adventure Works;";
1963                         Assert.AreEqual ("{SQL Server}", sb["Driver"], "#C1");
1964                         Assert.AreEqual ("(local host)", sb["Server"], "#C2");
1965                         Assert.AreEqual ("Yes Or No", sb["Trusted_Connection"], "#C3");
1966                         Assert.AreEqual ("driver=\"{SQL Server}\";server=\"(local host)\";" +
1967                                 "trusted_connection=\"Yes Or No\";database=\"Adventure Works\"",
1968                                 sb.ConnectionString, "#C4");
1969
1970                         sb = new DbConnectionStringBuilder (false);
1971                         sb.ConnectionString = "Driver={SQLServer};Server=(local);" +
1972                                 "Trusted_Connection=Yes;Database=AdventureWorks;";
1973                         Assert.AreEqual ("{SQLServer}", sb["Driver"], "#D1");
1974                         Assert.AreEqual ("(local)", sb["Server"], "#D2");
1975                         Assert.AreEqual ("Yes", sb["Trusted_Connection"], "#D3");
1976                         Assert.AreEqual ("driver={SQLServer};server=(local);" +
1977                                 "trusted_connection=Yes;database=AdventureWorks",
1978                                 sb.ConnectionString, "#D4");
1979
1980                         sb = new DbConnectionStringBuilder (true);
1981                         sb.ConnectionString = "Driver={SQL Server};Server=(local host);" +
1982                                 "Trusted_Connection=Yes Or No;Database=Adventure Works;";
1983                         Assert.AreEqual ("{SQL Server}", sb["Driver"], "#E1");
1984                         Assert.AreEqual ("(local host)", sb["Server"], "#E2");
1985                         Assert.AreEqual ("Yes Or No", sb["Trusted_Connection"], "#E3");
1986                         Assert.AreEqual ("driver={SQL Server};server=(local host);" +
1987                                 "trusted_connection=Yes Or No;database=Adventure Works",
1988                                 sb.ConnectionString, "#E4");
1989
1990                         sb = new DbConnectionStringBuilder (true);
1991                         sb.ConnectionString = "Driver={SQLServer};Server=(local);" +
1992                                 "Trusted_Connection=Yes;Database=AdventureWorks;";
1993                         Assert.AreEqual ("{SQLServer}", sb["Driver"], "#F1");
1994                         Assert.AreEqual ("(local)", sb["Server"], "#F2");
1995                         Assert.AreEqual ("Yes", sb["Trusted_Connection"], "#F3");
1996                         Assert.AreEqual ("driver={SQLServer};server=(local);" +
1997                                 "trusted_connection=Yes;database=AdventureWorks",
1998                                 sb.ConnectionString, "#F4");
1999                 }
2000
2001                 [Test]
2002                 public void EmbeddedCharTest3 ()
2003                 {
2004                         string dataSource = "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.1.101)" +
2005                                 "(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=TESTDB)))";
2006                         DbConnectionStringBuilder sb;
2007
2008                         sb = new DbConnectionStringBuilder ();
2009                         sb.ConnectionString = "User ID=SCOTT;Password=TiGeR;Data Source=" + dataSource;
2010                         Assert.AreEqual (dataSource, sb["Data Source"], "#A1");
2011                         Assert.AreEqual ("SCOTT", sb["User ID"], "#A2");
2012                         Assert.AreEqual ("TiGeR", sb["Password"], "#A3");
2013                         Assert.AreEqual (
2014                                 "user id=SCOTT;password=TiGeR;data source=\"(DESCRIPTION=(ADDRESS=(PROTOCOL=" +
2015                                 "TCP)(HOST=192.168.1.101)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)" +
2016                                 "(SERVICE_NAME=TESTDB)))\"", sb.ConnectionString, "#A4");
2017
2018                         sb = new DbConnectionStringBuilder (false);
2019                         sb.ConnectionString = "User ID=SCOTT;Password=TiGeR;Data Source=" + dataSource;
2020                         Assert.AreEqual (dataSource, sb["Data Source"], "#B1");
2021                         Assert.AreEqual ("SCOTT", sb["User ID"], "#B2");
2022                         Assert.AreEqual ("TiGeR", sb["Password"], "#B3");
2023                         Assert.AreEqual (
2024                                 "user id=SCOTT;password=TiGeR;data source=\"(DESCRIPTION=(ADDRESS=(PROTOCOL=" +
2025                                 "TCP)(HOST=192.168.1.101)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)" +
2026                                 "(SERVICE_NAME=TESTDB)))\"", sb.ConnectionString, "#B4");
2027
2028                         sb = new DbConnectionStringBuilder (true);
2029                         sb.ConnectionString = "User ID=SCOTT;Password=TiGeR;Data Source=" + dataSource;
2030                         Assert.AreEqual (dataSource, sb["Data Source"], "#C1");
2031                         Assert.AreEqual ("SCOTT", sb["User ID"], "#C2");
2032                         Assert.AreEqual ("TiGeR", sb["Password"], "#C3");
2033                         Assert.AreEqual (
2034                                 "user id=SCOTT;password=TiGeR;data source=(DESCRIPTION=(ADDRESS=(PROTOCOL=" +
2035                                 "TCP)(HOST=192.168.1.101)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)" +
2036                                 "(SERVICE_NAME=TESTDB)))", sb.ConnectionString, "#C4");
2037                 }
2038
2039                 [Test]
2040                 public void EmbeddedCharTest4 ()
2041                 {
2042                         DbConnectionStringBuilder sb;
2043
2044                         sb = new DbConnectionStringBuilder ();
2045                         sb.ConnectionString = "PassWord=abcdef2;uSER iD=someuser;DaTa SoUrCe=testdb";
2046                         sb["Integrated Security"] = "False";
2047                         Assert.AreEqual (
2048                                 "password=abcdef2;user id=someuser;data source=testdb;Integrated Security=False",
2049                                 sb.ConnectionString, "#A");
2050
2051                         sb = new DbConnectionStringBuilder (false);
2052                         sb.ConnectionString = "PassWord=abcdef2;uSER iD=someuser;DaTa SoUrCe=testdb";
2053                         sb["Integrated Security"] = "False";
2054                         Assert.AreEqual (
2055                                 "password=abcdef2;user id=someuser;data source=testdb;Integrated Security=False",
2056                                 sb.ConnectionString, "#B");
2057
2058                         sb = new DbConnectionStringBuilder (true);
2059                         sb.ConnectionString = "PassWord=abcdef2;uSER iD=someuser;DaTa SoUrCe=testdb";
2060                         sb["Integrated Security"] = "False";
2061                         Assert.AreEqual (
2062                                 "password=abcdef2;user id=someuser;data source=testdb;Integrated Security=False",
2063                                 sb.ConnectionString, "#C");
2064                 }
2065
2066                 [Test]
2067                 public void EmbeddedCharTest5 ()
2068                 {
2069                         string connectionString = "A={abcdef2};B=some{us;C=test}db;D=12\"3;E=\"45;6\";F=AB==C;G{A'}\";F={1='\"2};G==C=B==C;Z=ABC";
2070                         DbConnectionStringBuilder sb;
2071
2072                         sb = new DbConnectionStringBuilder ();
2073                         sb.ConnectionString = connectionString;
2074                         Assert.AreEqual ("a={abcdef2};b=some{us;c=test}db;d='12\"3';e=\"45;6\";f=\"AB==C\";g{a'}\";f=\"{1='\"\"2}\";g==c=\"B==C\";z=ABC", sb.ConnectionString, "#A1");
2075                         Assert.AreEqual ("{abcdef2}", sb ["A"], "#A2");
2076                         Assert.AreEqual ("some{us", sb ["B"], "#A3");
2077                         Assert.AreEqual ("test}db", sb ["C"], "#A4");
2078                         Assert.AreEqual ("12\"3", sb ["D"], "#A5");
2079                         Assert.AreEqual ("45;6", sb ["E"], "#A6");
2080                         Assert.AreEqual ("AB==C", sb ["F"], "#A7");
2081                         Assert.AreEqual ("{1='\"2}", sb ["g{a'}\";f"], "#A8");
2082                         Assert.AreEqual ("ABC", sb ["Z"], "#A9");
2083                         Assert.AreEqual ("B==C", sb ["g=c"], "#A10");
2084
2085                         sb = new DbConnectionStringBuilder (false);
2086                         sb.ConnectionString = connectionString;
2087                         Assert.AreEqual ("a={abcdef2};b=some{us;c=test}db;d='12\"3';e=\"45;6\";f=\"AB==C\";g{a'}\";f=\"{1='\"\"2}\";g==c=\"B==C\";z=ABC", sb.ConnectionString, "#B1");
2088                         Assert.AreEqual ("{abcdef2}", sb ["A"], "#B2");
2089                         Assert.AreEqual ("some{us", sb ["B"], "#B3");
2090                         Assert.AreEqual ("test}db", sb ["C"], "#B4");
2091                         Assert.AreEqual ("12\"3", sb ["D"], "#B5");
2092                         Assert.AreEqual ("45;6", sb ["E"], "#B6");
2093                         Assert.AreEqual ("AB==C", sb ["F"], "#B7");
2094                         Assert.AreEqual ("{1='\"2}", sb ["g{a'}\";f"], "#B8");
2095                         Assert.AreEqual ("ABC", sb ["Z"], "#B9");
2096                         Assert.AreEqual ("B==C", sb ["g=c"], "#B10");
2097
2098                         sb = new DbConnectionStringBuilder (true);
2099                         sb.ConnectionString = connectionString;
2100                         Assert.AreEqual ("a={abcdef2};b=some{us;c=test}db;d=12\"3;e=\"45;6\";f=AB==C;g{a'}\";f={1='\"2};g==C=B==C;z=ABC", sb.ConnectionString, "#C1");
2101                         Assert.AreEqual ("{abcdef2}", sb ["A"], "#C2");
2102                         Assert.AreEqual ("some{us", sb ["B"], "#C3");
2103                         Assert.AreEqual ("test}db", sb ["C"], "#C4");
2104                         Assert.AreEqual ("12\"3", sb ["D"], "#C5");
2105                         Assert.AreEqual ("\"45", sb ["E"], "#C6");
2106                         Assert.AreEqual ("AB==C", sb ["6\";f"], "#C7");
2107                         Assert.AreEqual ("{1='\"2}", sb ["g{a'}\";f"], "#C8");
2108                         Assert.AreEqual ("ABC", sb ["Z"], "#C9");
2109                         Assert.AreEqual ("=C=B==C", sb ["g"], "#C10");
2110                 }
2111
2112                 [Test]
2113                 public void EmbeddedCharTest6 ()
2114                 {
2115                         string [][] shared_tests = new string [][] {
2116                                 new string [] { "A=(B;", "A", "(B", "a=(B" },
2117                                 new string [] { "A={B{}", "A", "{B{}", "a={B{}" },
2118                                 new string [] { "A={B{{}", "A", "{B{{}", "a={B{{}" },
2119                                 new string [] { " A =B{C", "A", "B{C", "a=B{C" },
2120                                 new string [] { " A =B{{C}", "A", "B{{C}", "a=B{{C}" },
2121                                 new string [] { "A={{{B}}}", "A", "{{{B}}}", "a={{{B}}}" },
2122                                 new string [] { "A={B}", "A", "{B}", "a={B}" },
2123                                 new string [] { "A= {B}", "A", "{B}", "a={B}" },
2124                                 new string [] { " A =BC",  "a", "BC", "a=BC" },
2125                                 new string [] { "\rA\t=BC",  "a", "BC", "a=BC" },
2126                                 new string [] { "\rA\t=BC",  "a", "BC", "a=BC" },
2127                                 new string [] { "A;B=BC",  "a;b", "BC", "a;b=BC" },
2128                                 };
2129
2130                         string [][] non_odbc_tests = new string [][] {
2131                                 new string [] { "A=''", "A", "", "a=" },
2132                                 new string [] { "A='BC;D'", "A", "BC;D", "a=\"BC;D\"" },
2133                                 new string [] { "A=BC''D", "A", "BC''D", "a=\"BC''D\"" },
2134                                 new string [] { "A='\"'", "A", "\"", "a='\"'" },
2135                                 new string [] { "A=B\"\"C;", "A", "B\"\"C", "a='B\"\"C'" },
2136                                 new string [] { "A={B{", "A", "{B{", "a={B{" },
2137                                 new string [] { "A={B}C", "A", "{B}C", "a={B}C" },
2138                                 new string [] { "A=B'C", "A", "B'C", "a=\"B'C\"" },
2139                                 new string [] { "A=B''C", "A", "B''C", "a=\"B''C\"" },
2140                                 new string [] { "A=  B C ;", "A", "B C", "a=\"B C\"" },
2141                                 new string [] { "A={B { }} }", "A", "{B { }} }", "a=\"{B { }} }\"" },
2142                                 new string [] { "A={B {{ }} }", "A", "{B {{ }} }", "a=\"{B {{ }} }\"" },
2143                                 new string [] { "A= B {C ", "A", "B {C", "a=\"B {C\"" },
2144                                 new string [] { "A= B }C ", "A", "B }C", "a=\"B }C\"" },
2145                                 new string [] { "A=B }C", "A", "B }C", "a=\"B }C\"" },
2146                                 new string [] { "A=B { }C", "A", "B { }C", "a=\"B { }C\"" },
2147                                 new string [] { "A= B{C {}}", "A", "B{C {}}", "a=\"B{C {}}\"" },
2148                                 new string [] { "A= {C {};B=A", "A", "{C {}", "a=\"{C {}\";b=A" },
2149                                 new string [] { "A= {C {}  ", "A", "{C {}", "a=\"{C {}\"" },
2150                                 new string [] { "A= {C {}  ;B=A", "A", "{C {}", "a=\"{C {}\";b=A" },
2151                                 new string [] { "A= {C {}}}", "A", "{C {}}}", "a=\"{C {}}}\"" },
2152                                 new string [] { "A={B=C}", "A", "{B=C}", "a=\"{B=C}\"" },
2153                                 new string [] { "A={B==C}", "A", "{B==C}", "a=\"{B==C}\"" },
2154                                 new string [] { "A=B==C", "A", "B==C", "a=\"B==C\"" },
2155                                 new string [] { "A={=}", "A", "{=}", "a=\"{=}\"" },
2156                                 new string [] { "A={==}", "A", "{==}", "a=\"{==}\"" },
2157                                 new string [] { "A=\"B;(C)'\"", "A", "B;(C)'", "a=\"B;(C)'\"" },
2158                                 new string [] { "A=B(=)C", "A", "B(=)C", "a=\"B(=)C\"" },
2159                                 new string [] { "A=B=C", "A", "B=C", "a=\"B=C\"" },
2160                                 new string [] { "A=B(==)C", "A", "B(==)C", "a=\"B(==)C\"" },
2161                                 new string [] { "A=B  C", "A", "B  C", "a=\"B  C\"" },
2162                                 new string [] { "A= B  C ", "A", "B  C", "a=\"B  C\"" },
2163                                 new string [] { "A=  B  C  ", "A", "B  C", "a=\"B  C\"" },
2164                                 new string [] { "A='  B C '", "A", "  B C ", "a=\"  B C \"" },
2165                                 new string [] { "A=\"  B C \"", "A", "  B C ", "a=\"  B C \"" },
2166                                 new string [] { "A={  B C }", "A", "{  B C }", "a=\"{  B C }\"" },
2167                                 new string [] { "A=  B C  ;", "A", "B C", "a=\"B C\"" },
2168                                 new string [] { "A=  B\rC\r\t;", "A", "B\rC", "a=\"B\rC\"" },
2169                                 new string [] { "A=\"\"\"B;C\"\"\"", "A", "\"B;C\"", "a='\"B;C\"'" },
2170                                 new string [] { "A= \"\"\"B;C\"\"\" ", "A", "\"B;C\"", "a='\"B;C\"'" },
2171                                 new string [] { "A='''B;C'''", "A", "'B;C'", "a=\"'B;C'\"" },
2172                                 new string [] { "A= '''B;C''' ", "A", "'B;C'", "a=\"'B;C'\"" },
2173                                 new string [] { "A={{", "A", "{{", "a={{" },
2174                                 new string [] { "A={B C}", "A", "{B C}", "a=\"{B C}\"" },
2175                                 new string [] { "A={ B C }", "A", "{ B C }", "a=\"{ B C }\"" },
2176                                 new string [] { "A={B {{ } }", "A", "{B {{ } }", "a=\"{B {{ } }\"" },
2177                                 new string [] { "A='='", "A", "=", "a=\"=\"" },
2178                                 new string [] { "A='=='", "A", "==", "a=\"==\"" },
2179                                 new string [] { "A=\"=\"", "A", "=", "a=\"=\"" },
2180                                 new string [] { "A=\"==\"", "A", "==", "a=\"==\"" },
2181                                 new string [] { "A={B}}", "A", "{B}}", "a={B}}" },
2182                                 new string [] { "A=\";\"", "A", ";", "a=\";\"" },
2183                                 new string [] { "A(=)=B", "A(", ")=B", "a(=\")=B\"" },
2184                                 new string [] { "A==B=C",  "A=B", "C", "a==b=C" },
2185                                 new string [] { "A===B=C",  "A=", "B=C", "a===\"B=C\"" },
2186                                 new string [] { "(A=)=BC",  "(a", ")=BC", "(a=\")=BC\"" },
2187                                 new string [] { "A==C=B==C", "a=c", "B==C", "a==c=\"B==C\"" },
2188                                 };
2189                         DbConnectionStringBuilder sb;
2190
2191                         for (int i = 0; i < non_odbc_tests.Length; i++) {
2192                                 string [] test = non_odbc_tests [i];
2193                                 sb = new DbConnectionStringBuilder ();
2194                                 sb.ConnectionString = test [0];
2195                                 Assert.AreEqual (test [3], sb.ConnectionString, "#A1:" + i);
2196                                 Assert.AreEqual (test [2], sb [test [1]], "#A2:" + i);
2197                         }
2198
2199                         for (int i = 0; i < non_odbc_tests.Length; i++) {
2200                                 string [] test = non_odbc_tests [i];
2201                                 sb = new DbConnectionStringBuilder (false);
2202                                 sb.ConnectionString = test [0];
2203                                 Assert.AreEqual (test [3], sb.ConnectionString, "#B1:" + i);
2204                                 Assert.AreEqual (test [2], sb [test [1]], "#B2:" + i);
2205                         }
2206
2207                         for (int i = 0; i < shared_tests.Length; i++) {
2208                                 string [] test = shared_tests [i];
2209                                 sb = new DbConnectionStringBuilder ();
2210                                 sb.ConnectionString = test [0];
2211                                 Assert.AreEqual (test [3], sb.ConnectionString, "#C1:" + i);
2212                                 Assert.AreEqual (test [2], sb [test [1]], "#C2:" + i);
2213                         }
2214
2215                         for (int i = 0; i < shared_tests.Length; i++) {
2216                                 string [] test = shared_tests [i];
2217                                 sb = new DbConnectionStringBuilder (false);
2218                                 sb.ConnectionString = test [0];
2219                                 Assert.AreEqual (test [3], sb.ConnectionString, "#D1:" + i);
2220                                 Assert.AreEqual (test [2], sb [test [1]], "#D2:" + i);
2221                         }
2222
2223                         string [][] odbc_tests = new string [][] {
2224                                 new string [] { "A=B(=)C", "A", "B(=)C", "a=B(=)C" },
2225                                 new string [] { "A=B(==)C", "A", "B(==)C", "a=B(==)C" },
2226                                 new string [] { "A=  B C  ;", "A", "B C", "a=B C" },
2227                                 new string [] { "A=  B\rC\r\t;", "A", "B\rC", "a=B\rC" },
2228                                 new string [] { "A='''", "A", "'''", "a='''" },
2229                                 new string [] { "A=''", "A", "''", "a=''" },
2230                                 new string [] { "A=''B", "A", "''B", "a=''B" },
2231                                 new string [] { "A=BC''D", "A", "BC''D", "a=BC''D" },
2232                                 new string [] { "A='\"'", "A", "'\"'", "a='\"'" },
2233                                 new string [] { "A=\"\"B", "A", "\"\"B", "a=\"\"B"},
2234                                 new string [] { "A=B\"\"C;", "A", "B\"\"C", "a=B\"\"C" },
2235                                 new string [] { "A=\"B", "A", "\"B", "a=\"B" },
2236                                 new string [] { "A=\"", "A", "\"", "a=\"" },
2237                                 new string [] { "A=B'C", "A", "B'C", "a=B'C" },
2238                                 new string [] { "A=B''C", "A", "B''C", "a=B''C" },
2239                                 new string [] { "A='A'C", "A", "'A'C", "a='A'C" },
2240                                 new string [] { "A=B  C", "A", "B  C", "a=B  C" },
2241                                 new string [] { "A= B  C ", "A", "B  C", "a=B  C" },
2242                                 new string [] { "A=  B  C  ", "A", "B  C", "a=B  C" },
2243                                 new string [] { "A='  B C '", "A", "'  B C '", "a='  B C '" },
2244                                 new string [] { "A=\"  B C \"", "A", "\"  B C \"", "a=\"  B C \"" },
2245                                 new string [] { "A={  B C }", "A", "{  B C }", "a={  B C }" },
2246                                 new string [] { "A=  B C ;", "A", "B C", "a=B C" },
2247                                 new string [] { "A=\"\"BC\"\"", "A", "\"\"BC\"\"", "a=\"\"BC\"\"" },
2248                                 new string [] { "A=\"\"B\"C\"\";", "A", "\"\"B\"C\"\"", "a=\"\"B\"C\"\"" },
2249                                 new string [] { "A= \"\"B\"C\"\" ", "A", "\"\"B\"C\"\"", "a=\"\"B\"C\"\"" },
2250                                 new string [] { "A=''BC''", "A", "''BC''", "a=''BC''" },
2251                                 new string [] { "A=''B'C'';", "A", "''B'C''", "a=''B'C''" },
2252                                 new string [] { "A= ''B'C'' ", "A", "''B'C''", "a=''B'C''" },
2253                                 new string [] { "A={B C}", "A", "{B C}", "a={B C}" },
2254                                 new string [] { "A={ B C }", "A", "{ B C }", "a={ B C }" },
2255                                 new string [] { "A={ B;C }", "A", "{ B;C }", "a={ B;C }" },
2256                                 new string [] { "A={B { }} }", "A", "{B { }} }", "a={B { }} }" },
2257                                 new string [] { "A={ B;= {;=}};= }", "A", "{ B;= {;=}};= }", "a={ B;= {;=}};= }" },
2258                                 new string [] { "A={B {{ }} }", "A", "{B {{ }} }", "a={B {{ }} }" },
2259                                 new string [] { "A={ B;= {{:= }};= }", "A", "{ B;= {{:= }};= }", "a={ B;= {{:= }};= }" },
2260                                 new string [] { "A= B {C ", "A", "B {C", "a=B {C" },
2261                                 new string [] { "A= B }C ", "A", "B }C", "a=B }C" },
2262                                 new string [] { "A=B }C", "A", "B }C", "a=B }C" },
2263                                 new string [] { "A=B { }C", "A", "B { }C", "a=B { }C" },
2264                                 new string [] { "A= {B;{}", "A", "{B;{}", "a={B;{}" },
2265                                 new string [] { "A= {B;{}}}", "A", "{B;{}}}", "a={B;{}}}" },
2266                                 new string [] { "A= B{C {}}", "A", "B{C {}}", "a=B{C {}}" },
2267                                 new string [] { "A= {C {};B=A", "A", "{C {}", "a={C {};b=A" },
2268                                 new string [] { "A= {C {}  ", "A", "{C {}", "a={C {}" },
2269                                 new string [] { "A= {C {}  ;B=A", "A", "{C {}", "a={C {};b=A" },
2270                                 new string [] { "A= {C {}}}", "A", "{C {}}}", "a={C {}}}" },
2271                                 new string [] { "A={B=C}", "A", "{B=C}", "a={B=C}" },
2272                                 new string [] { "A={B==C}", "A", "{B==C}", "a={B==C}" },
2273                                 new string [] { "A=B==C", "A", "B==C", "a=B==C" },
2274                                 new string [] { "A='='", "A", "'='", "a='='" },
2275                                 new string [] { "A='=='", "A", "'=='", "a='=='" },
2276                                 new string [] { "A=\"=\"", "A", "\"=\"", "a=\"=\"" },
2277                                 new string [] { "A=\"==\"", "A", "\"==\"", "a=\"==\"" },
2278                                 new string [] { "A={=}", "A", "{=}", "a={=}" },
2279                                 new string [] { "A={==}", "A", "{==}", "a={==}" },
2280                                 new string [] { "A=B=C", "A", "B=C", "a=B=C" },
2281                                 new string [] { "A(=)=B", "A(", ")=B", "a(=)=B" },
2282                                 new string [] { "A==B=C",  "A", "=B=C", "a==B=C" },
2283                                 new string [] { "A===B=C",  "A", "==B=C", "a===B=C" },
2284                                 new string [] { "A'='=B=C",  "A'", "'=B=C", "a'='=B=C" },
2285                                 new string [] { "A\"=\"=B=C",  "A\"", "\"=B=C", "a\"=\"=B=C" },
2286                                 new string [] { "\"A=\"=BC",  "\"a", "\"=BC", "\"a=\"=BC" },
2287                                 new string [] { "(A=)=BC",  "(a", ")=BC", "(a=)=BC" },
2288                                 new string [] { "A==C=B==C", "A", "=C=B==C", "a==C=B==C" },
2289                                 };
2290
2291                         for (int i = 0; i < odbc_tests.Length; i++) {
2292                                 string [] test = odbc_tests [i];
2293                                 sb = new DbConnectionStringBuilder (true);
2294                                 sb.ConnectionString = test [0];
2295                                 Assert.AreEqual (test [3], sb.ConnectionString, "#E1:" + i);
2296                                 Assert.AreEqual (test [2], sb [test [1]], "#E2:" + i);
2297                         }
2298
2299                         for (int i = 0; i < shared_tests.Length; i++) {
2300                                 string [] test = shared_tests [i];
2301                                 sb = new DbConnectionStringBuilder (true);
2302                                 sb.ConnectionString = test [0];
2303                                 Assert.AreEqual (test [3], sb.ConnectionString, "#F1:" + i);
2304                                 Assert.AreEqual (test [2], sb [test [1]], "#F2:" + i);
2305                         }
2306
2307                         // each test that is in odbc_tests and not in non_odbc_tests
2308                         // (or vice versa) should result in an ArgumentException
2309                         AssertValueTest (non_odbc_tests, odbc_tests, true, "#G:");
2310                         AssertValueTest (odbc_tests, non_odbc_tests, false, "#H:");
2311                 }
2312
2313                 [Test]
2314                 public void EmbeddedChar_ConnectionString_Invalid ()
2315                 {
2316                         string [] tests = new string [] {
2317                                 " =",
2318                                 "=",
2319                                 "=;",
2320                                 "=ABC;",
2321                                 "='A'",
2322                                 "A",
2323                                 "A=(B;)",
2324                                 "A=B';'C",
2325                                 "A=B { {;} }",
2326                                 "A=B { ; }C",
2327                                 "A=BC'E;F'D",
2328                                 };
2329
2330                         DbConnectionStringBuilder [] cbs = new DbConnectionStringBuilder [] {
2331                                 new DbConnectionStringBuilder (),
2332                                 new DbConnectionStringBuilder (false),
2333                                 new DbConnectionStringBuilder (true)
2334                                 };
2335
2336                         for (int i = 0; i < tests.Length; i++) {
2337                                 for (int j = 0; j < cbs.Length; j++) {
2338                                         DbConnectionStringBuilder cb =cbs [j];
2339                                         try {
2340                                                 cb.ConnectionString = tests [i];
2341                                                 Assert.Fail ("#1:" + i + " (" + j + ")");
2342                                         } catch (ArgumentException ex) {
2343                                                 // Format of the initialization string does
2344                                                 // not conform to specification starting
2345                                                 // at index 0
2346                                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:"+ i + " (" + j + ")");
2347                                                 Assert.IsNull (ex.InnerException, "#3:" + i + " (" + j + ")");
2348                                                 Assert.IsNotNull (ex.Message, "#4:" + i + " (" + j + ")");
2349                                                 Assert.IsNull (ex.ParamName, "#5:" + i + " (" + j + ")");
2350                                         }
2351                                 }
2352                         }
2353                 }
2354
2355                 void AssertValueTest (string [][] tests1, string [][] tests2, bool useOdbc, string prefix)
2356                 {
2357                         DbConnectionStringBuilder sb = new DbConnectionStringBuilder (useOdbc);
2358                         for (int i = 0; i < tests1.Length; i++) {
2359                                 string [] test1 = tests1 [i];
2360                                 bool found = false;
2361                                 for (int j = 0; j < tests2.Length; j++) {
2362                                         string [] test2 = tests2 [j];
2363                                         if (test2 [0] == test1 [0]) {
2364                                                 found = true;
2365
2366                                                 if (test2 [1] != test1 [1])
2367                                                         continue;
2368                                                 if (test2 [2] != test1 [2])
2369                                                         continue;
2370                                                 if (test2 [3] != test1 [3])
2371                                                         continue;
2372
2373                                                 Assert.Fail (string.Format (
2374                                                         "{0}test1 {1} and test2 {2} " +
2375                                                         "should be moved to shared_tests.",
2376                                                         prefix, i, j));
2377                                         }
2378                                 }
2379                                 if (found)
2380                                         continue;
2381
2382                                 try {
2383                                         sb.ConnectionString = test1 [0];
2384                                         Assert.Fail (prefix + "1 (" + i + ")");
2385                                 } catch (ArgumentException ex) {
2386                                         // Format of the initialization string does
2387                                         // not conform to specification starting
2388                                         // at index 0
2389                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), prefix + "2 (" + i + ")");
2390                                         Assert.IsNull (ex.InnerException, prefix + "3 (" + i + ")");
2391                                         Assert.IsNotNull (ex.Message, prefix + "4 (" + i + ")");
2392                                         Assert.IsNull (ex.ParamName, prefix + "5 (" + i + ")");
2393                                 }
2394                         }
2395
2396                         // check uniqueness of tests
2397                         for (int i = 0; i < tests1.Length; i++) {
2398                                 for (int j = 0; j < tests1.Length; j++) {
2399                                         if (i == j)
2400                                                 continue;
2401                                         if (tests1 [i] == tests1 [j])
2402                                                 Assert.Fail (string.Format (
2403                                                         "{0}Duplicate test in test1 " +
2404                                                         "{1} and {2}.", prefix, i, j));
2405                                 }
2406                         }
2407
2408                         // check uniqueness of tests
2409                         for (int i = 0; i < tests2.Length; i++) {
2410                                 for (int j = 0; j < tests2.Length; j++) {
2411                                         if (i == j)
2412                                                 continue;
2413                                         if (tests2 [i] == tests2 [j])
2414                                                 Assert.Fail (string.Format (
2415                                                         "{0}Duplicate test in test2 " +
2416                                                         "{1} and {2}.", prefix, i, j));
2417                                 }
2418                         }
2419                 }
2420         }
2421 }
2422
2423 #endif // NET_2_0