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