EntityWithUserTypeCanHaveLinqGenerators: Fix R# warnings and various minor cleanup.

oskarb · oskarb · commit a96e826b9199 · 2016-11-20T11:18:00.000+01:00
diff --git a/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/EntityWithUserTypeProperty.cs b/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/EntityWithUserTypeProperty.cs
@@ -1,9 +1,4 @@
-﻿using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using NHibernate.Mapping.ByCode;
-using NHibernate.Mapping.ByCode.Conformist;
-
+﻿
 namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators
 {
 	public class EntityWithUserTypeProperty
diff --git a/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/EntityWithUserTypePropertyGeneratorsRegistry.cs b/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/EntityWithUserTypePropertyGeneratorsRegistry.cs
@@ -5,10 +5,10 @@ namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators
 {
 	public class EntityWithUserTypePropertyGeneratorsRegistry : DefaultLinqToHqlGeneratorsRegistry
 	{
-		public EntityWithUserTypePropertyGeneratorsRegistry() : base()
+		public EntityWithUserTypePropertyGeneratorsRegistry()
 		{
 			RegisterGenerator(ReflectionHelper.GetMethod((IExample e) => e.IsEquivalentTo(null)),
-							new EntityWithUserTypePropertyIsEquivelentGenerator());
+							new EntityWithUserTypePropertyIsEquivalentGenerator());
 		}
 	}
-}
+}
diff --git a/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/EntityWithUserTypePropertyIsEquivalentGenerator.cs b/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/EntityWithUserTypePropertyIsEquivalentGenerator.cs
@@ -9,24 +9,27 @@
 
 namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators
 {
-	public class EntityWithUserTypePropertyIsEquivelentGenerator : BaseHqlGeneratorForMethod
+	public class EntityWithUserTypePropertyIsEquivalentGenerator : BaseHqlGeneratorForMethod
 	{
-		public EntityWithUserTypePropertyIsEquivelentGenerator() : base()
+		public EntityWithUserTypePropertyIsEquivalentGenerator()
 		{
-			SupportedMethods = new[] { ReflectionHelper.GetMethodDefinition((IExample e) => e.IsEquivalentTo(null)) };
+			SupportedMethods = new[] {ReflectionHelper.GetMethodDefinition((IExample e) => e.IsEquivalentTo(null))};
 		}
-		public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
+
+		public override HqlTreeNode BuildHql(
+			MethodInfo method,
+			Expression targetObject,
+			ReadOnlyCollection<Expression> arguments,
+			HqlTreeBuilder treeBuilder,
+			IHqlExpressionVisitor visitor)
 		{
 			var left = treeBuilder.Cast(visitor.Visit(targetObject).AsExpression(), typeof(string));
-			var right = treeBuilder.Cast(visitor.Visit(arguments.Cast<Expression>().First()).AsExpression(),
-										 typeof(string));
-
-
+			var right = treeBuilder.Cast(visitor.Visit(arguments.First()).AsExpression(), typeof(string));
 
 			var leftSubstring = treeBuilder.MethodCall("substring", left, treeBuilder.Constant(4));
 			var rightSubstring = treeBuilder.MethodCall("substring", right, treeBuilder.Constant(4));
 			var equals = treeBuilder.Equality(leftSubstring, rightSubstring);
 			return equals;
 		}
 	}
-}
+}
diff --git a/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/ExampleUserType.cs b/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/ExampleUserType.cs
@@ -1,7 +1,5 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Data;
-using System.Text;
 using NHibernate.SqlTypes;
 using NHibernate.UserTypes;
 
@@ -54,7 +52,7 @@ public object Disassemble(object value)
 			return value;
 		}
 
-		public SqlType[] SqlTypes { get { return new[] { SqlTypeFactory.GetString(255) }; } }
+		public SqlType[] SqlTypes { get { return new SqlType[] { SqlTypeFactory.GetString(255) }; } }
 
 		public System.Type ReturnedType { get { return typeof(IExample); } }
 		public bool IsMutable { get { return true; } }
diff --git a/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/Fixture.cs
@@ -1,11 +1,7 @@
-﻿using System;
-using System.Collections;
+﻿using System.Collections;
 using System.Linq;
 using NHibernate.Cfg;
-using NHibernate.Dialect;
 using NHibernate.Linq;
-using NHibernate.Mapping.ByCode;
-using NHibernate.Test.NHSpecificTest.FileStreamSql2008;
 using NUnit.Framework;
 
 
@@ -25,16 +21,10 @@ protected override string MappingsAssembly
 			get { return "NHibernate.Test"; }
 		}
 
-		protected override bool AppliesTo(Dialect.Dialect dialect)
+		protected override void Configure(Configuration configuration)
 		{
-			return true;
-		}
-
-		protected override void Configure(Configuration cfg)
-		{
-
-			base.Configure(cfg);
-			cfg.LinqToHqlGeneratorsRegistry<EntityWithUserTypePropertyGeneratorsRegistry>();
+			base.Configure(configuration);
+			configuration.LinqToHqlGeneratorsRegistry<EntityWithUserTypePropertyGeneratorsRegistry>();
 		}
 
 		protected override void OnSetUp()
@@ -111,8 +101,9 @@ public void LinqMethodWorksForUserType()
 				Assert.AreEqual(2, entities.Count);
 			}
 		}
+
 		[Test]
-		public void CanQueryWithHQL()
+		public void CanQueryWithHql()
 		{
 			using (var session = OpenSession())
 			using (session.BeginTransaction())
@@ -126,4 +117,4 @@ public void CanQueryWithHQL()
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/IExample.cs b/src/NHibernate.Test/NHSpecificTest/EntityWithUserTypeCanHaveLinqGenerators/IExample.cs
@@ -1,11 +1,9 @@
-using System;
 
 namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators
 {
-	
 	public interface IExample
 	{
 		string Value { get; set; }
 		bool IsEquivalentTo(IExample that);
 	}
-}
+}
diff --git a/src/NHibernate.Test/NHibernate.Test.csproj b/src/NHibernate.Test/NHibernate.Test.csproj
@@ -725,7 +725,7 @@
     <Compile Include="Component\Basic\ComponentWithUniqueConstraintTests.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\BarExample.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\EntityWithUserTypeProperty.cs" />
-    <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\EntityWithUserTypePropertyIsEquivelentGenerator.cs" />
+    <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\EntityWithUserTypePropertyIsEquivalentGenerator.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\EntityWithUserTypePropertyGeneratorsRegistry.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\ExampleUserType.cs" />
     <Compile Include="NHSpecificTest\EntityWithUserTypeCanHaveLinqGenerators\Fixture.cs" />
diff --git a/src/NHibernate/Linq/Visitors/ExpressionParameterVisitor.cs b/src/NHibernate/Linq/Visitors/ExpressionParameterVisitor.cs
@@ -119,4 +119,4 @@ private static bool IsNullObject(ConstantExpression expression)
 			return expression.Type == typeof(Object) && expression.Value == null;
 		}
 	}
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -5,10 +5,10 @@ namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators`
`5`	`5`	`{`
`6`	`6`	`public class EntityWithUserTypePropertyGeneratorsRegistry : DefaultLinqToHqlGeneratorsRegistry`
`7`	`7`	`{`
`8`		`- public EntityWithUserTypePropertyGeneratorsRegistry() : base()`
	`8`	`+ public EntityWithUserTypePropertyGeneratorsRegistry()`
`9`	`9`	`{`
`10`	`10`	`RegisterGenerator(ReflectionHelper.GetMethod((IExample e) => e.IsEquivalentTo(null)),`
`11`		`- new EntityWithUserTypePropertyIsEquivelentGenerator());`
	`11`	`+ new EntityWithUserTypePropertyIsEquivalentGenerator());`
`12`	`12`	`}`
`13`	`13`	`}`
`14`		`-}`
	`14`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -9,24 +9,27 @@`
`9`	`9`
`10`	`10`	`namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators`
`11`	`11`	`{`
`12`		`- public class EntityWithUserTypePropertyIsEquivelentGenerator : BaseHqlGeneratorForMethod`
	`12`	`+ public class EntityWithUserTypePropertyIsEquivalentGenerator : BaseHqlGeneratorForMethod`
`13`	`13`	`{`
`14`		`- public EntityWithUserTypePropertyIsEquivelentGenerator() : base()`
	`14`	`+ public EntityWithUserTypePropertyIsEquivalentGenerator()`
`15`	`15`	`{`
`16`		`- SupportedMethods = new[] { ReflectionHelper.GetMethodDefinition((IExample e) => e.IsEquivalentTo(null)) };`
	`16`	`+ SupportedMethods = new[] {ReflectionHelper.GetMethodDefinition((IExample e) => e.IsEquivalentTo(null))};`
`17`	`17`	`}`
`18`		`- public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)`
	`18`	`+`
	`19`	`+ public override HqlTreeNode BuildHql(`
	`20`	`+ MethodInfo method,`
	`21`	`+ Expression targetObject,`
	`22`	`+ ReadOnlyCollection<Expression> arguments,`
	`23`	`+ HqlTreeBuilder treeBuilder,`
	`24`	`+ IHqlExpressionVisitor visitor)`
`19`	`25`	`{`
`20`	`26`	`var left = treeBuilder.Cast(visitor.Visit(targetObject).AsExpression(), typeof(string));`
`21`		`- var right = treeBuilder.Cast(visitor.Visit(arguments.Cast<Expression>().First()).AsExpression(),`
`22`		`- typeof(string));`
`23`		`-`
`24`		`-`
	`27`	`+ var right = treeBuilder.Cast(visitor.Visit(arguments.First()).AsExpression(), typeof(string));`
`25`	`28`
`26`	`29`	`var leftSubstring = treeBuilder.MethodCall("substring", left, treeBuilder.Constant(4));`
`27`	`30`	`var rightSubstring = treeBuilder.MethodCall("substring", right, treeBuilder.Constant(4));`
`28`	`31`	`var equals = treeBuilder.Equality(leftSubstring, rightSubstring);`
`29`	`32`	`return equals;`
`30`	`33`	`}`
`31`	`34`	`}`
`32`		`-}`
	`35`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,7 @@`
`1`		`-using System;`
`2`		`-using System.Collections;`
	`1`	`+using System.Collections;`
`3`	`2`	`using System.Linq;`
`4`	`3`	`using NHibernate.Cfg;`
`5`		`-using NHibernate.Dialect;`
`6`	`4`	`using NHibernate.Linq;`
`7`		`-using NHibernate.Mapping.ByCode;`
`8`		`-using NHibernate.Test.NHSpecificTest.FileStreamSql2008;`
`9`	`5`	`using NUnit.Framework;`
`10`	`6`
`11`	`7`
`@@ -25,16 +21,10 @@ protected override string MappingsAssembly`
`25`	`21`	`get { return "NHibernate.Test"; }`
`26`	`22`	`}`
`27`	`23`
`28`		`- protected override bool AppliesTo(Dialect.Dialect dialect)`
	`24`	`+ protected override void Configure(Configuration configuration)`
`29`	`25`	`{`
`30`		`- return true;`
`31`		`- }`
`32`		`-`
`33`		`- protected override void Configure(Configuration cfg)`
`34`		`- {`
`35`		`-`
`36`		`- base.Configure(cfg);`
`37`		`- cfg.LinqToHqlGeneratorsRegistry<EntityWithUserTypePropertyGeneratorsRegistry>();`
	`26`	`+ base.Configure(configuration);`
	`27`	`+ configuration.LinqToHqlGeneratorsRegistry<EntityWithUserTypePropertyGeneratorsRegistry>();`
`38`	`28`	`}`
`39`	`29`
`40`	`30`	`protected override void OnSetUp()`
`@@ -111,8 +101,9 @@ public void LinqMethodWorksForUserType()`
`111`	`101`	`Assert.AreEqual(2, entities.Count);`
`112`	`102`	`}`
`113`	`103`	`}`
	`104`	`+`
`114`	`105`	`[Test]`
`115`		`- public void CanQueryWithHQL()`
	`106`	`+ public void CanQueryWithHql()`
`116`	`107`	`{`
`117`	`108`	`using (var session = OpenSession())`
`118`	`109`	`using (session.BeginTransaction())`
`@@ -126,4 +117,4 @@ public void CanQueryWithHQL()`
`126`	`117`	`}`
`127`	`118`	`}`
`128`	`119`	`}`
`129`		`-}`
	`120`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,9 @@`
`1`		`-using System;`
`2`	`1`
`3`	`2`	`namespace NHibernate.Test.NHSpecificTest.EntityWithUserTypeCanHaveLinqGenerators`
`4`	`3`	`{`
`5`		`-`
`6`	`4`	`public interface IExample`
`7`	`5`	`{`
`8`	`6`	`string Value { get; set; }`
`9`	`7`	`bool IsEquivalentTo(IExample that);`
`10`	`8`	`}`
`11`		`-}`
	`9`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -119,4 +119,4 @@ private static bool IsNullObject(ConstantExpression expression)`
`119`	`119`	`return expression.Type == typeof(Object) && expression.Value == null;`
`120`	`120`	`}`
`121`	`121`	`}`
`122`		`-}`
	`122`	`+}`