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