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

// DbConnectionStringBuilderTest.cs - NUnit Test Cases for Testing the 
// DbConnectionStringBuilder class
//
// Author: 
//      Sureshkumar T ([email protected])
//	Daniel Morgan ([email protected])
//	Gert Driesen ([email protected]
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
// Copyright (C) 2008 Daniel Morgan
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

#if NET_2_0

#region Using directives

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Reflection;
using System.Text;

using NUnit.Framework;

#endregion

namespace MonoTests.System.Data.Common
{
	[TestFixture]
	public class DbConnectionStringBuilderTest
	{
		private DbConnectionStringBuilder builder = null;
		private const string SERVER = "SERVER";
		private const string SERVER_VALUE = "localhost";

		[SetUp]
		public void SetUp ()
		{
			builder = new DbConnectionStringBuilder ();
		}

		[Test]
		public void Add ()
		{
			builder.Add ("driverid", "420");
			builder.Add ("driverid", "560");
			builder.Add ("DriverID", "840");
			Assert.AreEqual ("840", builder ["driverId"], "#A1");
			Assert.IsTrue (builder.ContainsKey ("driverId"), "#A2");
			builder.Add ("Driver", "OdbcDriver");
			Assert.AreEqual ("OdbcDriver", builder ["Driver"], "#B1");
			Assert.IsTrue (builder.ContainsKey ("Driver"), "#B2");
			builder.Add ("Driver", "{OdbcDriver");
			Assert.AreEqual ("{OdbcDriver", builder ["Driver"], "#C1");
			Assert.IsTrue (builder.ContainsKey ("Driver"), "#C2");
			builder.Add ("Dsn", "MyDsn");
			Assert.AreEqual ("MyDsn", builder ["Dsn"], "#D1");
			Assert.IsTrue (builder.ContainsKey ("Dsn"), "#D2");
			builder.Add ("dsN", "MyDsn2");
			Assert.AreEqual ("MyDsn2", builder ["Dsn"], "#E1");
			Assert.IsTrue (builder.ContainsKey ("Dsn"), "#E2");
		}

		[Test]
		public void Add_Keyword_Invalid ()
		{
			string [] invalid_keywords = new string [] {
				string.Empty,
				" ",
				" abc",
				"abc ",
				"\r",
				"ab\rc",
				";abc",
				"a\0b"
				};

			for (int i = 0; i < invalid_keywords.Length; i++) {
				string keyword = invalid_keywords [i];
				try {
					builder.Add (keyword, "abc");
					Assert.Fail ("#1:" + i);
				} catch (ArgumentException ex) {
					// Invalid keyword, contain one or more of 'no characters',
					// 'control characters', 'leading or trailing whitespace'
					// or 'leading semicolons'
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:"+ i);
					Assert.IsNull (ex.InnerException, "#3:" + i);
					Assert.IsNotNull (ex.Message, "#4:" + i);
					Assert.IsTrue (ex.Message.IndexOf ("'" + keyword + "'") == -1, "#5:" + i);
					Assert.AreEqual (keyword, ex.ParamName, "#6:" + i);
				}
			}
		}

		[Test]
		public void Add_Keyword_Null ()
		{
			try {
				builder.Add (null, "abc");
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("keyword", ex.ParamName, "#5");
			}
		}

		[Test]
		public void ConnectionString ()
		{
			DbConnectionStringBuilder sb;

			sb = new DbConnectionStringBuilder ();
			sb.ConnectionString = "A=B";
			Assert.IsTrue (sb.ContainsKey ("A"), "#A1");
			Assert.AreEqual ("a=B", sb.ConnectionString, "#A2");
			Assert.AreEqual (1, sb.Count, "#A3");
			Assert.AreEqual (1, sb.Keys.Count, "#A4");

			sb.ConnectionString = null;
			Assert.IsFalse (sb.ContainsKey ("A"), "#B1");
			Assert.AreEqual (string.Empty, sb.ConnectionString, "#B2");
			Assert.AreEqual (0, sb.Count, "#B3");
			Assert.AreEqual (0, sb.Keys.Count, "#B4");

			sb = new DbConnectionStringBuilder ();
			sb.ConnectionString = "A=B";
			sb.ConnectionString = string.Empty;
			Assert.IsFalse (sb.ContainsKey ("A"), "#C1");
			Assert.AreEqual (string.Empty, sb.ConnectionString, "#C2");
			Assert.AreEqual (0, sb.Count, "#C3");
			Assert.AreEqual (0, sb.Keys.Count, "#C4");

			sb = new DbConnectionStringBuilder ();
			sb.ConnectionString = "A=B";
			sb.ConnectionString = "\r ";
			Assert.IsFalse (sb.ContainsKey ("A"), "#D1");
			Assert.AreEqual (string.Empty, sb.ConnectionString, "#D2");
			Assert.AreEqual (0, sb.Count, "#D3");
			Assert.AreEqual (0, sb.Keys.Count, "#D4");
		}

		[Test]
		public void ConnectionString_Value_Empty ()
		{
			DbConnectionStringBuilder [] sbs = new DbConnectionStringBuilder [] {
				new DbConnectionStringBuilder (),
				new DbConnectionStringBuilder (false),
				new DbConnectionStringBuilder (true)
				};

			foreach (DbConnectionStringBuilder sb in sbs) {
				sb.ConnectionString = "A=";
				Assert.IsFalse (sb.ContainsKey ("A"), "#1");
				Assert.AreEqual (string.Empty, sb.ConnectionString, "#2");
				Assert.AreEqual (0, sb.Count, "#3");
			}
		}

		[Test]
		public void Clear ()
		{
			DbConnectionStringBuilder [] sbs = new DbConnectionStringBuilder [] {
				new DbConnectionStringBuilder (),
				new DbConnectionStringBuilder (false),
				new DbConnectionStringBuilder (true)
				};

			foreach (DbConnectionStringBuilder sb in sbs) {
				sb ["Dbq"] = "C:\\Data.xls";
				sb ["Driver"] = "790";
				sb.Add ("Port", "56");
				sb.Clear ();
				Assert.AreEqual (string.Empty, sb.ConnectionString, "#1");
				Assert.IsFalse (sb.ContainsKey ("Dbq"), "#2");
				Assert.IsFalse (sb.ContainsKey ("Driver"), "#3");
				Assert.IsFalse (sb.ContainsKey ("Port"), "#4");
				Assert.AreEqual (0, sb.Count, "#5");
				Assert.AreEqual (0, sb.Keys.Count, "#6");
				Assert.AreEqual (0, sb.Values.Count, "#7");
			}
		}

                [Test]
                public void AddDuplicateTest ()
                {
                        builder.Add (SERVER, SERVER_VALUE);
                        builder.Add (SERVER, SERVER_VALUE);
                        // should allow duplicate addition. rather, it should re-assign
                        Assert.AreEqual (SERVER + "=" + SERVER_VALUE, builder.ConnectionString,
                                         "Duplicates addition does not change the value!");
                }

		[Test]
		public void Indexer ()
		{
			builder ["abc Def"] = "xa 34";
			Assert.AreEqual ("xa 34", builder ["abc def"], "#A1");
			Assert.AreEqual ("abc Def=\"xa 34\"", builder.ConnectionString, "#A2");
			builder ["na;"] = "abc;";
			Assert.AreEqual ("abc;", builder ["na;"], "#B1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"abc;\"", builder.ConnectionString, "#B2");
			builder ["Na;"] = "de\rfg";
			Assert.AreEqual ("de\rfg", builder ["na;"], "#C1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\"", builder.ConnectionString, "#C2");
			builder ["val"] = ";xyz";
			Assert.AreEqual (";xyz", builder ["val"], "#D1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\"", builder.ConnectionString, "#D2");
			builder ["name"] = string.Empty;
			Assert.AreEqual (string.Empty, builder ["name"], "#E1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\";name=", builder.ConnectionString, "#E2");
			builder ["name"] = " ";
			Assert.AreEqual (" ", builder ["name"], "#F1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\";name=\" \"", builder.ConnectionString, "#F2");

			builder = new DbConnectionStringBuilder (false);
			builder ["abc Def"] = "xa 34";
			Assert.AreEqual ("xa 34", builder ["abc def"], "#A1");
			Assert.AreEqual ("abc Def=\"xa 34\"", builder.ConnectionString, "#A2");
			builder ["na;"] = "abc;";
			Assert.AreEqual ("abc;", builder ["na;"], "#B1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"abc;\"", builder.ConnectionString, "#B2");
			builder ["Na;"] = "de\rfg";
			Assert.AreEqual ("de\rfg", builder ["na;"], "#C1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\"", builder.ConnectionString, "#C2");
			builder ["val"] = ";xyz";
			Assert.AreEqual (";xyz", builder ["val"], "#D1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\"", builder.ConnectionString, "#D2");
			builder ["name"] = string.Empty;
			Assert.AreEqual (string.Empty, builder ["name"], "#E1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\";name=", builder.ConnectionString, "#E2");
			builder ["name"] = " ";
			Assert.AreEqual (" ", builder ["name"], "#F1");
			Assert.AreEqual ("abc Def=\"xa 34\";na;=\"de\rfg\";val=\";xyz\";name=\" \"", builder.ConnectionString, "#F2");

			builder = new DbConnectionStringBuilder (true);
			builder ["abc Def"] = "xa 34";
			Assert.AreEqual ("xa 34", builder ["abc def"], "#A1");
			Assert.AreEqual ("abc Def=xa 34", builder.ConnectionString, "#A2");
			builder ["na;"] = "abc;";
			Assert.AreEqual ("abc;", builder ["na;"], "#B1");
			Assert.AreEqual ("abc Def=xa 34;na;={abc;}", builder.ConnectionString, "#B2");
			builder ["Na;"] = "de\rfg";
			Assert.AreEqual ("de\rfg", builder ["na;"], "#C1");
			Assert.AreEqual ("abc Def=xa 34;na;=de\rfg", builder.ConnectionString, "#C2");
			builder ["val"] = ";xyz";
			Assert.AreEqual (";xyz", builder ["val"], "#D1");
			Assert.AreEqual ("abc Def=xa 34;na;=de\rfg;val={;xyz}", builder.ConnectionString, "#D2");
			builder ["name"] = string.Empty;
			Assert.AreEqual (string.Empty, builder ["name"], "#E1");
			Assert.AreEqual ("abc Def=xa 34;na;=de\rfg;val={;xyz};name=", builder.ConnectionString, "#E2");
			builder ["name"] = " ";
			Assert.AreEqual (" ", builder ["name"], "#F1");
			Assert.AreEqual ("abc Def=xa 34;na;=de\rfg;val={;xyz};name= ", builder.ConnectionString, "#F2");
		}

		[Test]
		public void Indexer_Keyword_Invalid ()
		{
			string [] invalid_keywords = new string [] {
				string.Empty,
				" ",
				" abc",
				"abc ",
				"\r",
				"ab\rc",
				";abc",
				"a\0b"
				};

			for (int i = 0; i < invalid_keywords.Length; i++) {
				string keyword = invalid_keywords [i];
				try {
					builder [keyword] = "abc";
					Assert.Fail ("#A1:" + i);
				} catch (ArgumentException ex) {
					// Invalid keyword, contain one or more of 'no characters',
					// 'control characters', 'leading or trailing whitespace'
					// or 'leading semicolons'
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2:"+ i);
					Assert.IsNull (ex.InnerException, "#A3:" + i);
					Assert.IsNotNull (ex.Message, "#A4:" + i);
					Assert.IsTrue (ex.Message.IndexOf ("'" + keyword + "'") == -1, "#A5:" + i);
					Assert.AreEqual (keyword, ex.ParamName, "#A6:" + i);
				}

				builder [keyword] = null;
				Assert.IsFalse (builder.ContainsKey (keyword), "#B");

				try {
					object value = builder [keyword];
					Assert.Fail ("#C1:" + i);
				} catch (ArgumentException ex) {
					// Keyword not supported: '...'
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2:"+ i);
					Assert.IsNull (ex.InnerException, "#C3:" + i);
					Assert.IsNotNull (ex.Message, "#C4:" + i);
					Assert.IsTrue (ex.Message.IndexOf ("'" + keyword + "'") != -1, "#C5:" + i);
					Assert.IsNull (ex.ParamName, "#C6:" + i);
				}
			}
		}

		[Test]
		public void Indexer_Keyword_NotSupported ()
		{
			try {
				object value = builder ["abc"];
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Keyword not supported: 'abc'
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.IsTrue (ex.Message.IndexOf ("'abc'") != -1, "#5");
				Assert.IsNull (ex.ParamName, "#6");
			}
		}

		[Test]
		public void Indexer_Keyword_Null ()
		{
			try {
				builder [null] = "abc";
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("keyword", ex.ParamName, "#A5");
			}

			try {
				builder [null] = null;
				Assert.Fail ("#B1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("keyword", ex.ParamName, "#B5");
			}

			try {
				object value = builder [null];
				Assert.Fail ("#C1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
				Assert.IsNull (ex.InnerException, "#C3");
				Assert.IsNotNull (ex.Message, "#C4");
				Assert.AreEqual ("keyword", ex.ParamName, "#C5");
			}
		}

		[Test]
		public void Indexer_Value_Null ()
		{
			builder ["DriverID"] = null;
			Assert.AreEqual (string.Empty, builder.ConnectionString, "#A1");
			try {
				object value = builder ["DriverID"];
				Assert.Fail ("#A2:" + value);
			} catch (ArgumentException ex) {
				// Keyword not supported: 'DriverID'
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A3");
				Assert.IsNull (ex.InnerException, "#A4");
				Assert.IsNotNull (ex.Message, "#A5");
				Assert.IsTrue (ex.Message.IndexOf ("'DriverID'") != -1, "#A6:" + ex.Message);
				Assert.IsNull (ex.ParamName, "#A7");
			}
			Assert.IsFalse (builder.ContainsKey ("DriverID"), "#A8");
			Assert.AreEqual (string.Empty, builder.ConnectionString, "#A9");

			builder ["DriverID"] = "A";
			Assert.AreEqual ("DriverID=A", builder.ConnectionString, "#B1");
			builder ["DriverID"] = null;
			Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B2");
			Assert.AreEqual (string.Empty, builder.ConnectionString, "#B3");
		}

		[Test]
		public void Remove ()
		{
			Assert.IsFalse (builder.Remove ("Dsn"), "#A1");
			Assert.IsFalse (builder.Remove ("Driver"), "#A2");
			builder.Add ("DriverID", "790");
			builder ["DefaultDir"] = "C:\\";
			Assert.IsTrue (builder.Remove ("DriverID"), "#B1");
			Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B2");
			Assert.IsFalse (builder.Remove ("DriverID"), "#B3");
			Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B4");
			Assert.IsTrue (builder.Remove ("defaulTdIr"), "#B5");
			Assert.IsFalse (builder.ContainsKey ("DefaultDir"), "#B6");
			Assert.IsFalse (builder.Remove ("defaulTdIr"), "#B7");
			Assert.IsFalse (builder.Remove ("userid"), "#B8");
			Assert.IsFalse (builder.Remove (string.Empty), "#B9");
			Assert.IsFalse (builder.Remove ("\r"), "#B10");
			Assert.IsFalse (builder.Remove ("a;"), "#B11");
			builder ["Dsn"] = "myDsn";
			Assert.IsTrue (builder.Remove ("Dsn"), "#C1");
			Assert.IsFalse (builder.ContainsKey ("Dsn"), "#C2");
			Assert.IsFalse (builder.Remove ("Dsn"), "#C3");
			builder ["Driver"] = "SQL Server";
			Assert.IsTrue (builder.Remove ("Driver"), "#D1");
			Assert.IsFalse (builder.ContainsKey ("Driver"), "#D2");
			Assert.IsFalse (builder.Remove ("Driver"), "#D3");

			builder = new DbConnectionStringBuilder (false);
			Assert.IsFalse (builder.Remove ("Dsn"), "#A1");
			Assert.IsFalse (builder.Remove ("Driver"), "#A2");
			builder.Add ("DriverID", "790");
			builder ["DefaultDir"] = "C:\\";
			Assert.IsTrue (builder.Remove ("DriverID"), "#B1");
			Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B2");
			Assert.IsFalse (builder.Remove ("DriverID"), "#B3");
			Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B4");
			Assert.IsTrue (builder.Remove ("defaulTdIr"), "#B5");
			Assert.IsFalse (builder.ContainsKey ("DefaultDir"), "#B6");
			Assert.IsFalse (builder.Remove ("defaulTdIr"), "#B7");
			Assert.IsFalse (builder.Remove ("userid"), "#B8");
			Assert.IsFalse (builder.Remove (string.Empty), "#B9");
			Assert.IsFalse (builder.Remove ("\r"), "#B10");
			Assert.IsFalse (builder.Remove ("a;"), "#B11");
			builder ["Dsn"] = "myDsn";
			Assert.IsTrue (builder.Remove ("Dsn"), "#C1");
			Assert.IsFalse (builder.ContainsKey ("Dsn"), "#C2");
			Assert.IsFalse (builder.Remove ("Dsn"), "#C3");
			builder ["Driver"] = "SQL Server";
			Assert.IsTrue (builder.Remove ("Driver"), "#D1");
			Assert.IsFalse (builder.ContainsKey ("Driver"), "#D2");
			Assert.IsFalse (builder.Remove ("Driver"), "#D3");

			builder = new DbConnectionStringBuilder (true);
			Assert.IsFalse (builder.Remove ("Dsn"), "#A1");
			Assert.IsFalse (builder.Remove ("Driver"), "#A2");
			builder.Add ("DriverID", "790");
			builder ["DefaultDir"] = "C:\\";
			Assert.IsTrue (builder.Remove ("DriverID"), "#B1");
			Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B2");
			Assert.IsFalse (builder.Remove ("DriverID"), "#B3");
			Assert.IsFalse (builder.ContainsKey ("DriverID"), "#B4");
			Assert.IsTrue (builder.Remove ("defaulTdIr"), "#B5");
			Assert.IsFalse (builder.ContainsKey ("DefaultDir"), "#B6");
			Assert.IsFalse (builder.Remove ("defaulTdIr"), "#B7");
			Assert.IsFalse (builder.Remove ("userid"), "#B8");
			Assert.IsFalse (builder.Remove (string.Empty), "#B9");
			Assert.IsFalse (builder.Remove ("\r"), "#B10");
			Assert.IsFalse (builder.Remove ("a;"), "#B11");
			builder ["Dsn"] = "myDsn";
			Assert.IsTrue (builder.Remove ("Dsn"), "#C1");
			Assert.IsFalse (builder.ContainsKey ("Dsn"), "#C2");
			Assert.IsFalse (builder.Remove ("Dsn"), "#C3");
			builder ["Driver"] = "SQL Server";
			Assert.IsTrue (builder.Remove ("Driver"), "#D1");
			Assert.IsFalse (builder.ContainsKey ("Driver"), "#D2");
			Assert.IsFalse (builder.Remove ("Driver"), "#D3");
		}

		[Test]
		public void Remove_Keyword_Null ()
		{
			try {
				builder.Remove (null);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("keyword", ex.ParamName, "#5");
			}
		}

		[Test]
		public void ContainsKey ()
		{
			builder ["SourceType"] = "DBC";
			builder.Add ("Port", "56");
			Assert.IsTrue (builder.ContainsKey ("SourceType"), "#A1");
			Assert.IsTrue (builder.ContainsKey ("Port"), "#A2");
			Assert.IsFalse (builder.ContainsKey ("Dsn"), "#A3");
			Assert.IsFalse (builder.ContainsKey ("Driver"), "#A4");
			Assert.IsFalse (builder.ContainsKey ("xyz"), "#A5");
			builder ["Dsn"] = "myDsn";
			Assert.IsTrue (builder.ContainsKey ("Dsn"), "#A6");
			builder ["Driver"] = "SQL Server";
			Assert.IsTrue (builder.ContainsKey ("Driver"), "#A7");
			builder ["abc"] = "pqr";
			Assert.IsTrue (builder.ContainsKey ("ABC"), "#A8");
			Assert.IsFalse (builder.ContainsKey (string.Empty), "#A9");

			builder = new DbConnectionStringBuilder (false);
			builder ["SourceType"] = "DBC";
			builder.Add ("Port", "56");
			Assert.IsTrue (builder.ContainsKey ("SourceType"), "#A1");
			Assert.IsTrue (builder.ContainsKey ("Port"), "#A2");
			Assert.IsFalse (builder.ContainsKey ("Dsn"), "#A3");
			Assert.IsFalse (builder.ContainsKey ("Driver"), "#A4");
			Assert.IsFalse (builder.ContainsKey ("xyz"), "#A5");
			builder ["Dsn"] = "myDsn";
			Assert.IsTrue (builder.ContainsKey ("Dsn"), "#A6");
			builder ["Driver"] = "SQL Server";
			Assert.IsTrue (builder.ContainsKey ("Driver"), "#A7");
			builder ["abc"] = "pqr";
			Assert.IsTrue (builder.ContainsKey ("ABC"), "#A8");
			Assert.IsFalse (builder.ContainsKey (string.Empty), "#A9");

			builder = new DbConnectionStringBuilder (true);
			builder ["SourceType"] = "DBC";
			builder.Add ("Port", "56");
			Assert.IsTrue (builder.ContainsKey ("SourceType"), "#A1");
			Assert.IsTrue (builder.ContainsKey ("Port"), "#A2");
			Assert.IsFalse (builder.ContainsKey ("Dsn"), "#A3");
			Assert.IsFalse (builder.ContainsKey ("Driver"), "#A4");
			Assert.IsFalse (builder.ContainsKey ("xyz"), "#A5");
			builder ["Dsn"] = "myDsn";
			Assert.IsTrue (builder.ContainsKey ("Dsn"), "#A6");
			builder ["Driver"] = "SQL Server";
			Assert.IsTrue (builder.ContainsKey ("Driver"), "#A7");
			builder ["abc"] = "pqr";
			Assert.IsTrue (builder.ContainsKey ("ABC"), "#A8");
			Assert.IsFalse (builder.ContainsKey (string.Empty), "#A9");
		}

		[Test]
		public void ContainsKey_Keyword_Null ()
		{
			builder ["SourceType"] = "DBC";
			try {
				builder.ContainsKey (null);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("keyword", ex.ParamName, "#5");
			}
		}

                [Test]
                public void EquivalentToTest ()
                {
                        builder.Add (SERVER, SERVER_VALUE);
                        DbConnectionStringBuilder sb2 = new DbConnectionStringBuilder ();
                        sb2.Add (SERVER, SERVER_VALUE);
                        bool value = builder.EquivalentTo (sb2);
                        Assert.IsTrue (value, "builder comparision does not work!");

                        // negative tests
                        sb2.Add (SERVER + "1", SERVER_VALUE);
                        value = builder.EquivalentTo (sb2);
                        Assert.IsFalse (value, "builder comparision does not work for not equivalent strings!");
                }

		[Test] // AppendKeyValuePair (StringBuilder, String, String)
		public void AppendKeyValuePair1 ()
		{
			StringBuilder sb = new StringBuilder ();
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure");
			Assert.AreEqual ("Database=Adventure", sb.ToString (), "#A1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture");
			Assert.AreEqual ("Database=\"Adven'ture\"", sb.ToString (), "#A2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture");
			Assert.AreEqual ("Database='Adven\"ture'", sb.ToString (), "#A3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure\"");
			Assert.AreEqual ("Database='\"Adventure\"'", sb.ToString (), "#A4");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture\"");
			Assert.AreEqual ("Database=\"\"\"Adven'ture\"\"\"", sb.ToString (), "#A5");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture");
			Assert.AreEqual ("Database=\"Adven;ture\"", sb.ToString (), "#B1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure;");
			Assert.AreEqual ("Database=\"Adventure;\"", sb.ToString (), "#B2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure");
			Assert.AreEqual ("Database=\";Adventure\"", sb.ToString (), "#B3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture");
			Assert.AreEqual ("Database=\"Adv'en;ture\"", sb.ToString (), "#B4");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture");
			Assert.AreEqual ("Database='Adv\"en;ture'", sb.ToString (), "#B5");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture");
			Assert.AreEqual ("Database=\"A'dv\"\"en;ture\"", sb.ToString (), "#B6");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture\"");
			Assert.AreEqual ("Database='\"Adven;ture\"'", sb.ToString (), "#B7");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture");
			Assert.AreEqual ("Database=\"Adven=ture\"", sb.ToString (), "#C1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture");
			Assert.AreEqual ("Database=\"Adv'en=ture\"", sb.ToString (), "#C2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture");
			Assert.AreEqual ("Database='Adv\"en=ture'", sb.ToString (), "#C3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture");
			Assert.AreEqual ("Database=\"A'dv\"\"en=ture\"", sb.ToString (), "#C4");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture\"");
			Assert.AreEqual ("Database='\"Adven=ture\"'", sb.ToString (), "#C5");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture");
			Assert.AreEqual ("Database=Adven{ture", sb.ToString (), "#D1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture");
			Assert.AreEqual ("Database=Adven}ture", sb.ToString (), "#D2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure");
			Assert.AreEqual ("Database={Adventure", sb.ToString (), "#D3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure");
			Assert.AreEqual ("Database=}Adventure", sb.ToString (), "#D4");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure{");
			Assert.AreEqual ("Database=Adventure{", sb.ToString (), "#D5");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure}");
			Assert.AreEqual ("Database=Adventure}", sb.ToString (), "#D6");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture");
			Assert.AreEqual ("Database=\"Adv'en{ture\"", sb.ToString (), "#D7");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture");
			Assert.AreEqual ("Database=\"Adv'en}ture\"", sb.ToString (), "#D8");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture");
			Assert.AreEqual ("Database='Adv\"en{ture'", sb.ToString (), "#D9");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture");
			Assert.AreEqual ("Database='Adv\"en}ture'", sb.ToString (), "#D10");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture");
			Assert.AreEqual ("Database=\"A'dv\"\"en{ture\"", sb.ToString (), "#D11");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture");
			Assert.AreEqual ("Database=\"A'dv\"\"en}ture\"", sb.ToString (), "#D12");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture\"");
			Assert.AreEqual ("Database='\"Adven{ture\"'", sb.ToString (), "#D13");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture\"");
			Assert.AreEqual ("Database='\"Adven}ture\"'", sb.ToString (), "#D14");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure");
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost");
			Assert.AreEqual ("Database=Adventure;Server=localhost", sb.ToString (), "#E1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", string.Empty);
			Assert.AreEqual ("Database=", sb.ToString (), "#E2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", null);
			Assert.AreEqual ("Database=", sb.ToString (), "#E3");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Datab=ase", "Adven=ture", false);
			Assert.AreEqual ("Datab==ase=\"Adven=ture\"", sb.ToString (), "#F1");
		}

		[Test] // AppendKeyValuePair (StringBuilder, String, String)
		public void AppendKeyValuePair1_Builder_Null ()
		{
			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					(StringBuilder) null, "Server",
					"localhost");
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("builder", ex.ParamName, "#5");
			}
		}

		[Test] // AppendKeyValuePair (StringBuilder, String, String)
		public void AppendKeyValuePair1_Keyword_Empty ()
		{
			StringBuilder sb = new StringBuilder ();
			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					sb, string.Empty, "localhost");
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Expecting non-empty string for 'keyName'
				// parameter
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.IsNull (ex.ParamName, "#5");
			}
		}

		[Test] // AppendKeyValuePair (StringBuilder, String, String)
		public void AppendKeyValuePair1_Keyword_Null ()
		{
			StringBuilder sb = new StringBuilder ();
			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					sb, (string) null, "localhost");
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("keyName", ex.ParamName, "#5");
			}
		}

		[Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
		public void AppendKeyValuePair2_UseOdbcRules_False ()
		{
			StringBuilder sb = new StringBuilder ();
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works", false);
			Assert.AreEqual ("Database=\"Adventure Works\"", sb.ToString (), "#A1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure", false);
			Assert.AreEqual ("Database=Adventure", sb.ToString (), "#A2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture Works", false);
			Assert.AreEqual ("Database=\"Adven'ture Works\"", sb.ToString (), "#A3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture", false);
			Assert.AreEqual ("Database=\"Adven'ture\"", sb.ToString (), "#A4");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture Works", false);
			Assert.AreEqual ("Database='Adven\"ture Works'", sb.ToString (), "#A5");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture", false);
			Assert.AreEqual ("Database='Adven\"ture'", sb.ToString (), "#A6");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure Works\"", false);
			Assert.AreEqual ("Database='\"Adventure Works\"'", sb.ToString (), "#A7");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure\"", false);
			Assert.AreEqual ("Database='\"Adventure\"'", sb.ToString (), "#A8");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture Works\"", false);
			Assert.AreEqual ("Database=\"\"\"Adven'ture Works\"\"\"", sb.ToString (), "#A9");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture\"", false);
			Assert.AreEqual ("Database=\"\"\"Adven'ture\"\"\"", sb.ToString (), "#A10");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture Works", false);
			Assert.AreEqual ("Database=\"Adven;ture Works\"", sb.ToString (), "#B1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture", false);
			Assert.AreEqual ("Database=\"Adven;ture\"", sb.ToString (), "#B2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works;", false);
			Assert.AreEqual ("Database=\"Adventure Works;\"", sb.ToString (), "#B3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure;", false);
			Assert.AreEqual ("Database=\"Adventure;\"", sb.ToString (), "#B4");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure Works", false);
			Assert.AreEqual ("Database=\";Adventure Works\"", sb.ToString (), "#B5");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure", false);
			Assert.AreEqual ("Database=\";Adventure\"", sb.ToString (), "#B6");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture Works", false);
			Assert.AreEqual ("Database=\"Adv'en;ture Works\"", sb.ToString (), "#B7");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture", false);
			Assert.AreEqual ("Database=\"Adv'en;ture\"", sb.ToString (), "#B8");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture Works", false);
			Assert.AreEqual ("Database='Adv\"en;ture Works'", sb.ToString (), "#B9");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture", false);
			Assert.AreEqual ("Database='Adv\"en;ture'", sb.ToString (), "#B10");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture Works", false);
			Assert.AreEqual ("Database=\"A'dv\"\"en;ture Works\"", sb.ToString (), "#B11");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture", false);
			Assert.AreEqual ("Database=\"A'dv\"\"en;ture\"", sb.ToString (), "#B12");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture Works\"", false);
			Assert.AreEqual ("Database='\"Adven;ture Works\"'", sb.ToString (), "#B13");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture\"", false);
			Assert.AreEqual ("Database='\"Adven;ture\"'", sb.ToString (), "#B14");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture Works", false);
			Assert.AreEqual ("Database=\"Adven=ture Works\"", sb.ToString (), "#C1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture", false);
			Assert.AreEqual ("Database=\"Adven=ture\"", sb.ToString (), "#C2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture Works", false);
			Assert.AreEqual ("Database=\"Adv'en=ture Works\"", sb.ToString (), "#C3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture", false);
			Assert.AreEqual ("Database=\"Adv'en=ture\"", sb.ToString (), "#C4");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture Works", false);
			Assert.AreEqual ("Database='Adv\"en=ture Works'", sb.ToString (), "#C5");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture", false);
			Assert.AreEqual ("Database='Adv\"en=ture'", sb.ToString (), "#C6");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture Works", false);
			Assert.AreEqual ("Database=\"A'dv\"\"en=ture Works\"", sb.ToString (), "#C7");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture", false);
			Assert.AreEqual ("Database=\"A'dv\"\"en=ture\"", sb.ToString (), "#C8");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture Works\"", false);
			Assert.AreEqual ("Database='\"Adven=ture Works\"'", sb.ToString (), "#C9");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture\"", false);
			Assert.AreEqual ("Database='\"Adven=ture\"'", sb.ToString (), "#C10");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture Works", false);
			Assert.AreEqual ("Database=\"Adven{ture Works\"", sb.ToString (), "#D1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture", false);
			Assert.AreEqual ("Database=Adven{ture", sb.ToString (), "#D2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture Works", false);
			Assert.AreEqual ("Database=\"Adven}ture Works\"", sb.ToString (), "#D3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture", false);
			Assert.AreEqual ("Database=Adven}ture", sb.ToString (), "#D4");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure Works", false);
			Assert.AreEqual ("Database=\"{Adventure Works\"", sb.ToString (), "#D5");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure", false);
			Assert.AreEqual ("Database={Adventure", sb.ToString (), "#D6");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure Works", false);
			Assert.AreEqual ("Database=\"}Adventure Works\"", sb.ToString (), "#D7");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure", false);
			Assert.AreEqual ("Database=}Adventure", sb.ToString (), "#D8");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works{", false);
			Assert.AreEqual ("Database=\"Adventure Works{\"", sb.ToString (), "#D9");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure{", false);
			Assert.AreEqual ("Database=Adventure{", sb.ToString (), "#D10");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works}", false);
			Assert.AreEqual ("Database=\"Adventure Works}\"", sb.ToString (), "#D11");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure}", false);
			Assert.AreEqual ("Database=Adventure}", sb.ToString (), "#D12");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture Works", false);
			Assert.AreEqual ("Database=\"Adv'en{ture Works\"", sb.ToString (), "#D13");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture", false);
			Assert.AreEqual ("Database=\"Adv'en{ture\"", sb.ToString (), "#D14");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture Works", false);
			Assert.AreEqual ("Database=\"Adv'en}ture Works\"", sb.ToString (), "#D15");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture", false);
			Assert.AreEqual ("Database=\"Adv'en}ture\"", sb.ToString (), "#D16");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture Works", false);
			Assert.AreEqual ("Database='Adv\"en{ture Works'", sb.ToString (), "#D17");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture", false);
			Assert.AreEqual ("Database='Adv\"en{ture'", sb.ToString (), "#D18");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture Works", false);
			Assert.AreEqual ("Database='Adv\"en}ture Works'", sb.ToString (), "#D19");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture", false);
			Assert.AreEqual ("Database='Adv\"en}ture'", sb.ToString (), "#D20");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture Works", false);
			Assert.AreEqual ("Database=\"A'dv\"\"en{ture Works\"", sb.ToString (), "#D21");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture", false);
			Assert.AreEqual ("Database=\"A'dv\"\"en{ture\"", sb.ToString (), "#D22");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture Works", false);
			Assert.AreEqual ("Database=\"A'dv\"\"en}ture Works\"", sb.ToString (), "#D23");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture", false);
			Assert.AreEqual ("Database=\"A'dv\"\"en}ture\"", sb.ToString (), "#D24");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture Works\"", false);
			Assert.AreEqual ("Database='\"Adven{ture Works\"'", sb.ToString (), "#D25");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture\"", false);
			Assert.AreEqual ("Database='\"Adven{ture\"'", sb.ToString (), "#D26");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture Works\"", false);
			Assert.AreEqual ("Database='\"Adven}ture Works\"'", sb.ToString (), "#D27");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture\"", false);
			Assert.AreEqual ("Database='\"Adven}ture\"'", sb.ToString (), "#D28");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}}}", false);
			Assert.AreEqual ("Database={{{B}}}", sb.ToString (), "#D33a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}}}", false);
			Assert.AreEqual ("Driver={{{B}}}", sb.ToString (), "#D33b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{A{B{C}D}E}", false);
			Assert.AreEqual ("Database={A{B{C}D}E}", sb.ToString (), "#D33c");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{A{B{C}D}E}", false);
			Assert.AreEqual ("Driver={A{B{C}D}E}", sb.ToString (), "#D33d");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}}", false);
			Assert.AreEqual ("Database={{{B}}", sb.ToString (), "#D33e");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}}", false);
			Assert.AreEqual ("Driver={{{B}}", sb.ToString (), "#D33f");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}", false);
			Assert.AreEqual ("Database={{{B}", sb.ToString (), "#D33g");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}", false);
			Assert.AreEqual ("Driver={{{B}", sb.ToString (), "#D33h");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{B}", false);
			Assert.AreEqual ("Database={{B}", sb.ToString (), "#D33i");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{B}", false);
			Assert.AreEqual ("Driver={{B}", sb.ToString (), "#D33j");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{B}}", false);
			Assert.AreEqual ("Database={B}}", sb.ToString (), "#D33k");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{B}}", false);
			Assert.AreEqual ("Driver={B}}", sb.ToString (), "#D33l");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{B}}C", false);
			Assert.AreEqual ("Database={B}}C", sb.ToString (), "#D33k");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{B}}C", false);
			Assert.AreEqual ("Driver={B}}C", sb.ToString (), "#D33l");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A{B}}", false);
			Assert.AreEqual ("Database=A{B}}", sb.ToString (), "#D33k");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A{B}}", false);
			Assert.AreEqual ("Driver=A{B}}", sb.ToString (), "#D33l");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", " {B}} ", false);
			Assert.AreEqual ("Database=\" {B}} \"", sb.ToString (), "#D33k");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", " {B}} ", false);
			Assert.AreEqual ("Driver=\" {B}} \"", sb.ToString (), "#D33l");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{B}}", false);
			Assert.AreEqual ("Database={{B}}", sb.ToString (), "#D33a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{B}}", false);
			Assert.AreEqual ("Driver={{B}}", sb.ToString (), "#D33b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}}", false);
			Assert.AreEqual ("Database=}}", sb.ToString (), "#D33a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}}", false);
			Assert.AreEqual ("Driver=}}", sb.ToString (), "#D33b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}", false);
			Assert.AreEqual ("Database=}", sb.ToString (), "#D33a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}", false);
			Assert.AreEqual ("Driver=}", sb.ToString (), "#D33b");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works", false);
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", false);
			Assert.AreEqual ("Database=\"Adventure Works\";Server=localhost", sb.ToString (), "#E1");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure", false);
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", false);
			Assert.AreEqual ("Database=Adventure;Server=localhost", sb.ToString (), "#E2");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", string.Empty, false);
			Assert.AreEqual ("Database=", sb.ToString (), "#E3");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", null, false);
			Assert.AreEqual ("Database=", sb.ToString (), "#E4");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Datab=ase", "Adven=ture", false);
			Assert.AreEqual ("Datab==ase=\"Adven=ture\"", sb.ToString (), "#F1");
		}

		[Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
		public void AppendKeyValuePair2_UseOdbcRules_True ()
		{
			StringBuilder sb = new StringBuilder ();
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works", true);
			Assert.AreEqual ("Database=Adventure Works", sb.ToString (), "#A1a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works", true);
			Assert.AreEqual ("Driver={Adventure Works}", sb.ToString (), "#A1b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure", true);
			Assert.AreEqual ("Database=Adventure", sb.ToString (), "#A2a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure", true);
			Assert.AreEqual ("Driver={Adventure}", sb.ToString (), "#A2b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture Works", true);
			Assert.AreEqual ("Database=Adven'ture Works", sb.ToString (), "#A3a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven'ture Works", true);
			Assert.AreEqual ("Driver={Adven'ture Works}", sb.ToString (), "#A3b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven'ture", true);
			Assert.AreEqual ("Database=Adven'ture", sb.ToString (), "#A4a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven'ture", true);
			Assert.AreEqual ("Driver={Adven'ture}", sb.ToString (), "#A4b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture Works", true);
			Assert.AreEqual ("Database=Adven\"ture Works", sb.ToString (), "#A5a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven\"ture Works", true);
			Assert.AreEqual ("Driver={Adven\"ture Works}", sb.ToString (), "#A5b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven\"ture", true);
			Assert.AreEqual ("Database=Adven\"ture", sb.ToString (), "#A6a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven\"ture", true);
			Assert.AreEqual ("Driver={Adven\"ture}", sb.ToString (), "#A6b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure Works\"", true);
			Assert.AreEqual ("Database=\"Adventure Works\"", sb.ToString (), "#A7a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adventure Works\"", true);
			Assert.AreEqual ("Driver={\"Adventure Works\"}", sb.ToString (), "#A7b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adventure\"", true);
			Assert.AreEqual ("Database=\"Adventure\"", sb.ToString (), "#A8a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adventure\"", true);
			Assert.AreEqual ("Driver={\"Adventure\"}", sb.ToString (), "#A8b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture Works\"", true);
			Assert.AreEqual ("Database=\"Adven'ture Works\"", sb.ToString (), "#A9a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven'ture Works\"", true);
			Assert.AreEqual ("Driver={\"Adven'ture Works\"}", sb.ToString (), "#A9b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven'ture\"", true);
			Assert.AreEqual ("Database=\"Adven'ture\"", sb.ToString (), "#A10a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven'ture\"", true);
			Assert.AreEqual ("Driver={\"Adven'ture\"}", sb.ToString (), "#A10b");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture Works", true);
			Assert.AreEqual ("Database={Adven;ture Works}", sb.ToString (), "#B1a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven;ture Works", true);
			Assert.AreEqual ("Driver={Adven;ture Works}", sb.ToString (), "#B1b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven;ture", true);
			Assert.AreEqual ("Database={Adven;ture}", sb.ToString (), "#B2a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven;ture", true);
			Assert.AreEqual ("Driver={Adven;ture}", sb.ToString (), "#B2b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works;", true);
			Assert.AreEqual ("Database={Adventure Works;}", sb.ToString (), "#B3a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works;", true);
			Assert.AreEqual ("Driver={Adventure Works;}", sb.ToString (), "#B3b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure;", true);
			Assert.AreEqual ("Database={Adventure;}", sb.ToString (), "#B4a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure;", true);
			Assert.AreEqual ("Driver={Adventure;}", sb.ToString (), "#B4b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure Works", true);
			Assert.AreEqual ("Database={;Adventure Works}", sb.ToString (), "#B5a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", ";Adventure Works", true);
			Assert.AreEqual ("Driver={;Adventure Works}", sb.ToString (), "#B5b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", ";Adventure", true);
			Assert.AreEqual ("Database={;Adventure}", sb.ToString (), "#B6a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", ";Adventure", true);
			Assert.AreEqual ("Driver={;Adventure}", sb.ToString (), "#B6b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture Works", true);
			Assert.AreEqual ("Database={Adv'en;ture Works}", sb.ToString (), "#B7a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en;ture Works", true);
			Assert.AreEqual ("Driver={Adv'en;ture Works}", sb.ToString (), "#B7b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en;ture", true);
			Assert.AreEqual ("Database={Adv'en;ture}", sb.ToString (), "#B8a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en;ture", true);
			Assert.AreEqual ("Driver={Adv'en;ture}", sb.ToString (), "#B8b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture Works", true);
			Assert.AreEqual ("Database={Adv\"en;ture Works}", sb.ToString (), "#B9A");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en;ture Works", true);
			Assert.AreEqual ("Driver={Adv\"en;ture Works}", sb.ToString (), "#B9b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en;ture", true);
			Assert.AreEqual ("Database={Adv\"en;ture}", sb.ToString (), "#B10a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en;ture", true);
			Assert.AreEqual ("Driver={Adv\"en;ture}", sb.ToString (), "#B10b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture Works", true);
			Assert.AreEqual ("Database={A'dv\"en;ture Works}", sb.ToString (), "#B11a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en;ture Works", true);
			Assert.AreEqual ("Driver={A'dv\"en;ture Works}", sb.ToString (), "#B11b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en;ture", true);
			Assert.AreEqual ("Database={A'dv\"en;ture}", sb.ToString (), "#B12a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en;ture", true);
			Assert.AreEqual ("Driver={A'dv\"en;ture}", sb.ToString (), "#B12b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture Works\"", true);
			Assert.AreEqual ("Database={\"Adven;ture Works\"}", sb.ToString (), "#B13a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven;ture Works\"", true);
			Assert.AreEqual ("Driver={\"Adven;ture Works\"}", sb.ToString (), "#B13b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven;ture\"", true);
			Assert.AreEqual ("Database={\"Adven;ture\"}", sb.ToString (), "#B14a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven;ture\"", true);
			Assert.AreEqual ("Driver={\"Adven;ture\"}", sb.ToString (), "#B14b");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture Works", true);
			Assert.AreEqual ("Database=Adven=ture Works", sb.ToString (), "#C1a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven=ture Works", true);
			Assert.AreEqual ("Driver={Adven=ture Works}", sb.ToString (), "#C1b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven=ture", true);
			Assert.AreEqual ("Database=Adven=ture", sb.ToString (), "#C2a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven=ture", true);
			Assert.AreEqual ("Driver={Adven=ture}", sb.ToString (), "#C2b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture Works", true);
			Assert.AreEqual ("Database=Adv'en=ture Works", sb.ToString (), "#C3a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en=ture Works", true);
			Assert.AreEqual ("Driver={Adv'en=ture Works}", sb.ToString (), "#C3b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en=ture", true);
			Assert.AreEqual ("Database=Adv'en=ture", sb.ToString (), "#C4a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en=ture", true);
			Assert.AreEqual ("Driver={Adv'en=ture}", sb.ToString (), "#C4b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture Works", true);
			Assert.AreEqual ("Database=Adv\"en=ture Works", sb.ToString (), "#C5a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en=ture Works", true);
			Assert.AreEqual ("Driver={Adv\"en=ture Works}", sb.ToString (), "#C5b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en=ture", true);
			Assert.AreEqual ("Database=Adv\"en=ture", sb.ToString (), "#C6a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en=ture", true);
			Assert.AreEqual ("Driver={Adv\"en=ture}", sb.ToString (), "#C6b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture Works", true);
			Assert.AreEqual ("Database=A'dv\"en=ture Works", sb.ToString (), "#C7a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en=ture Works", true);
			Assert.AreEqual ("Driver={A'dv\"en=ture Works}", sb.ToString (), "#C7b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en=ture", true);
			Assert.AreEqual ("Database=A'dv\"en=ture", sb.ToString (), "#C8a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en=ture", true);
			Assert.AreEqual ("Driver={A'dv\"en=ture}", sb.ToString (), "#C8b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture Works\"", true);
			Assert.AreEqual ("Database=\"Adven=ture Works\"", sb.ToString (), "#C9a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven=ture Works\"", true);
			Assert.AreEqual ("Driver={\"Adven=ture Works\"}", sb.ToString (), "#C9b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven=ture\"", true);
			Assert.AreEqual ("Database=\"Adven=ture\"", sb.ToString (), "#C10a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven=ture\"", true);
			Assert.AreEqual ("Driver={\"Adven=ture\"}", sb.ToString (), "#C10b");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture Works", true);
			Assert.AreEqual ("Database=Adven{ture Works", sb.ToString (), "#D1a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven{ture Works", true);
			Assert.AreEqual ("Driver={Adven{ture Works}", sb.ToString (), "#D1b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{tu}re Works", true);
			Assert.AreEqual ("Database=Adven{tu}re Works", sb.ToString (), "#D1c");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven{tu}re Works", true);
			Assert.AreEqual ("Driver={Adven{tu}}re Works}", sb.ToString (), "#D1d");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{ture", true);
			Assert.AreEqual ("Database=Adven{ture", sb.ToString (), "#D2a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven{ture", true);
			Assert.AreEqual ("Driver={Adven{ture}", sb.ToString (), "#D2b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven{tu}re", true);
			Assert.AreEqual ("Database=Adven{tu}re", sb.ToString (), "#D2c");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven{tu}re", true);
			Assert.AreEqual ("Driver={Adven{tu}}re}", sb.ToString (), "#D2d");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture Works", true);
			Assert.AreEqual ("Database=Adven}ture Works", sb.ToString (), "#D3a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven}ture Works", true);
			Assert.AreEqual ("Driver={Adven}}ture Works}", sb.ToString (), "#D3b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adven}ture", true);
			Assert.AreEqual ("Database=Adven}ture", sb.ToString (), "#D4a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adven}ture", true);
			Assert.AreEqual ("Driver={Adven}}ture}", sb.ToString (), "#D4b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure Works", true);
			Assert.AreEqual ("Database={{Adventure Works}", sb.ToString (), "#D5a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure Works", true);
			Assert.AreEqual ("Driver={{Adventure Works}", sb.ToString (), "#D5b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure", true);
			Assert.AreEqual ("Database={{Adventure}", sb.ToString (), "#D6a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure", true);
			Assert.AreEqual ("Driver={{Adventure}", sb.ToString (), "#D6b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure Works}", true);
			Assert.AreEqual ("Database={Adventure Works}", sb.ToString (), "#D7a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure Works}", true);
			Assert.AreEqual ("Driver={Adventure Works}", sb.ToString (), "#D7b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventu{re Works}", true);
			Assert.AreEqual ("Database={Adventu{re Works}", sb.ToString (), "#D7c");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventu{re Works}", true);
			Assert.AreEqual ("Driver={Adventu{re Works}", sb.ToString (), "#D7d");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventu}re Works}", true);
			Assert.AreEqual ("Database={{Adventu}}re Works}}}", sb.ToString (), "#D7e");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventu}re Works}", true);
			Assert.AreEqual ("Driver={{Adventu}}re Works}}}", sb.ToString (), "#D7f");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure}", true);
			Assert.AreEqual ("Database={Adventure}", sb.ToString (), "#D8a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure}", true);
			Assert.AreEqual ("Driver={Adventure}", sb.ToString (), "#D8b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventu{re}", true);
			Assert.AreEqual ("Database={Adventu{re}", sb.ToString (), "#D8c");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventu{re}", true);
			Assert.AreEqual ("Driver={Adventu{re}", sb.ToString (), "#D8d");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventu}re}", true);
			Assert.AreEqual ("Database={{Adventu}}re}}}", sb.ToString (), "#D8e");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventu}re}", true);
			Assert.AreEqual ("Driver={{Adventu}}re}}}", sb.ToString (), "#D8f");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adventure }Works", true);
			Assert.AreEqual ("Database={{Adventure }}Works}", sb.ToString (), "#D9a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adventure }Works", true);
			Assert.AreEqual ("Driver={{Adventure }}Works}", sb.ToString (), "#D9b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{Adven}ture", true);
			Assert.AreEqual ("Database={{Adven}}ture}", sb.ToString (), "#D10a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{Adven}ture", true);
			Assert.AreEqual ("Driver={{Adven}}ture}", sb.ToString (), "#D10b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure Works", true);
			Assert.AreEqual ("Database=}Adventure Works", sb.ToString (), "#D11a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}Adventure Works", true);
			Assert.AreEqual ("Driver={}}Adventure Works}", sb.ToString (), "#D11b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}Adventure", true);
			Assert.AreEqual ("Database=}Adventure", sb.ToString (), "#D12a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}Adventure", true);
			Assert.AreEqual ("Driver={}}Adventure}", sb.ToString (), "#D12b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works{", true);
			Assert.AreEqual ("Database=Adventure Works{", sb.ToString (), "#D13a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works{", true);
			Assert.AreEqual ("Driver={Adventure Works{}", sb.ToString (), "#D13b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure{", true);
			Assert.AreEqual ("Database=Adventure{", sb.ToString (), "#D14a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure{", true);
			Assert.AreEqual ("Driver={Adventure{}", sb.ToString (), "#D14b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works}", true);
			Assert.AreEqual ("Database=Adventure Works}", sb.ToString (), "#D15a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works}", true);
			Assert.AreEqual ("Driver={Adventure Works}}}", sb.ToString (), "#D15b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure}", true);
			Assert.AreEqual ("Database=Adventure}", sb.ToString (), "#D16a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure}", true);
			Assert.AreEqual ("Driver={Adventure}}}", sb.ToString (), "#D16b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture Works", true);
			Assert.AreEqual ("Database=Adv'en{ture Works", sb.ToString (), "#D17a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en{ture Works", true);
			Assert.AreEqual ("Driver={Adv'en{ture Works}", sb.ToString (), "#D17b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en{ture", true);
			Assert.AreEqual ("Database=Adv'en{ture", sb.ToString (), "#D18a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en{ture", true);
			Assert.AreEqual ("Driver={Adv'en{ture}", sb.ToString (), "#D18b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture Works", true);
			Assert.AreEqual ("Database=Adv'en}ture Works", sb.ToString (), "#D19a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en}ture Works", true);
			Assert.AreEqual ("Driver={Adv'en}}ture Works}", sb.ToString (), "#D19b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv'en}ture", true);
			Assert.AreEqual ("Database=Adv'en}ture", sb.ToString (), "#D20a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv'en}ture", true);
			Assert.AreEqual ("Driver={Adv'en}}ture}", sb.ToString (), "#D20b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture Works", true);
			Assert.AreEqual ("Database=Adv\"en{ture Works", sb.ToString (), "#D21a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en{ture Works", true);
			Assert.AreEqual ("Driver={Adv\"en{ture Works}", sb.ToString (), "#D21b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en{ture", true);
			Assert.AreEqual ("Database=Adv\"en{ture", sb.ToString (), "#D22a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en{ture", true);
			Assert.AreEqual ("Driver={Adv\"en{ture}", sb.ToString (), "#D22b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture Works", true);
			Assert.AreEqual ("Database=Adv\"en}ture Works", sb.ToString (), "#D23a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en}ture Works", true);
			Assert.AreEqual ("Driver={Adv\"en}}ture Works}", sb.ToString (), "#D23b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adv\"en}ture", true);
			Assert.AreEqual ("Database=Adv\"en}ture", sb.ToString (), "#D24a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adv\"en}ture", true);
			Assert.AreEqual ("Driver={Adv\"en}}ture}", sb.ToString (), "#D24b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture Works", true);
			Assert.AreEqual ("Database=A'dv\"en{ture Works", sb.ToString (), "#D25a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en{ture Works", true);
			Assert.AreEqual ("Driver={A'dv\"en{ture Works}", sb.ToString (), "#D25b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en{ture", true);
			Assert.AreEqual ("Database=A'dv\"en{ture", sb.ToString (), "#D26a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en{ture", true);
			Assert.AreEqual ("Driver={A'dv\"en{ture}", sb.ToString (), "#D26b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture Works", true);
			Assert.AreEqual ("Database=A'dv\"en}ture Works", sb.ToString (), "#D27a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en}ture Works", true);
			Assert.AreEqual ("Driver={A'dv\"en}}ture Works}", sb.ToString (), "#D27b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A'dv\"en}ture", true);
			Assert.AreEqual ("Database=A'dv\"en}ture", sb.ToString (), "#D28a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A'dv\"en}ture", true);
			Assert.AreEqual ("Driver={A'dv\"en}}ture}", sb.ToString (), "#D28b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture Works\"", true);
			Assert.AreEqual ("Database=\"Adven{ture Works\"", sb.ToString (), "#D29a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven{ture Works\"", true);
			Assert.AreEqual ("Driver={\"Adven{ture Works\"}", sb.ToString (), "#D29b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven{ture\"", true);
			Assert.AreEqual ("Database=\"Adven{ture\"", sb.ToString (), "#D30a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven{ture\"", true);
			Assert.AreEqual ("Driver={\"Adven{ture\"}", sb.ToString (), "#D30b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture Works\"", true);
			Assert.AreEqual ("Database=\"Adven}ture Works\"", sb.ToString (), "#D31a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven}ture Works\"", true);
			Assert.AreEqual ("Driver={\"Adven}}ture Works\"}", sb.ToString (), "#D31b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "\"Adven}ture\"", true);
			Assert.AreEqual ("Database=\"Adven}ture\"", sb.ToString (), "#D32a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "\"Adven}ture\"", true);
			Assert.AreEqual ("Driver={\"Adven}}ture\"}", sb.ToString (), "#D32b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}}}", true);
			Assert.AreEqual ("Database={{{B}}}", sb.ToString (), "#D33a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}}}", true);
			Assert.AreEqual ("Driver={{{B}}}", sb.ToString (), "#D33b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{A{B{C}D}E}", true);
			Assert.AreEqual ("Database={{A{B{C}}D}}E}}}", sb.ToString (), "#D33c");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{A{B{C}D}E}", true);
			Assert.AreEqual ("Driver={{A{B{C}}D}}E}}}", sb.ToString (), "#D33d");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}}", true);
			Assert.AreEqual ("Database={{{{B}}}}}", sb.ToString (), "#D33e");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}}", true);
			Assert.AreEqual ("Driver={{{{B}}}}}", sb.ToString (), "#D33f");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{{B}", true);
			Assert.AreEqual ("Database={{{B}", sb.ToString (), "#D33g");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{{B}", true);
			Assert.AreEqual ("Driver={{{B}", sb.ToString (), "#D33h");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{B}", true);
			Assert.AreEqual ("Database={{B}", sb.ToString (), "#D33i");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{B}", true);
			Assert.AreEqual ("Driver={{B}", sb.ToString (), "#D33j");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{B}}", true);
			Assert.AreEqual ("Database={{B}}}}}", sb.ToString (), "#D33k");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{B}}", true);
			Assert.AreEqual ("Driver={{B}}}}}", sb.ToString (), "#D33l");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{B}}C", true);
			Assert.AreEqual ("Database={{B}}}}C}", sb.ToString (), "#D33k");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{B}}C", true);
			Assert.AreEqual ("Driver={{B}}}}C}", sb.ToString (), "#D33l");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "A{B}}", true);
			Assert.AreEqual ("Database=A{B}}", sb.ToString (), "#D33k");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "A{B}}", true);
			Assert.AreEqual ("Driver={A{B}}}}}", sb.ToString (), "#D33l");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", " {B}} ", true);
			Assert.AreEqual ("Database= {B}} ", sb.ToString (), "#D33k");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", " {B}} ", true);
			Assert.AreEqual ("Driver={ {B}}}} }", sb.ToString (), "#D33l");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "{{B}}", true);
			Assert.AreEqual ("Database={{{B}}}}}", sb.ToString (), "#D33a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "{{B}}", true);
			Assert.AreEqual ("Driver={{{B}}}}}", sb.ToString (), "#D33b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}}", true);
			Assert.AreEqual ("Database=}}", sb.ToString (), "#D33a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}}", true);
			Assert.AreEqual ("Driver={}}}}}", sb.ToString (), "#D33b");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "}", true);
			Assert.AreEqual ("Database=}", sb.ToString (), "#D33a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "}", true);
			Assert.AreEqual ("Driver={}}}", sb.ToString (), "#D33b");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure Works", true);
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", true);
			Assert.AreEqual ("Database=Adventure Works;Server=localhost", sb.ToString (), "#E1a", true);
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure Works", true);
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", true);
			Assert.AreEqual ("Driver={Adventure Works};Server=localhost", sb.ToString (), "#E1b", true);
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", "Adventure", true);
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", true);
			Assert.AreEqual ("Database=Adventure;Server=localhost", sb.ToString (), "#E2a", true);
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", "Adventure", true);
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Server", "localhost", true);
			Assert.AreEqual ("Driver={Adventure};Server=localhost", sb.ToString (), "#E2b", true);
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", string.Empty, true);
			Assert.AreEqual ("Database=", sb.ToString (), "#E3a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", string.Empty, true);
			Assert.AreEqual ("Driver=", sb.ToString (), "#E3a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Database", null, true);
			Assert.AreEqual ("Database=", sb.ToString (), "#E4a");
			sb.Length = 0;
			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Driver", null, true);
			Assert.AreEqual ("Driver=", sb.ToString (), "#E4b");
			sb.Length = 0;

			DbConnectionStringBuilder.AppendKeyValuePair (sb, "Datab=ase", "Adven=ture", true);
			Assert.AreEqual ("Datab=ase=Adven=ture", sb.ToString (), "#F1");
		}

		[Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
		public void AppendKeyValuePair2_Builder_Null ()
		{
			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					(StringBuilder) null, "Server",
					"localhost", true);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("builder", ex.ParamName, "#A5");
			}

			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					(StringBuilder) null, "Server",
					"localhost", false);
				Assert.Fail ("#B1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("builder", ex.ParamName, "#B5");
			}
		}

		[Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
		public void AppendKeyValuePair2_Keyword_Empty ()
		{
			StringBuilder sb = new StringBuilder ();
			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					sb, string.Empty, "localhost", true);
				Assert.Fail ("#A1");
			} catch (ArgumentException ex) {
				// Expecting non-empty string for 'keyName'
				// parameter
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.IsNull (ex.ParamName, "#A5");
			}

			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					sb, string.Empty, "localhost", false);
				Assert.Fail ("#B1");
			} catch (ArgumentException ex) {
				// Expecting non-empty string for 'keyName'
				// parameter
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.IsNull (ex.ParamName, "#B5");
			}
		}

		[Test] // AppendKeyValuePair (StringBuilder, String, String, Boolean)
		public void AppendKeyValuePair2_Keyword_Null ()
		{
			StringBuilder sb = new StringBuilder ();
			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					sb, (string) null, "localhost", true);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("keyName", ex.ParamName, "#A5");
			}

			try {
				DbConnectionStringBuilder.AppendKeyValuePair (
					sb, (string) null, "localhost", false);
				Assert.Fail ("#B1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("keyName", ex.ParamName, "#B5");
			}
		}

                [Test]
                public void ToStringTest ()
                {
                        builder.Add (SERVER, SERVER_VALUE);
                        string str = builder.ToString ();
                        string value = builder.ConnectionString;
                        Assert.AreEqual (value, str,
                                         "ToString shoud return ConnectionString!");
                }

                [Test]
                public void ItemTest ()
                {
                        builder.Add (SERVER, SERVER_VALUE);
                        string value = (string) builder [SERVER];
                        Assert.AreEqual (SERVER_VALUE, value,
                                         "Item indexor does not retrun correct value!");
                }

                [Test]
                public void ICollectionCopyToTest ()
                {
                        KeyValuePair<string, object> [] dict = new KeyValuePair<string, object> [2];
                        builder.Add (SERVER, SERVER_VALUE);
                        builder.Add (SERVER + "1", SERVER_VALUE + "1");

			int i = 0;
			int j = 1;
			((ICollection) builder).CopyTo (dict, 0);
                        Assert.AreEqual (SERVER, dict [i].Key, "not equal");
                        Assert.AreEqual (SERVER_VALUE, dict [i].Value, "not equal");
                        Assert.AreEqual (SERVER + "1", dict [j].Key, "not equal");
                        Assert.AreEqual (SERVER_VALUE + "1", dict [j].Value, "not equal");
                }

                [Test]
                [ExpectedException (typeof (ArgumentException))]
                public void NegICollectionCopyToTest ()
                {
                        KeyValuePair<string, object> [] dict = new KeyValuePair<string, object> [1];
                        builder.Add (SERVER, SERVER_VALUE);
                        builder.Add (SERVER + "1", SERVER_VALUE + "1");
			((ICollection) builder).CopyTo (dict, 0);
                        Assert.Fail ("Exception Destination Array not enough is not thrown!");
                }

		[Test]
		public void TryGetValueTest ()
		{
			object value = null;

			builder ["DriverID"] = "790";
			builder.Add ("Server", "C:\\");
			Assert.IsTrue (builder.TryGetValue ("DriverID", out value), "#A1");
			Assert.AreEqual ("790", value, "#A2");
			Assert.IsTrue (builder.TryGetValue ("SERVER", out value), "#B1");
			Assert.AreEqual ("C:\\", value, "#B2");
			Assert.IsFalse (builder.TryGetValue (string.Empty, out value), "#C1");
			Assert.IsNull (value, "#C2");
			Assert.IsFalse (builder.TryGetValue ("a;", out value), "#D1");
			Assert.IsNull (value, "#D2");
			Assert.IsFalse (builder.TryGetValue ("\r", out value), "#E1");
			Assert.IsNull (value, "#E2");
			Assert.IsFalse (builder.TryGetValue (" ", out value), "#F1");
			Assert.IsNull (value, "#F2");
			Assert.IsFalse (builder.TryGetValue ("doesnotexist", out value), "#G1");
			Assert.IsNull (value, "#G2");
			Assert.IsFalse (builder.TryGetValue ("Driver", out value), "#H1");
			Assert.IsNull (value, "#H2");
			Assert.IsFalse (builder.TryGetValue ("Dsn", out value), "#I1");
			Assert.IsNull (value, "#I2");

			builder = new DbConnectionStringBuilder (false);
			builder ["DriverID"] = "790";
			builder.Add ("Server", "C:\\");
			Assert.IsTrue (builder.TryGetValue ("DriverID", out value), "#A1");
			Assert.AreEqual ("790", value, "#A2");
			Assert.IsTrue (builder.TryGetValue ("SERVER", out value), "#B1");
			Assert.AreEqual ("C:\\", value, "#B2");
			Assert.IsFalse (builder.TryGetValue (string.Empty, out value), "#C1");
			Assert.IsNull (value, "#C2");
			Assert.IsFalse (builder.TryGetValue ("a;", out value), "#D1");
			Assert.IsNull (value, "#D2");
			Assert.IsFalse (builder.TryGetValue ("\r", out value), "#E1");
			Assert.IsNull (value, "#E2");
			Assert.IsFalse (builder.TryGetValue (" ", out value), "#F1");
			Assert.IsNull (value, "#F2");
			Assert.IsFalse (builder.TryGetValue ("doesnotexist", out value), "#G1");
			Assert.IsNull (value, "#G2");
			Assert.IsFalse (builder.TryGetValue ("Driver", out value), "#H1");
			Assert.IsNull (value, "#H2");
			Assert.IsFalse (builder.TryGetValue ("Dsn", out value), "#I1");
			Assert.IsNull (value, "#I2");

			builder = new DbConnectionStringBuilder (true);
			builder ["DriverID"] = "790";
			builder.Add ("Server", "C:\\");
			Assert.IsTrue (builder.TryGetValue ("DriverID", out value), "#A1");
			Assert.AreEqual ("790", value, "#A2");
			Assert.IsTrue (builder.TryGetValue ("SERVER", out value), "#B1");
			Assert.AreEqual ("C:\\", value, "#B2");
			Assert.IsFalse (builder.TryGetValue (string.Empty, out value), "#C1");
			Assert.IsNull (value, "#C2");
			Assert.IsFalse (builder.TryGetValue ("a;", out value), "#D1");
			Assert.IsNull (value, "#D2");
			Assert.IsFalse (builder.TryGetValue ("\r", out value), "#E1");
			Assert.IsNull (value, "#E2");
			Assert.IsFalse (builder.TryGetValue (" ", out value), "#F1");
			Assert.IsNull (value, "#F2");
			Assert.IsFalse (builder.TryGetValue ("doesnotexist", out value), "#G1");
			Assert.IsNull (value, "#G2");
			Assert.IsFalse (builder.TryGetValue ("Driver", out value), "#H1");
			Assert.IsNull (value, "#H2");
			Assert.IsFalse (builder.TryGetValue ("Dsn", out value), "#I1");
			Assert.IsNull (value, "#I2");
		}

		[Test]
		public void TryGetValue_Keyword_Null ()
		{
			object value = null;
			try {
				builder.TryGetValue (null, out value);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("keyword", ex.ParamName, "#5");
			}
		}

                [Test]
				[NUnit.Framework.Category ("MobileNotWorking")] // DefaultMemberAttribute is removed by the tuner, causing #3 to fail
                public void ICTD_GetClassNameTest ()
                {
                        ICustomTypeDescriptor ictd = (ICustomTypeDescriptor) builder;
                        string className = ictd.GetClassName ();
                        Assert.AreEqual (builder.GetType ().ToString (), className, "#1");

                        AttributeCollection collection = ictd.GetAttributes ();
                        Assert.AreEqual (1, collection.Count, "#2");
                        object [] attr = builder.GetType ().GetCustomAttributes (typeof (DefaultMemberAttribute), false);
                        if (attr.Length > 0) {
                                DefaultMemberAttribute defAtt = (DefaultMemberAttribute) attr [0];
                                Assert.AreEqual ("Item", defAtt.MemberName, "#3");
                        } else
                                Assert.Fail ("#3");

                        string compName = ictd.GetComponentName ();
                        Assert.IsNull (compName, "#4");

                        TypeConverter converter = ictd.GetConverter ();
                        Assert.AreEqual (typeof (CollectionConverter), converter.GetType (), "#5");

                        EventDescriptor evtDesc = ictd.GetDefaultEvent ();
                        Assert.IsNull (evtDesc, "#6");

                        PropertyDescriptor property = ictd.GetDefaultProperty ();
                        Assert.IsNull (property, "#7");
                }

		[Test]
		public void EmbeddedCharTest1 ()
		{
			// Notice how the keywords show up in the connection string
			//  in the order they were added.
			// And notice the case of the keyword when added is preserved
			//  in the connection string.

			DbConnectionStringBuilder sb = new DbConnectionStringBuilder ();

			sb["Data Source"] = "testdb";
			sb["User ID"] = "someuser";
			sb["Password"] = "abcdef";
			Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=abcdef", 
				sb.ConnectionString, "cs#1");

			sb["Password"] = "abcdef#";
			Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=abcdef#", 
				sb.ConnectionString, "cs#2");

			// an embedded single-quote value will result in the value being delimieted with double quotes
			sb["Password"] = "abc\'def";
			Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=\"abc\'def\"", 
				sb.ConnectionString, "cs#3");

			// an embedded double-quote value will result in the value being delimieted with single quotes
			sb["Password"] = "abc\"def";
			Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=\'abc\"def\'", 
				sb.ConnectionString, "cs#4");

			// an embedded single-quote and double-quote in the value
			// will result in the value being delimited by double-quotes
			// with the embedded double quote being escaped with two double-quotes
			sb["Password"] = "abc\"d\'ef";
			Assert.AreEqual ("Data Source=testdb;User ID=someuser;Password=\"abc\"\"d\'ef\"", 
				sb.ConnectionString, "cs#5");

			sb = new DbConnectionStringBuilder ();
			sb["PASSWORD"] = "abcdef1";
			sb["user id"] = "someuser";
			sb["Data Source"] = "testdb";
			Assert.AreEqual ("PASSWORD=abcdef1;user id=someuser;Data Source=testdb", 
				sb.ConnectionString, "cs#6");

			// case is preserved for a keyword that was added the first time
			sb = new DbConnectionStringBuilder ();
			sb["PassWord"] = "abcdef2";
			sb["uSER iD"] = "someuser";
			sb["DaTa SoUrCe"] = "testdb";
			Assert.AreEqual ("PassWord=abcdef2;uSER iD=someuser;DaTa SoUrCe=testdb", 
				sb.ConnectionString, "cs#7");
			sb["passWORD"] = "abc123";
			Assert.AreEqual ("PassWord=abc123;uSER iD=someuser;DaTa SoUrCe=testdb", 
				sb.ConnectionString, "cs#8");

			// embedded equal sign in the value will cause the value to be
			// delimited with double-quotes
			sb = new DbConnectionStringBuilder ();
			sb["Password"] = "abc=def";
			sb["Data Source"] = "testdb";
			sb["User ID"] = "someuser";
			Assert.AreEqual ("Password=\"abc=def\";Data Source=testdb;User ID=someuser", 
				sb.ConnectionString, "cs#9");

			// embedded semicolon in the value will cause the value to be
			// delimited with double-quotes
			sb = new DbConnectionStringBuilder ();
			sb["Password"] = "abc;def";
			sb["Data Source"] = "testdb";
			sb["User ID"] = "someuser";
			Assert.AreEqual ("Password=\"abc;def\";Data Source=testdb;User ID=someuser", 
				sb.ConnectionString, "cs#10");

			// more right parentheses then left parentheses - happily takes it
			sb = new DbConnectionStringBuilder();
			sb.ConnectionString = "Data Source=(((Blah=Something))))))";
			Assert.AreEqual ("data source=\"(((Blah=Something))))))\"", 
				sb.ConnectionString, "cs#11");

			// more left curly braces then right curly braces - happily takes it
			sb = new DbConnectionStringBuilder();
			sb.ConnectionString = "Data Source={{{{Blah=Something}}";
			Assert.AreEqual ("data source=\"{{{{Blah=Something}}\"", 
				sb.ConnectionString, "cs#12");

			// spaces, empty string, null are treated like an empty string
			// and any previous settings is cleared
			sb.ConnectionString = "   ";
			Assert.AreEqual (String.Empty, 
				sb.ConnectionString, "cs#13");

			sb.ConnectionString = " ";
			Assert.AreEqual (String.Empty, 
				sb.ConnectionString, "cs#14");

			sb.ConnectionString = "";
			Assert.AreEqual (String.Empty, 
				sb.ConnectionString, "cs#15");

			sb.ConnectionString = String.Empty;
			Assert.AreEqual (String.Empty, 
				sb.ConnectionString, "cs#16");

			sb.ConnectionString = null;
			Assert.AreEqual (String.Empty, 
				sb.ConnectionString, "cs#17");

			sb = new DbConnectionStringBuilder();
			Assert.AreEqual (String.Empty, 
				sb.ConnectionString, "cs#18");
		}

		[Test]
		public void EmbeddedCharTest2 ()
		{
			DbConnectionStringBuilder sb;

			sb = new DbConnectionStringBuilder ();
			sb.ConnectionString = "Driver={SQL Server};Server=(local host);" +
				"Trusted_Connection=Yes Or No;Database=Adventure Works;";
			Assert.AreEqual ("{SQL Server}", sb["Driver"], "#A1");
			Assert.AreEqual ("(local host)", sb["Server"], "#A2");
			Assert.AreEqual ("Yes Or No", sb["Trusted_Connection"], "#A3");
			Assert.AreEqual ("driver=\"{SQL Server}\";server=\"(local host)\";" +
				"trusted_connection=\"Yes Or No\";database=\"Adventure Works\"",
				sb.ConnectionString, "#A4");

			sb = new DbConnectionStringBuilder ();
			sb.ConnectionString = "Driver={SQLServer};Server=(local);" +
				"Trusted_Connection=Yes;Database=AdventureWorks;";
			Assert.AreEqual ("{SQLServer}", sb["Driver"], "#B1");
			Assert.AreEqual ("(local)", sb["Server"], "#B2");
			Assert.AreEqual ("Yes", sb["Trusted_Connection"], "#B3");
			Assert.AreEqual ("driver={SQLServer};server=(local);" +
				"trusted_connection=Yes;database=AdventureWorks",
				sb.ConnectionString, "#B4");

			sb = new DbConnectionStringBuilder (false);
			sb.ConnectionString = "Driver={SQL Server};Server=(local host);" +
				"Trusted_Connection=Yes Or No;Database=Adventure Works;";
			Assert.AreEqual ("{SQL Server}", sb["Driver"], "#C1");
			Assert.AreEqual ("(local host)", sb["Server"], "#C2");
			Assert.AreEqual ("Yes Or No", sb["Trusted_Connection"], "#C3");
			Assert.AreEqual ("driver=\"{SQL Server}\";server=\"(local host)\";" +
				"trusted_connection=\"Yes Or No\";database=\"Adventure Works\"",
				sb.ConnectionString, "#C4");

			sb = new DbConnectionStringBuilder (false);
			sb.ConnectionString = "Driver={SQLServer};Server=(local);" +
				"Trusted_Connection=Yes;Database=AdventureWorks;";
			Assert.AreEqual ("{SQLServer}", sb["Driver"], "#D1");
			Assert.AreEqual ("(local)", sb["Server"], "#D2");
			Assert.AreEqual ("Yes", sb["Trusted_Connection"], "#D3");
			Assert.AreEqual ("driver={SQLServer};server=(local);" +
				"trusted_connection=Yes;database=AdventureWorks",
				sb.ConnectionString, "#D4");

			sb = new DbConnectionStringBuilder (true);
			sb.ConnectionString = "Driver={SQL Server};Server=(local host);" +
				"Trusted_Connection=Yes Or No;Database=Adventure Works;";
			Assert.AreEqual ("{SQL Server}", sb["Driver"], "#E1");
			Assert.AreEqual ("(local host)", sb["Server"], "#E2");
			Assert.AreEqual ("Yes Or No", sb["Trusted_Connection"], "#E3");
			Assert.AreEqual ("driver={SQL Server};server=(local host);" +
				"trusted_connection=Yes Or No;database=Adventure Works",
				sb.ConnectionString, "#E4");

			sb = new DbConnectionStringBuilder (true);
			sb.ConnectionString = "Driver={SQLServer};Server=(local);" +
				"Trusted_Connection=Yes;Database=AdventureWorks;";
			Assert.AreEqual ("{SQLServer}", sb["Driver"], "#F1");
			Assert.AreEqual ("(local)", sb["Server"], "#F2");
			Assert.AreEqual ("Yes", sb["Trusted_Connection"], "#F3");
			Assert.AreEqual ("driver={SQLServer};server=(local);" +
				"trusted_connection=Yes;database=AdventureWorks",
				sb.ConnectionString, "#F4");
		}

		[Test]
		public void EmbeddedCharTest3 ()
		{
			string dataSource = "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.1.101)" + 
				"(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=TESTDB)))";
			DbConnectionStringBuilder sb;

			sb = new DbConnectionStringBuilder ();
			sb.ConnectionString = "User ID=SCOTT;Password=TiGeR;Data Source=" + dataSource;
			Assert.AreEqual (dataSource, sb["Data Source"], "#A1");
			Assert.AreEqual ("SCOTT", sb["User ID"], "#A2");
			Assert.AreEqual ("TiGeR", sb["Password"], "#A3");
			Assert.AreEqual ( 
				"user id=SCOTT;password=TiGeR;data source=\"(DESCRIPTION=(ADDRESS=(PROTOCOL=" +
				"TCP)(HOST=192.168.1.101)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)" +
				"(SERVICE_NAME=TESTDB)))\"", sb.ConnectionString, "#A4");

			sb = new DbConnectionStringBuilder (false);
			sb.ConnectionString = "User ID=SCOTT;Password=TiGeR;Data Source=" + dataSource;
			Assert.AreEqual (dataSource, sb["Data Source"], "#B1");
			Assert.AreEqual ("SCOTT", sb["User ID"], "#B2");
			Assert.AreEqual ("TiGeR", sb["Password"], "#B3");
			Assert.AreEqual ( 
				"user id=SCOTT;password=TiGeR;data source=\"(DESCRIPTION=(ADDRESS=(PROTOCOL=" +
				"TCP)(HOST=192.168.1.101)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)" +
				"(SERVICE_NAME=TESTDB)))\"", sb.ConnectionString, "#B4");

			sb = new DbConnectionStringBuilder (true);
			sb.ConnectionString = "User ID=SCOTT;Password=TiGeR;Data Source=" + dataSource;
			Assert.AreEqual (dataSource, sb["Data Source"], "#C1");
			Assert.AreEqual ("SCOTT", sb["User ID"], "#C2");
			Assert.AreEqual ("TiGeR", sb["Password"], "#C3");
			Assert.AreEqual ( 
				"user id=SCOTT;password=TiGeR;data source=(DESCRIPTION=(ADDRESS=(PROTOCOL=" +
				"TCP)(HOST=192.168.1.101)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)" +
				"(SERVICE_NAME=TESTDB)))", sb.ConnectionString, "#C4");
		}

		[Test]
		public void EmbeddedCharTest4 ()
		{
			DbConnectionStringBuilder sb;

			sb = new DbConnectionStringBuilder ();
			sb.ConnectionString = "PassWord=abcdef2;uSER iD=someuser;DaTa SoUrCe=testdb";
			sb["Integrated Security"] = "False";
			Assert.AreEqual ( 
				"password=abcdef2;user id=someuser;data source=testdb;Integrated Security=False",
				sb.ConnectionString, "#A");

			sb = new DbConnectionStringBuilder (false);
			sb.ConnectionString = "PassWord=abcdef2;uSER iD=someuser;DaTa SoUrCe=testdb";
			sb["Integrated Security"] = "False";
			Assert.AreEqual ( 
				"password=abcdef2;user id=someuser;data source=testdb;Integrated Security=False",
				sb.ConnectionString, "#B");

			sb = new DbConnectionStringBuilder (true);
			sb.ConnectionString = "PassWord=abcdef2;uSER iD=someuser;DaTa SoUrCe=testdb";
			sb["Integrated Security"] = "False";
			Assert.AreEqual ( 
				"password=abcdef2;user id=someuser;data source=testdb;Integrated Security=False",
				sb.ConnectionString, "#C");
		}

		[Test]
		public void EmbeddedCharTest5 ()
		{
			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";
			DbConnectionStringBuilder sb;

			sb = new DbConnectionStringBuilder ();
			sb.ConnectionString = connectionString;
			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");
			Assert.AreEqual ("{abcdef2}", sb ["A"], "#A2");
			Assert.AreEqual ("some{us", sb ["B"], "#A3");
			Assert.AreEqual ("test}db", sb ["C"], "#A4");
			Assert.AreEqual ("12\"3", sb ["D"], "#A5");
			Assert.AreEqual ("45;6", sb ["E"], "#A6");
			Assert.AreEqual ("AB==C", sb ["F"], "#A7");
			Assert.AreEqual ("{1='\"2}", sb ["g{a'}\";f"], "#A8");
			Assert.AreEqual ("ABC", sb ["Z"], "#A9");
			Assert.AreEqual ("B==C", sb ["g=c"], "#A10");

			sb = new DbConnectionStringBuilder (false);
			sb.ConnectionString = connectionString;
			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");
			Assert.AreEqual ("{abcdef2}", sb ["A"], "#B2");
			Assert.AreEqual ("some{us", sb ["B"], "#B3");
			Assert.AreEqual ("test}db", sb ["C"], "#B4");
			Assert.AreEqual ("12\"3", sb ["D"], "#B5");
			Assert.AreEqual ("45;6", sb ["E"], "#B6");
			Assert.AreEqual ("AB==C", sb ["F"], "#B7");
			Assert.AreEqual ("{1='\"2}", sb ["g{a'}\";f"], "#B8");
			Assert.AreEqual ("ABC", sb ["Z"], "#B9");
			Assert.AreEqual ("B==C", sb ["g=c"], "#B10");

			sb = new DbConnectionStringBuilder (true);
			sb.ConnectionString = connectionString;
			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");
			Assert.AreEqual ("{abcdef2}", sb ["A"], "#C2");
			Assert.AreEqual ("some{us", sb ["B"], "#C3");
			Assert.AreEqual ("test}db", sb ["C"], "#C4");
			Assert.AreEqual ("12\"3", sb ["D"], "#C5");
			Assert.AreEqual ("\"45", sb ["E"], "#C6");
			Assert.AreEqual ("AB==C", sb ["6\";f"], "#C7");
			Assert.AreEqual ("{1='\"2}", sb ["g{a'}\";f"], "#C8");
			Assert.AreEqual ("ABC", sb ["Z"], "#C9");
			Assert.AreEqual ("=C=B==C", sb ["g"], "#C10");
		}

		[Test]
		public void EmbeddedCharTest6 ()
		{
			string [][] shared_tests = new string [][] {
				new string [] { "A=(B;", "A", "(B", "a=(B" },
				new string [] { "A={B{}", "A", "{B{}", "a={B{}" },
				new string [] { "A={B{{}", "A", "{B{{}", "a={B{{}" },
				new string [] { " A =B{C", "A", "B{C", "a=B{C" },
				new string [] { " A =B{{C}", "A", "B{{C}", "a=B{{C}" },
				new string [] { "A={{{B}}}", "A", "{{{B}}}", "a={{{B}}}" },
				new string [] { "A={B}", "A", "{B}", "a={B}" },
				new string [] { "A= {B}", "A", "{B}", "a={B}" },
				new string [] { " A =BC",  "a", "BC", "a=BC" },
				new string [] { "\rA\t=BC",  "a", "BC", "a=BC" },
				new string [] { "\rA\t=BC",  "a", "BC", "a=BC" },
				new string [] { "A;B=BC",  "a;b", "BC", "a;b=BC" },
				};

			string [][] non_odbc_tests = new string [][] {
				new string [] { "A=''", "A", "", "a=" },
				new string [] { "A='BC;D'", "A", "BC;D", "a=\"BC;D\"" },
				new string [] { "A=BC''D", "A", "BC''D", "a=\"BC''D\"" },
				new string [] { "A='\"'", "A", "\"", "a='\"'" },
				new string [] { "A=B\"\"C;", "A", "B\"\"C", "a='B\"\"C'" },
				new string [] { "A={B{", "A", "{B{", "a={B{" },
				new string [] { "A={B}C", "A", "{B}C", "a={B}C" },
				new string [] { "A=B'C", "A", "B'C", "a=\"B'C\"" },
				new string [] { "A=B''C", "A", "B''C", "a=\"B''C\"" },
				new string [] { "A=  B C ;", "A", "B C", "a=\"B C\"" },
				new string [] { "A={B { }} }", "A", "{B { }} }", "a=\"{B { }} }\"" },
				new string [] { "A={B {{ }} }", "A", "{B {{ }} }", "a=\"{B {{ }} }\"" },
				new string [] { "A= B {C ", "A", "B {C", "a=\"B {C\"" },
				new string [] { "A= B }C ", "A", "B }C", "a=\"B }C\"" },
				new string [] { "A=B }C", "A", "B }C", "a=\"B }C\"" },
				new string [] { "A=B { }C", "A", "B { }C", "a=\"B { }C\"" },
				new string [] { "A= B{C {}}", "A", "B{C {}}", "a=\"B{C {}}\"" },
				new string [] { "A= {C {};B=A", "A", "{C {}", "a=\"{C {}\";b=A" },
				new string [] { "A= {C {}  ", "A", "{C {}", "a=\"{C {}\"" },
				new string [] { "A= {C {}  ;B=A", "A", "{C {}", "a=\"{C {}\";b=A" },
				new string [] { "A= {C {}}}", "A", "{C {}}}", "a=\"{C {}}}\"" },
				new string [] { "A={B=C}", "A", "{B=C}", "a=\"{B=C}\"" },
				new string [] { "A={B==C}", "A", "{B==C}", "a=\"{B==C}\"" },
				new string [] { "A=B==C", "A", "B==C", "a=\"B==C\"" },
				new string [] { "A={=}", "A", "{=}", "a=\"{=}\"" },
				new string [] { "A={==}", "A", "{==}", "a=\"{==}\"" },
				new string [] { "A=\"B;(C)'\"", "A", "B;(C)'", "a=\"B;(C)'\"" },
				new string [] { "A=B(=)C", "A", "B(=)C", "a=\"B(=)C\"" },
				new string [] { "A=B=C", "A", "B=C", "a=\"B=C\"" },
				new string [] { "A=B(==)C", "A", "B(==)C", "a=\"B(==)C\"" },
				new string [] { "A=B  C", "A", "B  C", "a=\"B  C\"" },
				new string [] { "A= B  C ", "A", "B  C", "a=\"B  C\"" },
				new string [] { "A=  B  C  ", "A", "B  C", "a=\"B  C\"" },
				new string [] { "A='  B C '", "A", "  B C ", "a=\"  B C \"" },
				new string [] { "A=\"  B C \"", "A", "  B C ", "a=\"  B C \"" },
				new string [] { "A={  B C }", "A", "{  B C }", "a=\"{  B C }\"" },
				new string [] { "A=  B C  ;", "A", "B C", "a=\"B C\"" },
				new string [] { "A=  B\rC\r\t;", "A", "B\rC", "a=\"B\rC\"" },
				new string [] { "A=\"\"\"B;C\"\"\"", "A", "\"B;C\"", "a='\"B;C\"'" },
				new string [] { "A= \"\"\"B;C\"\"\" ", "A", "\"B;C\"", "a='\"B;C\"'" },
				new string [] { "A='''B;C'''", "A", "'B;C'", "a=\"'B;C'\"" },
				new string [] { "A= '''B;C''' ", "A", "'B;C'", "a=\"'B;C'\"" },
				new string [] { "A={{", "A", "{{", "a={{" },
				new string [] { "A={B C}", "A", "{B C}", "a=\"{B C}\"" },
				new string [] { "A={ B C }", "A", "{ B C }", "a=\"{ B C }\"" },
				new string [] { "A={B {{ } }", "A", "{B {{ } }", "a=\"{B {{ } }\"" },
				new string [] { "A='='", "A", "=", "a=\"=\"" },
				new string [] { "A='=='", "A", "==", "a=\"==\"" },
				new string [] { "A=\"=\"", "A", "=", "a=\"=\"" },
				new string [] { "A=\"==\"", "A", "==", "a=\"==\"" },
				new string [] { "A={B}}", "A", "{B}}", "a={B}}" },
				new string [] { "A=\";\"", "A", ";", "a=\";\"" },
				new string [] { "A(=)=B", "A(", ")=B", "a(=\")=B\"" },
				new string [] { "A==B=C",  "A=B", "C", "a==b=C" },
				new string [] { "A===B=C",  "A=", "B=C", "a===\"B=C\"" },
				new string [] { "(A=)=BC",  "(a", ")=BC", "(a=\")=BC\"" },
				new string [] { "A==C=B==C", "a=c", "B==C", "a==c=\"B==C\"" },
				};
			DbConnectionStringBuilder sb;

			for (int i = 0; i < non_odbc_tests.Length; i++) {
				string [] test = non_odbc_tests [i];
				sb = new DbConnectionStringBuilder ();
				sb.ConnectionString = test [0];
				Assert.AreEqual (test [3], sb.ConnectionString, "#A1:" + i);
				Assert.AreEqual (test [2], sb [test [1]], "#A2:" + i);
			}

			for (int i = 0; i < non_odbc_tests.Length; i++) {
				string [] test = non_odbc_tests [i];
				sb = new DbConnectionStringBuilder (false);
				sb.ConnectionString = test [0];
				Assert.AreEqual (test [3], sb.ConnectionString, "#B1:" + i);
				Assert.AreEqual (test [2], sb [test [1]], "#B2:" + i);
			}

			for (int i = 0; i < shared_tests.Length; i++) {
				string [] test = shared_tests [i];
				sb = new DbConnectionStringBuilder ();
				sb.ConnectionString = test [0];
				Assert.AreEqual (test [3], sb.ConnectionString, "#C1:" + i);
				Assert.AreEqual (test [2], sb [test [1]], "#C2:" + i);
			}

			for (int i = 0; i < shared_tests.Length; i++) {
				string [] test = shared_tests [i];
				sb = new DbConnectionStringBuilder (false);
				sb.ConnectionString = test [0];
				Assert.AreEqual (test [3], sb.ConnectionString, "#D1:" + i);
				Assert.AreEqual (test [2], sb [test [1]], "#D2:" + i);
			}

			string [][] odbc_tests = new string [][] {
				new string [] { "A=B(=)C", "A", "B(=)C", "a=B(=)C" },
				new string [] { "A=B(==)C", "A", "B(==)C", "a=B(==)C" },
				new string [] { "A=  B C  ;", "A", "B C", "a=B C" },
				new string [] { "A=  B\rC\r\t;", "A", "B\rC", "a=B\rC" },
				new string [] { "A='''", "A", "'''", "a='''" },
				new string [] { "A=''", "A", "''", "a=''" },
				new string [] { "A=''B", "A", "''B", "a=''B" },
				new string [] { "A=BC''D", "A", "BC''D", "a=BC''D" },
				new string [] { "A='\"'", "A", "'\"'", "a='\"'" },
				new string [] { "A=\"\"B", "A", "\"\"B", "a=\"\"B"},
				new string [] { "A=B\"\"C;", "A", "B\"\"C", "a=B\"\"C" },
				new string [] { "A=\"B", "A", "\"B", "a=\"B" },
				new string [] { "A=\"", "A", "\"", "a=\"" },
				new string [] { "A=B'C", "A", "B'C", "a=B'C" },
				new string [] { "A=B''C", "A", "B''C", "a=B''C" },
				new string [] { "A='A'C", "A", "'A'C", "a='A'C" },
				new string [] { "A=B  C", "A", "B  C", "a=B  C" },
				new string [] { "A= B  C ", "A", "B  C", "a=B  C" },
				new string [] { "A=  B  C  ", "A", "B  C", "a=B  C" },
				new string [] { "A='  B C '", "A", "'  B C '", "a='  B C '" },
				new string [] { "A=\"  B C \"", "A", "\"  B C \"", "a=\"  B C \"" },
				new string [] { "A={  B C }", "A", "{  B C }", "a={  B C }" },
				new string [] { "A=  B C ;", "A", "B C", "a=B C" },
				new string [] { "A=\"\"BC\"\"", "A", "\"\"BC\"\"", "a=\"\"BC\"\"" },
				new string [] { "A=\"\"B\"C\"\";", "A", "\"\"B\"C\"\"", "a=\"\"B\"C\"\"" },
				new string [] { "A= \"\"B\"C\"\" ", "A", "\"\"B\"C\"\"", "a=\"\"B\"C\"\"" },
				new string [] { "A=''BC''", "A", "''BC''", "a=''BC''" },
				new string [] { "A=''B'C'';", "A", "''B'C''", "a=''B'C''" },
				new string [] { "A= ''B'C'' ", "A", "''B'C''", "a=''B'C''" },
				new string [] { "A={B C}", "A", "{B C}", "a={B C}" },
				new string [] { "A={ B C }", "A", "{ B C }", "a={ B C }" },
				new string [] { "A={ B;C }", "A", "{ B;C }", "a={ B;C }" },
				new string [] { "A={B { }} }", "A", "{B { }} }", "a={B { }} }" },
				new string [] { "A={ B;= {;=}};= }", "A", "{ B;= {;=}};= }", "a={ B;= {;=}};= }" },
				new string [] { "A={B {{ }} }", "A", "{B {{ }} }", "a={B {{ }} }" },
				new string [] { "A={ B;= {{:= }};= }", "A", "{ B;= {{:= }};= }", "a={ B;= {{:= }};= }" },
				new string [] { "A= B {C ", "A", "B {C", "a=B {C" },
				new string [] { "A= B }C ", "A", "B }C", "a=B }C" },
				new string [] { "A=B }C", "A", "B }C", "a=B }C" },
				new string [] { "A=B { }C", "A", "B { }C", "a=B { }C" },
				new string [] { "A= {B;{}", "A", "{B;{}", "a={B;{}" },
				new string [] { "A= {B;{}}}", "A", "{B;{}}}", "a={B;{}}}" },
				new string [] { "A= B{C {}}", "A", "B{C {}}", "a=B{C {}}" },
				new string [] { "A= {C {};B=A", "A", "{C {}", "a={C {};b=A" },
				new string [] { "A= {C {}  ", "A", "{C {}", "a={C {}" },
				new string [] { "A= {C {}  ;B=A", "A", "{C {}", "a={C {};b=A" },
				new string [] { "A= {C {}}}", "A", "{C {}}}", "a={C {}}}" },
				new string [] { "A={B=C}", "A", "{B=C}", "a={B=C}" },
				new string [] { "A={B==C}", "A", "{B==C}", "a={B==C}" },
				new string [] { "A=B==C", "A", "B==C", "a=B==C" },
				new string [] { "A='='", "A", "'='", "a='='" },
				new string [] { "A='=='", "A", "'=='", "a='=='" },
				new string [] { "A=\"=\"", "A", "\"=\"", "a=\"=\"" },
				new string [] { "A=\"==\"", "A", "\"==\"", "a=\"==\"" },
				new string [] { "A={=}", "A", "{=}", "a={=}" },
				new string [] { "A={==}", "A", "{==}", "a={==}" },
				new string [] { "A=B=C", "A", "B=C", "a=B=C" },
				new string [] { "A(=)=B", "A(", ")=B", "a(=)=B" },
				new string [] { "A==B=C",  "A", "=B=C", "a==B=C" },
				new string [] { "A===B=C",  "A", "==B=C", "a===B=C" },
				new string [] { "A'='=B=C",  "A'", "'=B=C", "a'='=B=C" },
				new string [] { "A\"=\"=B=C",  "A\"", "\"=B=C", "a\"=\"=B=C" },
				new string [] { "\"A=\"=BC",  "\"a", "\"=BC", "\"a=\"=BC" },
				new string [] { "(A=)=BC",  "(a", ")=BC", "(a=)=BC" },
				new string [] { "A==C=B==C", "A", "=C=B==C", "a==C=B==C" },
				};

			for (int i = 0; i < odbc_tests.Length; i++) {
				string [] test = odbc_tests [i];
				sb = new DbConnectionStringBuilder (true);
				sb.ConnectionString = test [0];
				Assert.AreEqual (test [3], sb.ConnectionString, "#E1:" + i);
				Assert.AreEqual (test [2], sb [test [1]], "#E2:" + i);
			}

			for (int i = 0; i < shared_tests.Length; i++) {
				string [] test = shared_tests [i];
				sb = new DbConnectionStringBuilder (true);
				sb.ConnectionString = test [0];
				Assert.AreEqual (test [3], sb.ConnectionString, "#F1:" + i);
				Assert.AreEqual (test [2], sb [test [1]], "#F2:" + i);
			}

			// each test that is in odbc_tests and not in non_odbc_tests
			// (or vice versa) should result in an ArgumentException
			AssertValueTest (non_odbc_tests, odbc_tests, true, "#G:");
			AssertValueTest (odbc_tests, non_odbc_tests, false, "#H:");
		}

		[Test]
		public void EmbeddedChar_ConnectionString_Invalid ()
		{
			string [] tests = new string [] {
				" =",
				"=",
				"=;",
				"=ABC;",
				"='A'",
				"A",
				"A=(B;)",
				"A=B';'C",
				"A=B { {;} }",
				"A=B { ; }C",
				"A=BC'E;F'D",
				};

			DbConnectionStringBuilder [] cbs = new DbConnectionStringBuilder [] {
				new DbConnectionStringBuilder (),
				new DbConnectionStringBuilder (false),
				new DbConnectionStringBuilder (true)
				};

			for (int i = 0; i < tests.Length; i++) {
				for (int j = 0; j < cbs.Length; j++) {
					DbConnectionStringBuilder cb =cbs [j];
					try {
						cb.ConnectionString = tests [i];
						Assert.Fail ("#1:" + i + " (" + j + ")");
					} catch (ArgumentException ex) {
						// Format of the initialization string does
						// not conform to specification starting
						// at index 0
						Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:"+ i + " (" + j + ")");
						Assert.IsNull (ex.InnerException, "#3:" + i + " (" + j + ")");
						Assert.IsNotNull (ex.Message, "#4:" + i + " (" + j + ")");
						Assert.IsNull (ex.ParamName, "#5:" + i + " (" + j + ")");
					}
				}
			}
		}

		void AssertValueTest (string [][] tests1, string [][] tests2, bool useOdbc, string prefix)
		{
			DbConnectionStringBuilder sb = new DbConnectionStringBuilder (useOdbc);
			for (int i = 0; i < tests1.Length; i++) {
				string [] test1 = tests1 [i];
				bool found = false;
				for (int j = 0; j < tests2.Length; j++) {
					string [] test2 = tests2 [j];
					if (test2 [0] == test1 [0]) {
						found = true;

						if (test2 [1] != test1 [1])
							continue;
						if (test2 [2] != test1 [2])
							continue;
						if (test2 [3] != test1 [3])
							continue;

						Assert.Fail (string.Format (
							"{0}test1 {1} and test2 {2} " +
							"should be moved to shared_tests.",
							prefix, i, j));
					}
				}
				if (found)
					continue;

				try {
					sb.ConnectionString = test1 [0];
					Assert.Fail (prefix + "1 (" + i + ")");
				} catch (ArgumentException ex) {
					// Format of the initialization string does
					// not conform to specification starting
					// at index 0
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), prefix + "2 (" + i + ")");
					Assert.IsNull (ex.InnerException, prefix + "3 (" + i + ")");
					Assert.IsNotNull (ex.Message, prefix + "4 (" + i + ")");
					Assert.IsNull (ex.ParamName, prefix + "5 (" + i + ")");
				}
			}

			// check uniqueness of tests
			for (int i = 0; i < tests1.Length; i++) {
				for (int j = 0; j < tests1.Length; j++) {
					if (i == j)
						continue;
					if (tests1 [i] == tests1 [j])
						Assert.Fail (string.Format (
							"{0}Duplicate test in test1 " +
							"{1} and {2}.", prefix, i, j));
				}
			}

			// check uniqueness of tests
			for (int i = 0; i < tests2.Length; i++) {
				for (int j = 0; j < tests2.Length; j++) {
					if (i == j)
						continue;
					if (tests2 [i] == tests2 [j])
						Assert.Fail (string.Format (
							"{0}Duplicate test in test2 " +
							"{1} and {2}.", prefix, i, j));
				}
			}
		}
	}
}

#endif // NET_2_0