mcs/class/System.Core/Test/System.Threading/ReaderWriterLockSlimTest.cs

   1 //
   2 // ReaderWriterLockSlimTest.cs
   3 //
   4 // Authors:
   5 //      Marek Safar (marek.safar@gmail.com)
   6 //
   7 // Copyright (C) 2009 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 using NUnit.Framework;
  31 using System.Threading;
  32 using System.Linq;
  33
  34 namespace MonoTests.System.Threading
  35 {
  36         [TestFixture]
  37         public class ReaderWriterLockSlim2Test
  38         {
  39                 [Test]
  40                 public void DefaultValues ()
  41                 {
  42                         var v = new ReaderWriterLockSlim ();
  43                         Assert.AreEqual (0, v.CurrentReadCount, "1");
  44                         Assert.AreEqual (false, v.IsReadLockHeld, "2");
  45                         Assert.AreEqual (false, v.IsUpgradeableReadLockHeld, "3");
  46                         Assert.AreEqual (false, v.IsWriteLockHeld, "4");
  47                         Assert.AreEqual (LockRecursionPolicy.NoRecursion, v.RecursionPolicy, "5");
  48                         Assert.AreEqual (0, v.RecursiveReadCount, "6");
  49                         Assert.AreEqual (0, v.RecursiveUpgradeCount, "7");
  50                         Assert.AreEqual (0, v.RecursiveWriteCount, "8");
  51                         Assert.AreEqual (0, v.WaitingReadCount, "9");
  52                         Assert.AreEqual (0, v.WaitingUpgradeCount, "10");
  53                         Assert.AreEqual (0, v.WaitingWriteCount, "11");
  54                 }
  55
  56                 [Test]
  57                 public void Dispose_Errors ()
  58                 {
  59                         var v = new ReaderWriterLockSlim ();
  60                         v.Dispose ();
  61
  62                         try {
  63                                 v.EnterUpgradeableReadLock ();
  64                                 Assert.Fail ("1");
  65                         } catch (ObjectDisposedException) {
  66                         }
  67
  68                         try {
  69                                 v.EnterReadLock ();
  70                                 Assert.Fail ("2");
  71                         } catch (ObjectDisposedException) {
  72                         }
  73
  74                         try {
  75                                 v.EnterWriteLock ();
  76                                 Assert.Fail ("3");
  77                         } catch (ObjectDisposedException) {
  78                         }
  79                 }
  80
  81                 [Test]
  82                 public void TryEnterReadLock_OutOfRange ()
  83                 {
  84                         var v = new ReaderWriterLockSlim ();
  85                         try {
  86                                 v.TryEnterReadLock (-2);
  87                                 Assert.Fail ("1");
  88                         } catch (ArgumentOutOfRangeException) {
  89                         }
  90
  91                         try {
  92                                 v.TryEnterReadLock (TimeSpan.MaxValue);
  93                                 Assert.Fail ("2");
  94                         } catch (ArgumentOutOfRangeException) {
  95                         }
  96
  97                         try {
  98                                 v.TryEnterReadLock (TimeSpan.MinValue);
  99                                 Assert.Fail ("3");
 100                         } catch (ArgumentOutOfRangeException) {
 101                         }
 102                 }
 103
 104                 [Test]
 105                 public void TryEnterUpgradeableReadLock_OutOfRange ()
 106                 {
 107                         var v = new ReaderWriterLockSlim ();
 108                         try {
 109                                 v.TryEnterUpgradeableReadLock (-2);
 110                                 Assert.Fail ("1");
 111                         } catch (ArgumentOutOfRangeException) {
 112                         }
 113
 114                         try {
 115                                 v.TryEnterUpgradeableReadLock (TimeSpan.MaxValue);
 116                                 Assert.Fail ("2");
 117                         } catch (ArgumentOutOfRangeException) {
 118                         }
 119
 120                         try {
 121                                 v.TryEnterUpgradeableReadLock (TimeSpan.MinValue);
 122                                 Assert.Fail ("3");
 123                         } catch (ArgumentOutOfRangeException) {
 124                         }
 125                 }
 126
 127                 [Test]
 128                 public void TryEnterWriteLock_OutOfRange ()
 129                 {
 130                         var v = new ReaderWriterLockSlim ();
 131                         try {
 132                                 v.TryEnterWriteLock (-2);
 133                                 Assert.Fail ("1");
 134                         } catch (ArgumentOutOfRangeException) {
 135                         }
 136
 137                         try {
 138                                 v.TryEnterWriteLock (TimeSpan.MaxValue);
 139                                 Assert.Fail ("2");
 140                         } catch (ArgumentOutOfRangeException) {
 141                         }
 142
 143                         try {
 144                                 v.TryEnterWriteLock (TimeSpan.MinValue);
 145                                 Assert.Fail ("3");
 146                         } catch (ArgumentOutOfRangeException) {
 147                         }
 148                 }
 149
 150                 [Test, ExpectedException (typeof (SynchronizationLockException))]
 151                 public void ExitReadLock ()
 152                 {
 153                         var v = new ReaderWriterLockSlim ();
 154                         v.ExitReadLock ();
 155                 }
 156
 157                 [Test, ExpectedException (typeof (SynchronizationLockException))]
 158                 public void ExitWriteLock ()
 159                 {
 160                         var v = new ReaderWriterLockSlim ();
 161                         v.ExitWriteLock ();
 162                 }
 163
 164                 [Test]
 165                 public void EnterReadLock_NoRecursionError ()
 166                 {
 167                         var v = new ReaderWriterLockSlim ();
 168                         v.EnterReadLock ();
 169                         Assert.AreEqual (1, v.RecursiveReadCount);
 170
 171                         try {
 172                                 v.EnterReadLock ();
 173                                 Assert.Fail ("1");
 174                         } catch (LockRecursionException) {
 175                         }
 176
 177                         try {
 178                                 v.EnterWriteLock ();
 179                                 Assert.Fail ("2");
 180                         } catch (LockRecursionException) {
 181                         }
 182                 }
 183
 184                 [Test]
 185                 public void EnterReadLock ()
 186                 {
 187                         var v = new ReaderWriterLockSlim ();
 188
 189                         v.EnterReadLock ();
 190                         Assert.IsTrue (v.IsReadLockHeld, "A");
 191                         Assert.AreEqual (0, v.RecursiveWriteCount, "A1");
 192                         Assert.AreEqual (1, v.RecursiveReadCount, "A2");
 193                         Assert.AreEqual (0, v.RecursiveUpgradeCount, "A3");
 194                         Assert.AreEqual (0, v.WaitingReadCount, "A4");
 195                         Assert.AreEqual (0, v.WaitingUpgradeCount, "A5");
 196                         Assert.AreEqual (0, v.WaitingWriteCount, "A6");
 197                         v.ExitReadLock ();
 198
 199                         v.EnterReadLock ();
 200                         Assert.IsTrue (v.IsReadLockHeld, "B");
 201                         Assert.AreEqual (0, v.RecursiveWriteCount, "B1");
 202                         Assert.AreEqual (1, v.RecursiveReadCount, "B2");
 203                         Assert.AreEqual (0, v.RecursiveUpgradeCount, "B3");
 204                         Assert.AreEqual (0, v.WaitingReadCount, "B4");
 205                         Assert.AreEqual (0, v.WaitingUpgradeCount, "B5");
 206                         Assert.AreEqual (0, v.WaitingWriteCount, "B6");
 207                         v.ExitReadLock ();
 208                 }
 209
 210                 [Test]
 211                 public void EnterWriteLock_NoRecursionError ()
 212                 {
 213                         var v = new ReaderWriterLockSlim ();
 214                         v.EnterWriteLock ();
 215                         Assert.AreEqual (1, v.RecursiveWriteCount);
 216
 217                         try {
 218                                 v.EnterWriteLock ();
 219                                 Assert.Fail ("1");
 220                         } catch (LockRecursionException) {
 221                         }
 222
 223                         try {
 224                                 v.EnterReadLock ();
 225                                 Assert.Fail ("2");
 226                         } catch (LockRecursionException) {
 227                         }
 228                 }
 229
 230                 [Test]
 231                 public void EnterWriteLock ()
 232                 {
 233                         var v = new ReaderWriterLockSlim ();
 234
 235                         v.EnterWriteLock ();
 236                         Assert.IsTrue (v.IsWriteLockHeld, "A");
 237                         Assert.AreEqual (1, v.RecursiveWriteCount, "A1");
 238                         Assert.AreEqual (0, v.RecursiveReadCount, "A2");
 239                         Assert.AreEqual (0, v.RecursiveUpgradeCount, "A3");
 240                         Assert.AreEqual (0, v.WaitingReadCount, "A4");
 241                         Assert.AreEqual (0, v.WaitingUpgradeCount, "A5");
 242                         Assert.AreEqual (0, v.WaitingWriteCount, "A6");
 243                         v.ExitWriteLock ();
 244
 245                         v.EnterWriteLock ();
 246                         Assert.IsTrue (v.IsWriteLockHeld, "B");
 247                         Assert.AreEqual (1, v.RecursiveWriteCount, "B1");
 248                         Assert.AreEqual (0, v.RecursiveReadCount, "B2");
 249                         Assert.AreEqual (0, v.RecursiveUpgradeCount, "B3");
 250                         Assert.AreEqual (0, v.WaitingReadCount, "B4");
 251                         Assert.AreEqual (0, v.WaitingUpgradeCount, "B5");
 252                         Assert.AreEqual (0, v.WaitingWriteCount, "B6");
 253                         v.ExitWriteLock ();
 254                 }
 255
 256                 [Test]
 257                 public void EnterUpgradeableReadLock_NoRecursionError ()
 258                 {
 259                         var v = new ReaderWriterLockSlim ();
 260                         v.EnterUpgradeableReadLock ();
 261                         Assert.AreEqual (1, v.RecursiveUpgradeCount);
 262
 263                         try {
 264                                 v.EnterUpgradeableReadLock ();
 265                                 Assert.Fail ("2");
 266                         } catch (LockRecursionException) {
 267                         }
 268                 }
 269
 270                 [Test]
 271                 public void EnterUpgradeableReadLock ()
 272                 {
 273                         var v = new ReaderWriterLockSlim ();
 274
 275                         v.EnterUpgradeableReadLock ();
 276                         Assert.IsTrue (v.IsUpgradeableReadLockHeld, "A");
 277                         Assert.AreEqual (0, v.RecursiveWriteCount, "A1");
 278                         Assert.AreEqual (0, v.RecursiveReadCount, "A2");
 279                         Assert.AreEqual (1, v.RecursiveUpgradeCount, "A3");
 280                         Assert.AreEqual (0, v.WaitingReadCount, "A4");
 281                         Assert.AreEqual (0, v.WaitingUpgradeCount, "A5");
 282                         Assert.AreEqual (0, v.WaitingWriteCount, "A6");
 283                         v.ExitUpgradeableReadLock ();
 284
 285                         v.EnterUpgradeableReadLock ();
 286                         Assert.IsTrue (v.IsUpgradeableReadLockHeld, "B");
 287                         Assert.AreEqual (0, v.RecursiveWriteCount, "B1");
 288                         Assert.AreEqual (0, v.RecursiveReadCount, "B2");
 289                         Assert.AreEqual (1, v.RecursiveUpgradeCount, "B3");
 290                         Assert.AreEqual (0, v.WaitingReadCount, "B4");
 291                         Assert.AreEqual (0, v.WaitingUpgradeCount, "B5");
 292                         Assert.AreEqual (0, v.WaitingWriteCount, "B6");
 293
 294                         v.EnterReadLock ();
 295                         v.ExitUpgradeableReadLock ();
 296
 297                         Assert.IsTrue (v.IsReadLockHeld, "C");
 298                         Assert.AreEqual (0, v.RecursiveWriteCount, "C1");
 299                         Assert.AreEqual (1, v.RecursiveReadCount, "C2");
 300                         Assert.AreEqual (0, v.RecursiveUpgradeCount, "C3");
 301                         Assert.AreEqual (0, v.WaitingReadCount, "C4");
 302                         Assert.AreEqual (0, v.WaitingUpgradeCount, "C5");
 303                         Assert.AreEqual (0, v.WaitingWriteCount, "C6");
 304
 305                         v.ExitReadLock ();
 306                 }
 307
 308                 [Test]
 309                 public void EnterReadLock_MultiRead ()
 310                 {
 311                         var v = new ReaderWriterLockSlim ();
 312                         int local = 10;
 313
 314                         var r = from i in Enumerable.Range (1, 30) select new Thread (() => {
 315
 316                                 // Just to cause some contention
 317                                 Thread.Sleep (100);
 318
 319                                 v.EnterReadLock ();
 320
 321                                 Assert.AreEqual (10, local);
 322                         });
 323
 324                         var threads = r.ToList ();
 325
 326                         foreach (var t in threads) {
 327                                 t.Start ();
 328                         }
 329
 330                         foreach (var t in threads) {
 331                                 // Console.WriteLine (t.ThreadState);
 332                                 t.Join ();
 333                         }
 334                 }
 335
 336                 [Test]
 337                 public void TryEnterWriteLock_WhileReading ()
 338                 {
 339                         var v = new ReaderWriterLockSlim ();
 340                         AutoResetEvent ev = new AutoResetEvent (false);
 341                         AutoResetEvent ev2 = new AutoResetEvent (false);
 342
 343                         Thread t1 = new Thread (() => {
 344                                 v.EnterReadLock ();
 345                                 ev2.Set ();
 346                                 ev.WaitOne ();
 347                                 v.ExitReadLock ();
 348                         });
 349
 350                         t1.Start ();
 351                         ev2.WaitOne ();
 352
 353                         Assert.IsFalse (v.TryEnterWriteLock (100));
 354                         Assert.IsFalse (v.TryEnterReadLock (100));
 355                         ev.Set ();
 356
 357                         Assert.IsTrue (v.TryEnterWriteLock (100));
 358                 }
 359
 360                 [Test]
 361                 public void EnterWriteLock_MultiRead ()
 362                 {
 363                         var v = new ReaderWriterLockSlim ();
 364                         int local = 10;
 365
 366                         var r = from i in Enumerable.Range (1, 10) select new Thread (() => {
 367                                 v.EnterReadLock ();
 368
 369                                 Assert.AreEqual (11, local);
 370                         });
 371
 372                         v.EnterWriteLock ();
 373
 374                         var threads = r.ToList ();
 375                         foreach (var t in threads) {
 376                                 t.Start ();
 377                         }
 378
 379                         Thread.Sleep (200);
 380                         local = 11;
 381
 382                         // FIXME: Don't rely on Thread.Sleep (200)
 383                         Assert.AreEqual (0, v.WaitingWriteCount, "in waiting write");
 384                         Assert.AreEqual (10, v.WaitingReadCount, "in waiting read");
 385                         Assert.AreEqual (0, v.WaitingUpgradeCount, "in waiting upgrade");
 386                         v.ExitWriteLock ();
 387
 388                         foreach (var t in threads) {
 389                                 // Console.WriteLine (t.ThreadState);
 390                                 t.Join ();
 391                         }
 392                 }
 393
 394                 [Test]
 395                 public void EnterWriteLock_After_ExitUpgradeableReadLock ()
 396                 {
 397                         var v = new ReaderWriterLockSlim ();
 398
 399                         v.EnterUpgradeableReadLock ();
 400                         Assert.IsTrue (v.TryEnterWriteLock (100));
 401                         v.ExitWriteLock ();
 402                         v.ExitUpgradeableReadLock ();
 403                         Assert.IsTrue (v.TryEnterWriteLock (100));
 404                         v.ExitWriteLock ();
 405                 }
 406
 407                 [Test]
 408                 public void RecursiveReadLockTest ()
 409                 {
 410                         var v = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion);
 411
 412                         Assert.IsTrue (v.TryEnterReadLock (100), "#1");
 413                         Assert.IsTrue (v.TryEnterReadLock (100), "#2");
 414                         Assert.IsTrue (v.TryEnterReadLock (100), "#3");
 415
 416                         Assert.AreEqual (3, v.RecursiveReadCount);
 417                 }
 418
 419                 [Test]
 420                 public void RecursiveReadPlusWriteLockTest ()
 421                 {
 422                         var v = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion);
 423
 424                         try {
 425                                 v.EnterReadLock ();
 426                                 v.EnterWriteLock ();
 427                                 Assert.Fail ("1");
 428                         } catch (LockRecursionException ex) {
 429                                 Assert.IsNotNull (ex, "#1");
 430                         }
 431                 }
 432
 433                 [Test]
 434                 public void RecursiveReadPlusUpgradeableLockTest ()
 435                 {
 436                         var v = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion);
 437
 438                         try {
 439                                 v.EnterReadLock ();
 440                                 v.EnterUpgradeableReadLock ();
 441                                 Assert.Fail ("1");
 442                         } catch (LockRecursionException ex) {
 443                                 Assert.IsNotNull (ex, "#1");
 444                         }
 445                 }
 446
 447                 [Test]
 448                 public void RecursiveWriteLockTest ()
 449                 {
 450                         var v = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion);
 451
 452                         Assert.IsTrue (v.TryEnterWriteLock (100), "#1");
 453                         Assert.IsTrue (v.TryEnterWriteLock (100), "#2");
 454                         Assert.IsTrue (v.TryEnterWriteLock (100), "#3");
 455
 456                         Assert.AreEqual (3, v.RecursiveWriteCount);
 457                 }
 458
 459                 [Test]
 460                 public void RecursiveWritePlusReadLockTest ()
 461                 {
 462                         var v = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion);
 463
 464                         Assert.IsTrue (v.TryEnterWriteLock (100), "#1");
 465                         Assert.AreEqual (1, v.RecursiveWriteCount, "1b");
 466                         Assert.AreEqual (0, v.RecursiveReadCount, "1c");
 467
 468                         Assert.IsTrue (v.TryEnterReadLock (100), "#2");
 469                         Assert.AreEqual (1, v.RecursiveWriteCount, "2b");
 470                         Assert.AreEqual (1, v.RecursiveReadCount, "2c");
 471
 472                         Assert.IsTrue (v.TryEnterReadLock (100), "#3");
 473                         Assert.AreEqual (1, v.RecursiveWriteCount, "3b");
 474                         Assert.AreEqual (2, v.RecursiveReadCount, "3c");
 475
 476                         v.ExitReadLock ();
 477                         Assert.AreEqual (1, v.RecursiveWriteCount, "4b");
 478                         Assert.AreEqual (1, v.RecursiveReadCount, "4c");
 479                 }
 480
 481                 [Test]
 482                 public void RecursiveUpgradeableReadLockTest ()
 483                 {
 484                         var v = new ReaderWriterLockSlim (LockRecursionPolicy.SupportsRecursion);
 485
 486                         Assert.IsTrue (v.TryEnterUpgradeableReadLock (100), "#1");
 487                         Assert.IsTrue (v.TryEnterUpgradeableReadLock (100), "#2");
 488                         Assert.IsTrue (v.TryEnterUpgradeableReadLock (100), "#3");
 489
 490                         Assert.AreEqual (3, v.RecursiveUpgradeCount);
 491                 }
 492         }
 493 }