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

   1 #if NET_2_0
   2 using System;
   3 using System.Collections.Generic;
   4 using System.IO;
   5 using System.Text;
   6 using System.Runtime.Serialization;
   7 using System.Runtime.Serialization.Formatters.Binary;
   8 using NUnit.Framework;
   9
  10 namespace MonoTests.System.Collections.Generic
  11 {
  12         [TestFixture]
  13         public class LinkedListTest
  14         {
  15                 LinkedList <int> intlist;
  16                 LinkedList <string> strings;
  17
  18                 [SetUp]
  19                 public void Setup ()
  20                 {
  21                         intlist = new LinkedList <int> ();
  22
  23                         // 2 3 4
  24                         intlist.AddLast (3);
  25                         intlist.AddLast (4);
  26                         intlist.AddFirst (2);
  27
  28                         string [] tmpStrings = new string [] { "foo", "bar", "baz" };
  29                         // FIXME workaround for 74953
  30
  31                         List <string> workaround = new List <string> ();
  32                         foreach (string s in tmpStrings)
  33                                 workaround.Add (s);
  34
  35                         // strings = new LinkedList <string> (tmpStrings);
  36                         strings = new LinkedList <string> (workaround);
  37                 }
  38
  39                 [Test]
  40                 public void AddedTest ()
  41                 {
  42                         int i = 2;
  43                         foreach (int current in intlist)
  44                         {
  45                                 Assert.AreEqual (i, current);
  46                                 i++;
  47                         }
  48                         Assert.AreEqual (5, i);
  49                 }
  50
  51                 [Test]
  52                 public void CreatedTest ()
  53                 {
  54                         string [] values = new string [] { "foo", "bar", "baz" };
  55                         int i = 0;
  56                         foreach (string current in strings)
  57                         {
  58                                 Assert.AreEqual (values [i], current);
  59                                 i++;
  60                         }
  61                         Assert.AreEqual (3, i);
  62                 }
  63
  64                 [Test]
  65                 public void NonCircularNodeTest ()
  66                 {
  67                         LinkedListNode <int> node = intlist.First;
  68                         Assert.AreEqual (2, node.Value);
  69                         LinkedListNode <int> previous = node.Previous;
  70                         Assert.IsNull (previous);
  71
  72                         node = node.Next;
  73                         Assert.IsNotNull (node);
  74                         Assert.AreEqual (3, node.Value);
  75
  76                         node = node.Next;
  77                         Assert.IsNotNull (node);
  78                         Assert.AreEqual (4, node.Value);
  79
  80                         node = node.Next;
  81                         Assert.IsNull (node);
  82                 }
  83
  84                 [Test]
  85                 public void ClearTest ()
  86                 {
  87                         LinkedListNode <int> node = intlist.First;
  88                         intlist.Clear ();
  89
  90                         Assert.AreEqual (0, intlist.Count);
  91                         Assert.AreEqual (2, node.Value);
  92                         Assert.IsNull (node.Next);
  93                         Assert.IsNull (node.Previous);
  94                 }
  95
  96                 [Test]
  97                 public void ContainsTest ()
  98                 {
  99                         Assert.IsTrue (intlist.Contains (3));
 100                         Assert.IsFalse (intlist.Contains (5));
 101                 }
 102
 103                 [Test]
 104                 public void AddBeforeAndAfterTest ()
 105                 {
 106                         LinkedListNode <int> node = intlist.Find (3);
 107                         intlist.AddAfter (node, new LinkedListNode <int> (5));
 108                         LinkedListNode <int> sixNode = intlist.AddAfter (node, 6);
 109                         LinkedListNode <int> sevenNode = intlist.AddBefore (node, 7);
 110                         intlist.AddBefore (node, new LinkedListNode <int> (8));
 111
 112                         Assert.AreEqual (6, sixNode.Value);
 113                         Assert.AreEqual (7, sevenNode.Value);
 114
 115                         // 2 7 8 3 6 5 4
 116                         int [] values = new int [] { 2, 7, 8, 3, 6, 5, 4 };
 117                         int i = 0;
 118                         foreach (int current in intlist)
 119                         {
 120                                 Assert.AreEqual (values [i], current);
 121                                 i++;
 122                         }
 123                         for (LinkedListNode <int> current = intlist.First; current != null; current = current.Next )
 124                                 Assert.AreSame (intlist, current.List);
 125                 }
 126
 127                 [Test]
 128                 public void CopyToTest ()
 129                 {
 130                         int [] values = new int [] { 2, 3, 4 };
 131                         int [] output = new int [3];
 132                         intlist.CopyTo (output, 0);
 133                         for (int i = 0; i < 3; i++)
 134                                 Assert.AreEqual (values [i], output [i]);
 135
 136                         LinkedList <int> l = new LinkedList <int> ();
 137                         values = new int [l.Count];
 138                         l.CopyTo (values, 0);
 139                 }
 140
 141                 [Test]
 142                 public void FindTest ()
 143                 {
 144                         intlist.AddFirst (4);
 145
 146                         LinkedListNode <int> head, tail;
 147                         head = intlist.Find (4);
 148                         tail = intlist.FindLast (4);
 149                         Assert.AreEqual (intlist.First, head);
 150                         Assert.AreEqual (intlist.Last, tail);
 151                 }
 152
 153                 [Test]
 154                 public void RemoveTest ()
 155                 {
 156                         Assert.IsTrue (intlist.Remove (3));
 157                         Assert.AreEqual (2, intlist.Count);
 158
 159                         int [] values = { 2, 4 };
 160                         int i = 0;
 161                         foreach (int current in intlist)
 162                         {
 163                                 Assert.AreEqual (values [i], current);
 164                                 i++;
 165                         }
 166                         Assert.IsFalse (intlist.Remove (5));
 167
 168                         LinkedListNode <string> node = strings.Find ("baz");
 169                         strings.Remove (node);
 170
 171                         Assert.IsNull (node.List);
 172                         Assert.IsNull (node.Previous);
 173                         Assert.IsNull (node.Next);
 174
 175                         string [] values2 = { "foo", "bar" };
 176                         i = 0;
 177                         foreach (string current in strings)
 178                         {
 179                                 Assert.AreEqual (values2 [i], current);
 180                                 i++;
 181                         }
 182                 }
 183
 184                 [Test, ExpectedException (typeof (ArgumentNullException))]
 185                 public void RemoveNullNodeTest ()
 186                 {
 187                         intlist.Remove (null);
 188                 }
 189
 190                 [Test, ExpectedException (typeof (InvalidOperationException))]
 191                 public void RemoveInvalidNodeTest ()
 192                 {
 193                         intlist.Remove (new LinkedListNode <int> (4));
 194                 }
 195
 196                 [Test]
 197                 public void RemoveFirstLastTest ()
 198                 {
 199                         strings.RemoveFirst ();
 200                         strings.RemoveLast ();
 201                         Assert.AreEqual (1, strings.Count);
 202                         Assert.AreEqual ("bar", strings.First.Value);
 203                 }
 204
 205                 [Test]
 206                 public void ListSerializationTest ()
 207                 {
 208                         BinaryFormatter formatter = new BinaryFormatter();
 209                         MemoryStream stream = new MemoryStream();
 210                         formatter.Serialize(stream, intlist);
 211
 212                         stream.Position = 0;
 213                         object deserialized = formatter.Deserialize(stream);
 214
 215                         Assert.IsTrue(deserialized is LinkedList <int>);
 216
 217                         LinkedList <int> dlist = deserialized as LinkedList <int>;
 218
 219                         int [] values = { 2, 3, 4 };
 220                         int i = 0;
 221                         foreach (int value in dlist)
 222                         {
 223                                 Assert.AreEqual (values [i], value);
 224                                 i++;
 225                         }
 226                         Assert.AreEqual(3, i);
 227                 }
 228
 229                 /* FIXME: disabled pending fix for #75299
 230                 [Test]
 231                 */
 232                 public void EnumeratorSerializationTest ()
 233                 {
 234                         BinaryFormatter formatter = new BinaryFormatter ();
 235                         MemoryStream stream = new MemoryStream ();
 236                         LinkedList<int>.Enumerator e = intlist.GetEnumerator ();
 237                         formatter.Serialize (stream, e);
 238
 239                         stream.Position = 0;
 240                         object deserialized = formatter.Deserialize(stream);
 241
 242                         Assert.IsTrue(deserialized is LinkedList <int>.Enumerator);
 243
 244                         LinkedList <int>.Enumerator d = (LinkedList <int>.Enumerator) deserialized;
 245
 246                         int [] values = { 2, 3, 4 };
 247                         int i = 0;
 248                         while (d.MoveNext ())
 249                         {
 250                                 Assert.AreEqual (values [i], d.Current);
 251                                 i++;
 252                         }
 253                         Assert.AreEqual(3, i);
 254                 }
 255
 256                 [Test] //bug 481621
 257                 public void PlayWithNullValues ()
 258                 {
 259                         LinkedList <string> li = new LinkedList <string> ();
 260                         li.AddLast ((string)null);
 261                         li.AddLast ("abcd");
 262                         li.AddLast ((string)null);
 263                         li.AddLast ("efgh");
 264                         Assert.AreEqual (4, li.Count);
 265                         Assert.AreEqual ("efgh", li.Last.Value);
 266                         Assert.IsNull (li.First.Value);
 267
 268                         Assert.IsTrue (li.Remove ((string)null));
 269                         Assert.AreEqual (3, li.Count);
 270                         Assert.AreEqual ("efgh", li.Last.Value);
 271                         Assert.AreEqual ("abcd", li.First.Value);
 272
 273                         Assert.IsTrue (li.Remove ((string)null));
 274                         Assert.AreEqual (2, li.Count);
 275                         Assert.AreEqual ("efgh", li.Last.Value);
 276                         Assert.AreEqual ("abcd", li.First.Value);
 277
 278                         Assert.IsFalse (li.Remove ((string)null));
 279                         Assert.AreEqual (2, li.Count);
 280                         Assert.AreEqual ("efgh", li.Last.Value);
 281                         Assert.AreEqual ("abcd", li.First.Value);
 282                 }
 283         }
 284 }
 285
 286 #endif