mcs/class/corlib/Test/System.Collections.Concurrent/ConcurrentStackTests.cs

   1 #if NET_4_0
   2 // ConcurrentStackTests.cs
   3 //
   4 // Copyright (c) 2008 Jérémie "Garuma" Laval
   5 //
   6 // Permission is hereby granted, free of charge, to any person obtaining a copy
   7 // of this software and associated documentation files (the "Software"), to deal
   8 // in the Software without restriction, including without limitation the rights
   9 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 // copies of the Software, and to permit persons to whom the Software is
  11 // furnished to do so, subject to the following conditions:
  12 //
  13 // The above copyright notice and this permission notice shall be included in
  14 // all copies or substantial portions of the Software.
  15 //
  16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22 // THE SOFTWARE.
  23 //
  24 //
  25
  26 using System;
  27 using System.Threading;
  28 using System.Linq;
  29 using System.Collections.Concurrent;
  30 using NUnit.Framework;
  31 using NUnit.Framework.Constraints;
  32
  33 namespace MonoTests.System.Collections.Concurrent
  34 {
  35         [TestFixture()]
  36         public class ConcurrentStackTests
  37         {
  38                 ConcurrentStack<int> stack;
  39
  40                 [SetUpAttribute]
  41                 public void Setup()
  42                 {
  43                         stack = new ConcurrentStack<int>();
  44                         for (int i = 0; i < 10; i++) {
  45                                 stack.Push(i);
  46                         }
  47                 }
  48
  49                 [Test]
  50                 public void StressPushTestCase ()
  51                 {
  52                         /*ParallelTestHelper.Repeat (delegate {
  53                                 stack = new ConcurrentStack<int> ();
  54                                 int amount = -1;
  55                                 const int count = 10;
  56                                 const int threads = 5;
  57
  58                                 ParallelTestHelper.ParallelStressTest (stack, (q) => {
  59                                         int t = Interlocked.Increment (ref amount);
  60                                         for (int i = 0; i < count; i++)
  61                                                 stack.Push (t);
  62                                 }, threads);
  63
  64                                 Assert.AreEqual (threads * count, stack.Count, "#-1");
  65                                 int[] values = new int[threads];
  66                                 int temp;
  67                                 while (stack.TryPop (out temp)) {
  68                                         values[temp]++;
  69                                 }
  70
  71                                 for (int i = 0; i < threads; i++)
  72                                         Assert.AreEqual (count, values[i], "#" + i);
  73                         });*/
  74                         CollectionStressTestHelper.AddStressTest (new ConcurrentStack<int> ());
  75                 }
  76
  77                 [Test]
  78                 public void StressPopTestCase ()
  79                 {
  80                         /*ParallelTestHelper.Repeat (delegate {
  81                                 stack = new ConcurrentStack<int> ();
  82                                 const int count = 10;
  83                                 const int threads = 5;
  84                                 const int delta = 5;
  85
  86                                 for (int i = 0; i < (count + delta) * threads; i++)
  87                                         stack.Push (i);
  88
  89                                 bool state = true;
  90
  91                                 ParallelTestHelper.ParallelStressTest (stack, (q) => {
  92                                         int t;
  93                                         for (int i = 0; i < count; i++)
  94                                                 state &= stack.TryPop (out t);
  95                                 }, threads);
  96
  97                                 Assert.IsTrue (state, "#1");
  98                                 Assert.AreEqual (delta * threads, stack.Count, "#2");
  99
 100                                 string actual = string.Empty;
 101                                 int temp;
 102                                 while (stack.TryPop (out temp)) {
 103                                         actual += temp;
 104                                 }
 105                                 string expected = Enumerable.Range (0, delta * threads).Reverse()
 106                                         .Aggregate (string.Empty, (acc, v) => acc + v);
 107
 108                                 Assert.AreEqual (expected, actual, "#3");
 109                         });*/
 110
 111                         CollectionStressTestHelper.RemoveStressTest (new ConcurrentStack<int> (), CheckOrderingType.Reversed);
 112                 }
 113
 114                 [Test]
 115                 public void CountTestCase()
 116                 {
 117                         Assert.IsTrue(stack.Count == 10, "#1");
 118                         int value;
 119                         stack.TryPeek(out value);
 120                         stack.TryPop(out value);
 121                         stack.TryPop(out value);
 122                         Assert.IsTrue(stack.Count == 8, "#2");
 123                         stack.Clear();
 124                         Assert.IsTrue(stack.Count == 0, "#3");
 125                         Assert.IsTrue(stack.IsEmpty, "#4");
 126                 }
 127
 128                 [Test()]
 129                 public void EnumerateTestCase()
 130                 {
 131                         string s = string.Empty;
 132                         foreach (int i in stack) {
 133                                 s += i;
 134                         }
 135                         Assert.IsTrue(s == "9876543210", "#1 : " + s);
 136                 }
 137
 138                 [Test()]
 139                 public void TryPeekTestCase()
 140                 {
 141                         int value;
 142                         stack.TryPeek(out value);
 143                         Assert.IsTrue(value == 9, "#1 : " + value);
 144                         stack.TryPop(out value);
 145                         Assert.IsTrue(value == 9, "#2 : " + value);
 146                         stack.TryPop(out value);
 147                         Assert.IsTrue(value == 8, "#3 : " + value);
 148                         stack.TryPeek(out value);
 149                         Assert.IsTrue(value == 7, "#4 : " + value);
 150                         stack.TryPeek(out value);
 151                         Assert.IsTrue(value == 7, "#5 : " + value);
 152                 }
 153
 154                 [Test()]
 155                 public void TryPopTestCase()
 156                 {
 157                         int value;
 158                         stack.TryPeek(out value);
 159                         Assert.IsTrue(value == 9, "#1");
 160                         stack.TryPop(out value);
 161                         stack.TryPop(out value);
 162                         Assert.IsTrue(value == 8, "#2 : " + value);
 163                 }
 164
 165                 [Test()]
 166                 public void TryPopEmptyTestCase()
 167                 {
 168                         int value;
 169                         stack.Clear();
 170                         stack.Push(1);
 171                         Assert.IsTrue(stack.TryPop(out value), "#1");
 172                         Assert.IsFalse(stack.TryPop(out value), "#2");
 173                         Assert.IsTrue(stack.IsEmpty, "#3");
 174                 }
 175
 176                 [Test]
 177                 public void ToArrayTest()
 178                 {
 179                         int[] array = stack.ToArray();
 180                         string s = string.Empty;
 181                         foreach (int i in array) {
 182                                 s += i;
 183                         }
 184                         Assert.IsTrue(s == "9876543210", "#1 : " + s);
 185                         stack.CopyTo(array, 0);
 186                         s = string.Empty;
 187                         foreach (int i in array) {
 188                                 s += i;
 189                         }
 190                         Assert.IsTrue(s == "9876543210", "#1 : " + s);
 191                 }
 192
 193                 [Test, ExpectedException (typeof (ArgumentNullException))]
 194                 public void ToExistingArray_Null ()
 195                 {
 196                         stack.CopyTo (null, 0);
 197                 }
 198
 199                 [Test, ExpectedException (typeof (ArgumentOutOfRangeException))]
 200                 public void ToExistingArray_OutOfRange ()
 201                 {
 202                         stack.CopyTo (new int[3], -1);
 203                 }
 204
 205                 [Test, ExpectedException (typeof (ArgumentException))]
 206                 public void ToExistingArray_IndexOverflow ()
 207                 {
 208                         stack.CopyTo (new int[3], 4);
 209                 }
 210
 211                 [Test, ExpectedException (typeof (ArgumentException))]
 212                 public void ToExistingArray_Overflow ()
 213                 {
 214                         stack.CopyTo (new int[3], 0);
 215                 }
 216
 217                 [Test]
 218                 public void TryPopRangeTest ()
 219                 {
 220                         int[] values = new int[3];
 221                         Assert.AreEqual (3, stack.TryPopRange (values));
 222                         Assert.That (values, new CollectionEquivalentConstraint (new int[] { 9, 8, 7 }));
 223                         Assert.AreEqual (10 - values.Length, stack.Count);
 224                         for (int i = 9 - values.Length; i >= 0; i--) {
 225                                 int outValue;
 226                                 Assert.IsTrue (stack.TryPop (out outValue));
 227                                 Assert.AreEqual (i, outValue);
 228                         }
 229                 }
 230
 231                 [Test]
 232                 public void TryPopRangeEmpty ()
 233                 {
 234                         stack = new ConcurrentStack<int>();
 235                         Assert.AreEqual (0, stack.TryPopRange (new int [1]));
 236                 }
 237
 238                 [Test]
 239                 public void TryPopRangeTestWithOneElement ()
 240                 {
 241                         int[] values = new int[1];
 242                         Assert.AreEqual (1, stack.TryPopRange (values));
 243                         Assert.That (values, new CollectionEquivalentConstraint (new int[] { 9 }));
 244                         Assert.AreEqual (10 - values.Length, stack.Count);
 245                         for (int i = 9 - values.Length; i >= 0; i--) {
 246                                 int outValue;
 247                                 Assert.IsTrue (stack.TryPop (out outValue));
 248                                 Assert.AreEqual (i, outValue);
 249                         }
 250                 }
 251
 252                 [Test]
 253                 public void TryPopRangeFullTest ()
 254                 {
 255                         int[] values = new int[10];
 256                         Assert.AreEqual (10, stack.TryPopRange (values));
 257                         Assert.That (values, new CollectionEquivalentConstraint (Enumerable.Range (0, 10).Reverse ()));
 258                         Assert.AreEqual (0, stack.Count);
 259                 }
 260
 261                 [Test]
 262                 public void TryPopRangePartialFillTest ()
 263                 {
 264                         int[] values = new int[5];
 265                         Assert.AreEqual (2, stack.TryPopRange (values, 3, 2));
 266                         Assert.That (values, new CollectionEquivalentConstraint (new int[] { 0, 0, 0, 9, 8 }));
 267                         Assert.AreEqual (8, stack.Count);
 268                 }
 269
 270                 [Test, ExpectedException (typeof (ArgumentOutOfRangeException))]
 271                 public void TryPopRange_NegativeIndex ()
 272                 {
 273                         stack.TryPopRange (new int[3], -2, 3);
 274                 }
 275
 276                 [Test, ExpectedException (typeof (ArgumentOutOfRangeException))]
 277                 public void TryPopRange_LargeIndex ()
 278                 {
 279                         stack.TryPopRange (new int[3], 200, 3);
 280                 }
 281
 282                 [Test, ExpectedException (typeof (ArgumentException))]
 283                 public void TryPopRange_LargeCount ()
 284                 {
 285                         stack.TryPopRange (new int[3], 2, 5);
 286                 }
 287
 288                 [Test, ExpectedException (typeof (ArgumentNullException))]
 289                 public void TryPopRange_NullArray ()
 290                 {
 291                         stack.TryPopRange (null);
 292                 }
 293         }
 294 }
 295 #endif