From 1c7dcfa0d514166ee24e8aab17f886eddd45f940 Mon Sep 17 00:00:00 2001
From: Bradley Grainger <bgrainger@gmail.com>
Date: Thu, 8 Apr 2010 20:13:52 -0700
Subject: [PATCH] Added argument validation, compatibility with OrderBy
 behaviour for null 'comparer'.

---
 src/Logos.Utility/EnumerableUtility.cs        | 18 +++++++--
 .../OrderedEnumerableTests.cs                 | 40 +++++++++++++++++++
 2 files changed, 54 insertions(+), 4 deletions(-)

diff --git a/src/Logos.Utility/EnumerableUtility.cs b/src/Logos.Utility/EnumerableUtility.cs
index 4e0e9b4..9de4e2d 100644
--- a/src/Logos.Utility/EnumerableUtility.cs
+++ b/src/Logos.Utility/EnumerableUtility.cs
@@ -31,7 +31,7 @@ public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> source)
 		/// elements that are requested from the return value.</remarks>
 		public static IOrderedEnumerable<TSource> LazyOrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
 		{
-			return LazyOrderBy(source, keySelector, Comparer<TKey>.Default);
+			return LazyOrderBy(source, keySelector, null, false);
 		}
 
 		/// <summary>
@@ -45,7 +45,7 @@ public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> source)
 		/// elements that are requested from the return value.</remarks>
 		public static IOrderedEnumerable<TSource> LazyOrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
 		{
-			return new OrderedEnumerable<TSource>(source, new ElementComparer<TSource, TKey>(keySelector, comparer, false, null));
+			return LazyOrderBy(source, keySelector, comparer, false);
 		}
 
 		/// <summary>
@@ -58,7 +58,7 @@ public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> source)
 		/// elements that are requested from the return value.</remarks>
 		public static IOrderedEnumerable<TSource> LazyOrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
 		{
-			return LazyOrderByDescending(source, keySelector, Comparer<TKey>.Default);
+			return LazyOrderBy(source, keySelector, null, true);
 		}
 
 		/// <summary>
@@ -72,7 +72,17 @@ public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> source)
 		/// elements that are requested from the return value.</remarks>
 		public static IOrderedEnumerable<TSource> LazyOrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
 		{
-			return new OrderedEnumerable<TSource>(source, new ElementComparer<TSource, TKey>(keySelector, comparer, true, null));
+			return LazyOrderBy(source, keySelector, comparer, true);
+		}
+
+		private static IOrderedEnumerable<TSource> LazyOrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer, bool descending)
+		{
+			if (source == null)
+				throw new ArgumentNullException("source");
+			if (keySelector == null)
+				throw new ArgumentNullException("keySelector");
+
+			return new OrderedEnumerable<TSource>(source, new ElementComparer<TSource, TKey>(keySelector, comparer ?? Comparer<TKey>.Default, descending, null));
 		}
 
 		/// <summary>
diff --git a/tests/Logos.Utility.Tests/OrderedEnumerableTests.cs b/tests/Logos.Utility.Tests/OrderedEnumerableTests.cs
index 22a5aaa..3025430 100644
--- a/tests/Logos.Utility.Tests/OrderedEnumerableTests.cs
+++ b/tests/Logos.Utility.Tests/OrderedEnumerableTests.cs
@@ -138,6 +138,46 @@ public void SortFirstDescendingCustom()
 			CollectionAssert.AreEqual(sorted1, sorted2);
 		}
 
+		[Test]
+		public void AscendingNullArguments()
+		{
+			Assert.Throws<ArgumentNullException>(() => ((IEnumerable<int>) null).OrderBy(x => x));
+			Assert.Throws<ArgumentNullException>(() => Enumerable.Range(0, 10).OrderBy((Func<int, int>) null));
+		}
+
+		[Test]
+		public void DescendingNullArguments()
+		{
+			Assert.Throws<ArgumentNullException>(() => ((IEnumerable<int>) null).OrderByDescending(x => x));
+			Assert.Throws<ArgumentNullException>(() => Enumerable.Range(0, 10).OrderByDescending((Func<int, int>) null));
+		}
+
+		[Test]
+		public void DefaultComparerAscending()
+		{
+			Random random = new Random(9);
+			int[] numbers = new int[100000];
+			for (int index = 0; index < numbers.Length; index++)
+				numbers[index] = random.Next();
+
+			var sorted1 = numbers.OrderBy(x => x, null);
+			var sorted2 = numbers.LazyOrderBy(x => x, null);
+			CollectionAssert.AreEqual(sorted1, sorted2);
+		}
+
+		[Test]
+		public void DefaultComparerDescending()
+		{
+			Random random = new Random(9);
+			int[] numbers = new int[100000];
+			for (int index = 0; index < numbers.Length; index++)
+				numbers[index] = random.Next();
+
+			var sorted1 = numbers.OrderByDescending(x => x, null);
+			var sorted2 = numbers.LazyOrderByDescending(x => x, null);
+			CollectionAssert.AreEqual(sorted1, sorted2);
+		}
+
 		// The Triple struct can be used to verify that the sort is stable by sorting by the First (and Second)
 		// properties, then using the Third property to verify that objects are in the right order.
 		[DebuggerDisplay("F={m_first} S={m_second} T={m_third}")]