NH-3850 - Polymorphic Linq query results aggregators failures: amending test cases for acknowledging cases which will not be fixed, including a potential breaking change.

Author: fredericDelaporte

src/NHibernate.Test/NHSpecificTest/NH3850/Fixture.cs

@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using NHibernate.Linq;
 using NUnit.Framework;
@@ -350,14 +353,14 @@ public void AnyObject()
 		}
 
 		// Failing case till NH-3850 is fixed
-		[Test]
+		[Test, Ignore("Won't fix: requires reshaping the query")]
 		public void AverageBBase()
 		{
 			Average<DomainClassBExtendedByA>(1.5m);
 		}
 
 		// Non-reg case
-		[Test]
+		[Test, Ignore("Accidentally works: requires reshaping the query for being reliable")]
 		public void AverageCBase()
 		{
 			Average<DomainClassCExtendedByD>(1.5m);
@@ -378,7 +381,7 @@ public void AverageF()
 		}
 
 		// Failing case till NH-3850 is fixed
-		[Test]
+		[Test, Ignore("Won't fix: requires reshaping the query")]
 		public void AverageGBase()
 		{
 			Average<DomainClassGExtendedByH>(2.5m);
@@ -401,7 +404,7 @@ private void Average<DC>(decimal? expectedResult) where DC : DomainClassBase
 		}
 
 		// Failing case till NH-3850 is fixed
-		[Test]
+		[Test, Ignore("Won't fix: requires reshaping the query")]
 		public void AverageObject()
 		{
 			using (var session = OpenSession())
@@ -1113,7 +1116,7 @@ public void SumE()
 		}
 
 		// Non-reg case
-		[Test]
+		[Test, Ignore("Candidate potential breaking changes: Sum would now yield 0 instead of null on empty result sets.")]
 		public void SumF()
 		{
 			Sum<DomainClassF>(null);
@@ -1161,5 +1164,69 @@ private void Sum<DC>(int? expectedResult) where DC : DomainClassBase
 					Assert.AreEqual(expectedResult.Value, dbl.Value, 0.001d);
 			}
 		}
+
+		[Test]
+		public void BadOverload()
+		{
+			var sumMethodTemplate = ReflectionHelper.GetMethod(() => Queryable.Sum((IQueryable<int>)null));
+			Assert.Throws<InvalidOperationException>(() =>
+			{
+				ReflectionHelper.GetMethodOverload(sumMethodTemplate, new[] { typeof(object) });
+			});
+		}
+		
+		[Test, Explicit("Just a blunt perf comparison among some candidate overload reflection patterns, one being required for NH-3850")]
+		public void OverloadReflectionBluntPerfCompare()
+		{
+			var sumMethodTemplate = ReflectionHelper.GetMethod(() => Queryable.Sum((IQueryable<int>)null));
+
+			var swNoSameParamsCheck = new Stopwatch();
+			swNoSameParamsCheck.Start();
+			for (var i = 0; i < 1000; i++)
+			{
+				var sumMethod = sumMethodTemplate.DeclaringType.GetMethod(sumMethodTemplate.Name,
+					(sumMethodTemplate.IsStatic ? BindingFlags.Static : BindingFlags.Instance) | BindingFlags.Public,
+					null, new[] { typeof(IQueryable<decimal>) }, null);
+				Trace.TraceInformation(sumMethod.ToString());
+			}
+			swNoSameParamsCheck.Stop();
+			
+			var swCurrentChoiceSameType = new Stopwatch();
+			swCurrentChoiceSameType.Start();
+			for (var i = 0; i < 1000; i++)
+			{
+				var sumMethod = ReflectionHelper.GetMethodOverload(sumMethodTemplate, new[] { typeof(IQueryable<int>) });
+				Trace.TraceInformation(sumMethod.ToString());
+			}
+			swCurrentChoiceSameType.Stop();
+
+			var swCurrentChoice = new Stopwatch();
+			swCurrentChoice.Start();
+			for (var i = 0; i < 1000; i++)
+			{
+				var sumMethod = ReflectionHelper.GetMethodOverload(sumMethodTemplate, new[] { typeof(IQueryable<long>) });
+				Trace.TraceInformation(sumMethod.ToString());
+			}
+			swCurrentChoice.Stop();
+
+			var swEnHlp = new Stopwatch();
+			swEnHlp.Start();
+			for (var i = 0; i < 1000; i++)
+			{
+				// Testing the obsolete helper perf. Disable obsolete warning. Remove this swEnHlp part of the test if this helper is to be removed.
+#pragma warning disable 0618
+				var sumMethod = EnumerableHelper.GetMethod("Sum", new[] { typeof(IEnumerable<int>) });
+#pragma warning restore 0618
+				Trace.TraceInformation(sumMethod.ToString());
+			}
+			swEnHlp.Stop();
+
+			Assert.Pass(@"Blunt perf timings:
+Direct reflection: {0}
+Current impl, same overload: {1}
+Current impl, other overload: {2}
+EnumerableHelper.GetMethod(non generic overload): {3}",
+				swNoSameParamsCheck.Elapsed, swCurrentChoiceSameType.Elapsed, swCurrentChoice.Elapsed, swEnHlp.Elapsed);
+		}
 	}
 }