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
  32 namespace MonoTests.System.Collections.Concurrent
  33 {
  34         [TestFixture()]
  35         public class ConcurrentStackTests
  36         {
  37                 ConcurrentStack<int> stack;
  38
  39                 [SetUpAttribute]
  40                 public void Setup()
  41                 {
  42                         stack = new ConcurrentStack<int>();
  43                         for (int i = 0; i < 10; i++) {
  44                                 stack.Push(i);
  45                         }
  46                 }
  47
  48                 [Test]
  49                 public void StressPushTestCase ()
  50                 {
  51                         /*ParallelTestHelper.Repeat (delegate {
  52                                 stack = new ConcurrentStack<int> ();
  53                                 int amount = -1;
  54                                 const int count = 10;
  55                                 const int threads = 5;
  56
  57                                 ParallelTestHelper.ParallelStressTest (stack, (q) => {
  58                                         int t = Interlocked.Increment (ref amount);
  59                                         for (int i = 0; i < count; i++)
  60                                                 stack.Push (t);
  61                                 }, threads);
  62
  63                                 Assert.AreEqual (threads * count, stack.Count, "#-1");
  64                                 int[] values = new int[threads];
  65                                 int temp;
  66                                 while (stack.TryPop (out temp)) {
  67                                         values[temp]++;
  68                                 }
  69
  70                                 for (int i = 0; i < threads; i++)
  71                                         Assert.AreEqual (count, values[i], "#" + i);
  72                         });*/
  73                         CollectionStressTestHelper.AddStressTest (new ConcurrentStack<int> ());
  74                 }
  75
  76                 [Test]
  77                 public void StressPopTestCase ()
  78                 {
  79                         /*ParallelTestHelper.Repeat (delegate {
  80                                 stack = new ConcurrentStack<int> ();
  81                                 const int count = 10;
  82                                 const int threads = 5;
  83                                 const int delta = 5;
  84
  85                                 for (int i = 0; i < (count + delta) * threads; i++)
  86                                         stack.Push (i);
  87
  88                                 bool state = true;
  89
  90                                 ParallelTestHelper.ParallelStressTest (stack, (q) => {
  91                                         int t;
  92                                         for (int i = 0; i < count; i++)
  93                                                 state &= stack.TryPop (out t);
  94                                 }, threads);
  95
  96                                 Assert.IsTrue (state, "#1");
  97                                 Assert.AreEqual (delta * threads, stack.Count, "#2");
  98
  99                                 string actual = string.Empty;
 100                                 int temp;
 101                                 while (stack.TryPop (out temp)) {
 102                                         actual += temp;
 103                                 }
 104                                 string expected = Enumerable.Range (0, delta * threads).Reverse()
 105                                         .Aggregate (string.Empty, (acc, v) => acc + v);
 106
 107                                 Assert.AreEqual (expected, actual, "#3");
 108                         });*/
 109
 110                         CollectionStressTestHelper.RemoveStressTest (new ConcurrentStack<int> (), CheckOrderingType.Reversed);
 111                 }
 112
 113                 [Test]
 114                 public void CountTestCase()
 115                 {
 116                         Assert.IsTrue(stack.Count == 10, "#1");
 117                         int value;
 118                         stack.TryPeek(out value);
 119                         stack.TryPop(out value);
 120                         stack.TryPop(out value);
 121                         Assert.IsTrue(stack.Count == 8, "#2");
 122                         stack.Clear();
 123                         Assert.IsTrue(stack.Count == 0, "#3");
 124                         Assert.IsTrue(stack.IsEmpty, "#4");
 125                 }
 126
 127                 //[Ignore]
 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]
 194                 public void TryPopRangeTest ()
 195                 {
 196                         int[] values = new int[3];
 197                         Assert.AreEqual (3, stack.TryPopRange (values));
 198                         CollectionAssert.AreEquivalent (new int[] { 9, 8, 7 }, values);
 199                         Assert.AreEqual (10 - values.Length, stack.Count);
 200                         for (int i = 9 - values.Length; i >= 0; i--) {
 201                                 int outValue;
 202                                 Assert.IsTrue (stack.TryPop (out outValue));
 203                                 Assert.AreEqual (i, outValue);
 204                         }
 205                 }
 206
 207                 [Test]
 208                 public void TryPopRangeTestWithOneElement ()
 209                 {
 210                         int[] values = new int[1];
 211                         Assert.AreEqual (1, stack.TryPopRange (values));
 212                         CollectionAssert.AreEquivalent (new int[] { 9 }, values);
 213                         Assert.AreEqual (10 - values.Length, stack.Count);
 214                         for (int i = 9 - values.Length; i >= 0; i--) {
 215                                 int outValue;
 216                                 Assert.IsTrue (stack.TryPop (out outValue));
 217                                 Assert.AreEqual (i, outValue);
 218                         }
 219                 }
 220
 221                 [Test]
 222                 public void TryPopRangeFullTest ()
 223                 {
 224                         int[] values = new int[10];
 225                         Assert.AreEqual (10, stack.TryPopRange (values));
 226                         CollectionAssert.AreEquivalent (Enumerable.Range (0, 10).Reverse ().ToArray (), values);
 227                         Assert.AreEqual (0, stack.Count);
 228                 }
 229
 230                 [Test]
 231                 public void TryPopRangePartialFillTest ()
 232                 {
 233                         int[] values = new int[5];
 234                         Assert.AreEqual (2, stack.TryPopRange (values, 3, 2));
 235                         CollectionAssert.AreEquivalent (new int[] { 0, 0, 0, 9, 8 }, values);
 236                         Assert.AreEqual (8, stack.Count);
 237                 }
 238
 239                 [Test, ExpectedException (typeof (ArgumentOutOfRangeException))]
 240                 public void TryPopRange_NegativeIndex ()
 241                 {
 242                         stack.TryPopRange (new int[3], -2, 3);
 243                 }
 244
 245                 [Test, ExpectedException (typeof (ArgumentOutOfRangeException))]
 246                 public void TryPopRange_LargeIndex ()
 247                 {
 248                         stack.TryPopRange (new int[3], 200, 3);
 249                 }
 250
 251                 [Test, ExpectedException (typeof (ArgumentException))]
 252                 public void TryPopRange_LargeCount ()
 253                 {
 254                         stack.TryPopRange (new int[3], 2, 5);
 255                 }
 256
 257                 [Test, ExpectedException (typeof (ArgumentNullException))]
 258                 public void TryPopRange_NullArray ()
 259                 {
 260                         stack.TryPopRange (null);
 261                 }
 262         }
 263 }
 264 #endif