mcs/class/System.ServiceModel/Test/System.ServiceModel.Channels/CommunicationObjectSyncTest.cs

   1 //
   2 // Unit tests for System.ServiceModel.CommunicationObject
   3 //
   4 // Contact:
   5 //   Moonlight List (moonlight-list@lists.ximian.com)
   6 //
   7 // Copyright (C) 2011 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30
  31 using System.ServiceModel;
  32 using System.ServiceModel.Channels;
  33
  34 // the file 'NUnitMoonHelper.cs' makes the Moon's unit test compiles and runs on NUnit
  35 using Microsoft.VisualStudio.TestTools.UnitTesting;
  36 using Mono.Moonlight.UnitTesting;
  37
  38 namespace MonoTests.System.ServiceModel.Channels {
  39
  40         [TestClass]
  41         public class CommunicationObjectSyncTest {
  42
  43                 class CommunicationObjectPoker : CommunicationObject {
  44
  45                         public CommunicationObjectPoker ()
  46                         {
  47                         }
  48
  49                         public CommunicationObjectPoker (object o)
  50                                 : base (o)
  51                         {
  52                         }
  53
  54                         public bool DefaultCloseTimeoutCalled { get; set; }
  55                         public bool DefaultOpenTimeoutCalled { get; set; }
  56
  57                         public bool OnBeginCloseCalled { get; set; }
  58                         public bool OnCloseCalled { get; set; }
  59                         public bool OnEndCloseCalled { get; set; }
  60
  61                         public bool OnBeginOpenCalled { get; set; }
  62                         public bool OnOpenCalled { get; set; }
  63                         public bool OnEndOpenCalled { get; set; }
  64
  65                         public bool OnAbortCalled { get; set; }
  66                         public CommunicationState OnAbortState { get; set; }
  67
  68                         public bool Disposed {
  69                                 get { return IsDisposed; }
  70                         }
  71
  72                         protected override TimeSpan DefaultCloseTimeout {
  73                                 get {
  74                                         DefaultCloseTimeoutCalled = true;
  75                                         return TimeSpan.Zero;
  76                                 }
  77                         }
  78
  79                         protected override TimeSpan DefaultOpenTimeout {
  80                                 get {
  81                                         DefaultOpenTimeoutCalled = true;
  82                                         return TimeSpan.Zero;
  83                                 }
  84                         }
  85
  86                         protected override void OnAbort ()
  87                         {
  88                                 OnAbortCalled = true;
  89                                 Assert.AreEqual (OnAbortState, State, "OnAbort/State");
  90                                 Assert.IsFalse (Disposed, "OnAbort/IsDisposed");
  91                         }
  92
  93                         protected override IAsyncResult OnBeginClose (TimeSpan timeout, AsyncCallback callback, object state)
  94                         {
  95                                 OnBeginCloseCalled = true;
  96                                 return null;
  97                         }
  98
  99                         protected override IAsyncResult OnBeginOpen (TimeSpan timeout, AsyncCallback callback, object state)
 100                         {
 101                                 OnBeginOpenCalled = true;
 102                                 return null;
 103                         }
 104
 105                         protected override void OnClose (TimeSpan timeout)
 106                         {
 107                                 OnCloseCalled = true;
 108                         }
 109
 110                         protected override void OnEndClose (IAsyncResult result)
 111                         {
 112                                 OnEndCloseCalled = true;
 113                         }
 114
 115                         protected override void OnEndOpen (IAsyncResult result)
 116                         {
 117                                 OnEndOpenCalled = true;
 118                         }
 119
 120                         protected override void OnOpen (TimeSpan timeout)
 121                         {
 122                                 OnOpenCalled = true;
 123                         }
 124
 125                         public void _Fault ()
 126                         {
 127                                 Fault ();
 128                                 Assert.AreEqual (CommunicationState.Faulted, State, "Fault/State");
 129                                 Assert.IsFalse (Disposed, "Fault/IsDisposed");
 130                         }
 131
 132                         public void _FaultNoAssert ()
 133                         {
 134                                 Fault ();
 135                         }
 136
 137                         public object _ThisLock {
 138                                 get { return ThisLock; }
 139                         }
 140
 141                         public void _ThrowIfDisposed ()
 142                         {
 143                                 ThrowIfDisposed ();
 144                         }
 145
 146                         public void _ThrowIfDisposedOrImmutable ()
 147                         {
 148                                 ThrowIfDisposedOrImmutable ();
 149                         }
 150
 151                         public void _ThrowIfDisposedOrNotOpen ()
 152                         {
 153                                 ThrowIfDisposedOrNotOpen ();
 154                         }
 155                 }
 156
 157                 [TestMethod]
 158                 public void Constructor ()
 159                 {
 160                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 161                         Assert.AreEqual (typeof (object), co._ThisLock.GetType (), "ThisLock/default");
 162
 163                         co = new CommunicationObjectPoker (null);
 164                         Assert.IsNull (co._ThisLock, "ThisLock/null");
 165
 166                         co = new CommunicationObjectPoker (String.Empty);
 167                         Assert.AreSame (String.Empty, co._ThisLock, "ThisLock/weak");
 168                 }
 169
 170                 [TestMethod]
 171 #if MOBILE
 172                 [MoonlightBug]
 173 #else
 174                 [NUnit.Framework.Ignore]
 175 #endif
 176                 public void Create_Abort ()
 177                 {
 178                         int closing = 0;
 179                         int closed = 0;
 180
 181                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 182                         co.Closing += delegate (object sender, EventArgs e) {
 183                                 closing++;
 184                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 185                                 Assert.AreSame (co, sender, "Closing/sender");
 186                                 Assert.AreSame (EventArgs.Empty, e, "Closing/e");
 187
 188                                 Assert.IsFalse (co.Disposed, "Closing/Disposed");
 189                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 190                                         co._ThrowIfDisposed ();
 191                                 }, "Closing/ThrowIfDisposed");
 192                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 193                                         co._ThrowIfDisposedOrImmutable ();
 194                                 }, "Closing/ThrowIfDisposedOrImmutable");
 195                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 196                                         co._ThrowIfDisposedOrNotOpen ();
 197                                 }, "Closing/ThrowIfDisposedOrNotOpen");
 198                         };
 199                         co.Closed += delegate (object sender, EventArgs e) {
 200                                 closed++;
 201                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 202                                 Assert.AreSame (co, sender, "Closed/sender");
 203                                 Assert.AreSame (EventArgs.Empty, e, "Closed/e");
 204
 205                                 Assert.IsTrue (co.Disposed, "Closed/Disposed");
 206                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 207                                         co._ThrowIfDisposed ();
 208                                 }, "Closed/ThrowIfDisposed");
 209                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 210                                         co._ThrowIfDisposedOrImmutable ();
 211                                 }, "Closed/ThrowIfDisposedOrImmutable");
 212                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 213                                         co._ThrowIfDisposedOrNotOpen ();
 214                                 }, "Closed/ThrowIfDisposedOrNotOpen");
 215                         };
 216                         Assert.AreEqual (CommunicationState.Created, co.State, "State/before");
 217
 218                         co.OnAbortState = CommunicationState.Closing;
 219                         co.Abort ();
 220                         Assert.AreEqual (1, closing, "closing");
 221                         Assert.AreEqual (1, closed, "closed");
 222
 223                         Assert.AreEqual (CommunicationState.Closed, co.State, "State/after");
 224                         Assert.IsTrue (co.Disposed, "IsDisposed");
 225
 226                         Assert.IsFalse (co.DefaultCloseTimeoutCalled, "DefaultCloseTimeoutCalled");
 227                         Assert.IsFalse (co.DefaultOpenTimeoutCalled, "DefaultOpenTimeoutCalled");
 228                         Assert.IsTrue (co.OnAbortCalled, "OnAbortCalled");
 229
 230                         Assert.IsFalse (co.OnBeginCloseCalled, "OnBeginCloseCalled");
 231                         Assert.IsFalse (co.OnCloseCalled, "OnCloseCalled");
 232                         Assert.IsFalse (co.OnEndCloseCalled, "OnEndCloseCalled");
 233
 234                         Assert.IsFalse (co.OnBeginOpenCalled, "OnBeginOpenCalled");
 235                         Assert.IsFalse (co.OnOpenCalled, "OnOpenCalled");
 236                         Assert.IsFalse (co.OnEndOpenCalled, "OnEndCloseCalled");
 237                 }
 238
 239                 [TestMethod]
 240 #if MOBILE
 241                 [MoonlightBug]
 242 #else
 243                 [NUnit.Framework.Ignore]
 244 #endif
 245                 public void Create_Close ()
 246                 {
 247                         int opening = 0;
 248                         int opened = 0;
 249                         int closing = 0;
 250                         int closed = 0;
 251
 252                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 253                         co.Opening += delegate (object sender, EventArgs e) {
 254                                 opening++;
 255                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 256                                 Assert.AreSame (co, sender, "Opening/sender");
 257                                 Assert.AreSame (EventArgs.Empty, e, "Opening/e");
 258                         };
 259                         co.Opened += delegate (object sender, EventArgs e) {
 260                                 opened++;
 261                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 262                                 Assert.AreSame (co, sender, "Opened/sender");
 263                                 Assert.AreSame (EventArgs.Empty, e, "Opened/e");
 264                         };
 265                         co.Closing += delegate (object sender, EventArgs e) {
 266                                 closing++;
 267                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 268                                 Assert.AreSame (co, sender, "Closing/sender");
 269                                 Assert.AreSame (EventArgs.Empty, e, "Closing/e");
 270
 271                                 Assert.IsFalse (co.Disposed, "Closing/Disposed");
 272                                 // note: IsDisposed is false but we still throw!
 273                                 // but this match MSDN docs about ThrowIfDisposed
 274                                 Assert.Throws<ObjectDisposedException> (delegate {
 275                                         co._ThrowIfDisposed ();
 276                                 }, "Closing/ThrowIfDisposed");
 277                                 Assert.Throws<ObjectDisposedException> (delegate {
 278                                         co._ThrowIfDisposedOrImmutable ();
 279                                 }, "Closing/ThrowIfDisposedOrImmutable");
 280                                 Assert.Throws<ObjectDisposedException> (delegate {
 281                                         co._ThrowIfDisposedOrNotOpen ();
 282                                 }, "Closing/ThrowIfDisposedOrNotOpen");
 283                         };
 284                         co.Closed += delegate (object sender, EventArgs e) {
 285                                 closed++;
 286                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 287                                 Assert.AreSame (co, sender, "Closed/sender");
 288                                 Assert.AreSame (EventArgs.Empty, e, "Closed/e");
 289
 290                                 Assert.IsTrue (co.Disposed, "Closed/Disposed");
 291                                 Assert.Throws<ObjectDisposedException> (delegate {
 292                                         co._ThrowIfDisposed ();
 293                                 }, "Closed/ThrowIfDisposed");
 294                                 Assert.Throws<ObjectDisposedException> (delegate {
 295                                         co._ThrowIfDisposedOrImmutable ();
 296                                 }, "Closed/ThrowIfDisposedOrImmutable");
 297                                 Assert.Throws<ObjectDisposedException> (delegate {
 298                                         co._ThrowIfDisposedOrNotOpen ();
 299                                 }, "Closed/ThrowIfDisposedOrNotOpen");
 300                         };
 301                         Assert.AreEqual (CommunicationState.Created, co.State, "State/before");
 302
 303                         co.OnAbortState = CommunicationState.Closing;
 304                         // note: since this is not a "direct" abort then ObjectDisposedException
 305                         co.Close ();
 306                         Assert.AreEqual (0, opening, "opening");
 307                         Assert.AreEqual (0, opened, "opened");
 308                         Assert.AreEqual (1, closing, "closing");
 309                         Assert.AreEqual (1, closed, "closed");
 310
 311                         Assert.AreEqual (CommunicationState.Closed, co.State, "State/after");
 312                         Assert.IsTrue (co.Disposed, "IsDisposed");
 313
 314                         Assert.IsTrue (co.DefaultCloseTimeoutCalled, "DefaultCloseTimeoutCalled");
 315                         Assert.IsFalse (co.DefaultOpenTimeoutCalled, "DefaultOpenTimeoutCalled");
 316                         Assert.IsTrue (co.OnAbortCalled, "OnAbortCalled");
 317
 318                         Assert.IsFalse (co.OnBeginCloseCalled, "OnBeginCloseCalled");
 319                         Assert.IsFalse (co.OnCloseCalled, "OnCloseCalled");
 320                         Assert.IsFalse (co.OnEndCloseCalled, "OnEndCloseCalled");
 321
 322                         Assert.IsFalse (co.OnBeginOpenCalled, "OnBeginOpenCalled");
 323                         Assert.IsFalse (co.OnOpenCalled, "OnOpenCalled");
 324                         Assert.IsFalse (co.OnEndOpenCalled, "OnEndCloseCalled");
 325
 326                         // 2nd time, no events raised
 327                         co.Close ();
 328                         Assert.AreEqual (0, opening, "opening-b");
 329                         Assert.AreEqual (0, opened, "opened-b");
 330                         Assert.AreEqual (1, closing, "closing-c");
 331                         Assert.AreEqual (1, closed, "closed-c");
 332
 333                         Assert.Throws<ObjectDisposedException> (delegate {
 334                                 co.Open ();
 335                         }, "Open");
 336                         Assert.AreEqual (0, opening, "opening-c");
 337                         Assert.AreEqual (0, opened, "opened-c");
 338                         Assert.AreEqual (1, closing, "closing-c");
 339                         Assert.AreEqual (1, closed, "closed-c");
 340                 }
 341
 342                 [TestMethod]
 343 #if MOBILE
 344                 [MoonlightBug]
 345 #else
 346                 [NUnit.Framework.Ignore]
 347 #endif
 348                 public void Create_Close_Fault ()
 349                 {
 350                         bool faulted = false;
 351
 352                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 353                         co.Faulted += delegate (object sender, EventArgs e) {
 354                                 faulted = true; // won't be hit
 355                         };
 356                         co.Open ();
 357                         co.Close (); // real Close, not an implicit Abort since Open was called
 358                         co._FaultNoAssert (); // don't check State since it won't be Faulted
 359                         Assert.AreEqual (CommunicationState.Closed, co.State, "State/Fault");
 360                         Assert.IsFalse (faulted, "Faulted");
 361                 }
 362
 363                 [TestMethod]
 364 #if MOBILE
 365                 [MoonlightBug]
 366 #else
 367                 [NUnit.Framework.Ignore]
 368 #endif
 369                 public void Create_Open_Close_Abort ()
 370                 {
 371                         int opening = 0;
 372                         int opened = 0;
 373                         int closing = 0;
 374                         int closed = 0;
 375
 376                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 377                         co.Opening += delegate (object sender, EventArgs e) {
 378                                 opening++;
 379                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 380                                 Assert.AreSame (co, sender, "Opening/sender");
 381                                 Assert.AreSame (EventArgs.Empty, e, "Opening/e");
 382                         };
 383                         co.Opened += delegate (object sender, EventArgs e) {
 384                                 opened++;
 385                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 386                                 Assert.AreSame (co, sender, "Opened/sender");
 387                                 Assert.AreSame (EventArgs.Empty, e, "Opened/e");
 388                         };
 389                         co.Closing += delegate (object sender, EventArgs e) {
 390                                 closing++;
 391                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 392                                 Assert.AreSame (co, sender, "Closing/sender");
 393                                 Assert.AreSame (EventArgs.Empty, e, "Closing/e");
 394                         };
 395                         co.Closed += delegate (object sender, EventArgs e) {
 396                                 closed++;
 397                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 398                                 Assert.AreSame (co, sender, "Closed/sender");
 399                                 Assert.AreSame (EventArgs.Empty, e, "Closed/e");
 400                         };
 401                         Assert.AreEqual (CommunicationState.Created, co.State, "State/before");
 402
 403                         co.Open ();
 404                         Assert.AreEqual (1, opening, "opening");
 405                         Assert.AreEqual (1, opened, "opened");
 406                         Assert.AreEqual (0, closing, "closing");
 407                         Assert.AreEqual (0, closed, "closed");
 408
 409                         Assert.AreEqual (CommunicationState.Opened, co.State, "State/after/open");
 410                         Assert.IsFalse (co.Disposed, "IsDisposed/open");
 411
 412                         Assert.IsFalse (co.DefaultCloseTimeoutCalled, "DefaultCloseTimeoutCalled/open");
 413                         Assert.IsTrue (co.DefaultOpenTimeoutCalled, "DefaultOpenTimeoutCalled/open");
 414                         Assert.IsFalse (co.OnAbortCalled, "OnAbortCalled/open");
 415
 416                         Assert.IsFalse (co.OnBeginCloseCalled, "OnBeginCloseCalled/open");
 417                         Assert.IsFalse (co.OnCloseCalled, "OnCloseCalled/open");
 418                         Assert.IsFalse (co.OnEndCloseCalled, "OnEndCloseCalled/open");
 419
 420                         Assert.IsFalse (co.OnBeginOpenCalled, "OnBeginOpenCalled/open");
 421                         Assert.IsTrue (co.OnOpenCalled, "OnOpenCalled/open");
 422                         Assert.IsFalse (co.OnEndOpenCalled, "OnEndCloseCalled/open");
 423
 424                         co.Close ();
 425                         Assert.AreEqual (1, opening, "opening-b");
 426                         Assert.AreEqual (1, opened, "opened-b");
 427                         Assert.AreEqual (1, closing, "closing-b");
 428                         Assert.AreEqual (1, closed, "closed-b");
 429
 430                         Assert.AreEqual (CommunicationState.Closed, co.State, "State/close");
 431                         Assert.IsTrue (co.Disposed, "IsDisposed/close");
 432
 433                         Assert.IsTrue (co.DefaultCloseTimeoutCalled, "DefaultCloseTimeoutCalled/close");
 434                         Assert.IsTrue (co.DefaultOpenTimeoutCalled, "DefaultOpenTimeoutCalled/close");
 435                         Assert.IsFalse (co.OnAbortCalled, "OnAbortCalled/close");
 436
 437                         Assert.IsFalse (co.OnBeginCloseCalled, "OnBeginCloseCalled/close");
 438                         Assert.IsTrue (co.OnCloseCalled, "OnCloseCalled/close");
 439                         Assert.IsFalse (co.OnEndCloseCalled, "OnEndCloseCalled/close");
 440
 441                         Assert.IsFalse (co.OnBeginOpenCalled, "OnBeginOpenCalled/close");
 442                         Assert.IsTrue (co.OnOpenCalled, "OnOpenCalled/close");
 443                         Assert.IsFalse (co.OnEndOpenCalled, "OnEndCloseCalled/close");
 444
 445                         co.Abort ();
 446                         Assert.AreEqual (1, opening, "opening-c");
 447                         Assert.AreEqual (1, opened, "opened-c");
 448                         Assert.AreEqual (1, closing, "closing-c");
 449                         Assert.AreEqual (1, closed, "closed-c");
 450
 451                         Assert.IsFalse (co.OnAbortCalled, "OnAbortCalled/abort");
 452                         Assert.AreEqual (CommunicationState.Closed, co.State, "State/abort");
 453                 }
 454
 455                 [TestMethod]
 456 #if MOBILE
 457                 [MoonlightBug]
 458 #else
 459                 [NUnit.Framework.Ignore]
 460 #endif
 461                 public void Create_Fault_Abort ()
 462                 {
 463                         int opening = 0;
 464                         int opened = 0;
 465                         int closing = 0;
 466                         int closed = 0;
 467
 468                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 469                         co.Opening += delegate (object sender, EventArgs e) {
 470                                 opening++;
 471                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 472                                 Assert.AreSame (co, sender, "Opening/sender");
 473                                 Assert.AreSame (EventArgs.Empty, e, "Opening/e");
 474                         };
 475                         co.Opened += delegate (object sender, EventArgs e) {
 476                                 opened++;
 477                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 478                                 Assert.AreSame (co, sender, "Opened/sender");
 479                                 Assert.AreSame (EventArgs.Empty, e, "Opened/e");
 480                         };
 481                         co.Closing += delegate (object sender, EventArgs e) {
 482                                 closing++;
 483                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 484                                 Assert.AreSame (co, sender, "Closing/sender");
 485                                 Assert.AreSame (EventArgs.Empty, e, "Closing/e");
 486
 487                                 Assert.IsFalse (co.Disposed, "Closing/Disposed");
 488                                 // note: IsDisposed is false but we still throw!
 489                                 // but this match MSDN docs about ThrowIfDisposed
 490                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 491                                         co._ThrowIfDisposed ();
 492                                 }, "Closing/ThrowIfDisposed");
 493                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 494                                         co._ThrowIfDisposedOrImmutable ();
 495                                 }, "Closing/ThrowIfDisposedOrImmutable");
 496                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 497                                         co._ThrowIfDisposedOrNotOpen ();
 498                                 }, "Closing/ThrowIfDisposedOrNotOpen");
 499                         };
 500                         co.Closed += delegate (object sender, EventArgs e) {
 501                                 closed++;
 502                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 503                                 Assert.AreSame (co, sender, "Closed/sender");
 504                                 Assert.AreSame (EventArgs.Empty, e, "Closed/e");
 505
 506                                 Assert.IsTrue (co.Disposed, "Closed/Disposed");
 507                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 508                                         co._ThrowIfDisposed ();
 509                                 }, "Closed/ThrowIfDisposed");
 510                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 511                                         co._ThrowIfDisposedOrImmutable ();
 512                                 }, "Closed/ThrowIfDisposedOrImmutable");
 513                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 514                                         co._ThrowIfDisposedOrNotOpen ();
 515                                 }, "Closed/ThrowIfDisposedOrNotOpen");
 516                         };
 517                         Assert.AreEqual (CommunicationState.Created, co.State, "State/before");
 518
 519                         co.OnAbortState = CommunicationState.Closing;
 520                         co._Fault ();
 521                         Assert.AreEqual (0, opening, "opening");
 522                         Assert.AreEqual (0, opened, "opened");
 523                         Assert.AreEqual (0, closing, "closing");
 524                         Assert.AreEqual (0, closed, "closed");
 525
 526                         Assert.AreEqual (CommunicationState.Faulted, co.State, "State/after");
 527                         Assert.IsFalse (co.Disposed, "IsDisposed");
 528
 529                         Assert.IsFalse (co.DefaultCloseTimeoutCalled, "DefaultCloseTimeoutCalled");
 530                         Assert.IsFalse (co.DefaultOpenTimeoutCalled, "DefaultOpenTimeoutCalled");
 531                         Assert.IsFalse (co.OnAbortCalled, "OnAbortCalled");
 532
 533                         Assert.IsFalse (co.OnBeginCloseCalled, "OnBeginCloseCalled");
 534                         Assert.IsFalse (co.OnCloseCalled, "OnCloseCalled");
 535                         Assert.IsFalse (co.OnEndCloseCalled, "OnEndCloseCalled");
 536
 537                         Assert.IsFalse (co.OnBeginOpenCalled, "OnBeginOpenCalled");
 538                         Assert.IsFalse (co.OnOpenCalled, "OnOpenCalled");
 539                         Assert.IsFalse (co.OnEndOpenCalled, "OnEndCloseCalled");
 540
 541                         co.Abort ();
 542                         Assert.AreEqual (0, opening, "opening-b");
 543                         Assert.AreEqual (0, opened, "opened-b");
 544                         Assert.AreEqual (1, closing, "closing-c");
 545                         Assert.AreEqual (1, closed, "closed-c");
 546                 }
 547
 548                 [TestMethod]
 549 #if MOBILE
 550                 [MoonlightBug]
 551 #else
 552                 [NUnit.Framework.Ignore]
 553 #endif
 554                 public void Create_Fault_Open_Close ()
 555                 {
 556                         int opening = 0;
 557                         int opened = 0;
 558                         int closing = 0;
 559                         int closed = 0;
 560                         int faulted = 0;
 561
 562                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 563                         co.Faulted += delegate (object sender, EventArgs e) {
 564                                 faulted++;
 565                                 Assert.AreEqual (CommunicationState.Faulted, co.State, "State/Faulted");
 566                                 Assert.AreSame (co, sender, "sender");
 567                                 Assert.AreSame (EventArgs.Empty, e, "e");
 568                         };
 569                         co.Opening += delegate (object sender, EventArgs e) {
 570                                 opening++;
 571                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 572                                 Assert.AreSame (co, sender, "Opening/sender");
 573                                 Assert.AreSame (EventArgs.Empty, e, "Opening/e");
 574                         };
 575                         co.Opened += delegate (object sender, EventArgs e) {
 576                                 opened++;
 577                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 578                                 Assert.AreSame (co, sender, "Opened/sender");
 579                                 Assert.AreSame (EventArgs.Empty, e, "Opened/e");
 580                         };
 581                         co.Closing += delegate (object sender, EventArgs e) {
 582                                 closing++;
 583                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 584                                 Assert.AreSame (co, sender, "Closing/sender");
 585                                 Assert.AreSame (EventArgs.Empty, e, "Closing/e");
 586                         };
 587                         co.Closed += delegate (object sender, EventArgs e) {
 588                                 closed++;
 589                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 590                                 Assert.AreSame (co, sender, "Closed/sender");
 591                                 Assert.AreSame (EventArgs.Empty, e, "Closed/e");
 592                         };
 593
 594                         Assert.AreEqual (CommunicationState.Created, co.State, "State/before");
 595
 596                         co._Fault ();
 597                         Assert.AreEqual (0, opening, "opening");
 598                         Assert.AreEqual (0, opened, "opened");
 599                         Assert.AreEqual (0, closing, "closing");
 600                         Assert.AreEqual (0, closed, "closed");
 601                         Assert.AreEqual (1, faulted, "faulted");
 602
 603                         Assert.AreEqual (CommunicationState.Faulted, co.State, "State/after");
 604                         Assert.IsFalse (co.Disposed, "IsDisposed");
 605
 606                         // 2nd fault does not throw a CommunicationObjectFaultedException
 607                         // nor does it raise Faulted again
 608                         co._Fault ();
 609                         Assert.AreEqual (1, faulted, "faulted(same)");
 610
 611                         Assert.IsFalse (co.DefaultCloseTimeoutCalled, "DefaultCloseTimeoutCalled");
 612                         Assert.IsFalse (co.DefaultOpenTimeoutCalled, "DefaultOpenTimeoutCalled");
 613                         Assert.IsFalse (co.OnAbortCalled, "OnAbortCalled");
 614
 615                         Assert.IsFalse (co.OnBeginCloseCalled, "OnBeginCloseCalled");
 616                         Assert.IsFalse (co.OnCloseCalled, "OnCloseCalled");
 617                         Assert.IsFalse (co.OnEndCloseCalled, "OnEndCloseCalled");
 618
 619                         Assert.IsFalse (co.OnBeginOpenCalled, "OnBeginOpenCalled");
 620                         Assert.IsFalse (co.OnOpenCalled, "OnOpenCalled");
 621                         Assert.IsFalse (co.OnEndOpenCalled, "OnEndCloseCalled");
 622
 623                         Assert.Throws<CommunicationObjectFaultedException> (delegate {
 624                                 co.Open ();
 625                         }, "Open");
 626                         Assert.AreEqual (0, opening, "opening-b");
 627                         Assert.AreEqual (0, opened, "opened-b");
 628                         Assert.AreEqual (CommunicationState.Faulted, co.State, "State/Open");
 629
 630                         // calling Close on an Faulted instance will call OnAbort (not OnClose)
 631                         co.OnAbortState = CommunicationState.Closing;
 632                         Assert.IsFalse (co.OnAbortCalled, "OnAbortCalled/before");
 633                         Assert.Throws<CommunicationObjectFaultedException> (delegate {
 634                                 co.Close ();
 635                         }, "Close");
 636                         Assert.IsTrue (co.OnAbortCalled, "OnAbortCalled/after");
 637                         Assert.IsFalse (co.OnCloseCalled, "OnCloseCalled/after");
 638                         Assert.AreEqual (1, closing, "closing-c");
 639                         Assert.AreEqual (1, closed, "closed-c");
 640                         Assert.AreEqual (CommunicationState.Closed, co.State, "State/Close");
 641                 }
 642
 643                 [TestMethod]
 644 #if MOBILE
 645                 [MoonlightBug]
 646 #else
 647                 [NUnit.Framework.Ignore]
 648 #endif
 649                 public void Create_Fault_Open_Abort_Close ()
 650                 {
 651                         int opening = 0;
 652                         int opened = 0;
 653                         int closing = 0;
 654                         int closed = 0;
 655                         int faulted = 0;
 656
 657                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 658                         co.Faulted += delegate (object sender, EventArgs e) {
 659                                 faulted++;
 660                                 Assert.AreEqual (CommunicationState.Faulted, co.State, "State/Faulted");
 661                                 Assert.AreSame (co, sender, "sender");
 662                                 Assert.AreSame (EventArgs.Empty, e, "e");
 663                         };
 664                         co.Opening += delegate (object sender, EventArgs e) {
 665                                 opening++;
 666                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 667                                 Assert.AreSame (co, sender, "Opening/sender");
 668                                 Assert.AreSame (EventArgs.Empty, e, "Opening/e");
 669                         };
 670                         co.Opened += delegate (object sender, EventArgs e) {
 671                                 opened++;
 672                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 673                                 Assert.AreSame (co, sender, "Opened/sender");
 674                                 Assert.AreSame (EventArgs.Empty, e, "Opened/e");
 675                         };
 676                         co.Closing += delegate (object sender, EventArgs e) {
 677                                 closing++;
 678                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 679                                 Assert.AreSame (co, sender, "Closing/sender");
 680                                 Assert.AreSame (EventArgs.Empty, e, "Closing/e");
 681                         };
 682                         co.Closed += delegate (object sender, EventArgs e) {
 683                                 closed++;
 684                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 685                                 Assert.AreSame (co, sender, "Closed/sender");
 686                                 Assert.AreSame (EventArgs.Empty, e, "Closed/e");
 687                         };
 688
 689                         Assert.AreEqual (CommunicationState.Created, co.State, "State/before");
 690
 691                         co._Fault ();
 692                         Assert.AreEqual (0, opening, "opening");
 693                         Assert.AreEqual (0, opened, "opened");
 694                         Assert.AreEqual (0, closing, "closing");
 695                         Assert.AreEqual (0, closed, "closed");
 696                         Assert.AreEqual (1, faulted, "faulted");
 697
 698                         Assert.AreEqual (CommunicationState.Faulted, co.State, "State/after");
 699                         Assert.IsFalse (co.Disposed, "IsDisposed");
 700
 701                         // 2nd fault does not throw a CommunicationObjectFaultedException
 702                         // nor does it raise Faulted again
 703                         co._Fault ();
 704                         Assert.AreEqual (1, faulted, "faulted(same)");
 705
 706                         Assert.IsFalse (co.DefaultCloseTimeoutCalled, "DefaultCloseTimeoutCalled");
 707                         Assert.IsFalse (co.DefaultOpenTimeoutCalled, "DefaultOpenTimeoutCalled");
 708                         Assert.IsFalse (co.OnAbortCalled, "OnAbortCalled");
 709
 710                         Assert.IsFalse (co.OnBeginCloseCalled, "OnBeginCloseCalled");
 711                         Assert.IsFalse (co.OnCloseCalled, "OnCloseCalled");
 712                         Assert.IsFalse (co.OnEndCloseCalled, "OnEndCloseCalled");
 713
 714                         Assert.IsFalse (co.OnBeginOpenCalled, "OnBeginOpenCalled");
 715                         Assert.IsFalse (co.OnOpenCalled, "OnOpenCalled");
 716                         Assert.IsFalse (co.OnEndOpenCalled, "OnEndCloseCalled");
 717
 718                         Assert.Throws<CommunicationObjectFaultedException> (delegate {
 719                                 co.Open ();
 720                         }, "Open");
 721                         Assert.AreEqual (0, opening, "opening-b");
 722                         Assert.AreEqual (0, opened, "opened-b");
 723
 724                         co.OnAbortState = CommunicationState.Closing;
 725                         // Abort does not throw a CommunicationObjectFaultedException
 726                         co.Abort ();
 727                         Assert.AreEqual (1, closing, "closing-b");
 728                         Assert.AreEqual (1, closed, "closed-b");
 729
 730                         co.Close ();
 731                         Assert.AreEqual (1, closing, "closing-c");
 732                         Assert.AreEqual (1, closed, "closed-c");
 733                 }
 734
 735                 [TestMethod]
 736 #if MOBILE
 737                 [MoonlightBug]
 738 #else
 739                 [NUnit.Framework.Ignore]
 740 #endif
 741                 public void Create_Open_Open ()
 742                 {
 743                         int opening = 0;
 744                         int opened = 0;
 745
 746                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 747                         co.Opening += delegate (object sender, EventArgs e) {
 748                                 opening++;
 749                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 750                                 Assert.AreSame (co, sender, "Opening/sender");
 751                                 Assert.AreSame (EventArgs.Empty, e, "Opening/e");
 752                         };
 753                         co.Opened += delegate (object sender, EventArgs e) {
 754                                 opened++;
 755                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 756                                 Assert.AreSame (co, sender, "Opened/sender");
 757                                 Assert.AreSame (EventArgs.Empty, e, "Opened/e");
 758                         };
 759
 760                         co.Open ();
 761                         Assert.AreEqual (1, opening, "opening");
 762                         Assert.AreEqual (1, opened, "opened");
 763                         Assert.AreEqual (CommunicationState.Opened, co.State, "State/after/open");
 764                         Assert.IsFalse (co.Disposed, "IsDisposed/open");
 765
 766                         Assert.Throws<InvalidOperationException> (delegate {
 767                                 co.Open ();
 768                         }, "Open/2");
 769                         Assert.AreEqual (1, opening, "opening-b");
 770                         Assert.AreEqual (1, opened, "openedg-b");
 771                         Assert.AreEqual (CommunicationState.Opened, co.State, "State/after/openg-b");
 772                         Assert.IsFalse (co.Disposed, "IsDisposed/openg-b");
 773                 }
 774
 775
 776                 // http://msdn.microsoft.com/en-us/library/ms789041.aspx
 777                 // ThrowIfDisposed throws an exception if the state is Closing, Closed or Faulted.
 778
 779                 [TestMethod]
 780 #if MOBILE
 781                 [MoonlightBug]
 782 #else
 783                 [NUnit.Framework.Ignore]
 784 #endif
 785                 public void ThrowIfDisposed_Open_Close ()
 786                 {
 787                         bool opening = false;
 788                         bool opened = false;
 789                         bool closing = false;
 790                         bool closed = false;
 791                         bool faulted = false;
 792
 793                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 794
 795                         co.Opening += delegate (object sender, EventArgs e) {
 796                                 opening = true;
 797                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 798                                 co._ThrowIfDisposed ();
 799                         };
 800                         co.Opened += delegate (object sender, EventArgs e) {
 801                                 opened = true;
 802                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 803                                 co._ThrowIfDisposed ();
 804                         };
 805                         co.Closing += delegate (object sender, EventArgs e) {
 806                                 closing = true;
 807                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 808                                 Assert.Throws<ObjectDisposedException> (delegate {
 809                                         co._ThrowIfDisposed ();
 810                                 }, "ThrowIfDisposed/Closing");
 811                         };
 812                         co.Closed += delegate (object sender, EventArgs e) {
 813                                 closed = true;
 814                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 815                                 Assert.Throws<ObjectDisposedException> (delegate {
 816                                         co._ThrowIfDisposed ();
 817                                 }, "ThrowIfDisposed/Closed");
 818                         };
 819                         co.Faulted += delegate (object sender, EventArgs e) {
 820                                 faulted = true;
 821                                 Assert.AreEqual (CommunicationState.Faulted, co.State, "Faulted/State");
 822                                 Assert.Throws<CommunicationObjectFaultedException> (delegate {
 823                                         co._ThrowIfDisposed ();
 824                                 }, "ThrowIfDisposed/Faulted");
 825                         };
 826
 827                         Assert.AreEqual (CommunicationState.Created, co.State, "Created");
 828                         co._ThrowIfDisposed ();
 829
 830                         co.Open ();
 831
 832                         co.Close ();
 833
 834                         co._FaultNoAssert ();
 835
 836                         // ensure all states were tested
 837                         Assert.IsTrue (opening, "opening");
 838                         Assert.IsTrue (opened, "opened");
 839                         Assert.IsTrue (closing, "closing");
 840                         Assert.IsTrue (closed, "closing");
 841                         Assert.IsFalse (faulted, "faulted");
 842                 }
 843
 844
 845                 [TestMethod]
 846 #if MOBILE
 847                 [MoonlightBug]
 848 #else
 849                 [NUnit.Framework.Ignore]
 850 #endif
 851                 public void ThrowIfDisposed_Fault_Abort ()
 852                 {
 853                         bool opening = false;
 854                         bool opened = false;
 855                         bool closing = false;
 856                         bool closed = false;
 857                         bool faulted = false;
 858
 859                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 860
 861                         co.Opening += delegate (object sender, EventArgs e) {
 862                                 opening = true;
 863                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 864                                 co._ThrowIfDisposed ();
 865                         };
 866                         co.Opened += delegate (object sender, EventArgs e) {
 867                                 opened = true;
 868                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 869                                 co._ThrowIfDisposed ();
 870                         };
 871                         co.Closing += delegate (object sender, EventArgs e) {
 872                                 closing = true;
 873                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 874                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 875                                         co._ThrowIfDisposed ();
 876                                 }, "ThrowIfDisposed/Closing");
 877                         };
 878                         co.Closed += delegate (object sender, EventArgs e) {
 879                                 closed = true;
 880                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 881                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
 882                                         co._ThrowIfDisposed ();
 883                                 }, "ThrowIfDisposed/Closed");
 884                         };
 885                         co.Faulted += delegate (object sender, EventArgs e) {
 886                                 faulted = true;
 887                                 Assert.AreEqual (CommunicationState.Faulted, co.State, "Faulted/State");
 888                                 Assert.Throws<CommunicationObjectFaultedException> (delegate {
 889                                         co._ThrowIfDisposed ();
 890                                 }, "ThrowIfDisposed/Faulted");
 891                         };
 892
 893                         Assert.AreEqual (CommunicationState.Created, co.State, "Created");
 894                         co._ThrowIfDisposed ();
 895
 896                         co._FaultNoAssert ();
 897
 898                         co.OnAbortState = CommunicationState.Closing;
 899                         co.Abort ();
 900
 901                         // ensure all states were tested
 902                         Assert.IsFalse (opening, "opening");
 903                         Assert.IsFalse (opened, "opened");
 904                         Assert.IsTrue (closing, "closing");
 905                         Assert.IsTrue (closed, "closing");
 906                         Assert.IsTrue (faulted, "faulted");
 907                 }
 908
 909                 // http://msdn.microsoft.com/en-us/library/ms789041.aspx
 910                 // ThrowIfDisposedOrImmutable throws an exception if the state is not Created.
 911
 912                 [TestMethod]
 913 #if MOBILE
 914                 [MoonlightBug]
 915 #else
 916                 [NUnit.Framework.Ignore]
 917 #endif
 918                 public void ThrowIfDisposedOrImmutable_Open_Close ()
 919                 {
 920                         bool opening = false;
 921                         bool opened = false;
 922                         bool closing = false;
 923                         bool closed = false;
 924                         bool faulted = false;
 925
 926                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 927
 928                         co.Opening += delegate (object sender, EventArgs e) {
 929                                 opening = true;
 930                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
 931                                 Assert.Throws<InvalidOperationException> (delegate {
 932                                         co._ThrowIfDisposedOrImmutable ();
 933                                 }, "ThrowIfDisposedOrImmutable/Opening");
 934                         };
 935                         co.Opened += delegate (object sender, EventArgs e) {
 936                                 opened = true;
 937                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
 938                                 Assert.Throws<InvalidOperationException> (delegate {
 939                                         co._ThrowIfDisposedOrImmutable ();
 940                                 }, "ThrowIfDisposedOrImmutable/Opened");
 941                         };
 942                         co.Closing += delegate (object sender, EventArgs e) {
 943                                 closing = true;
 944                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
 945                                 Assert.Throws<ObjectDisposedException> (delegate {
 946                                         co._ThrowIfDisposedOrImmutable ();
 947                                 }, "ThrowIfDisposedOrImmutable/Closing");
 948                         };
 949                         co.Closed += delegate (object sender, EventArgs e) {
 950                                 closed = true;
 951                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
 952                                 Assert.Throws<ObjectDisposedException> (delegate {
 953                                         co._ThrowIfDisposedOrImmutable ();
 954                                 }, "ThrowIfDisposedOrImmutable/Closed");
 955                         };
 956                         co.Faulted += delegate (object sender, EventArgs e) {
 957                                 faulted = true;
 958                                 Assert.AreEqual (CommunicationState.Faulted, co.State, "Faulted/State");
 959                                 Assert.Throws<CommunicationObjectFaultedException> (delegate {
 960                                         co._ThrowIfDisposedOrImmutable ();
 961                                 }, "ThrowIfDisposedOrImmutable/Faulted");
 962                         };
 963
 964                         Assert.AreEqual (CommunicationState.Created, co.State, "Created");
 965                         co._ThrowIfDisposedOrImmutable ();
 966
 967                         co.Open ();
 968
 969                         co.Close ();
 970
 971                         co._FaultNoAssert ();
 972
 973                         // ensure all states were tested
 974                         Assert.IsTrue (opening, "opening");
 975                         Assert.IsTrue (opened, "opened");
 976                         Assert.IsTrue (closing, "closing");
 977                         Assert.IsTrue (closed, "closing");
 978                         Assert.IsFalse (faulted, "faulted");
 979                 }
 980
 981                 [TestMethod]
 982 #if MOBILE
 983                 [MoonlightBug]
 984 #else
 985                 [NUnit.Framework.Ignore]
 986 #endif
 987                 public void ThrowIfDisposedOrImmutable_Fault_Abort ()
 988                 {
 989                         bool opening = false;
 990                         bool opened = false;
 991                         bool closing = false;
 992                         bool closed = false;
 993                         bool faulted = false;
 994
 995                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
 996
 997                         co.Opening += delegate (object sender, EventArgs e) {
 998                                 opening = true;
 999                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
1000                                 Assert.Throws<ObjectDisposedException> (delegate {
1001                                         co._ThrowIfDisposedOrImmutable ();
1002                                 }, "ThrowIfDisposedOrImmutable/Opening");
1003                         };
1004                         co.Opened += delegate (object sender, EventArgs e) {
1005                                 opened = true;
1006                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
1007                                 Assert.Throws<ObjectDisposedException> (delegate {
1008                                         co._ThrowIfDisposedOrImmutable ();
1009                                 }, "ThrowIfDisposedOrImmutable/Opened");
1010                         };
1011                         co.Closing += delegate (object sender, EventArgs e) {
1012                                 closing = true;
1013                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
1014                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
1015                                         co._ThrowIfDisposedOrImmutable ();
1016                                 }, "ThrowIfDisposedOrImmutable/Closing");
1017                         };
1018                         co.Closed += delegate (object sender, EventArgs e) {
1019                                 closed = true;
1020                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
1021                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
1022                                         co._ThrowIfDisposedOrImmutable ();
1023                                 }, "ThrowIfDisposedOrImmutable/Closed");
1024                         };
1025                         co.Faulted += delegate (object sender, EventArgs e) {
1026                                 faulted = true;
1027                                 Assert.AreEqual (CommunicationState.Faulted, co.State, "Faulted/State");
1028                                 Assert.Throws<CommunicationObjectFaultedException> (delegate {
1029                                         co._ThrowIfDisposedOrImmutable ();
1030                                 }, "ThrowIfDisposedOrImmutable/Faulted");
1031                         };
1032
1033                         Assert.AreEqual (CommunicationState.Created, co.State, "Created");
1034                         co._ThrowIfDisposedOrImmutable ();
1035
1036                         co._FaultNoAssert ();
1037
1038                         co.OnAbortState = CommunicationState.Closing;
1039                         co.Abort ();
1040
1041                         // ensure all states were tested
1042                         Assert.IsFalse (opening, "opening");
1043                         Assert.IsFalse (opened, "opened");
1044                         Assert.IsTrue (closing, "closing");
1045                         Assert.IsTrue (closed, "closing");
1046                         Assert.IsTrue (faulted, "faulted");
1047                 }
1048
1049                 // http://msdn.microsoft.com/en-us/library/ms789041.aspx
1050                 // ThrowIfDisposedOrNotOpen throws an exception if the state is not Opened.
1051
1052                 [TestMethod]
1053 #if MOBILE
1054                 [MoonlightBug]
1055 #else
1056                 [NUnit.Framework.Ignore]
1057 #endif
1058                 public void ThrowIfDisposedOrNotOpen_Open_Close ()
1059                 {
1060                         bool opening = false;
1061                         bool opened = false;
1062                         bool closing = false;
1063                         bool closed = false;
1064                         bool faulted = false;
1065
1066                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
1067
1068                         co.Opening += delegate (object sender, EventArgs e) {
1069                                 opening = true;
1070                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
1071                                 Assert.Throws<InvalidOperationException> (delegate {
1072                                         co._ThrowIfDisposedOrNotOpen ();
1073                                 }, "ThrowIfDisposedOrNotOpen/Opening");
1074                         };
1075                         co.Opened += delegate (object sender, EventArgs e) {
1076                                 opened = true;
1077                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
1078                                 co._ThrowIfDisposedOrNotOpen ();
1079                         };
1080                         co.Closing += delegate (object sender, EventArgs e) {
1081                                 closing = true;
1082                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
1083                                 Assert.Throws<ObjectDisposedException> (delegate {
1084                                         co._ThrowIfDisposedOrNotOpen ();
1085                                 }, "ThrowIfDisposedOrNotOpen/Closing");
1086                         };
1087                         co.Closed += delegate (object sender, EventArgs e) {
1088                                 closed = true;
1089                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
1090                                 Assert.Throws<ObjectDisposedException> (delegate {
1091                                         co._ThrowIfDisposedOrNotOpen ();
1092                                 }, "ThrowIfDisposedOrNotOpen/Closed");
1093                         };
1094                         co.Faulted += delegate (object sender, EventArgs e) {
1095                                 faulted = true;
1096                                 Assert.AreEqual (CommunicationState.Faulted, co.State, "Faulted/State");
1097                                 Assert.Throws<CommunicationObjectFaultedException> (delegate {
1098                                         co._ThrowIfDisposedOrNotOpen ();
1099                                 }, "ThrowIfDisposedOrNotOpen/Faulted");
1100                         };
1101
1102                         Assert.AreEqual (CommunicationState.Created, co.State, "Created");
1103                         Assert.Throws<InvalidOperationException> (delegate {
1104                                 co._ThrowIfDisposedOrNotOpen ();
1105                         }, "ThrowIfDisposedOrNotOpen/Created");
1106
1107                         co.Open ();
1108
1109                         co.Close ();
1110
1111                         co._FaultNoAssert ();
1112
1113                         // ensure all states were tested
1114                         Assert.IsTrue (opening, "opening");
1115                         Assert.IsTrue (opened, "opened");
1116                         Assert.IsTrue (closing, "closing");
1117                         Assert.IsTrue (closed, "closing");
1118                         Assert.IsFalse (faulted, "faulted");
1119                 }
1120
1121                 [TestMethod]
1122 #if MOBILE
1123                 [MoonlightBug]
1124 #else
1125                 [NUnit.Framework.Ignore]
1126 #endif
1127                 public void ThrowIfDisposedOrNotOpen_Fault_Abort ()
1128                 {
1129                         bool opening = false;
1130                         bool opened = false;
1131                         bool closing = false;
1132                         bool closed = false;
1133                         bool faulted = false;
1134
1135                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
1136
1137                         co.Opening += delegate (object sender, EventArgs e) {
1138                                 opening = true;
1139                                 Assert.AreEqual (CommunicationState.Opening, co.State, "Opening/State");
1140                                 Assert.Throws<ObjectDisposedException> (delegate {
1141                                         co._ThrowIfDisposedOrNotOpen ();
1142                                 }, "ThrowIfDisposedOrNotOpen/Opening");
1143                         };
1144                         co.Opened += delegate (object sender, EventArgs e) {
1145                                 opened = true;
1146                                 Assert.AreEqual (CommunicationState.Opened, co.State, "Opened/State");
1147                                 co._ThrowIfDisposedOrNotOpen ();
1148                         };
1149                         co.Closing += delegate (object sender, EventArgs e) {
1150                                 closing = true;
1151                                 Assert.AreEqual (CommunicationState.Closing, co.State, "Closing/State");
1152                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
1153                                         co._ThrowIfDisposedOrNotOpen ();
1154                                 }, "ThrowIfDisposedOrNotOpen/Closing");
1155                         };
1156                         co.Closed += delegate (object sender, EventArgs e) {
1157                                 closed = true;
1158                                 Assert.AreEqual (CommunicationState.Closed, co.State, "Closed/State");
1159                                 Assert.Throws<CommunicationObjectAbortedException> (delegate {
1160                                         co._ThrowIfDisposedOrNotOpen ();
1161                                 }, "ThrowIfDisposedOrNotOpen/Closed");
1162                         };
1163                         co.Faulted += delegate (object sender, EventArgs e) {
1164                                 faulted = true;
1165                                 Assert.AreEqual (CommunicationState.Faulted, co.State, "Faulted/State");
1166                                 Assert.Throws<CommunicationObjectFaultedException> (delegate {
1167                                         co._ThrowIfDisposedOrNotOpen ();
1168                                 }, "ThrowIfDisposedOrNotOpen/Faulted");
1169                         };
1170
1171                         Assert.AreEqual (CommunicationState.Created, co.State, "Created");
1172                         Assert.Throws<InvalidOperationException> (delegate {
1173                                 co._ThrowIfDisposedOrNotOpen ();
1174                         }, "ThrowIfDisposedOrNotOpen/Created");
1175
1176                         co._FaultNoAssert ();
1177
1178                         co.OnAbortState = CommunicationState.Closing;
1179                         co.Abort ();
1180
1181                         // ensure all states were tested
1182                         Assert.IsFalse (opening, "opening");
1183                         Assert.IsFalse (opened, "opened");
1184                         Assert.IsTrue (closing, "closing");
1185                         Assert.IsTrue (closed, "closing");
1186                         Assert.IsTrue (faulted, "faulted");
1187                 }
1188
1189                 class NoFaultCommunicationObject : CommunicationObjectPoker {
1190
1191                         protected override void OnFaulted ()
1192                         {
1193                                 Assert.AreEqual (CommunicationState.Faulted, State, "OnFaulted/State");
1194                                 // base not called - Faulted won't be raised
1195                         }
1196                 }
1197
1198                 [TestMethod]
1199 #if MOBILE
1200                 [MoonlightBug]
1201 #else
1202                 [NUnit.Framework.Ignore]
1203 #endif
1204                 public void NoOnFault ()
1205                 {
1206                         bool faulted = false;
1207                         NoFaultCommunicationObject co = new NoFaultCommunicationObject ();
1208                         co.Faulted += delegate (object sender, EventArgs e) {
1209                                 faulted = true;
1210                         };
1211                         co._FaultNoAssert ();
1212                         Assert.AreEqual (CommunicationState.Faulted, co.State, "State");
1213                         Assert.IsFalse (faulted, "faulted");
1214                 }
1215
1216                 class FaultCommunicationObject : CommunicationObjectPoker {
1217
1218                         protected override void OnFaulted ()
1219                         {
1220                                 base.OnFaulted ();
1221                                 throw new NotFiniteNumberException ();
1222                         }
1223                 }
1224
1225                 [TestMethod]
1226 #if MOBILE
1227                 [MoonlightBug]
1228 #else
1229                 [NUnit.Framework.Ignore]
1230 #endif
1231                 public void OnFaultThrowing ()
1232                 {
1233                         FaultCommunicationObject co = new FaultCommunicationObject ();
1234                         Assert.Throws<NotFiniteNumberException> (delegate {
1235                                 co._FaultNoAssert ();
1236                         }, "Fault");
1237                         // OnFault is not called more than one time
1238                         co._FaultNoAssert ();
1239                 }
1240
1241                 [TestMethod]
1242 #if MOBILE
1243                 [MoonlightBug]
1244 #else
1245                 [NUnit.Framework.Ignore]
1246 #endif
1247                 public void AbortWhileAborting ()
1248                 {
1249                         int closing = 0;
1250                         int closed = 0;
1251                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
1252                         co.Closing += delegate (object sender, EventArgs e) {
1253                                 closing++;
1254                                 co.OnAbortState = CommunicationState.Closing;
1255                                 co.Abort ();
1256                         };
1257                         co.Closed += delegate (object sender, EventArgs e) {
1258                                 closed++;
1259                                 co.Abort ();
1260                         };
1261                         co.OnAbortState = CommunicationState.Created;
1262                         // Abort will call Closing, which can call Abort...
1263                         co.Abort ();
1264
1265                         Assert.AreEqual (1, closing, "closing");
1266                         Assert.AreEqual (1, closed, "closed");
1267                 }
1268
1269                 [TestMethod]
1270 #if MOBILE
1271                 [MoonlightBug]
1272 #else
1273                 [NUnit.Framework.Ignore]
1274 #endif
1275                 public void AbortWhileClosing ()
1276                 {
1277                         int closing = 0;
1278                         int closed = 0;
1279                         CommunicationObjectPoker co = new CommunicationObjectPoker ();
1280                         co.Closing += delegate (object sender, EventArgs e) {
1281                                 closing++;
1282                                 co.OnAbortState = CommunicationState.Closing;
1283                                 // ensure we're not repeating OnClosing
1284                                 co.Abort ();
1285                         };
1286                         co.Closed += delegate (object sender, EventArgs e) {
1287                                 closed++;
1288                                 co.Abort ();
1289                         };
1290                         co.Close ();
1291
1292                         Assert.AreEqual (1, closing, "closing");
1293                         Assert.AreEqual (1, closed, "closed");
1294                 }
1295
1296                 class NoAbortCommunicationObject : CommunicationObjectPoker {
1297
1298                         protected override void OnAbort ()
1299                         {
1300                                 Assert.AreEqual (CommunicationState.Closing, State, "OnAbort/State");
1301                                 // base not called
1302                         }
1303                 }
1304
1305                 [TestMethod]
1306 #if MOBILE
1307                 [MoonlightBug]
1308 #else
1309                 [NUnit.Framework.Ignore]
1310 #endif
1311                 public void NoOnAbort ()
1312                 {
1313                         bool closing = false;
1314                         bool closed = false;
1315                         NoAbortCommunicationObject co = new NoAbortCommunicationObject ();
1316                         co.Closing += delegate (object sender, EventArgs e) {
1317                                 closing = true;
1318                         };
1319                         co.Closed += delegate (object sender, EventArgs e) {
1320                                 closed = true;
1321                         };
1322                         co.Abort ();
1323                         Assert.AreEqual (CommunicationState.Closed, co.State, "State");
1324                         Assert.IsTrue (closing, "closing");
1325                         Assert.IsTrue (closed, "closed");
1326                 }
1327         }
1328 }
1329