mcs/class/System.Data/Test/System.Data.SqlClient/SqlConnectionTest.cs

   1 //\r
   2 // SqlConnectionTest.cs - NUnit Test Cases for testing the\r
   3 //                        SqlConnection class\r
   4 // Author:\r
   5 //      Gert Driesen (drieseng@users.sourceforge.net)\r
   6 //\r
   7 // Copyright (c) 2004 Novell Inc., and the individuals listed\r
   8 // on the ChangeLog entries.\r
   9 //\r
  10 // Permission is hereby granted, free of charge, to any person obtaining\r
  11 // a copy of this software and associated documentation files (the\r
  12 // "Software"), to deal in the Software without restriction, including\r
  13 // without limitation the rights to use, copy, modify, merge, publish,\r
  14 // distribute, sublicense, and/or sell copies of the Software, and to\r
  15 // permit persons to whom the Software is furnished to do so, subject to\r
  16 // the following conditions:\r
  17 //\r
  18 // The above copyright notice and this permission notice shall be\r
  19 // included in all copies or substantial portions of the Software.\r
  20 //\r
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  28 //\r
  29 \r
  30 using System;\r
  31 using System.Data;\r
  32 using System.Data.SqlClient;\r
  33 \r
  34 using NUnit.Framework;\r
  35 \r
  36 namespace MonoTests.System.Data.SqlClient\r
  37 {\r
  38         [TestFixture]\r
  39         public class SqlConnectionTest\r
  40         {\r
  41                 [Test] // SqlConnection ()\r
  42                 public void Constructor1 ()\r
  43                 {\r
  44                         SqlConnection cn = new SqlConnection ();\r
  45 \r
  46                         Assert.AreEqual (string.Empty, cn.ConnectionString, "#1");\r
  47                         Assert.AreEqual (15, cn.ConnectionTimeout, "#2");\r
  48                         Assert.IsNull (cn.Container, "#3");\r
  49                         Assert.AreEqual (string.Empty, cn.Database, "#4");\r
  50                         Assert.AreEqual (string.Empty, cn.DataSource, "#5");\r
  51 #if NET_2_0\r
  52                         Assert.IsFalse (cn.FireInfoMessageEventOnUserErrors, "#6");\r
  53                         Assert.AreEqual (8000, cn.PacketSize, "#7");\r
  54 #else\r
  55                         Assert.AreEqual (8192, cn.PacketSize, "#7");\r
  56 #endif\r
  57                         Assert.IsNull (cn.Site, "#8");\r
  58                         Assert.AreEqual (ConnectionState.Closed, cn.State, "#9");\r
  59 #if NET_2_0\r
  60                         Assert.IsFalse (cn.StatisticsEnabled, "#10");\r
  61 #endif\r
  62                         Assert.IsTrue (string.Compare (Environment.MachineName, cn.WorkstationId, true) == 0, "#11");\r
  63                 }\r
  64 \r
  65                 [Test] // SqlConnection (string)\r
  66                 public void Constructor2 ()\r
  67                 {\r
  68                         string connectionString = "server=SQLSRV; database=Mono;";\r
  69 \r
  70                         SqlConnection cn = new SqlConnection (connectionString);\r
  71                         Assert.AreEqual (connectionString, cn.ConnectionString, "#A1");\r
  72                         Assert.AreEqual (15, cn.ConnectionTimeout, "#A2");\r
  73                         Assert.IsNull (cn.Container, "#A3");\r
  74                         Assert.AreEqual ("Mono", cn.Database, "#A4");\r
  75                         Assert.AreEqual ("SQLSRV", cn.DataSource, "#A5");\r
  76 #if NET_2_0\r
  77                         Assert.IsFalse (cn.FireInfoMessageEventOnUserErrors, "#A6");\r
  78                         Assert.AreEqual (8000, cn.PacketSize, "#A7");\r
  79 #else\r
  80                         Assert.AreEqual (8192, cn.PacketSize, "#A7");\r
  81 #endif\r
  82                         Assert.IsNull (cn.Site, "#A8");\r
  83                         Assert.AreEqual (ConnectionState.Closed, cn.State, "#A9");\r
  84 #if NET_2_0\r
  85                         Assert.IsFalse (cn.StatisticsEnabled, "#A10");\r
  86 #endif\r
  87                         Assert.IsTrue (string.Compare (Environment.MachineName, cn.WorkstationId, true) == 0, "#A11");\r
  88 \r
  89                         cn = new SqlConnection ((string) null);\r
  90                         Assert.AreEqual (string.Empty, cn.ConnectionString, "#B1");\r
  91                         Assert.AreEqual (15, cn.ConnectionTimeout, "#B2");\r
  92                         Assert.IsNull (cn.Container, "#B3");\r
  93                         Assert.AreEqual (string.Empty, cn.Database, "#B4");\r
  94                         Assert.AreEqual (string.Empty, cn.DataSource, "#B5");\r
  95 #if NET_2_0\r
  96                         Assert.IsFalse (cn.FireInfoMessageEventOnUserErrors, "#B6");\r
  97                         Assert.AreEqual (8000, cn.PacketSize, "#B7");\r
  98 #else\r
  99                         Assert.AreEqual (8192, cn.PacketSize, "#B7");\r
 100 #endif\r
 101                         Assert.IsNull (cn.Site, "#B8");\r
 102                         Assert.AreEqual (ConnectionState.Closed, cn.State, "#B9");\r
 103 #if NET_2_0\r
 104                         Assert.IsFalse (cn.StatisticsEnabled, "#B10");\r
 105 #endif\r
 106                         Assert.IsTrue (string.Compare (Environment.MachineName, cn.WorkstationId, true) == 0, "#B11");\r
 107                 }\r
 108 \r
 109                 [Test]\r
 110                 public void Constructor2_ConnectionString_Invalid ()\r
 111                 {\r
 112                         try {\r
 113                                 new SqlConnection ("InvalidConnectionString");\r
 114                                 Assert.Fail ("#A1");\r
 115                         } catch (ArgumentException ex) {\r
 116                                 // Format of the initialization string does\r
 117                                 // not conform to specification starting at\r
 118                                 // index 0\r
 119                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 120                                 Assert.IsNull (ex.InnerException, "#A3");\r
 121                                 Assert.IsNotNull (ex.Message, "#A4");\r
 122                                 Assert.IsNull (ex.ParamName, "#A5");\r
 123                         }\r
 124 \r
 125                         // invalid keyword\r
 126                         try {\r
 127                                 new SqlConnection ("invalidKeyword=10");\r
 128                                 Assert.Fail ("#B1");\r
 129                         } catch (ArgumentException ex) {\r
 130                                 // Keyword not supported: 'invalidkeyword'\r
 131                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 132                                 Assert.IsNull (ex.InnerException, "#B3");\r
 133                                 Assert.IsNotNull (ex.Message, "#B4");\r
 134                                 Assert.IsTrue (ex.Message.IndexOf ("'invalidkeyword'") != -1, "#B5");\r
 135                                 Assert.IsNull (ex.ParamName, "#B6");\r
 136                         }\r
 137 \r
 138                         // invalid packet size (< minimum)\r
 139                         try {\r
 140                                 new SqlConnection ("Packet Size=511");\r
 141                                 Assert.Fail ("#C1");\r
 142                         } catch (ArgumentException ex) {\r
 143                                 // Invalid 'Packet Size'.  The value must be an\r
 144                                 // integer >= 512 and <= 32768\r
 145                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");\r
 146                                 Assert.IsNull (ex.InnerException, "#C3");\r
 147                                 Assert.IsNotNull (ex.Message, "#C4");\r
 148                                 Assert.IsNull (ex.ParamName, "#C5");\r
 149                         }\r
 150 \r
 151                         // invalid packet size (> maximum)\r
 152                         try {\r
 153                                 new SqlConnection ("Packet Size=32769");\r
 154                                 Assert.Fail ("#D1");\r
 155                         } catch (ArgumentException ex) {\r
 156                                 // Invalid 'Packet Size'.  The value must be an\r
 157                                 // integer >= 512 and <= 32768\r
 158                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");\r
 159                                 Assert.IsNull (ex.InnerException, "#D3");\r
 160                                 Assert.IsNotNull (ex.Message, "#D4");\r
 161                                 Assert.IsNull (ex.ParamName, "#D5");\r
 162                         }\r
 163 \r
 164                         // negative connect timeout\r
 165                         try {\r
 166                                 new SqlConnection ("Connect Timeout=-1");\r
 167                                 Assert.Fail ("#E1");\r
 168                         } catch (ArgumentException ex) {\r
 169                                 // Invalid value for key 'connect timeout'\r
 170                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");\r
 171                                 Assert.IsNull (ex.InnerException, "#E3");\r
 172                                 Assert.IsNotNull (ex.Message, "#E4");\r
 173                                 Assert.IsNull (ex.ParamName, "#E5");\r
 174                         }\r
 175 \r
 176                         // negative max pool size\r
 177                         try {\r
 178                                 new SqlConnection ("Max Pool Size=-1");\r
 179                                 Assert.Fail ("#F1");\r
 180                         } catch (ArgumentException ex) {\r
 181                                 // Invalid value for key 'max pool size'\r
 182                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");\r
 183                                 Assert.IsNull (ex.InnerException, "#F3");\r
 184                                 Assert.IsNotNull (ex.Message, "#F4");\r
 185                                 Assert.IsNull (ex.ParamName, "#F5");\r
 186                         }\r
 187 \r
 188                         // negative min pool size\r
 189                         try {\r
 190                                 new SqlConnection ("Min Pool Size=-1");\r
 191                                 Assert.Fail ("#G1");\r
 192                         } catch (ArgumentException ex) {\r
 193                                 // Invalid value for key 'min pool size'\r
 194                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");\r
 195                                 Assert.IsNull (ex.InnerException, "#G3");\r
 196                                 Assert.IsNotNull (ex.Message, "#G4");\r
 197                                 Assert.IsNull (ex.ParamName, "#G5");\r
 198                         }\r
 199                 }\r
 200 \r
 201                 [Test]\r
 202                 public void BeginTransaction_Connection_Closed ()\r
 203                 {\r
 204                         SqlConnection cn = new SqlConnection ();\r
 205 \r
 206                         try {\r
 207                                 cn.BeginTransaction ();\r
 208                                 Assert.Fail ("#A1");\r
 209                         } catch (InvalidOperationException ex) {\r
 210                                 // Invalid operation. The connection is closed\r
 211                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");\r
 212                                 Assert.IsNull (ex.InnerException, "#A3");\r
 213                                 Assert.IsNotNull (ex.Message, "#A4");\r
 214                         }\r
 215 \r
 216                         try {\r
 217                                 cn.BeginTransaction ((IsolationLevel) 666);\r
 218                                 Assert.Fail ("#B1");\r
 219                         } catch (InvalidOperationException ex) {\r
 220                                 // Invalid operation. The connection is closed\r
 221                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");\r
 222                                 Assert.IsNull (ex.InnerException, "#B3");\r
 223                                 Assert.IsNotNull (ex.Message, "#B4");\r
 224                         }\r
 225 \r
 226                         try {\r
 227                                 cn.BeginTransaction (IsolationLevel.Serializable);\r
 228                                 Assert.Fail ("#C1");\r
 229                         } catch (InvalidOperationException ex) {\r
 230                                 // Invalid operation. The connection is closed\r
 231                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");\r
 232                                 Assert.IsNull (ex.InnerException, "#C3");\r
 233                                 Assert.IsNotNull (ex.Message, "#C4");\r
 234                         }\r
 235 \r
 236                         try {\r
 237                                 cn.BeginTransaction ("trans");\r
 238                                 Assert.Fail ("#D1");\r
 239                         } catch (InvalidOperationException ex) {\r
 240                                 // Invalid operation. The connection is closed\r
 241                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");\r
 242                                 Assert.IsNull (ex.InnerException, "#D3");\r
 243                                 Assert.IsNotNull (ex.Message, "#D4");\r
 244                         }\r
 245 \r
 246                         try {\r
 247                                 cn.BeginTransaction ((IsolationLevel) 666, "trans");\r
 248                                 Assert.Fail ("#E1");\r
 249                         } catch (InvalidOperationException ex) {\r
 250                                 // Invalid operation. The connection is closed\r
 251                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");\r
 252                                 Assert.IsNull (ex.InnerException, "#E3");\r
 253                                 Assert.IsNotNull (ex.Message, "#E4");\r
 254                         }\r
 255 \r
 256                         try {\r
 257                                 cn.BeginTransaction (IsolationLevel.Serializable, "trans");\r
 258                                 Assert.Fail ("#F1");\r
 259                         } catch (InvalidOperationException ex) {\r
 260                                 // Invalid operation. The connection is closed\r
 261                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");\r
 262                                 Assert.IsNull (ex.InnerException, "#F3");\r
 263                                 Assert.IsNotNull (ex.Message, "#F4");\r
 264                         }\r
 265                 }\r
 266 \r
 267                 [Test]\r
 268                 public void ChangeDatabase_Connection_Closed ()\r
 269                 {\r
 270                         SqlConnection cn = new SqlConnection ();\r
 271                         cn.ConnectionString = "server=SQLSRV";\r
 272 \r
 273                         try {\r
 274                                 cn.ChangeDatabase ("database");\r
 275                                 Assert.Fail ("#1");\r
 276                         } catch (InvalidOperationException ex) {\r
 277                                 // Invalid operation. The connection is closed\r
 278                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");\r
 279                                 Assert.IsNull (ex.InnerException, "#3");\r
 280                                 Assert.IsNotNull (ex.Message, "#4");\r
 281                         }\r
 282                 }\r
 283 \r
 284 #if NET_2_0\r
 285                 [Test]\r
 286                 public void ChangePassword_ConnectionString_Empty ()\r
 287                 {\r
 288                         try {\r
 289                                 SqlConnection.ChangePassword (string.Empty, "mono");\r
 290                                 Assert.Fail ("#1");\r
 291                         } catch (ArgumentNullException ex) {\r
 292                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 293                                 Assert.IsNull (ex.InnerException, "#3");\r
 294                                 Assert.IsNotNull (ex.Message, "#4");\r
 295                                 Assert.IsNotNull (ex.ParamName, "#5");\r
 296                                 Assert.IsTrue (ex.ParamName.IndexOf ("'connectionString'") != -1, "#6");\r
 297                         }\r
 298                 }\r
 299 \r
 300                 [Test]\r
 301                 public void ChangePassword_ConnectionString_Null ()\r
 302                 {\r
 303                         try {\r
 304                                 SqlConnection.ChangePassword ((string) null, "mono");\r
 305                                 Assert.Fail ("#1");\r
 306                         } catch (ArgumentNullException ex) {\r
 307                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 308                                 Assert.IsNull (ex.InnerException, "#3");\r
 309                                 Assert.IsNotNull (ex.Message, "#4");\r
 310                                 Assert.IsNotNull (ex.ParamName, "#5");\r
 311                                 Assert.IsTrue (ex.ParamName.IndexOf ("'connectionString'") != -1, "#6");\r
 312                         }\r
 313                 }\r
 314 \r
 315                 [Test]\r
 316                 public void ChangePassword_NewPassword_Empty ()\r
 317                 {\r
 318                         try {\r
 319                                 SqlConnection.ChangePassword ("server=SQLSRV", string.Empty);\r
 320                                 Assert.Fail ("#1");\r
 321                         } catch (ArgumentNullException ex) {\r
 322                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 323                                 Assert.IsNull (ex.InnerException, "#3");\r
 324                                 Assert.IsNotNull (ex.Message, "#4");\r
 325                                 Assert.IsNotNull (ex.ParamName, "#5");\r
 326                                 Assert.IsTrue (ex.ParamName.IndexOf ("'newPassword'") != -1, "#6");\r
 327                         }\r
 328                 }\r
 329 \r
 330                 [Test]\r
 331                 public void ChangePassword_NewPassword_ExceedMaxLength ()\r
 332                 {\r
 333                         try {\r
 334                                 SqlConnection.ChangePassword ("server=SQLSRV",\r
 335                                         new string ('d', 129));\r
 336                                 Assert.Fail ("#1");\r
 337                         } catch (ArgumentException ex) {\r
 338                                 // The length of argument 'newPassword' exceeds\r
 339                                 // it's limit of '128'\r
 340                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 341                                 Assert.IsNull (ex.InnerException, "#3");\r
 342                                 Assert.IsNotNull (ex.Message, "#4");\r
 343                                 Assert.IsTrue (ex.Message.IndexOf ("'newPassword'") != -1, "#5");\r
 344                                 Assert.IsTrue (ex.Message.IndexOf ("128") != -1, "#6");\r
 345                                 Assert.IsNull (ex.ParamName, "#7");\r
 346                         }\r
 347                 }\r
 348 \r
 349                 [Test]\r
 350                 public void ChangePassword_NewPassword_Null ()\r
 351                 {\r
 352                         try {\r
 353                                 SqlConnection.ChangePassword ("server=SQLSRV", (string) null);\r
 354                                 Assert.Fail ("#1");\r
 355                         } catch (ArgumentNullException ex) {\r
 356                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 357                                 Assert.IsNull (ex.InnerException, "#3");\r
 358                                 Assert.IsNotNull (ex.Message, "#4");\r
 359                                 Assert.IsNotNull (ex.ParamName, "#5");\r
 360                                 Assert.IsTrue (ex.ParamName.IndexOf ("'newPassword'") != -1, "#6");\r
 361                         }\r
 362                 }\r
 363 \r
 364                 [Test]\r
 365                 public void ClearPool_Connection_Null ()\r
 366                 {\r
 367                         try {\r
 368                                 SqlConnection.ClearPool ((SqlConnection) null);\r
 369                                 Assert.Fail ("#1");\r
 370                         } catch (ArgumentNullException ex) {\r
 371                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 372                                 Assert.IsNull (ex.InnerException, "#3");\r
 373                                 Assert.IsNotNull (ex.Message, "#4");\r
 374                                 Assert.AreEqual ("connection", ex.ParamName, "#5");\r
 375                         }\r
 376                 }\r
 377 #endif\r
 378 \r
 379                 [Test]\r
 380                 public void ConnectionString ()\r
 381                 {\r
 382                         SqlConnection cn = new SqlConnection ();\r
 383                         cn.ConnectionString = "server=SQLSRV";\r
 384                         Assert.AreEqual ("server=SQLSRV", cn.ConnectionString, "#1");\r
 385                         cn.ConnectionString = null;\r
 386                         Assert.AreEqual (string.Empty, cn.ConnectionString, "#2");\r
 387                         cn.ConnectionString = "server=SQLSRV";\r
 388                         Assert.AreEqual ("server=SQLSRV", cn.ConnectionString, "#3");\r
 389                         cn.ConnectionString = string.Empty;\r
 390                         Assert.AreEqual (string.Empty, cn.ConnectionString, "#4");\r
 391                 }\r
 392 \r
 393                 [Test]\r
 394                 public void ConnectionString_Value_Invalid ()\r
 395                 {\r
 396                         SqlConnection cn = new SqlConnection ();\r
 397 \r
 398                         try {\r
 399                                 cn.ConnectionString = "InvalidConnectionString";\r
 400                                 Assert.Fail ("#A1");\r
 401                         } catch (ArgumentException ex) {\r
 402                                 // Format of the initialization string does\r
 403                                 // not conform to specification starting at\r
 404                                 // index 0\r
 405                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 406                                 Assert.IsNull (ex.InnerException, "#A3");\r
 407                                 Assert.IsNotNull (ex.Message, "#A4");\r
 408                                 Assert.IsNull (ex.ParamName, "#A5");\r
 409                         }\r
 410 \r
 411                         // invalid keyword\r
 412                         try {\r
 413                                 cn.ConnectionString = "invalidKeyword=10";\r
 414                                 Assert.Fail ("#B1");\r
 415                         } catch (ArgumentException ex) {\r
 416                                 // Keyword not supported: 'invalidkeyword'\r
 417                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 418                                 Assert.IsNull (ex.InnerException, "#B3");\r
 419                                 Assert.IsNotNull (ex.Message, "#B4");\r
 420                                 Assert.IsTrue (ex.Message.IndexOf ("'invalidkeyword'") != -1, "#B5");\r
 421                                 Assert.IsNull (ex.ParamName, "#B6");\r
 422                         }\r
 423                 }\r
 424 \r
 425                 [Test]\r
 426                 public void CreateCommand ()\r
 427                 {\r
 428                         SqlConnection cn = new SqlConnection ();\r
 429                         SqlCommand cmd = cn.CreateCommand ();\r
 430                         Assert.IsNotNull (cmd, "#1");\r
 431                         Assert.AreEqual (string.Empty, cmd.CommandText, "#2");\r
 432                         Assert.AreEqual (30, cmd.CommandTimeout, "#3");\r
 433                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#4");\r
 434                         Assert.AreSame (cn, cmd.Connection, "#5");\r
 435                         Assert.IsNull (cmd.Container, "#6");\r
 436                         Assert.IsTrue (cmd.DesignTimeVisible, "#7");\r
 437 #if NET_2_0\r
 438                         Assert.IsNull (cmd.Notification, "#8");\r
 439                         Assert.IsTrue (cmd.NotificationAutoEnlist, "#9");\r
 440 #endif\r
 441                         Assert.IsNotNull (cmd.Parameters, "#10");\r
 442                         Assert.AreEqual (0, cmd.Parameters.Count, "#11");\r
 443                         Assert.IsNull (cmd.Site, "#12");\r
 444                         Assert.IsNull (cmd.Transaction, "#13");\r
 445                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#14");\r
 446                 }\r
 447 \r
 448                 [Test]\r
 449                 public void Dispose ()\r
 450                 {\r
 451                         SqlConnection cn = new SqlConnection ("Server=SQLSRV;Database=master;Timeout=25;Packet Size=512;Workstation ID=DUMMY");\r
 452                         cn.Dispose ();\r
 453 \r
 454                         Assert.AreEqual (string.Empty, cn.ConnectionString, "#1");\r
 455                         Assert.AreEqual (15, cn.ConnectionTimeout, "#2");\r
 456                         Assert.AreEqual (string.Empty, cn.Database, "#3");\r
 457                         Assert.AreEqual (string.Empty, cn.DataSource, "#4");\r
 458 #if NET_2_0\r
 459                         Assert.AreEqual (8000, cn.PacketSize, "#5");\r
 460 #else\r
 461                         Assert.AreEqual (8192, cn.PacketSize, "#5");\r
 462 #endif\r
 463                         Assert.IsTrue (string.Compare (Environment.MachineName, cn.WorkstationId, true) == 0, "#6");\r
 464                         Assert.AreEqual (ConnectionState.Closed, cn.State, "#7");\r
 465                         cn.Dispose ();\r
 466 \r
 467                         cn = new SqlConnection ();\r
 468                         cn.Dispose ();\r
 469                 }\r
 470 \r
 471 #if NET_2_0\r
 472                 [Test]\r
 473                 public void GetSchema_Connection_Closed ()\r
 474                 {\r
 475                         SqlConnection cn = new SqlConnection ();\r
 476 \r
 477                         try {\r
 478                                 cn.GetSchema ();\r
 479                                 Assert.Fail ("#A1");\r
 480                         } catch (InvalidOperationException ex) {\r
 481                                 // Invalid operation. The connection is closed\r
 482                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");\r
 483                                 Assert.IsNull (ex.InnerException, "#B3");\r
 484                                 Assert.IsNotNull (ex.Message, "#B4");\r
 485                         }\r
 486 \r
 487                         try {\r
 488                                 cn.GetSchema ("Tables");\r
 489                                 Assert.Fail ("#B1");\r
 490                         } catch (InvalidOperationException ex) {\r
 491                                 // Invalid operation. The connection is closed\r
 492                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");\r
 493                                 Assert.IsNull (ex.InnerException, "#B3");\r
 494                                 Assert.IsNotNull (ex.Message, "#B4");\r
 495                         }\r
 496 \r
 497                         try {\r
 498                                 cn.GetSchema ((string) null);\r
 499                                 Assert.Fail ("#C1");\r
 500                         } catch (InvalidOperationException ex) {\r
 501                                 // Invalid operation. The connection is closed\r
 502                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#C2");\r
 503                                 Assert.IsNull (ex.InnerException, "#C3");\r
 504                                 Assert.IsNotNull (ex.Message, "#C4");\r
 505                         }\r
 506 \r
 507                         try {\r
 508                                 cn.GetSchema ("Tables", new string [] { "master" });\r
 509                                 Assert.Fail ("#D1");\r
 510                         } catch (InvalidOperationException ex) {\r
 511                                 // Invalid operation. The connection is closed\r
 512                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");\r
 513                                 Assert.IsNull (ex.InnerException, "#D3");\r
 514                                 Assert.IsNotNull (ex.Message, "#D4");\r
 515                         }\r
 516 \r
 517                         try {\r
 518                                 cn.GetSchema ((string) null, new string [] { "master" });\r
 519                                 Assert.Fail ("#E1");\r
 520                         } catch (InvalidOperationException ex) {\r
 521                                 // Invalid operation. The connection is closed\r
 522                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");\r
 523                                 Assert.IsNull (ex.InnerException, "#E3");\r
 524                                 Assert.IsNotNull (ex.Message, "#E4");\r
 525                         }\r
 526 \r
 527                         try {\r
 528                                 cn.GetSchema ("Tables", (string []) null);\r
 529                                 Assert.Fail ("#F1");\r
 530                         } catch (InvalidOperationException ex) {\r
 531                                 // Invalid operation. The connection is closed\r
 532                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");\r
 533                                 Assert.IsNull (ex.InnerException, "#F3");\r
 534                                 Assert.IsNotNull (ex.Message, "#F4");\r
 535                         }\r
 536 \r
 537                         try {\r
 538                                 cn.GetSchema ((string) null, (string []) null);\r
 539                                 Assert.Fail ("#G1");\r
 540                         } catch (InvalidOperationException ex) {\r
 541                                 // Invalid operation. The connection is closed\r
 542                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#G2");\r
 543                                 Assert.IsNull (ex.InnerException, "#G3");\r
 544                                 Assert.IsNotNull (ex.Message, "#G4");\r
 545                         }\r
 546                 }\r
 547 #endif\r
 548 \r
 549                 [Test]\r
 550                 public void ConnectionString_AsynchronousProcessing ()\r
 551                 {\r
 552                         SqlConnection cn = new SqlConnection ();\r
 553 #if NET_2_0\r
 554                         cn.ConnectionString = "Asynchronous Processing=False";\r
 555                         cn.ConnectionString = "Async=True";\r
 556 #else\r
 557                         try {\r
 558                                 cn.ConnectionString = "Asynchronous Processing=False";\r
 559                                 Assert.Fail ("#A1");\r
 560                         } catch (ArgumentException ex) {\r
 561                                 // Keyword not supported: 'asynchronous processing'\r
 562                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 563                                 Assert.IsNull (ex.InnerException, "#A3");\r
 564                                 Assert.IsNotNull (ex.Message, "#A4");\r
 565                                 Assert.IsTrue (ex.Message.IndexOf ("'asynchronous processing'") != -1, "#A5:" + ex.Message);\r
 566                                 Assert.IsNull (ex.ParamName, "#A6");\r
 567                         }\r
 568 \r
 569                         try {\r
 570                                 cn.ConnectionString = "Async=True";\r
 571                                 Assert.Fail ("#B1");\r
 572                         } catch (ArgumentException ex) {\r
 573                                 // Keyword not supported: 'asynchronous processing'\r
 574                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 575                                 Assert.IsNull (ex.InnerException, "#B3");\r
 576                                 Assert.IsNotNull (ex.Message, "#B4");\r
 577                                 Assert.IsTrue (ex.Message.IndexOf ("'async'") != -1, "#B5:" + ex.Message);\r
 578                                 Assert.IsNull (ex.ParamName, "#B6");\r
 579                         }\r
 580 #endif\r
 581                 }\r
 582 \r
 583                 [Test]\r
 584                 public void ConnectionString_ConnectTimeout ()\r
 585                 {\r
 586                         SqlConnection cn = new SqlConnection ();\r
 587                         cn.ConnectionString = "Connection Timeout=45";\r
 588                         Assert.AreEqual (45, cn.ConnectionTimeout, "#1");\r
 589                         cn.ConnectionString = "Connect Timeout=40";\r
 590                         Assert.AreEqual (40, cn.ConnectionTimeout, "#2");\r
 591                         cn.ConnectionString = "Timeout=";\r
 592                         Assert.AreEqual (15, cn.ConnectionTimeout, "#3");\r
 593                         cn.ConnectionString = "Timeout=2147483647";\r
 594                         Assert.AreEqual (int.MaxValue, cn.ConnectionTimeout, "#4");\r
 595                         cn.ConnectionString = "Timeout=0";\r
 596                         Assert.AreEqual (0, cn.ConnectionTimeout, "#5");\r
 597                 }\r
 598 \r
 599                 [Test]\r
 600                 public void ConnectionString_ConnectTimeout_Invalid ()\r
 601                 {\r
 602                         SqlConnection cn = new SqlConnection ();\r
 603 \r
 604                         // negative number\r
 605                         try {\r
 606                                 cn.ConnectionString = "Connection timeout=-1";\r
 607                                 Assert.Fail ("#A1");\r
 608                         } catch (ArgumentException ex) {\r
 609                                 // Invalid value for key 'connect timeout'\r
 610                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 611                                 Assert.IsNull (ex.InnerException, "#A3");\r
 612                                 Assert.IsNotNull (ex.Message, "#A4");\r
 613 #if NET_2_0\r
 614                                 Assert.IsTrue (ex.Message.IndexOf ("'connect timeout'") != -1, "#A5:" + ex.Message);\r
 615 #endif\r
 616                                 Assert.IsNull (ex.ParamName, "#A6");\r
 617                         }\r
 618 \r
 619                         // invalid number\r
 620                         try {\r
 621                                 cn.ConnectionString = "connect Timeout=BB";\r
 622                                 Assert.Fail ("#B1");\r
 623                         } catch (ArgumentException ex) {\r
 624                                 // Invalid value for key 'connect timeout'\r
 625                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 626                                 Assert.IsNotNull (ex.InnerException, "#B3");\r
 627                                 Assert.AreEqual (typeof (FormatException), ex.InnerException.GetType (), "#B4");\r
 628                                 Assert.IsNotNull (ex.Message, "#B5");\r
 629                                 Assert.IsTrue (ex.Message.IndexOf ("'connect timeout'") != -1, "#B6:" + ex.Message);\r
 630                                 Assert.IsNull (ex.ParamName, "#B7");\r
 631 \r
 632                                 // Input string was not in a correct format\r
 633                                 FormatException fe = (FormatException) ex.InnerException;\r
 634                                 Assert.IsNull (fe.InnerException, "#B8");\r
 635                                 Assert.IsNotNull (fe.Message, "#B9");\r
 636                         }\r
 637 \r
 638                         // overflow\r
 639                         try {\r
 640                                 cn.ConnectionString = "timeout=2147483648";\r
 641                                 Assert.Fail ("#C1");\r
 642                         } catch (ArgumentException ex) {\r
 643                                 // Invalid value for key 'connect timeout'\r
 644                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");\r
 645                                 Assert.IsNotNull (ex.InnerException, "#C3");\r
 646                                 Assert.AreEqual (typeof (OverflowException), ex.InnerException.GetType (), "#C4");\r
 647                                 Assert.IsNotNull (ex.Message, "#C5");\r
 648                                 Assert.IsTrue (ex.Message.IndexOf ("'connect timeout'") != -1, "#C6:" + ex.Message);\r
 649                                 Assert.IsNull (ex.ParamName, "#C7");\r
 650 \r
 651                                 // Value was either too large or too small for an Int32\r
 652                                 OverflowException oe = (OverflowException) ex.InnerException;\r
 653                                 Assert.IsNull (oe.InnerException, "#C8");\r
 654                                 Assert.IsNotNull (oe.Message, "#C9");\r
 655                         }\r
 656                 }\r
 657 \r
 658                 [Test]\r
 659                 public void ConnectionString_Database_Synonyms ()\r
 660                 {\r
 661                         SqlConnection cn = null;\r
 662 \r
 663                         cn = new SqlConnection ();\r
 664                         cn.ConnectionString = "Initial Catalog=db";\r
 665                         Assert.AreEqual ("db", cn.Database);\r
 666 \r
 667                         cn = new SqlConnection ();\r
 668                         cn.ConnectionString = "Database=db";\r
 669                         Assert.AreEqual ("db", cn.Database);\r
 670                 }\r
 671 \r
 672                 [Test]\r
 673                 public void ConnectionString_DataSource_Synonyms ()\r
 674                 {\r
 675                         SqlConnection cn = null;\r
 676 \r
 677                         cn = new SqlConnection ();\r
 678                         cn.ConnectionString = "Data Source=server";\r
 679                         Assert.AreEqual ("server", cn.DataSource);\r
 680 \r
 681                         cn = new SqlConnection ();\r
 682                         cn.ConnectionString = "addr=server";\r
 683                         Assert.AreEqual ("server", cn.DataSource);\r
 684 \r
 685                         cn = new SqlConnection ();\r
 686                         cn.ConnectionString = "address=server";\r
 687                         Assert.AreEqual ("server", cn.DataSource);\r
 688 \r
 689                         cn = new SqlConnection ();\r
 690                         cn.ConnectionString = "network address=server";\r
 691                         Assert.AreEqual ("server", cn.DataSource);\r
 692 \r
 693                         cn = new SqlConnection ();\r
 694                         cn.ConnectionString = "server=server";\r
 695                         Assert.AreEqual ("server", cn.DataSource);\r
 696                 }\r
 697 \r
 698                 [Test]\r
 699                 public void ConnectionString_MaxPoolSize ()\r
 700                 {\r
 701                         SqlConnection cn = new SqlConnection ();\r
 702                         cn.ConnectionString = "Max Pool Size=2147483647";\r
 703                         cn.ConnectionString = "Max Pool Size=1";\r
 704                         cn.ConnectionString = "Max Pool Size=500";\r
 705                 }\r
 706 \r
 707                 [Test]\r
 708                 public void ConnectionString_MaxPoolSize_Invalid ()\r
 709                 {\r
 710                         SqlConnection cn = new SqlConnection ();\r
 711 \r
 712                         // negative number\r
 713                         try {\r
 714                                 cn.ConnectionString = "Max Pool Size=-1";\r
 715                                 Assert.Fail ("#A1");\r
 716                         } catch (ArgumentException ex) {\r
 717                                 // Invalid value for key 'max pool size'\r
 718                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 719                                 Assert.IsNull (ex.InnerException, "#A3");\r
 720                                 Assert.IsNotNull (ex.Message, "#A4");\r
 721 #if NET_2_0\r
 722                                 Assert.IsTrue (ex.Message.IndexOf ("'max pool size'") != -1, "#A5:" + ex.Message);\r
 723 #endif\r
 724                                 Assert.IsNull (ex.ParamName, "#A6");\r
 725                         }\r
 726 \r
 727                         // invalid number\r
 728                         try {\r
 729                                 cn.ConnectionString = "max Pool size=BB";\r
 730                                 Assert.Fail ("#B1");\r
 731                         } catch (ArgumentException ex) {\r
 732                                 // Invalid value for key 'max pool size'\r
 733                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 734                                 Assert.IsNotNull (ex.InnerException, "#B3");\r
 735                                 Assert.AreEqual (typeof (FormatException), ex.InnerException.GetType (), "#B4");\r
 736                                 Assert.IsNotNull (ex.Message, "#B5");\r
 737                                 Assert.IsTrue (ex.Message.IndexOf ("'max pool size'") != -1, "#B6:" + ex.Message);\r
 738                                 Assert.IsNull (ex.ParamName, "#B7");\r
 739 \r
 740                                 // Input string was not in a correct format\r
 741                                 FormatException fe = (FormatException) ex.InnerException;\r
 742                                 Assert.IsNull (fe.InnerException, "#B8");\r
 743                                 Assert.IsNotNull (fe.Message, "#B9");\r
 744                         }\r
 745 \r
 746                         // overflow\r
 747                         try {\r
 748                                 cn.ConnectionString = "max pool size=2147483648";\r
 749                                 Assert.Fail ("#C1");\r
 750                         } catch (ArgumentException ex) {\r
 751                                 // Invalid value for key 'max pool size'\r
 752                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");\r
 753                                 Assert.IsNotNull (ex.InnerException, "#C3");\r
 754                                 Assert.AreEqual (typeof (OverflowException), ex.InnerException.GetType (), "#C4");\r
 755                                 Assert.IsNotNull (ex.Message, "#C5");\r
 756                                 Assert.IsTrue (ex.Message.IndexOf ("'max pool size'") != -1, "#C6:" + ex.Message);\r
 757                                 Assert.IsNull (ex.ParamName, "#C7");\r
 758 \r
 759                                 // Value was either too large or too small for an Int32\r
 760                                 OverflowException oe = (OverflowException) ex.InnerException;\r
 761                                 Assert.IsNull (oe.InnerException, "#C8");\r
 762                                 Assert.IsNotNull (oe.Message, "#C9");\r
 763                         }\r
 764 \r
 765                         // less than minimum (1)\r
 766                         try {\r
 767                                 cn.ConnectionString = "Min Pool Size=0;Max Pool Size=0";\r
 768                                 Assert.Fail ("#D1");\r
 769                         } catch (ArgumentException ex) {\r
 770                                 // Invalid value for key 'max pool size'\r
 771                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");\r
 772                                 Assert.IsNull (ex.InnerException, "#D3");\r
 773                                 Assert.IsNotNull (ex.Message, "#D4");\r
 774 #if NET_2_0\r
 775                                 Assert.IsTrue (ex.Message.IndexOf ("'max pool size'") != -1, "#D5:" + ex.Message);\r
 776 #endif\r
 777                                 Assert.IsNull (ex.ParamName, "#D6");\r
 778                         }\r
 779 \r
 780                         // less than min pool size\r
 781                         try {\r
 782                                 cn.ConnectionString = "Min Pool Size=5;Max Pool Size=4";\r
 783                                 Assert.Fail ("#E1");\r
 784                         } catch (ArgumentException ex) {\r
 785                                 // Invalid min or max pool size values, min\r
 786                                 // pool size cannot be greater than the max\r
 787                                 // pool size\r
 788                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");\r
 789                                 Assert.IsNull (ex.InnerException, "#E3");\r
 790                                 Assert.IsNotNull (ex.Message, "#E4");\r
 791                                 Assert.IsNull (ex.ParamName, "#E5");\r
 792                         }\r
 793                 }\r
 794 \r
 795                 [Test]\r
 796                 public void ConnectionString_MinPoolSize ()\r
 797                 {\r
 798                         SqlConnection cn = new SqlConnection ();\r
 799                         cn.ConnectionString = "min Pool size=0";\r
 800                         cn.ConnectionString = "Min Pool size=100";\r
 801                         cn.ConnectionString = "Min Pool Size=2147483647;Max Pool Size=2147483647";\r
 802                 }\r
 803 \r
 804                 [Test]\r
 805                 public void ConnectionString_MinPoolSize_Invalid ()\r
 806                 {\r
 807                         SqlConnection cn = new SqlConnection ();\r
 808 \r
 809                         // negative number\r
 810                         try {\r
 811                                 cn.ConnectionString = "Min Pool Size=-1";\r
 812                                 Assert.Fail ("#A1");\r
 813                         } catch (ArgumentException ex) {\r
 814                                 // Invalid value for key 'min pool size'\r
 815                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 816                                 Assert.IsNull (ex.InnerException, "#A3");\r
 817                                 Assert.IsNotNull (ex.Message, "#A4");\r
 818 #if NET_2_0\r
 819                                 Assert.IsTrue (ex.Message.IndexOf ("'min pool size'") != -1, "#A5:" + ex.Message);\r
 820 #endif\r
 821                                 Assert.IsNull (ex.ParamName, "#A6");\r
 822                         }\r
 823 \r
 824                         // invalid number\r
 825                         try {\r
 826                                 cn.ConnectionString = "min Pool size=BB";\r
 827                                 Assert.Fail ("#B1");\r
 828                         } catch (ArgumentException ex) {\r
 829                                 // Invalid value for key 'min pool size'\r
 830                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 831                                 Assert.IsNotNull (ex.InnerException, "#B3");\r
 832                                 Assert.AreEqual (typeof (FormatException), ex.InnerException.GetType (), "#B4");\r
 833                                 Assert.IsNotNull (ex.Message, "#B5");\r
 834                                 Assert.IsTrue (ex.Message.IndexOf ("'min pool size'") != -1, "#B6:" + ex.Message);\r
 835                                 Assert.IsNull (ex.ParamName, "#B7");\r
 836 \r
 837                                 // Input string was not in a correct format\r
 838                                 FormatException fe = (FormatException) ex.InnerException;\r
 839                                 Assert.IsNull (fe.InnerException, "#B8");\r
 840                                 Assert.IsNotNull (fe.Message, "#B9");\r
 841                         }\r
 842 \r
 843                         // overflow\r
 844                         try {\r
 845                                 cn.ConnectionString = "min pool size=2147483648";\r
 846                                 Assert.Fail ("#C1");\r
 847                         } catch (ArgumentException ex) {\r
 848                                 // Invalid value for key 'min pool size'\r
 849                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");\r
 850                                 Assert.IsNotNull (ex.InnerException, "#C3");\r
 851                                 Assert.AreEqual (typeof (OverflowException), ex.InnerException.GetType (), "#C4");\r
 852                                 Assert.IsNotNull (ex.Message, "#C5");\r
 853                                 Assert.IsTrue (ex.Message.IndexOf ("'min pool size'") != -1, "#C6:" + ex.Message);\r
 854                                 Assert.IsNull (ex.ParamName, "#C7");\r
 855 \r
 856                                 // Value was either too large or too small for an Int32\r
 857                                 OverflowException oe = (OverflowException) ex.InnerException;\r
 858                                 Assert.IsNull (oe.InnerException, "#C8");\r
 859                                 Assert.IsNotNull (oe.Message, "#C9");\r
 860                         }\r
 861                 }\r
 862 \r
 863                 [Test]\r
 864                 public void ConnectionString_MultipleActiveResultSets ()\r
 865                 {\r
 866                         SqlConnection cn = new SqlConnection ();\r
 867 #if NET_2_0\r
 868                         cn.ConnectionString = "MultipleActiveResultSets=true";\r
 869 #else\r
 870                         try {\r
 871                                 cn.ConnectionString = "MultipleActiveResultSets=true";\r
 872                                 Assert.Fail ("#1");\r
 873                         } catch (ArgumentException ex) {\r
 874                                 // Keyword not supported: 'multipleactiveresultsets'\r
 875                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 876                                 Assert.IsNull (ex.InnerException, "#3");\r
 877                                 Assert.IsNotNull (ex.Message, "#4");\r
 878                                 Assert.IsTrue (ex.Message.IndexOf ("'multipleactiveresultsets'") != -1, "#5:" + ex.Message);\r
 879                                 Assert.IsNull (ex.ParamName, "#6");\r
 880                         }\r
 881 #endif\r
 882                 }\r
 883 \r
 884                 [Test]\r
 885                 public void ConnectionString_MultipleActiveResultSets_Invalid ()\r
 886                 {\r
 887                         SqlConnection cn = new SqlConnection ();\r
 888                         try {\r
 889                                 cn.ConnectionString = "MultipleActiveResultSets=1";\r
 890                                 Assert.Fail ("#1");\r
 891 #if NET_2_0\r
 892                         } catch (ArgumentException ex) {\r
 893                                 // Invalid value for key 'multipleactiveresultsets'\r
 894                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 895                                 Assert.IsNull (ex.InnerException, "#3");\r
 896                                 Assert.IsNotNull (ex.Message, "#4");\r
 897                                 Assert.IsTrue (ex.Message.IndexOf ("'multipleactiveresultsets'") != -1, "#5:" + ex.Message);\r
 898                                 Assert.IsNull (ex.ParamName, "#6");\r
 899                         }\r
 900 #else\r
 901                         } catch (ArgumentException ex) {\r
 902                                 // Keyword not supported: 'multipleactiveresultsets'\r
 903                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 904                                 Assert.IsNull (ex.InnerException, "#3");\r
 905                                 Assert.IsNotNull (ex.Message, "#4");\r
 906                                 Assert.IsTrue (ex.Message.IndexOf ("'multipleactiveresultsets'") != -1, "#5:" + ex.Message);\r
 907                                 Assert.IsNull (ex.ParamName, "#6");\r
 908                         }\r
 909 #endif\r
 910                 }\r
 911 \r
 912                 [Test]\r
 913                 public void ConnectionString_NetworkLibrary_Synonyms ()\r
 914                 {\r
 915                         SqlConnection cn = new SqlConnection ();\r
 916                         cn.ConnectionString = "Net=DBMSSOCN";\r
 917                         cn.ConnectionString = "Network=DBMSSOCN";\r
 918                         cn.ConnectionString = "Network library=DBMSSOCN";\r
 919                 }\r
 920 \r
 921                 [Test]\r
 922                 public void ConnectionString_PacketSize ()\r
 923                 {\r
 924                         SqlConnection cn = new SqlConnection ();\r
 925                         cn.ConnectionString = "Packet Size=1024";\r
 926                         Assert.AreEqual (1024, cn.PacketSize, "#1");\r
 927                         cn.ConnectionString = "packet SizE=533";\r
 928                         Assert.AreEqual (533, cn.PacketSize, "#2");\r
 929                         cn.ConnectionString = "packet SizE=512";\r
 930                         Assert.AreEqual (512, cn.PacketSize, "#3");\r
 931 #if NET_2_0\r
 932                         cn.ConnectionString = "packet SizE=32768";\r
 933                         Assert.AreEqual (32768, cn.PacketSize, "#4");\r
 934 #else\r
 935                         cn.ConnectionString = "packet SizE=32767";\r
 936                         Assert.AreEqual (32767, cn.PacketSize, "#4");\r
 937 #endif\r
 938                         cn.ConnectionString = "packet Size=";\r
 939 #if NET_2_0\r
 940                         Assert.AreEqual (8000, cn.PacketSize, "#5");\r
 941 #else\r
 942                         Assert.AreEqual (8192, cn.PacketSize, "#5");\r
 943 #endif\r
 944                 }\r
 945 \r
 946                 [Test]\r
 947                 public void ConnectionString_PacketSize_Invalid ()\r
 948                 {\r
 949                         SqlConnection cn = new SqlConnection ();\r
 950 \r
 951                         // invalid packet size (< minimum)\r
 952                         try {\r
 953                                 cn.ConnectionString = "Packet Size=511";\r
 954                                 Assert.Fail ("#A1");\r
 955                         } catch (ArgumentException ex) {\r
 956                                 // Invalid 'Packet Size'.  The value must be an\r
 957                                 // integer >= 512 and <= 32768\r
 958                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 959                                 Assert.IsNull (ex.InnerException, "#A3");\r
 960                                 Assert.IsNotNull (ex.Message, "#A4");\r
 961                                 Assert.IsTrue (ex.Message.IndexOf ("'Packet Size'") != -1, "#A5:" + ex.Message);\r
 962                                 Assert.IsNull (ex.ParamName, "#A6");\r
 963                         }\r
 964 \r
 965                         // invalid packet size (> maximum)\r
 966                         try {\r
 967 #if NET_2_0\r
 968                                 cn.ConnectionString = "packet SIze=32769";\r
 969 #else\r
 970                                 cn.ConnectionString = "packet SIze=32768";\r
 971 #endif\r
 972                                 Assert.Fail ("#B1");\r
 973                         } catch (ArgumentException ex) {\r
 974                                 // Invalid 'Packet Size'.  The value must be an\r
 975                                 // integer >= 512 and <= 32768\r
 976                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 977                                 Assert.IsNull (ex.InnerException, "#B3");\r
 978                                 Assert.IsNotNull (ex.Message, "#B4");\r
 979                                 Assert.IsTrue (ex.Message.IndexOf ("'Packet Size'") != -1, "#B5:" + ex.Message);\r
 980                                 Assert.IsNull (ex.ParamName, "#B6");\r
 981                         }\r
 982 \r
 983                         // overflow\r
 984                         try {\r
 985                                 cn.ConnectionString = "packet SIze=2147483648";\r
 986                                 Assert.Fail ("#C1");\r
 987                         } catch (ArgumentException ex) {\r
 988                                 // Invalid value for key 'packet size'\r
 989                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");\r
 990                                 Assert.IsNotNull (ex.InnerException, "#C3");\r
 991                                 Assert.AreEqual (typeof (OverflowException), ex.InnerException.GetType (), "#C4");\r
 992                                 Assert.IsNotNull (ex.Message, "#C5");\r
 993                                 Assert.IsTrue (ex.Message.IndexOf ("'packet size'") != -1, "#C6:" + ex.Message);\r
 994                                 Assert.IsNull (ex.ParamName, "#C7");\r
 995 \r
 996                                 // Value was either too large or too small for an Int32\r
 997                                 OverflowException oe = (OverflowException) ex.InnerException;\r
 998                                 Assert.IsNull (oe.InnerException, "#C8");\r
 999                                 Assert.IsNotNull (oe.Message, "#C9");\r
1000                         }\r
1001                 }\r
1002 \r
1003                 [Test]\r
1004                 public void ConnectionString_Password_Synonyms ()\r
1005                 {\r
1006                         SqlConnection cn = new SqlConnection ();\r
1007                         cn.ConnectionString = "Password=scrambled";\r
1008                         cn.ConnectionString = "Pwd=scrambled";\r
1009                 }\r
1010 \r
1011                 [Test]\r
1012                 public void ConnectionString_PersistSecurityInfo_Synonyms ()\r
1013                 {\r
1014                         SqlConnection cn = new SqlConnection ();\r
1015                         cn.ConnectionString = "Persist Security Info=true";\r
1016                         cn.ConnectionString = "PersistSecurityInfo=true";\r
1017                 }\r
1018 \r
1019                 [Test]\r
1020                 public void ConnectionString_UserID_Synonyms ()\r
1021                 {\r
1022                         SqlConnection cn = new SqlConnection ();\r
1023                         cn.ConnectionString = "User Id=test";\r
1024                         cn.ConnectionString = "User=test";\r
1025                         cn.ConnectionString = "Uid=test";\r
1026                 }\r
1027 \r
1028                 [Test]\r
1029                 public void ConnectionString_UserInstance ()\r
1030                 {\r
1031                         SqlConnection cn = new SqlConnection ();\r
1032 #if NET_2_0\r
1033                         cn.ConnectionString = "User Instance=true";\r
1034 #else\r
1035                         try {\r
1036                                 cn.ConnectionString = "User Instance=true";\r
1037                                 Assert.Fail ("#1");\r
1038                         } catch (ArgumentException ex) {\r
1039                                 // Keyword not supported: 'user instance'\r
1040                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
1041                                 Assert.IsNull (ex.InnerException, "#3");\r
1042                                 Assert.IsNotNull (ex.Message, "#4");\r
1043                                 Assert.IsTrue (ex.Message.IndexOf ("'user instance'") != -1, "#5:" + ex.Message);\r
1044                                 Assert.IsNull (ex.ParamName, "#6");\r
1045                         }\r
1046 #endif\r
1047                 }\r
1048 \r
1049                 [Test]\r
1050                 public void ConnectionString_UserInstance_Invalid ()\r
1051                 {\r
1052                         SqlConnection cn = new SqlConnection ();\r
1053                         try {\r
1054                                 cn.ConnectionString = "User Instance=1";\r
1055                                 Assert.Fail ("#1");\r
1056 #if NET_2_0\r
1057                         } catch (ArgumentException ex) {\r
1058                                 // Invalid value for key 'user instance'\r
1059                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
1060                                 Assert.IsNull (ex.InnerException, "#3");\r
1061                                 Assert.IsNotNull (ex.Message, "#4");\r
1062                                 Assert.IsTrue (ex.Message.IndexOf ("'user instance'") != -1, "#5:" + ex.Message);\r
1063                                 Assert.IsNull (ex.ParamName, "#6");\r
1064                         }\r
1065 #else\r
1066                         } catch (ArgumentException ex) {\r
1067                                 // Keyword not supported: 'user instance'\r
1068                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
1069                                 Assert.IsNull (ex.InnerException, "#3");\r
1070                                 Assert.IsNotNull (ex.Message, "#4");\r
1071                                 Assert.IsTrue (ex.Message.IndexOf ("'user instance'") != -1, "#5:" + ex.Message);\r
1072                                 Assert.IsNull (ex.ParamName, "#6");\r
1073                         }\r
1074 #endif\r
1075                 }\r
1076 \r
1077                 [Test]\r
1078                 public void ConnectionString_OtherKeywords ()\r
1079                 {\r
1080                         SqlConnection cn = new SqlConnection ();\r
1081                         cn.ConnectionString = "Application Name=test";\r
1082                         cn.ConnectionString = "App=test";\r
1083                         cn.ConnectionString = "Connection Reset=true";\r
1084                         cn.ConnectionString = "Current Language=test";\r
1085                         cn.ConnectionString = "Language=test";\r
1086                         cn.ConnectionString = "Encrypt=false";\r
1087                         //cn.ConnectionString = "Encrypt=true";\r
1088                         //cn.ConnectionString = "Enlist=false";\r
1089                         cn.ConnectionString = "Enlist=true";\r
1090                         cn.ConnectionString = "Integrated Security=true";\r
1091                         cn.ConnectionString = "Trusted_connection=true";\r
1092                         cn.ConnectionString = "Max Pool Size=10";\r
1093                         cn.ConnectionString = "Min Pool Size=10";\r
1094                         cn.ConnectionString = "Pooling=true";\r
1095                         cn.ConnectionString = "attachdbfilename=dunno";\r
1096                         cn.ConnectionString = "extended properties=dunno";\r
1097                         cn.ConnectionString = "initial file name=dunno";\r
1098                 }\r
1099 \r
1100                 [Test]\r
1101                 public void Open_ConnectionString_Empty ()\r
1102                 {\r
1103                         SqlConnection cn = new SqlConnection ();\r
1104                         cn.ConnectionString = string.Empty;\r
1105 \r
1106                         try {\r
1107                                 cn.Open ();\r
1108                                 Assert.Fail ("#1");\r
1109                         } catch (InvalidOperationException ex) {\r
1110                                 // The ConnectionString property has not been\r
1111                                 // initialized\r
1112                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");\r
1113                                 Assert.IsNull (ex.InnerException, "#3");\r
1114                                 Assert.IsNotNull (ex.Message, "#4");\r
1115                         }\r
1116                 }\r
1117 \r
1118                 [Test]\r
1119                 public void Open_ConnectionString_Null ()\r
1120                 {\r
1121                         SqlConnection cn = new SqlConnection ();\r
1122                         cn.ConnectionString = null;\r
1123 \r
1124                         try {\r
1125                                 cn.Open ();\r
1126                                 Assert.Fail ("#1");\r
1127                         } catch (InvalidOperationException ex) {\r
1128                                 // The ConnectionString property has not been\r
1129                                 // initialized\r
1130                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");\r
1131                                 Assert.IsNull (ex.InnerException, "#3");\r
1132                                 Assert.IsNotNull (ex.Message, "#4");\r
1133                         }\r
1134                 }\r
1135 \r
1136                 [Test]\r
1137                 public void Open_ConnectionString_Whitespace ()\r
1138                 {\r
1139                         SqlConnection cn = new SqlConnection ();\r
1140                         cn.ConnectionString = "    ";\r
1141 \r
1142                         try {\r
1143                                 cn.Open ();\r
1144                                 Assert.Fail ("#1");\r
1145                         } catch (InvalidOperationException ex) {\r
1146                                 // The ConnectionString property has not been\r
1147                                 // initialized\r
1148                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");\r
1149                                 Assert.IsNull (ex.InnerException, "#3");\r
1150                                 Assert.IsNotNull (ex.Message, "#4");\r
1151                         }\r
1152                 }\r
1153 \r
1154                 [Test]\r
1155                 public void ServerVersion_Connection_Closed ()\r
1156                 {\r
1157                         SqlConnection cn = new SqlConnection ();\r
1158                         try {\r
1159                                 Assert.Fail ("#A1:" + cn.ServerVersion);\r
1160                         } catch (InvalidOperationException ex) {\r
1161                                 // Invalid operation. The connection is closed\r
1162                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");\r
1163                                 Assert.IsNull (ex.InnerException, "#A3");\r
1164                                 Assert.IsNotNull (ex.Message, "#A4");\r
1165                         }\r
1166 \r
1167                         cn = new SqlConnection ("server=SQLSRV; database=Mono;");\r
1168                         try {\r
1169                                 Assert.Fail ("#B1:" + cn.ServerVersion);\r
1170                         } catch (InvalidOperationException ex) {\r
1171                                 // Invalid operation. The connection is closed\r
1172                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");\r
1173                                 Assert.IsNull (ex.InnerException, "#B3");\r
1174                                 Assert.IsNotNull (ex.Message, "#B4");\r
1175                         }\r
1176                 }\r
1177         }\r
1178 }\r