[system.core] Enable disabled test

[mono.git] / mcs / class / System.Core / Test / System.Linq / EnumerableMoreTest.cs

diff --git a/mcs/class/System.Core/Test/System.Linq/EnumerableMoreTest.cs b/mcs/class/System.Core/Test/System.Linq/EnumerableMoreTest.cs
index 70c6233fcd90a7ff8cfa03b016971bf92733cd9e..19bfe4856cdb59ddeefd570d6eae23ff03e4f73e 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq/EnumerableMoreTest.cs
+++ b/mcs/class/System.Core/Test/System.Linq/EnumerableMoreTest.cs
@@ -1,4 +1,4 @@
-//
+//
 // EnumerableMoreTest.cs
 //
 // Author:
@@ -550,8 +550,7 @@ namespace MonoTests.System.Linq {
                }
 
 
-               [Test]
-               [Ignore ("Takes some time.")]
+               //[Test]
                public void CountOverflowTest ()
                {
                        //BigEnumerable data = new BigEnumerable ((ulong) int.MaxValue + 1);
@@ -590,6 +589,7 @@ namespace MonoTests.System.Linq {
 
                        // LongCount<TSource> ()
                        Assert.AreEqual (5, data.LongCount ());
+                       Assert.AreEqual (5, Enumerable.Range (0, 5).LongCount ());
 
                        // LongCount<TSource> (Func<TSource, bool>)
                        Assert.AreEqual (3, data.LongCount (x => x < 5));
@@ -608,15 +608,27 @@ namespace MonoTests.System.Linq {
                        AssertException<ArgumentNullException> (delegate () { ((IEnumerable<string>) null).Contains ("2", (IEqualityComparer<string>) EqualityComparer<string>.Default); });
                }
 
+               static void IsFalse(bool b, int[] data) {
+                       if (b) {
+                               Console.WriteLine (data.Contains (0));
+                               object o = null;
+                               o.ToString ();
+                               Assert.IsFalse (true);
+                       }
+                       //Console.WriteLine ("HIT!");
+               }
+
                [Test]
                public void ContainsTest ()
                {
                        int [] data = { 5, 2, 3, 1, 6 };
-
+                       ICollection<int> icoll = data;
 
                        // Contains<TSource> (TSource)
                        Assert.IsTrue (data.Contains (2));
-                       Assert.IsFalse (data.Contains (0));
+                       for (int i = 0; i < 50; ++i)
+                               icoll.Contains (i);//Console.WriteLine (data.Contains (0));
+                       IsFalse (data.Contains (0), data);
 
                        // Contains<TSource> (TSource, IEqualityComparer<TSource>)
                        Assert.IsTrue (data.Contains (2, EqualityComparer<int>.Default));
@@ -738,7 +750,6 @@ namespace MonoTests.System.Linq {
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void SumTest ()
                {
                        string [] data = { "2", "3", "5", "5" };
@@ -911,7 +922,6 @@ namespace MonoTests.System.Linq {
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void MinTest ()
                {
                        string [] data = { "2", "1", "5", "3", "4" };
@@ -1502,7 +1512,6 @@ namespace MonoTests.System.Linq {
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void JoinArgumentNullTest ()
                {
                        string [] data = { "2", "1", "5", "3", "4" };
@@ -1545,7 +1554,18 @@ namespace MonoTests.System.Linq {
                }
 
                [Test]
-               [Category ("NotWorking")]
+               public void JoinTestNullKeys ()
+               {
+                       var l1 = new [] {
+                               new { Name = "name1", Nullable = (int?) null },
+                               new { Name = "name2", Nullable = (int?) null }
+                       };
+
+                       var count = l1.Join (l1, i => i.Nullable, i => i.Nullable, (x, y) => x.Name).Count ();
+                       Assert.AreEqual (0, count);
+               }
+
+               [Test]
                public void GroupJoinArgumentNullTest ()
                {
                        string [] data = { "2", "1", "5", "3", "4" };
@@ -1587,6 +1607,16 @@ namespace MonoTests.System.Linq {
                        AssertAreSame (expected2, dataOuter2.GroupJoin (dataInner2, x => x, x => x, (x, y) => { foreach (var s in y) x += s; return x; }, EqualityComparer<string>.Default));
                }
 
+               [Test]
+               public void GroupJoinWithNullKeys ()
+               {
+                       string[] l1 = { null };
+                       string[] l2 = { null, null };
+                       var res = l1.GroupJoin (l2, x => x, y => y, (a, b) => new { Key = a, Count = b.Count () }).ToArray ();
+                       Assert.AreEqual (1, res.Length);
+                       Assert.AreEqual (0, res [0].Count);
+               }
+
                [Test]
                public void OrderByArgumentNullTest ()
                {
@@ -1724,7 +1754,6 @@ namespace MonoTests.System.Linq {
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void GroupByArgumentNullTest ()
                {
                        string [] data = { "2", "1", "5", "3", "4" };
@@ -1772,7 +1801,6 @@ namespace MonoTests.System.Linq {
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void GroupByTest ()
                {
                        string [] data = { "2", "1", "5", "3", "4", "3" };
@@ -1818,6 +1846,35 @@ namespace MonoTests.System.Linq {
                        AssertAreSame (expected3, data.GroupBy (x => x, x => x, (x, y) => { foreach (var s in y) x += s; return x; }, EqualityComparer<string>.Default));
                }
 
+
+               class Data {
+
+                       public int Number;
+                       public string String;
+
+                       public Data (int number, string str)
+                       {
+                               Number = number;
+                               String = str;
+                       }
+               }
+
+               [Test]
+               public void GroupByLastNullGroup ()
+               {
+                       var values = new List<Data> ();
+
+                       values.Add (new Data (0, "a"));
+                       values.Add (new Data (1, "a"));
+                       values.Add (new Data (2, "b"));
+                       values.Add (new Data (3, "b"));
+                       values.Add (new Data (4, null));
+
+                       var groups = values.GroupBy (d => d.String);
+
+                       Assert.AreEqual (3, groups.Count ());
+               }
+
                [Test]
                public void ConcatArgumentNullTest ()
                {
@@ -2076,7 +2133,6 @@ namespace MonoTests.System.Linq {
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void ToDictionaryArgumentNullTest ()
                {
                        string [] data = { "2", "1", "5", "3", "4" };
@@ -2102,7 +2158,6 @@ namespace MonoTests.System.Linq {
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void ToDictionaryTest ()
                {
                        string [] data = { "2", "1", "5", "3", "4" };
@@ -2166,7 +2221,8 @@ namespace MonoTests.System.Linq {
                        expected.Add ("5", new List<string> () { "55" });
                        expected.Add ("4", new List<string> () { "42", "41" });
 
-
+                       Assert.AreEqual (expected.Count, ((IEnumerable<string>)data).ToLookup ((x => x [0].ToString ())).Count);
+                       
                        // ToLookup<string,string> (Func<string, string>)
                        AssertAreSame (expected, ((IEnumerable<string>) data).ToLookup ((x => x [0].ToString ())));
 
@@ -2179,6 +2235,25 @@ namespace MonoTests.System.Linq {
                        // ToLookup<string,string,string> (Func<string, string>, Func<string, string>, IEqualityComparer<string>)
                        AssertAreSame (expected, ((IEnumerable<string>) data).ToLookup (x => x [0].ToString (), x => x, EqualityComparer<string>.Default));
                }
+               
+               [Test]
+               public void ToLookupNullKeyTest ()
+               {
+                       string[] strs = new string[] { "one", null, "two", null, "three" };
+                       
+                       int i = 0;
+                       var l = strs.ToLookup (s => (s == null) ? null : "numbers", s => (s == null) ? (++i).ToString() : s);
+                       
+                       Assert.AreEqual (2, l.Count);
+                       Assert.AreEqual (2, l [null].Count());
+                       Assert.IsTrue (l [null].Contains ("1"));
+                       Assert.IsTrue (l [null].Contains ("2"));
+                       
+                       Assert.AreEqual (3, l ["numbers"].Count());
+                       Assert.IsTrue (l ["numbers"].Contains ("one"));
+                       Assert.IsTrue (l ["numbers"].Contains ("two"));
+                       Assert.IsTrue (l ["numbers"].Contains ("three"));
+               }
 
                [Test]
                public void DefaultIfEmptyArgumentNullTest ()
@@ -2273,5 +2348,14 @@ namespace MonoTests.System.Linq {
                        AssertException<ArgumentOutOfRangeException> (delegate () { Enumerable.Range (int.MaxValue - 5, 7); });
                        Enumerable.Range (int.MaxValue - 5, 6);
                }
+
+               [Test]
+               public void ExceptMultipleItems ()
+               {
+                       var data = new [] { 1, 2, 2, 2, 3, 4, 5, 5, 6, 7, 8, 8, 9, 10 };
+                       var expected = new [] { 2, 4, 6, 8, 10 };
+
+                       AssertAreSame (expected, data.Except (new [] { 1, 3, 5, 7, 9 }));
+               }
        }
 }