mcs/class/System/Test/System.Collections.Generic/QueueTest.cs

   1 //
   2 // Queue.cs
   3 //
   4 // Author:
   5 //  Ben Maurer (bmaurer@ximian.com)
   6 //
   7
   8 #if NET_2_0
   9 using System;
  10 using System.Collections;
  11 using System.Collections.Generic;
  12
  13 using NUnit.Framework;
  14
  15 namespace MonoTests.System.Collections.Generic {
  16         [TestFixture]
  17         public class QueueTest : Assertion
  18         {
  19                 [Test]
  20                 public void TestCtor ()
  21                 {
  22                         Queue <int> a = new Queue <int> ();
  23                         Queue <int> b = new Queue <int> (1);
  24                         Queue <object> c = new Queue <object> ();
  25                         Queue <object> d = new Queue <object> (1);
  26                         Queue <object> e = new Queue <object> (0);
  27                 }
  28
  29                 [Test]
  30                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
  31                 public void TestCtorEx ()
  32                 {
  33                         Queue <int> a = new Queue <int> (-1);
  34                 }
  35
  36                 [Test]
  37                 public void TestCtorEnum ()
  38                 {
  39                         List <int> l = new List <int> ();
  40                         l.Add (1);
  41                         l.Add (2);
  42                         l.Add (3);
  43
  44                         Queue <int> s = new Queue <int> (l);
  45
  46                         AssertDequeue (s, 1);
  47                         AssertDequeue (s, 2);
  48                         AssertDequeue (s, 3);
  49                 }
  50
  51                 [Test]
  52                 [ExpectedException (typeof (ArgumentNullException))]
  53                 public void TestCtorEnumNull ()
  54                 {
  55                         Queue <int> s = new Queue <int> (null);
  56                 }
  57
  58                 [Test]
  59                 public void TestClear()
  60                 {
  61                         Queue <int> s = new Queue <int> ();
  62                         s.Clear ();
  63
  64                         AssertEquals (s.Count, 0);
  65
  66                         s.Enqueue (1);
  67                         s.Enqueue (2);
  68
  69                         AssertEquals (s.Count, 2);
  70
  71                         s.Clear ();
  72
  73                         AssertEquals (s.Count, 0);
  74                 }
  75
  76                 [Test]
  77                 public void TestContains ()
  78                 {
  79                         Stack <int> s = new Stack <int> ();
  80
  81                         AssertEquals (s.Contains (1), false);
  82
  83                         s.Push (1);
  84
  85                         AssertEquals (s.Contains (1), true);
  86                         AssertEquals (s.Contains (0), false);
  87                 }
  88
  89                 [Test]
  90                 public void TestCopyTo ()
  91                 {
  92                         int [] x = new int [3];
  93                         Queue <int> z = new Queue <int> ();
  94                         z.Enqueue (1);
  95                         z.Enqueue (2);
  96                         x [0] = 10;
  97                         z.CopyTo (x, 1);
  98
  99                         AssertEquals (x [0], 10);
 100                         AssertEquals (x [1], 1);
 101                         AssertEquals (x [2], 2);
 102                 }
 103
 104                 [Test]
 105                 public void TestPeek ()
 106                 {
 107                         Queue <int> s = new Queue <int> ();
 108                         s.Enqueue (1);
 109
 110                         AssertEquals (s.Peek (), 1);
 111                         AssertEquals (s.Count, 1);
 112                 }
 113
 114                 [Test]
 115                 [ExpectedException (typeof (InvalidOperationException))]
 116                 public void TestPeekEx ()
 117                 {
 118                         Queue <int> s = new Queue <int> ();
 119                         s.Peek ();
 120                 }
 121
 122                 [Test]
 123                 [ExpectedException (typeof (InvalidOperationException))]
 124                 public void TestPeekEx2 ()
 125                 {
 126                         Queue <int> s = new Queue <int> ();
 127                         s.Enqueue (1);
 128                         s.Dequeue ();
 129                         s.Peek ();
 130                 }
 131
 132                 [Test]
 133                 public void TestDequeue ()
 134                 {
 135                         Queue <int> s = new Queue <int> ();
 136                         s.Enqueue (1);
 137
 138                         AssertEquals (s.Dequeue (), 1);
 139                         AssertEquals (s.Count, 0);
 140                 }
 141
 142                 [Test]
 143                 [ExpectedException (typeof (InvalidOperationException))]
 144                 public void TestDequeueEx ()
 145                 {
 146                         Queue <int> s = new Queue <int> ();
 147                         s.Dequeue ();
 148                 }
 149
 150                 [Test]
 151                 [ExpectedException (typeof (InvalidOperationException))]
 152                 public void TestDequeueEx2 ()
 153                 {
 154                         Queue <int> s = new Queue <int> ();
 155                         s.Enqueue (1);
 156                         s.Dequeue ();
 157                         s.Dequeue ();
 158                 }
 159
 160                 [Test]
 161                 public void TestEnqueue ()
 162                 {
 163                         Queue <int> s = new Queue <int> ();
 164                         s.Enqueue (1);
 165                         AssertEquals (s.Count, 1);
 166                         s.Enqueue (2);
 167                         AssertEquals (s.Count, 2);
 168
 169                         for (int i = 0; i < 100; i ++)
 170                                 s.Enqueue (i);
 171
 172                         AssertEquals (s.Count, 102);
 173                 }
 174
 175                 [Test]
 176                 public void TestToArray ()
 177                 {
 178                         Queue <int> s = new Queue <int> ();
 179
 180                         int [] x = s.ToArray ();
 181
 182                         AssertEquals (x.Length, 0);
 183
 184                         s.Enqueue (1);
 185                         x = s.ToArray ();
 186                         AssertEquals (x.Length, 1);
 187                         AssertEquals (x [0], 1);
 188                 }
 189
 190                 [Test]
 191                 public void TestTrimToSize ()
 192                 {
 193                         Queue <int> s = new Queue <int> ();
 194                         s.TrimToSize ();
 195                         s.Enqueue (1);
 196                         s.TrimToSize ();
 197                 }
 198
 199                 [Test]
 200                 public void TestEnumerator ()
 201                 {
 202                         Queue <int> s = new Queue <int> ();
 203
 204                         foreach (int x in s)
 205                                 Fail ();
 206
 207                         s.Enqueue (1);
 208
 209                         int i = 0;
 210
 211                         foreach (int x in s) {
 212                                 AssertEquals (i, 0);
 213                                 AssertEquals (x, 1);
 214                                 i ++;
 215                         }
 216
 217                         for (i = 2; i < 100; i ++)
 218                                 s.Enqueue (i);
 219
 220                         i = 1;
 221
 222                         foreach (int x in s) {
 223                                 AssertEquals (x, i);
 224                                 i ++;
 225                         }
 226                 }
 227
 228                 void AssertDequeue <T> (Queue <T> s, T t)
 229                 {
 230                         AssertEquals (s.Dequeue (), t);
 231                 }
 232         }
 233 }
 234 #endif