Merge pull request #119 from linq2db/master

sdanyliv · web-flow · commit c00e44a18b9e · 2021-03-09T16:50:11.000+02:00
Release 5.1.6
diff --git a/.editorconfig b/.editorconfig
@@ -40,12 +40,6 @@ end_of_line = lf
 dotnet_sort_system_directives_first = true
 dotnet_separate_import_directive_groups = false
 
-# Avoid "this." and "Me." if not necessary
-dotnet_style_qualification_for_field = false:refactoring
-dotnet_style_qualification_for_property = false:refactoring
-dotnet_style_qualification_for_method = false:refactoring
-dotnet_style_qualification_for_event = false:refactoring
-
 # Use language keywords instead of framework type names for type references
 dotnet_style_predefined_type_for_locals_parameters_members = true:error
 dotnet_style_predefined_type_for_member_access = true:suggestion
@@ -159,6 +153,9 @@ dotnet_diagnostic.CA2231.severity = none # CA2231: Overload operator equals on o
 # disabled, as NETFX doesn't have string.Contains overloads with comparison type
 dotnet_diagnostic.CA2249.severity = none # CA2249: Consider using String.Contains instead of String.IndexOf
 dotnet_diagnostic.CA3075.severity = error # CA3075: Insecure DTD Processing
+# very slow (https://github.com/dotnet/roslyn-analyzers/issues/4754)
+# also we don't have code that could be targeted by it
+dotnet_diagnostic.CA3076.severity = none # CA3076: Insecure XSLT Script Execution
 
 #########################################################################################################
 # inactive diagnostics (not reviewed yet => disabled to not fail build, basically TODO list for future) #
@@ -186,39 +183,78 @@ dotnet_diagnostic.CA1806.severity = none # CA1806: Do not ignore method results
 dotnet_diagnostic.CA1822.severity = none # CA1822: Mark members as static
 dotnet_diagnostic.CA2211.severity = none # CA2211: Non-constant fields should not be visible
 
-################
-# VS analyzers #
-################
-# IDE0051: Remove unused private members
-dotnet_diagnostic.IDE0051.severity = warning
-
-# IDE0055: Fix whitespace formatting
-dotnet_diagnostic.IDE0055.severity = none
-
-# IDE0057: Use range operators (requires .net core 3 or higher)
-dotnet_diagnostic.IDE0056.severity = none
-dotnet_diagnostic.IDE0057.severity = none
-
-# IDE0060: unused parameters should be removed or have a discard symbol name
-dotnet_diagnostic.IDE0060.severity = none
+###################################################################################
+# VS analyzers                                                                    #
+# https://docs.microsoft.com/en-us/dotnet/fundamentals/code-analysis/style-rules/ #
+###################################################################################
+dotnet_diagnostic.IDE0001.severity = error # IDE0001: Simplify name
+dotnet_diagnostic.IDE0002.severity = error # IDE0002: Simplify member access
 
-# CS1998: Async method lacks 'await' operators and will run synchronously
-dotnet_diagnostic.CS1998.severity = error
-
-# CS8618: Non-nullable field is uninitialized. Consider declaring as nullable.
-dotnet_diagnostic.CS8618.severity = error
-
-# CS4014: Because this call is not awaited, execution of the current method continues before the call is completed
-dotnet_diagnostic.CS4014.severity = error
+# IDE0003: Remove this or Me qualification
+# IDE0009: Add this or Me qualification
+dotnet_diagnostic.IDE0003.severity = error
+dotnet_style_qualification_for_field = false:refactoring
+dotnet_style_qualification_for_property = false:refactoring
+dotnet_style_qualification_for_method = false:refactoring
+dotnet_style_qualification_for_event = false:refactoring
 
-dotnet_diagnostic.IDE0058.severity = none # IDE0058: Expression value is never used
+dotnet_diagnostic.IDE0004.severity = error # IDE0004: Remove unnecessary cast
+dotnet_diagnostic.IDE0005.severity = error # IDE0005: Remove unnecessary import
+
+# not reviewed yet rules
+dotnet_diagnostic.IDE0007.severity = none # IDE0007: Use 'var' instead of explicit type
+dotnet_diagnostic.IDE0010.severity = none # IDE0010: Add missing cases to switch statement
+dotnet_diagnostic.IDE0011.severity = none # IDE0011: Add braces
+dotnet_diagnostic.IDE0016.severity = none # IDE0016: Use throw expression
+dotnet_diagnostic.IDE0017.severity = none # IDE0017: Use object initializers
+dotnet_diagnostic.IDE0018.severity = none # IDE0018: Inline variable declaration
+dotnet_diagnostic.IDE0019.severity = none # IDE0019: Use pattern matching to avoid 'as' followed by a 'null' check
+dotnet_diagnostic.IDE0025.severity = none # IDE0025: Use expression body for properties
+dotnet_diagnostic.IDE0026.severity = none # IDE0026: Use expression body for indexers
+dotnet_diagnostic.IDE0027.severity = none # IDE0027: Use expression body for accessors
+dotnet_diagnostic.IDE0028.severity = none # IDE0028: Use collection initializers
+dotnet_diagnostic.IDE0029.severity = none # IDE0029: Use coalesce expression (non-nullable types)
+dotnet_diagnostic.IDE0030.severity = none # IDE0030: Use coalesce expression
+dotnet_diagnostic.IDE0031.severity = none # IDE0031: Use null propagation
+dotnet_diagnostic.IDE0032.severity = none # IDE0032: Use auto property
+dotnet_diagnostic.IDE0034.severity = none # IDE0034: Simplify 'default' expression
+dotnet_diagnostic.IDE0036.severity = none # IDE0036: Order modifiers
+dotnet_diagnostic.IDE0037.severity = none # IDE0037: Use inferred member name
+dotnet_diagnostic.IDE0038.severity = none # IDE0038: Use pattern matching to avoid 'is' check followed by a cast
 dotnet_diagnostic.IDE0040.severity = none # IDE0040: Add accessibility modifiers
-dotnet_diagnostic.IDE0046.severity = suggestion # IDE0046: Convert to conditional expression
+dotnet_diagnostic.IDE0041.severity = none # IDE0041: Use is null check
+dotnet_diagnostic.IDE0044.severity = none # IDE0044: Add readonly modifier
+dotnet_diagnostic.IDE0045.severity = none # IDE0045: Use conditional expression for assignment
+dotnet_diagnostic.IDE0046.severity = none # IDE0046: Convert to conditional expression
+dotnet_diagnostic.IDE0047.severity = none # IDE0047: Remove unnecessary parentheses
+dotnet_diagnostic.IDE0048.severity = none # IDE0048: Add parentheses for clarity
+dotnet_diagnostic.IDE0049.severity = none # IDE0049: Use language keywords instead of framework type names for type references
+dotnet_diagnostic.IDE0050.severity = none # IDE0050: Convert to tuple
+dotnet_diagnostic.IDE0051.severity = none # IDE0051: Remove unused private members
+dotnet_diagnostic.IDE0052.severity = none # IDE0052: Remove unread private member
+dotnet_diagnostic.IDE0054.severity = none # IDE0054: Use compound assignment
+dotnet_diagnostic.IDE0055.severity = none # IDE0055: Formatting rules
+dotnet_diagnostic.IDE0056.severity = none # IDE0056: Use index operator
+dotnet_diagnostic.IDE0057.severity = none # IDE0057: Use range operator
+dotnet_diagnostic.IDE0058.severity = none # IDE0058: computed value is never used
+dotnet_diagnostic.IDE0059.severity = none # IDE0059: Remove unnecessary value assignment
+dotnet_diagnostic.IDE0060.severity = none # IDE0060: Remove unused parameter
+dotnet_diagnostic.IDE0061.severity = none # IDE0061: Use expression body for local functions
+dotnet_diagnostic.IDE0062.severity = none # IDE0062: Make local function static
 dotnet_diagnostic.IDE0065.severity = none # IDE0065: Misplaced using directive
-dotnet_diagnostic.IDE0011.severity = suggestion # IDE0011: Add braces
-dotnet_diagnostic.IDE0050.severity = suggestion # IDE0050: Convert to tuple
-dotnet_diagnostic.IDE0072.severity = suggestion # IDE0072: Add missing cases
-dotnet_diagnostic.IDE0054.severity = suggestion # IDE0054: Use compound assignment
-dotnet_diagnostic.IDE0010.severity = suggestion # IDE0010: Add missing cases
-dotnet_diagnostic.IDE0066.severity = suggestion # IDE0066: Convert switch statement to expression
-dotnet_diagnostic.IDE0007.severity = suggestion # IDE0007: Use implicit type
+dotnet_diagnostic.IDE0066.severity = none # IDE0066: Convert switch statement to expression
+dotnet_diagnostic.IDE0070.severity = none # IDE0070: Use 'System.HashCode.Combine'
+dotnet_diagnostic.IDE0072.severity = none # IDE0072: Add missing cases
+dotnet_diagnostic.IDE0075.severity = none # IDE0075: Simplify conditional expression
+dotnet_diagnostic.IDE0078.severity = none # IDE0078: Use pattern matching
+dotnet_diagnostic.IDE0079.severity = none # IDE0079: Remove unnecessary suppression
+dotnet_diagnostic.IDE0080.severity = none # IDE0080: Remove unnecessary suppression operator
+dotnet_diagnostic.IDE0081.severity = none # IDE0081: Remove ByVal
+dotnet_diagnostic.IDE0083.severity = none # IDE0083: Use pattern matching (not operator)
+dotnet_diagnostic.IDE1006.severity = none # IDE1006: Naming rule violation
+
+dotnet_diagnostic.CS1998.severity = error # CS1998: Async method lacks 'await' operators and will run synchronously
+dotnet_diagnostic.CS8618.severity = error # CS8618: Non-nullable field is uninitialized. Consider declaring as nullable.
+dotnet_diagnostic.CS4014.severity = error # CS4014: Because this call is not awaited, execution of the current method continues before the call is completed
+
+#
diff --git a/Build/linq2db.Default.props b/Build/linq2db.Default.props
@@ -1,6 +1,6 @@
 ﻿<Project>
 	<PropertyGroup>
-		<Version>5.1.5</Version>
+		<Version>5.1.6</Version>
 
 		<Authors>Svyatoslav Danyliv, Igor Tkachev, Dmitry Lukashenko, Ilya Chudin</Authors>
 		<Product>Linq to DB</Product>
diff --git a/Source/LinqToDB.EntityFrameworkCore/EFCoreMetadataReader.cs b/Source/LinqToDB.EntityFrameworkCore/EFCoreMetadataReader.cs
@@ -201,25 +201,25 @@ public T[] GetAttributes<T>(Type type, MemberInfo memberInfo, bool inherit = tru
 						var fk = navigation.ForeignKey;
 						if (!navigation.IsOnDependent)
 						{
-							var thisKey = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));
+							var thisKey  = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));
 							var otherKey = string.Join(",", fk.Properties.Select(p => p.Name));
 							associations.Add(new AssociationAttribute
 							{
-								ThisKey = thisKey,
-								OtherKey = otherKey,
-								CanBeNull = !fk.IsRequired,
+								ThisKey         = thisKey,
+								OtherKey        = otherKey,
+								CanBeNull       = !fk.IsRequiredDependent,
 								IsBackReference = false
 							});
 						}
 						else
 						{
-							var thisKey = string.Join(",", fk.Properties.Select(p => p.Name));
+							var thisKey  = string.Join(",", fk.Properties.Select(p => p.Name));
 							var otherKey = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));
 							associations.Add(new AssociationAttribute
 							{
-								ThisKey = thisKey,
-								OtherKey = otherKey,
-								CanBeNull = !fk.IsRequired,
+								ThisKey         = thisKey,
+								OtherKey        = otherKey,
+								CanBeNull       = !fk.IsRequired,
 								IsBackReference = true
 							});
 						}
diff --git a/Tests/LinqToDB.EntityFrameworkCore.PostgreSQL.Tests/SampleTests/AAA.cs b/Tests/LinqToDB.EntityFrameworkCore.PostgreSQL.Tests/SampleTests/AAA.cs
@@ -102,15 +102,15 @@ public static async Task Assert<T, TMock>(this Task<ActResult<T, TMock>> act, Fu
 		public readonly struct ArrangeResult<T, TMock>
 			where TMock : notnull
 		{
-			internal ArrangeResult(T @object, TMock? mock) => (Object, Mock) = (@object, mock);
+			internal ArrangeResult(T @object, TMock mock) => (Object, Mock) = (@object, mock);
 			internal T Object { get; }
 			internal TMock Mock { get; }
 		}
 
 		public readonly struct ActResult<T, TMock>
 			where T: notnull
 		{
-			internal ActResult(T? @object, TMock mock, Exception? exception)
+			internal ActResult(T @object, TMock mock, Exception? exception)
 				=> (Object, Mock, Exception) = (@object, mock, exception);
 			internal T Object { get; }
 			internal TMock Mock { get; }
diff --git a/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/IssueTests.cs b/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/IssueTests.cs
@@ -1,22 +1,25 @@
 ﻿using System.Linq;
 using LinqToDB.EntityFrameworkCore.BaseTests;
-using LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.Northwind;
+using LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.IssueModel;
 using Microsoft.EntityFrameworkCore;
 using NUnit.Framework;
-using NUnit.Framework.Constraints;
 
 namespace LinqToDB.EntityFrameworkCore.SqlServer.Tests
 {
 	[TestFixture]
 	public class IssueTests : TestsBase
 	{
-		private DbContextOptions<IssueContext> _options;
+		private DbContextOptions<IssueContext>? _options;
 		private bool _created;
 
 		public IssueTests()
+		{
+			InitOptions();
+		}
+
+		private void InitOptions()
 		{
 			var optionsBuilder = new DbContextOptionsBuilder<IssueContext>();
-			//new SqlServerDbContextOptionsBuilder(optionsBuilder);
 
 			optionsBuilder.UseSqlServer("Server=.;Database=IssuesEFCore;Integrated Security=SSPI");
 			optionsBuilder.UseLoggerFactory(TestUtils.LoggerFactory);
@@ -34,6 +37,7 @@ private IssueContext CreateContext()
 				ctx.Database.EnsureCreated();
 				_created = true;
 			}
+
 			return ctx;
 		}
 
@@ -53,5 +57,26 @@ public void Issue73Test()
 			AreEqual(efItems, linq2dbItems);
 		}
 
+		[Test]
+		public void Issue117Test()
+		{
+			using var ctx = CreateContext();
+
+			var userId = 1;
+
+			var query =
+				from p in ctx.Patents.Include(p => p.Assessment)
+				where p.Assessment == null || (p.Assessment.TechnicalReviewerId != userId)
+				select new { PatentId = p.Id, UserId = userId };
+
+			var resultEF = query.ToArray();
+
+			using var db = ctx.CreateLinqToDbConnection();
+
+			_ = query.ToLinqToDB(db).ToArray();
+
+			Assert.That(db.LastQuery, Does.Not.Contain("INNER"));
+		}
+
 	}
 }
diff --git a/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/Models/IssueModel/Issue117Entities.cs b/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/Models/IssueModel/Issue117Entities.cs
@@ -0,0 +1,19 @@
+﻿using System.ComponentModel.DataAnnotations;
+
+namespace LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.IssueModel
+{
+	public class Patent
+	{
+		[Key]
+		public int Id { get; set; }
+		public PatentAssessment? Assessment { get; set; }
+	}
+
+	public class PatentAssessment
+	{
+		[Key]
+		public int PatentId { get; set; }
+		public Patent Patent { get; set; } = null!;
+		public int? TechnicalReviewerId { get; set; }
+	}
+}
diff --git a/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/Models/IssueModel/IssueContext.cs b/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/Models/IssueModel/IssueContext.cs
@@ -1,17 +1,13 @@
-﻿using System.Reflection;
-using LinqToDB.EntityFrameworkCore.BaseTests.Models.Northwind;
-using LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.IssueModel;
-using LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.Northwind.Mapping;
-using LinqToDB.Expressions;
-using LinqToDB.Extensions;
-using Microsoft.EntityFrameworkCore;
-
-namespace LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.Northwind
+﻿using Microsoft.EntityFrameworkCore;
+
+namespace LinqToDB.EntityFrameworkCore.SqlServer.Tests.Models.IssueModel
 {
 	public class IssueContext : DbContext
 	{
 		public DbSet<Issue73Entity> Issue73Entities { get; set; } = null!;
 
+		public DbSet<Patent> Patents { get; set; } = null!;
+
 		public IssueContext(DbContextOptions options) : base(options)
 		{
 			
@@ -43,6 +39,14 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 					},
 				});
 			});
+
+			modelBuilder
+				.Entity<Patent>()
+				.HasOne(p => p.Assessment)
+				.WithOne(pa => pa.Patent)
+				.HasForeignKey<PatentAssessment>(pa => pa.PatentId)
+				.OnDelete(DeleteBehavior.Restrict);
+
 		}
 	}
 }
diff --git a/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/QueryableExtensions.cs b/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/QueryableExtensions.cs
@@ -48,5 +48,62 @@ public static IIncludableQueryable<TEntity, TProp> IncludeInline<TEntity, TProp,
 
 			return includable;
 		}
+
+		public static Expression<Func<T, bool>> MakePropertiesPredicate<T, TValue>(Expression<Func<TValue, TValue, bool>> pattern, TValue searchValue, bool isOr)
+		{
+			var parameter = Expression.Parameter(typeof(T), "e");
+			var searchExpr = Expression.Constant(searchValue);
+
+			var predicateBody = typeof(T).GetProperties()
+				.Where(p => p.PropertyType == typeof(TValue))
+				.Select(p =>
+					ExpressionReplacer.GetBody(pattern, Expression.MakeMemberAccess(
+						parameter, p), searchExpr))
+				.Aggregate(isOr ? Expression.OrElse : Expression.AndAlso);
+
+			return Expression.Lambda<Func<T, bool>>(predicateBody, parameter);
+		}
+
+		public static IQueryable<T> FilterByProperties<T, TValue>(this IQueryable<T> query, TValue searchValue,
+			Expression<Func<TValue, TValue, bool>> pattern, bool isOr)
+		{
+			return query.Where(MakePropertiesPredicate<T, TValue>(pattern, searchValue, isOr));
+		}
+
+		class ExpressionReplacer : ExpressionVisitor
+		{
+			readonly IDictionary<Expression, Expression> _replaceMap;
+
+			public ExpressionReplacer(IDictionary<Expression, Expression> replaceMap)
+			{
+				_replaceMap = replaceMap ?? throw new ArgumentNullException(nameof(replaceMap));
+			}
+
+			public override Expression Visit(Expression node)
+			{
+				if (node != null && _replaceMap.TryGetValue(node, out var replacement))
+					return replacement;
+				return base.Visit(node);
+			}
+
+			public static Expression Replace(Expression expr, Expression toReplace, Expression toExpr)
+			{
+				return new ExpressionReplacer(new Dictionary<Expression, Expression> { { toReplace, toExpr } }).Visit(expr);
+			}
+
+			public static Expression Replace(Expression expr, IDictionary<Expression, Expression> replaceMap)
+			{
+				return new ExpressionReplacer(replaceMap).Visit(expr);
+			}
+
+			public static Expression GetBody(LambdaExpression lambda, params Expression[] toReplace)
+			{
+				if (lambda.Parameters.Count != toReplace.Length)
+					throw new InvalidOperationException();
+
+				return new ExpressionReplacer(Enumerable.Range(0, lambda.Parameters.Count)
+					.ToDictionary(i => (Expression)lambda.Parameters[i], i => toReplace[i])).Visit(lambda.Body);
+			}
+		}
 	}
 }
diff --git a/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/ToolsTests.cs b/Tests/LinqToDB.EntityFrameworkCore.SqlServer.Tests/ToolsTests.cs
@@ -814,6 +814,19 @@ public void TestCreateTempTable([Values(true, false)] bool enableFilter)
 		}
 
 
+		[Test]
+		public void TestForeignKey([Values(true, false)] bool enableFilter)
+		{
+			using (var ctx = CreateContext(enableFilter))
+			{
+				var resultEF = ctx.Employees.Include(e => e.ReportsToNavigation).ToArray();
+				var result = ctx.Employees.Include(e => e.ReportsToNavigation).ToLinqToDB().ToArray();
+
+				AreEqual(resultEF, result);
+			}
+		}
+
+
 		[Test]
 		public void TestCommandTimeout()
 		{
diff --git a/azure-pipelines.yml b/azure-pipelines.yml

Original file line number	Diff line number	Diff line change
`@@ -201,25 +201,25 @@ public T[] GetAttributes<T>(Type type, MemberInfo memberInfo, bool inherit = tru`
`201`	`201`	`var fk = navigation.ForeignKey;`
`202`	`202`	`if (!navigation.IsOnDependent)`
`203`	`203`	`{`
`204`		`- var thisKey = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));`
	`204`	`+ var thisKey = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));`
`205`	`205`	`var otherKey = string.Join(",", fk.Properties.Select(p => p.Name));`
`206`	`206`	`associations.Add(new AssociationAttribute`
`207`	`207`	`{`
`208`		`- ThisKey = thisKey,`
`209`		`- OtherKey = otherKey,`
`210`		`- CanBeNull = !fk.IsRequired,`
	`208`	`+ ThisKey = thisKey,`
	`209`	`+ OtherKey = otherKey,`
	`210`	`+ CanBeNull = !fk.IsRequiredDependent,`
`211`	`211`	`IsBackReference = false`
`212`	`212`	`});`
`213`	`213`	`}`
`214`	`214`	`else`
`215`	`215`	`{`
`216`		`- var thisKey = string.Join(",", fk.Properties.Select(p => p.Name));`
	`216`	`+ var thisKey = string.Join(",", fk.Properties.Select(p => p.Name));`
`217`	`217`	`var otherKey = string.Join(",", fk.PrincipalKey.Properties.Select(p => p.Name));`
`218`	`218`	`associations.Add(new AssociationAttribute`
`219`	`219`	`{`
`220`		`- ThisKey = thisKey,`
`221`		`- OtherKey = otherKey,`
`222`		`- CanBeNull = !fk.IsRequired,`
	`220`	`+ ThisKey = thisKey,`
	`221`	`+ OtherKey = otherKey,`
	`222`	`+ CanBeNull = !fk.IsRequired,`
`223`	`223`	`IsBackReference = true`
`224`	`224`	`});`
`225`	`225`	`}`
Original file line number	Diff line number	Diff line change
`@@ -102,15 +102,15 @@ public static async Task Assert<T, TMock>(this Task<ActResult<T, TMock>> act, Fu`
`102`	`102`	`public readonly struct ArrangeResult<T, TMock>`
`103`	`103`	`where TMock : notnull`
`104`	`104`	`{`
`105`		`- internal ArrangeResult(T @object, TMock? mock) => (Object, Mock) = (@object, mock);`
	`105`	`+ internal ArrangeResult(T @object, TMock mock) => (Object, Mock) = (@object, mock);`
`106`	`106`	`internal T Object { get; }`
`107`	`107`	`internal TMock Mock { get; }`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`public readonly struct ActResult<T, TMock>`
`111`	`111`	`where T: notnull`
`112`	`112`	`{`
`113`		`- internal ActResult(T? @object, TMock mock, Exception? exception)`
	`113`	`+ internal ActResult(T @object, TMock mock, Exception? exception)`
`114`	`114`	`=> (Object, Mock, Exception) = (@object, mock, exception);`
`115`	`115`	`internal T Object { get; }`
`116`	`116`	`internal TMock Mock { get; }`