2007-11-13 Jb Evain <jbevain@novell.com>

	* EnumerableTest.cs: unit tests are good.

svn path=/trunk/mcs/; revision=89514

diff --git a/mcs/class/System.Core/Test/System.Linq/ChangeLog b/mcs/class/System.Core/Test/System.Linq/ChangeLog
index 0a7e2513bf93def40a33158a3d5433c3b8f3875b..bf56c7dc47e4942431ed5bb718a4d341bfc91847 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq/ChangeLog
+++ b/mcs/class/System.Core/Test/System.Linq/ChangeLog
@@ -1,3 +1,7 @@
+2007-11-13  Jb Evain  <jbevain@novell.com>
+
+       * EnumerableTest.cs: unit tests are good.
+
 2007-11-08  Jb Evain  <jbevain@novell.com>
 
        * EnumerableTest.cs: add test for SequenceEqual.

diff --git a/mcs/class/System.Core/Test/System.Linq/EnumerableTest.cs b/mcs/class/System.Core/Test/System.Linq/EnumerableTest.cs
index f0082293aac580d88c96df3657a7aabd8687a8b2..e181854f595fdd4d761a3a536268521e84fa3a8d 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq/EnumerableTest.cs
+++ b/mcs/class/System.Core/Test/System.Linq/EnumerableTest.cs
@@ -69,6 +69,54 @@ namespace MonoTests.System.Linq {
                        AssertAreSame (result, first.Union (second));
                }
 
+               class Foo {}
+               class Bar : Foo {}
+
+               [Test]
+               public void TestCast ()
+               {
+                       Bar a = new Bar ();
+                       Bar b = new Bar ();
+                       Bar c = new Bar ();
+
+                       Foo [] foos = new Foo [] {a, b, c};
+                       Bar [] result = new Bar [] {a, b, c};
+
+                       AssertAreSame (result, foos.Cast<Bar> ());
+               }
+
+               [Test]
+               public void TestLast ()
+               {
+                       int [] data = {1, 2, 3};
+
+                       Assert.AreEqual (3, data.Last ());
+               }
+
+               [Test]
+               public void TestLastOrDefault ()
+               {
+                       int [] data = {};
+
+                       Assert.AreEqual (default (int), data.LastOrDefault ());
+               }
+
+               [Test]
+               public void TestFirst ()
+               {
+                       int [] data = {1, 2, 3};
+
+                       Assert.AreEqual (1, data.First ());
+               }
+
+               [Test]
+               public void TestFirstOrDefault ()
+               {
+                       int [] data = {};
+
+                       Assert.AreEqual (default (int), data.FirstOrDefault ());
+               }
+
                [Test]
                public void TestSequenceEqual ()
                {
@@ -80,6 +128,113 @@ namespace MonoTests.System.Linq {
                        Assert.IsTrue (first.SequenceEqual (third));
                }
 
+               [Test]
+               public void TestSkip ()
+               {
+                       int [] data = {0, 1, 2, 3, 4, 5};
+                       int [] result = {3, 4, 5};
+
+                       AssertAreSame (result, data.Skip (3));
+               }
+
+               [Test]
+               public void TestSkipWhile ()
+               {
+                       int [] data = {0, 1, 2, 3, 4, 5};
+                       int [] result = {3, 4, 5};
+
+                       AssertAreSame (result, data.SkipWhile (i => i < 3));
+               }
+
+               [Test]
+               public void TestTake ()
+               {
+                       int [] data = {0, 1, 2, 3, 4, 5};
+                       int [] result = {0, 1, 2};
+
+                       AssertAreSame (result, data.Take (3));
+               }
+
+               [Test]
+               public void TestTakeWhile ()
+               {
+                       int [] data = {0, 1, 2, 3, 4, 5};
+                       int [] result = {0, 1, 2};
+
+                       AssertAreSame (result, data.TakeWhile (i => i < 3));
+               }
+
+               [Test]
+               public void TestSelect ()
+               {
+                       int [] data = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+                       int [] result = {1, 3, 5, 7, 9};
+
+                       AssertAreSame (result, data.Where (i => i % 2 != 0));
+               }
+
+               //[Test]
+               //public void TestReverse ()
+               //{
+               //      int [] data = {0, 1, 2, 3, 4};
+               //      int [] result = {4, 3, 2, 1, 0};
+               //
+               //      AssertAreSame (result, data.Reverse ());
+               //}
+
+               [Test]
+               public void TestSum ()
+               {
+                       int [] data = {1, 2, 3, 4};
+
+                       Assert.AreEqual (10, data.Sum ());
+               }
+
+               [Test]
+               public void TestMax ()
+               {
+                       int [] data = {1, 3, 5, 2};
+
+                       Assert.AreEqual (5, data.Max ());
+               }
+
+               [Test]
+               public void TestMin ()
+               {
+                       int [] data = {3, 5, 2, 6, 1, 7};
+
+                       Assert.AreEqual (1, data.Min ());
+               }
+
+               [Test]
+               public void TestToList ()
+               {
+                       int [] data = {3, 5, 2};
+
+                       var list = data.ToList ();
+
+                       AssertAreSame (data, list);
+
+                       Assert.AreEqual (typeof (List<int>), list.GetType ());
+               }
+
+               [Test]
+               public void TestToArray ()
+               {
+                       ICollection<int> coll = new List<int> ();
+                       coll.Add (0);
+                       coll.Add (1);
+                       coll.Add (2);
+
+                       int [] result = {0, 1, 2};
+
+                       var array = coll.ToArray ();
+
+                       AssertAreSame (result, array);
+
+                       Assert.AreEqual (typeof (int []), array.GetType ());
+               }
+
                static void AssertAreSame<T> (IEnumerable<T> expected, IEnumerable<T> actual)
                {
                        if (expected == null) {