Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/System.Data.DataSetExtensions/Test/Makefile

@@ -0,0 +1,8 @@
+thisdir = class/System.Data.DataSetExtensions/Test
+include ../../../build/rules.make
+
+all-local install-local clean-local test-local run-test-local run-test-ondotnet-local uninstall-local doc-update-local csproj-local:
+
+DISTFILES =  $(wildcard *.aspx)
+
+dist-local: dist-default

mcs/class/System.Data.DataSetExtensions/Test/System.Data/ChangeLog

@@ -0,0 +1,28 @@
+2008-12-02  Marek Habersack  <mhabersack@novell.com>
+
+	* DataRowExtensionsTest.cs: added
+
+2008-08-15  Gert Driesen  <drieseng@users.sourceforge.net>
+
+	* DataRowComparerTest.cs: added tests for Equals and GetHashCode.
+	Enabled GetHashCodeWithVersions test.
+
+2008-05-14  Atsushi Enomoto  <atsushi@ximian.com>
+
+	* DataTableExtensionsTest.cs : new test.
+
+2008-05-14  Atsushi Enomoto  <atsushi@ximian.com>
+
+	* EnumerableRowCollectionTest.cs : added tests for thenby (again
+	  commented out yet).
+
+2008-05-13  Atsushi Enomoto  <atsushi@ximian.com>
+
+	* EnumerableRowCollectionTest.cs : added tests for orderby (though
+	  commented out; they do not compile).
+
+2008-05-13  Atsushi Enomoto  <atsushi@ximian.com>
+
+	* DataRowComparerTest.cs, EnumerableRowCollectionTest.cs,
+	  testdataset1.xml : new tests.
+

mcs/class/System.Data.DataSetExtensions/Test/System.Data/DataRowComparerTest.cs

@@ -0,0 +1,254 @@
+//
+// DataRowComparerTest.cs
+//
+// Author:
+//   Atsushi Enomoto  <atsushi@ximian.com>
+//
+// Copyright (C) 2008 Novell, Inc. http://www.novell.com
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using NUnit.Framework;
+
+namespace MonoTests.System.Data
+{
+	[TestFixture]
+	public class DataRowComparerTest
+	{
+		[Test]
+		public void Default ()
+		{
+			DataRowComparer<DataRow> c1 = DataRowComparer.Default;
+			DataRowComparer<DataRow> c2 = DataRowComparer.Default;
+			Assert.AreSame (c1, c2);
+		}
+
+		[Test]
+		public void Equals ()
+		{
+			DataRowComparer<DataRow> c = DataRowComparer.Default;
+
+			DataTable dtA = new DataTable ("tableA");
+			dtA.Columns.Add ("col1", typeof (int));
+			dtA.Columns.Add ("col2", typeof (string));
+			dtA.Columns.Add ("col3", typeof (DateTime));
+			DataRow r1 = dtA.Rows.Add (3, "bar", new DateTime (2008, 5, 7));
+			DataRow r2 = dtA.Rows.Add (3, "bar", new DateTime (2008, 5, 7));
+
+			Assert.IsTrue (c.Equals (r1, r2), "#A1");
+			r1 ["col1"] = 4;
+			Assert.IsFalse (c.Equals (r1, r2), "#A2");
+			r1 ["col1"] = 3;
+			Assert.IsTrue (c.Equals (r1, r2), "#A3");
+
+			r1 ["col2"] = null;
+			Assert.IsFalse (c.Equals (r1, r2), "#B1");
+			r2 ["col2"] = null;
+			Assert.IsTrue (c.Equals (r1, r2), "#B2");
+			r1 ["col2"] = "bar";
+			Assert.IsFalse (c.Equals (r1, r2), "#B3");
+			r2 ["col2"] = "bar";
+			Assert.IsTrue (c.Equals (r1, r2), "#B4");
+
+			r1 ["col3"] = DBNull.Value;
+			Assert.IsFalse (c.Equals (r1, r2), "#C1");
+			r2 ["col3"] = DBNull.Value;
+			Assert.IsTrue (c.Equals (r1, r2), "#C2");
+			r1 ["col3"] = new DateTime (2008, 5, 7);
+			Assert.IsFalse (c.Equals (r1, r2), "#C3");
+			r2 ["col3"] = new DateTime (2008, 5, 7);
+			Assert.IsTrue (c.Equals (r1, r2), "#C4");
+
+			Assert.IsFalse (c.Equals (r1, null), "#D1");
+			Assert.IsFalse (c.Equals (null, r1), "#D2");
+			Assert.IsTrue (c.Equals (null, null), "#D3");
+
+			// rows do not have to share the same parent
+
+			DataTable dtB = new DataTable ("tableB");
+			dtB.Columns.Add ("colB1", typeof (int));
+			dtB.Columns.Add ("colB2", typeof (string));
+			dtB.Columns.Add ("colB3", typeof (DateTime));
+
+			DataRow r3 = dtB.Rows.Add (3, "bar", new DateTime (2008, 5, 7));
+
+			Assert.IsTrue (c.Equals (r1, r3), "#E1");
+			r1 ["col1"] = 4;
+			Assert.IsFalse (c.Equals (r1, r3), "#E2");
+			r1 ["col1"] = 3;
+			Assert.IsTrue (c.Equals (r1, r3), "#E3");
+
+			// difference in rowstate is ignored
+
+			r1.AcceptChanges ();
+
+			Assert.IsTrue (c.Equals (r1, r2), "#G1");
+			r1 ["col1"] = 4;
+			Assert.IsFalse (c.Equals (r1, r2), "#G2");
+			r1 ["col1"] = 3;
+			Assert.IsTrue (c.Equals (r1, r2), "#G3");
+
+			// rows have different number of columns
+
+			DataTable dtC = new DataTable ("tableC");
+			dtC.Columns.Add ("colC1", typeof (int));
+			dtC.Columns.Add ("colC2", typeof (string));
+
+			DataRow r4 = dtC.Rows.Add (3, "bar");
+
+			Assert.IsFalse (c.Equals (r1, r4), "#H1");
+			r1 ["col3"] = DBNull.Value;
+			Assert.IsFalse (c.Equals (r1, r4), "#H2");
+		}
+
+		[Test]
+		public void Equals_Rows_Detached ()
+		{
+			DataRowComparer<DataRow> c = DataRowComparer.Default;
+
+			DataTable dt = new DataTable ("tableA");
+			dt.Columns.Add ("col1", typeof (int));
+			dt.Columns.Add ("col2", typeof (string));
+			dt.Columns.Add ("col3", typeof (DateTime));
+			DataRow r1 = dt.Rows.Add (3, "bar", new DateTime (2008, 5, 7));
+			DataRow r2 = dt.NewRow ();
+			r2.ItemArray = new object [] { 3, "bar", new DateTime (2008, 5, 7) };
+			DataRow r3 = dt.NewRow ();
+			r3.ItemArray = new object [] { 3, "bar", new DateTime (2008, 5, 7) };
+
+			// left row detached
+			Assert.IsTrue (c.Equals (r2, r1), "#A1");
+			r1 ["col1"] = 4;
+			Assert.IsFalse (c.Equals (r2, r1), "#A2");
+			r1 ["col1"] = 3;
+			Assert.IsTrue (c.Equals (r2, r1), "#A3");
+
+			// right row detached
+			Assert.IsTrue (c.Equals (r1, r2), "#B1");
+			r1 ["col2"] = "baz";
+			Assert.IsFalse (c.Equals (r1, r2), "#B2");
+			r1 ["col2"] = "bar";
+			Assert.IsTrue (c.Equals (r1, r2), "#B3");
+
+			// both rows detached
+			Assert.IsTrue (c.Equals (r2, r3), "#C1");
+			r2 ["col3"] = new DateTime (2008, 6, 7);
+			Assert.IsFalse (c.Equals (r2, r3), "#C2");
+			r2 ["col3"] = new DateTime (2008, 5, 7);
+			Assert.IsTrue (c.Equals (r2, r3), "#C3");
+		}
+
+		[Test]
+		public void Equals_Rows_Deleted ()
+		{
+			DataRowComparer<DataRow> c = DataRowComparer.Default;
+
+			DataTable dtA = new DataTable ("tableA");
+			dtA.Columns.Add ("col1", typeof (int));
+			dtA.Columns.Add ("col2", typeof (string));
+			dtA.Columns.Add ("col3", typeof (DateTime));
+			DataRow r1 = dtA.Rows.Add (3, "bar", new DateTime (2008, 5, 7));
+			DataRow r2 = dtA.Rows.Add (3, "bar", new DateTime (2008, 5, 7));
+
+			r1.Delete ();
+
+			// left row deleted
+			try {
+				c.Equals (r1, r2);
+				Assert.Fail ("#A1");
+			} catch (RowNotInTableException ex) {
+				Assert.AreEqual (typeof (RowNotInTableException), ex.GetType (), "#A2");
+				Assert.IsNull (ex.InnerException, "#A3");
+				Assert.IsNotNull (ex.Message, "#A4");
+			}
+
+			// right row deleted
+			try {
+				c.Equals (r2, r1);
+				Assert.Fail ("#B1");
+			} catch (RowNotInTableException ex) {
+				Assert.AreEqual (typeof (RowNotInTableException), ex.GetType (), "#B2");
+				Assert.IsNull (ex.InnerException, "#B3");
+				Assert.IsNotNull (ex.Message, "#B4");
+			}
+
+			r2.Delete ();
+
+			// both rows deleted
+			try {
+				c.Equals (r2, r1);
+				Assert.Fail ("#C1");
+			} catch (RowNotInTableException ex) {
+				Assert.AreEqual (typeof (RowNotInTableException), ex.GetType (), "#C2");
+				Assert.IsNull (ex.InnerException, "#C3");
+				Assert.IsNotNull (ex.Message, "#C4");
+			}
+		}
+
+		[Test]
+		public void GetHashCodeWithVersions ()
+		{
+			DataSet ds = new DataSet ();
+			DataTable dt = new DataTable ("MyTable");
+			ds.Tables.Add (dt);
+			dt.Columns.Add ("col1");
+			dt.Columns.Add ("col2");
+			DataRow r1 = dt.Rows.Add (new object [] {"foo", "bar"});
+			DataRow r2 = dt.Rows.Add (new object [] {"foo", "bar"});
+			ds.AcceptChanges ();
+			DataRowComparer<DataRow> c = DataRowComparer.Default;
+			Assert.IsTrue (c.GetHashCode (r1) == c.GetHashCode (r2), "#1");
+			/*
+			// LAMESPEC: .NET fails here
+			r2 ["col2"] = "baz";
+			r2.AcceptChanges ();
+			Assert.IsFalse (c.GetHashCode (r1) == c.GetHashCode (r2), "#2");
+			ds.AcceptChanges (); // now r2 original value is "baz"
+			r2 ["col2"] = "bar";
+			Assert.IsFalse (c.GetHashCode (r1) == c.GetHashCode (r2), "#3");
+			// LAMESPEC: .NET fails here
+			DataRow r3 = dt.Rows.Add (new object [] {"foo", "baz"});
+			Assert.IsFalse (c.GetHashCode (r1) == c.GetHashCode (r3), "#4");
+			*/
+		}
+
+		[Test]
+		public void GetHashCode_Row_Null ()
+		{
+			DataRowComparer<DataRow> c = DataRowComparer.Default;
+
+			try {
+				c.GetHashCode (null);
+				Assert.Fail ("#1");
+			} catch (ArgumentNullException ex) {
+				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+				Assert.IsNull (ex.InnerException, "#3");
+				Assert.IsNotNull (ex.Message, "#4");
+				Assert.AreEqual ("row", ex.ParamName, "#5");
+			}
+		}
+	}
+}

mcs/class/System.Data.DataSetExtensions/Test/System.Data/DataRowExtensionsTest.cs

@@ -0,0 +1,82 @@
+//
+// DataRowExtensionsTest.cs
+//
+// Author:
+//   Marek Habersack (mhabersack@novell.com)
+//
+// Copyright (C) 2008 Novell, Inc. http://www.novell.com
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using NUnit.Framework;
+
+namespace MonoTests.System.Data
+{
+	[TestFixture]
+	public class DataRowExtensionsTest
+	{
+		DataRow SetupRow ()
+		{
+			DataTable dt = new DataTable ("TestTable");
+			DataColumn dc = new DataColumn ("Column1", typeof (string));
+			dc.AllowDBNull = true;
+			dt.Columns.Add (dc);
+
+			dc = new DataColumn ("Column2", typeof (int));
+			dc.AllowDBNull = true;
+			dt.Columns.Add (dc);
+			
+			DataRow row = dt.NewRow ();
+			dt.Rows.Add (row);
+			return row;
+		}
+		
+		[Test]
+		public void Field_T_DBNullFieldValue ()
+		{
+			DataRow row = SetupRow ();
+			row ["Column1"] = null;
+			row ["Column2"] = DBNull.Value;
+			
+			string s = row.Field <string> ("Column1");
+			Assert.AreEqual (null, s, "#A1");
+
+			int? i = row.Field <int?> ("Column2");
+			Assert.AreEqual (null, i, "#A2");
+		}
+
+		[Test]
+		[ExpectedException (typeof (StrongTypingException))]
+		public void Field_T_DBNullFieldValue_ValueType ()
+		{
+			DataRow row = SetupRow ();
+			row ["Column1"] = null;
+			row ["Column2"] = DBNull.Value;
+
+			int i = row.Field <int> ("Column2");
+		}
+	}
+}

mcs/class/System.Data.DataSetExtensions/Test/System.Data/DataTableExtensionsTest.cs

@@ -0,0 +1,86 @@
+//
+// DataTableExtensionsTest.cs
+//
+// Author:
+//   Atsushi Enomoto  <atsushi@ximian.com>
+//
+// Copyright (C) 2008 Novell, Inc. http://www.novell.com
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using NUnit.Framework;
+
+namespace MonoTests.System.Data
+{
+	[TestFixture]
+	public class DataTableExtensionsTest
+	{
+		[Test]
+		[ExpectedException (typeof (InvalidOperationException))] // for no rows
+		public void CopyToDataTableNoArgNoRows ()
+		{
+			DataTable dt = new DataTable ();
+			dt.Columns.Add ("CID", typeof (int));
+			dt.Columns.Add ("CName", typeof (string));
+			dt.AsEnumerable ().CopyToDataTable<DataRow> ();
+		}
+
+		[Test]
+		public void CopyToDataTableNoArg ()
+		{
+			DataTable dt = new DataTable ();
+			dt.Columns.Add ("CID", typeof (int));
+			dt.Columns.Add ("CName", typeof (string));
+			dt.Rows.Add (new object [] {1, "foo"});
+			DataTable dst = dt.AsEnumerable ().CopyToDataTable<DataRow> ();
+			Assert.AreEqual (1, dst.Rows.Count, "#1");
+			Assert.AreEqual ("foo", dst.Rows [0] ["CName"], "#2");
+		}
+
+		[Test]
+		// no error for empty table this time.
+		[Category ("NotWorking")] // some DataTableReader internal issues
+		public void CopyToDataTableTableArgNoRows ()
+		{
+			DataTable dt = new DataTable ();
+			dt.Columns.Add ("CID", typeof (int));
+			dt.Columns.Add ("CName", typeof (string));
+			DataTable dst = new DataTable ();
+			dt.AsEnumerable ().CopyToDataTable<DataRow> (dst, LoadOption.PreserveChanges);
+		}
+
+		[Test]
+		public void AsDataView ()
+		{
+			DataSet ds = new DataSet ();
+			ds.ReadXml ("Test/System.Data/testdataset1.xml");
+			DataTable dt = ds.Tables [0];
+			var dv = dt.AsEnumerable ().Where<DataRow> ((DataRow r) => (int) r ["Score"] > 60).AsDataView<DataRow> ();
+			Assert.AreEqual (1, dv [0] ["ID"], "#1");
+			Assert.AreEqual (4, dv [1] ["ID"], "#2");
+		}
+	}
+}

mcs/class/System.Data.DataSetExtensions/Test/System.Data/EnumerableRowCollectionTest.cs

@@ -0,0 +1,206 @@
+//
+// EnumerableRowCollectionTest.cs
+//
+// Author:
+//   Atsushi Enomoto  <atsushi@ximian.com>
+//
+// Copyright (C) 2008 Novell, Inc. http://www.novell.com
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using NUnit.Framework;
+
+namespace MonoTests.System.Data
+{
+	[TestFixture]
+	public class EnumerableRowCollectionTest
+	{
+		[Test]
+		public void QueryWhere ()
+		{
+			var ds = new DataSet ();
+			ds.ReadXml ("Test/System.Data/testdataset1.xml");
+			var table = ds.Tables [0];
+			/* schema generated as ...
+			var table = ds.Tables.Add ("ScoreList");
+			table.Columns.Add ("ID", typeof (int));
+			table.Columns.Add ("RegisteredDate", typeof (DateTime));
+			table.Columns.Add ("Name", typeof (string));
+			table.Columns.Add ("Score", typeof (int));
+			ds.WriteXml ("Test/System.Data/testdataset1.xsd", XmlWriteMode.WriteSchema);
+			*/
+			var q = from line in table.AsEnumerable ()
+				where line.Field<int> ("Score") > 80
+				select line;
+			bool iterated = false;
+			foreach (var line in q) {
+				if (iterated)
+					Assert.Fail ("should match only one raw");
+				Assert.AreEqual (100, line ["Score"], "#1");
+				iterated = true;
+			}
+		}
+
+		/* FIXME: enable it when it gets fixed: https://bugzilla.novell.com/show_bug.cgi?id=389795
+		[Test]
+		public void QueryWhereSelect ()
+		{
+			var ds = new DataSet ();
+			ds.ReadXml ("Test/System.Data/testdataset1.xml");
+			var table = ds.Tables [0];
+			var q = from line in table.AsEnumerable ()
+				where line.Field<int> ("Score") > 80
+				select new {
+					StudentID = line.Field<int> ("ID"),
+					StudentName = line.Field<string> ("Name"),
+					StudentScore = line.Field<int> ("Score") };
+			bool iterated = false;
+			foreach (var ql in q) {
+				if (iterated)
+					Assert.Fail ("should match only one raw");
+				Assert.AreEqual (100, ql.StudentScore, "#1");
+				iterated = true;
+			}
+		}
+
+		[Test]
+		public void QueryWhereSelectOrderBy ()
+		{
+			var ds = new DataSet ();
+			ds.ReadXml ("Test/System.Data/testdataset1.xml");
+			var table = ds.Tables [0];
+			var q = from line in table.AsEnumerable ()
+				where line.Field<int> ("Score") >= 80
+				orderby line.Field<int> ("ID")
+				select new {
+					StudentID = line.Field<int> ("ID"),
+					StudentName = line.Field<string> ("Name"),
+					StudentScore = line.Field<int> ("Score") };
+			int prevID = -1;
+			foreach (var ql in q) {
+				switch (prevID) {
+				case -1:
+					Assert.AreEqual (4, ql.StudentID, "#1");
+					break;
+				case 4:
+					Assert.AreEqual (1, ql.StudentID, "#2");
+					break;
+				default:
+					Assert.Fail ("should match only one raw");
+				}
+				prevID = ql.StudentID;
+			}
+		}
+
+		[Test]
+		public void QueryWhereSelectOrderByDescending ()
+		{
+			var ds = new DataSet ();
+			ds.ReadXml ("Test/System.Data/testdataset1.xml");
+			var table = ds.Tables [0];
+			var q = from line in table.AsEnumerable ()
+				where line.Field<int> ("Score") >= 80
+				orderby line.Field<int> ("ID") descending
+				select new {
+					StudentID = line.Field<int> ("ID"),
+					StudentName = line.Field<string> ("Name"),
+					StudentScore = line.Field<int> ("Score") };
+			int prevID = -1;
+			foreach (var ql in q) {
+				switch (prevID) {
+				case -1:
+					Assert.AreEqual (1, ql.StudentID, "#1");
+					break;
+				case 4:
+					Assert.AreEqual (4, ql.StudentID, "#2");
+					break;
+				default:
+					Assert.Fail ("should match only one raw");
+				}
+				prevID = ql.StudentID;
+			}
+		}
+
+		[Test]
+		public void ThenBy ()
+		{
+			var ds = new DataSet ();
+			ds.ReadXml ("Test/System.Data/testdataset1.xml");
+			var table = ds.Tables [0];
+			var q = from line in table.AsEnumerable ()
+				where line.Field<int> ("Score") >= 80
+				orderby line.Field<bool> ("Gender"), line.Field<int> ("ID")
+				select new {
+					StudentID = line.Field<int> ("ID"),
+					StudentName = line.Field<string> ("Name"),
+					StudentScore = line.Field<int> ("Score") };
+			int prevID = -1;
+			foreach (var ql in q) {
+				switch (prevID) {
+				case -1:
+					Assert.AreEqual (4, ql.StudentID, "#1");
+					break;
+				case 4:
+					Assert.AreEqual (1, ql.StudentID, "#2");
+					break;
+				default:
+					Assert.Fail ("should match only one raw");
+				}
+				prevID = ql.StudentID;
+			}
+		}
+
+		[Test]
+		public void ThenByDescending ()
+		{
+			var ds = new DataSet ();
+			ds.ReadXml ("Test/System.Data/testdataset1.xml");
+			var table = ds.Tables [0];
+			var q = from line in table.AsEnumerable ()
+				where line.Field<int> ("Score") >= 80
+				orderby line.Field<bool> ("Gender"), line.Field<int> ("ID") descending
+				select new {
+					StudentID = line.Field<int> ("ID"),
+					StudentName = line.Field<string> ("Name"),
+					StudentScore = line.Field<int> ("Score") };
+			int prevID = -1;
+			foreach (var ql in q) {
+				switch (prevID) {
+				case -1:
+					Assert.AreEqual (1, ql.StudentID, "#1");
+					break;
+				case 4:
+					Assert.AreEqual (4, ql.StudentID, "#2");
+					break;
+				default:
+					Assert.Fail ("should match only one raw");
+				}
+				prevID = ql.StudentID;
+			}
+		}
+		*/
+	}
+}

mcs/class/System.Data.DataSetExtensions/Test/System.Data/testdataset1.xml

@@ -0,0 +1,50 @@
+<TestDataSet>
+  <xs:schema id="NewDataSet" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xs:element name="NewDataSet" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">
+      <xs:complexType>
+        <xs:choice minOccurs="0" maxOccurs="unbounded">
+          <xs:element name="ScoreList">
+            <xs:complexType>
+              <xs:sequence>
+                <xs:element name="ID" type="xs:int" minOccurs="0" />
+                <xs:element name="RegisteredDate" type="xs:dateTime" minOccurs="0" />
+                <xs:element name="Name" type="xs:string" minOccurs="0" />
+                <xs:element name="Score" type="xs:int" minOccurs="0" />
+                <xs:element name="Gender" type="xs:boolean" minOccurs="0" />
+              </xs:sequence>
+            </xs:complexType>
+          </xs:element>
+        </xs:choice>
+      </xs:complexType>
+    </xs:element>
+  </xs:schema>
+  <ScoreList>
+    <ID>1</ID>
+    <RegisteredDate>2008-05-13T00:00:00.000</RegisteredDate>
+    <Name>Dorkpuff</Name>
+    <Score>100</Score>
+    <Gender>0</Gender>
+  </ScoreList>
+  <ScoreList>
+    <ID>2</ID>
+    <RegisteredDate>2008-05-14T00:00:00.000</RegisteredDate>
+    <Name>Headfoot</Name>
+    <Score>30</Score>
+    <Gender>0</Gender>
+  </ScoreList>
+  <ScoreList>
+    <ID>3</ID>
+    <RegisteredDate>2008-05-15T00:00:00.000</RegisteredDate>
+    <Name>Muckdoof</Name>
+    <Score>60</Score>
+    <Gender>1</Gender>
+  </ScoreList>
+  <ScoreList>
+    <ID>4</ID>
+    <RegisteredDate>2008-05-16T00:00:00.000</RegisteredDate>
+    <Name>Numbcheese</Name>
+    <Score>80</Score>
+    <Gender>0</Gender>
+  </ScoreList>
+</TestDataSet>
+