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                         Assert.IsTrue (v.IsReadLockHeld, "C");
 296                         Assert.AreEqual (0, v.RecursiveWriteCount, "C1");
 297                         Assert.AreEqual (1, v.RecursiveReadCount, "C2");
 298                         Assert.AreEqual (1, v.RecursiveUpgradeCount, "C3");
 299                         Assert.AreEqual (0, v.WaitingReadCount, "C4");
 300                         Assert.AreEqual (0, v.WaitingUpgradeCount, "C5");
 301                         Assert.AreEqual (0, v.WaitingWriteCount, "C6");
 302                         v.ExitReadLock ();
 303
 304                         v.ExitUpgradeableReadLock ();
 305                 }
 306
 307                 [Test]
 308                 public void EnterReadLock_MultiRead ()
 309                 {
 310                         var v = new ReaderWriterLockSlim ();
 311                         int local = 10;
 312
 313                         var r = from i in Enumerable.Range (1, 30) select new Thread (() => {
 314
 315                                 // Just to cause some contention
 316                                 Thread.Sleep (100);
 317
 318                                 v.EnterReadLock ();
 319
 320                                 Assert.AreEqual (10, local);
 321                         });
 322
 323                         var threads = r.ToList ();
 324
 325                         foreach (var t in threads) {
 326                                 t.Start ();
 327                         }
 328
 329                         foreach (var t in threads) {
 330                                 Console.WriteLine (t.ThreadState);
 331                                 t.Join ();
 332                         }
 333                 }
 334
 335                 [Test]
 336                 public void TryEnterWriteLock_WhileReading ()
 337                 {
 338                         var v = new ReaderWriterLockSlim ();
 339                         AutoResetEvent ev = new AutoResetEvent (false);
 340                         AutoResetEvent ev2 = new AutoResetEvent (false);
 341
 342                         Thread t1 = new Thread (() => {
 343                                 v.EnterReadLock ();
 344                                 ev2.Set ();
 345                                 ev.WaitOne ();
 346                                 v.ExitReadLock ();
 347                         });
 348
 349                         t1.Start ();
 350                         ev2.WaitOne ();
 351
 352                         Assert.IsFalse (v.TryEnterWriteLock (100));
 353                         Assert.IsTrue (v.TryEnterReadLock (100));
 354                         ev.Set ();
 355
 356                         v.ExitReadLock ();
 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, 30) 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 (30, v.WaitingReadCount, "in waiting read");
 384
 385                         Assert.AreEqual (0, v.WaitingWriteCount, "in waiting write");
 386                         Assert.AreEqual (0, v.WaitingUpgradeCount, "in waiting upgrade");
 387                         v.ExitWriteLock ();
 388
 389                         foreach (var t in threads) {
 390                                 Console.WriteLine (t.ThreadState);
 391                                 t.Join ();
 392                         }
 393                 }
 394
 395                 [Test]
 396                 public void EnterWriteLock_After_ExitUpgradeableReadLock ()
 397                 {
 398                         var v = new ReaderWriterLockSlim ();
 399
 400                         v.EnterUpgradeableReadLock ();
 401                         Assert.IsTrue (v.TryEnterWriteLock (100));
 402                         v.ExitWriteLock ();
 403                         v.ExitUpgradeableReadLock ();
 404                         Assert.IsTrue (v.TryEnterWriteLock (100));
 405                         v.ExitWriteLock ();
 406                 }
 407         }
 408 }