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