Merge pull request #901 from Blewzman/FixAggregateExceptionGetBaseException

[mono.git] / mcs / class / System / Test / System.Collections.Generic / SortedSetTest.cs

diff --git a/mcs/class/System/Test/System.Collections.Generic/SortedSetTest.cs b/mcs/class/System/Test/System.Collections.Generic/SortedSetTest.cs
index edee1199daf81361ab46f2062e16189440ce3b78..6c59bb4ead23bd053dbb3962d577e0d44b2f3d62 100644 (file)
--- a/mcs/class/System/Test/System.Collections.Generic/SortedSetTest.cs
+++ b/mcs/class/System/Test/System.Collections.Generic/SortedSetTest.cs
@@ -216,6 +216,7 @@ namespace MonoTests.System.Collections.Generic
 
                        view.Clear ();
 
+                       Assert.AreEqual (0, view.Count);
                        Assert.IsTrue (set.SequenceEqual (new [] { 1, 9 }));
                }
 
@@ -247,22 +248,56 @@ namespace MonoTests.System.Collections.Generic
                        Assert.IsTrue (view.SequenceEqual (new [] { 5 }));
                }
 
+               void EmptySubView (SortedSet<int> set)
+               {
+                       var view = set.GetViewBetween (-20, -15);
+                       Assert.AreEqual (0, view.Count);
+                       Assert.AreEqual (0, view.Min);
+                       Assert.AreEqual (0, view.Max);
+
+                       view = set.GetViewBetween (15, 20);
+                       Assert.AreEqual (0, view.Count);
+                       Assert.AreEqual (0, view.Min);
+                       Assert.AreEqual (0, view.Max);
+               }
+
+               [Test]
+               public void EmptySubView ()
+               {
+                       EmptySubView (new SortedSet<int> ());
+                       EmptySubView (new SortedSet<int> { 1, 3, 5, 7, 9 });
+                       EmptySubView (new SortedSet<int> { -40, 40 });
+                       EmptySubView (new SortedSet<int> { -40, -10, 10, 40 });
+               }
+
                [Test]
                public void ViewMin ()
                {
                        var set = new SortedSet<int> { 1, 3, 5, 7, 9 };
-                       var view = set.GetViewBetween (4, 8);
 
+                       var view = set.GetViewBetween (4, 8);
                        Assert.AreEqual (5, view.Min);
+
+                       view = set.GetViewBetween (-2, 4);
+                       Assert.AreEqual (1, view.Min);
+
+                       view = set.GetViewBetween (1, 9);
+                       Assert.AreEqual (1, view.Min);
                }
 
                [Test]
                public void ViewMax ()
                {
                        var set = new SortedSet<int> { 1, 3, 5, 7, 9 };
-                       var view = set.GetViewBetween (4, 8);
 
+                       var view = set.GetViewBetween (4, 8);
                        Assert.AreEqual (7, view.Max);
+
+                       view = set.GetViewBetween (4, 55);
+                       Assert.AreEqual (9, view.Max);
+
+                       view = set.GetViewBetween (1, 9);
+                       Assert.AreEqual (9, view.Max);
                }
 
                [Test]
@@ -272,6 +307,14 @@ namespace MonoTests.System.Collections.Generic
                        var view = set.GetViewBetween (4, 8);
 
                        Assert.AreEqual (5, view.Count);
+                       set.Remove (5);
+                       Assert.AreEqual (4, view.Count);
+                       set.Add (10);
+                       Assert.AreEqual (4, view.Count);
+                       set.Add (6);
+                       Assert.AreEqual (4, view.Count);
+                       set.Add (5);
+                       Assert.AreEqual (5, view.Count);
                }
 
                [Test, ExpectedException (typeof (ArgumentNullException))]
@@ -350,6 +393,14 @@ namespace MonoTests.System.Collections.Generic
                        Assert.IsTrue (set.SequenceEqual (new [] { 1, 9 }));
                }
 
+               [Test]
+               public void ExceptWithItself ()
+               {
+                       var set = new SortedSet<int> (new [] { 1, 5 });
+                       set.ExceptWith (set);
+                       Assert.AreEqual (0, set.Count);
+               }
+
                [Test]
                public void ViewExceptWith ()
                {
@@ -378,6 +429,14 @@ namespace MonoTests.System.Collections.Generic
                        Assert.IsTrue (set.SequenceEqual (new [] { 1, 2, 9, 11 }));
                }
 
+               [Test]
+               public void SymetricExceptWithItself ()
+               {
+                       var set = new SortedSet<int> (new [] { 1, 5 });
+                       set.SymmetricExceptWith (set);
+                       Assert.AreEqual (0, set.Count);
+               }
+
                [Test]
                public void ViewSymmetricExceptWith ()
                {
@@ -440,6 +499,9 @@ namespace MonoTests.System.Collections.Generic
                        var digits = new SortedSet<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
                        var squares = new SortedSet<int> { 0, 1, 4, 9 };
 
+                       var non_prime_odd_digit = odds.GetViewBetween (8, 42);
+                       var non_trit = digits.GetViewBetween (3, 42);
+
                        do_test (empty, empty, se: true);
                        do_test (empty, zero, psb: true);
                        do_test (empty, digits, psb: true);
@@ -458,6 +520,13 @@ namespace MonoTests.System.Collections.Generic
                        do_test (squares, digits, psb: true);
                        do_test (digits, digits, se: true);
                        do_test_e (digits, squares.Concat (evens.Concat (odds)), o: true, se: true);
+                       do_test (non_prime_odd_digit, digits, psb: true);
+                       do_test_e (non_prime_odd_digit, new [] { 9 }, o: true, se: true);
+                       do_test (non_trit, digits, psb: true);
+                       do_test (trit, non_trit);
+                       do_test_e (digits, trit.Concat (non_trit), o: true, se: true);
+                       do_test_e (non_trit, new [] { 3, 4, 5, 6, 7, 8, 9 }, o: true, se: true);
+                       do_test (digits.GetViewBetween (0, 2), trit, se: true);
                }
        }
 }