Features/coverage optimisations

AgileMapper.PerformanceTester.Net45/AgileMapper.PerformanceTester.Net45.csproj

@@ -37,8 +37,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.3.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.3.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="AutoMapper, Version=7.0.1.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
       <HintPath>..\packages\AutoMapper.7.0.1\lib\net45\AutoMapper.dll</HintPath>

AgileMapper.PerformanceTester.Net45/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net452" />
-  <package id="AgileObjects.ReadableExpressions" version="2.1.1" targetFramework="net452" />
+  <package id="AgileObjects.ReadableExpressions" version="2.3.1" targetFramework="net452" />
   <package id="AutoMapper" version="7.0.1" targetFramework="net452" />
   <package id="Expressmapper" version="1.9.1" targetFramework="net452" />
   <package id="Mapster" version="3.3.1" targetFramework="net452" />

AgileMapper.UnitTests.Net35/AgileMapper.UnitTests.Net35.csproj

@@ -37,8 +37,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net35\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.1\lib\net35\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.3.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.3.1\lib\net35\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.Dynamic, Version=1.1.2.22, Culture=neutral, PublicKeyToken=7f709c5b713576e1, processorArchitecture=MSIL">
       <HintPath>..\packages\DynamicLanguageRuntime.1.1.2\lib\Net35\Microsoft.Dynamic.dll</HintPath>

AgileMapper.UnitTests.Net35/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net35" />
-  <package id="AgileObjects.ReadableExpressions" version="2.1.1" targetFramework="net35" />
+  <package id="AgileObjects.ReadableExpressions" version="2.3.1" targetFramework="net35" />
   <package id="DynamicLanguageRuntime" version="1.1.2" targetFramework="net35" />
   <package id="NUnit" version="3.6.1" targetFramework="net35" />
   <package id="NUnit3TestAdapter" version="3.10.0" targetFramework="net35" />

AgileMapper.UnitTests.NonParallel/AgileMapper.UnitTests.NonParallel.csproj

@@ -42,8 +42,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.3.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.3.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />

AgileMapper.UnitTests.NonParallel/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AgileObjects.NetStandardPolyfills" version="1.4.0" targetFramework="net461" />
-  <package id="AgileObjects.ReadableExpressions" version="2.1.1" targetFramework="net461" />
+  <package id="AgileObjects.ReadableExpressions" version="2.3.1" targetFramework="net461" />
   <package id="xunit" version="2.4.1" targetFramework="net461" />
   <package id="xunit.abstractions" version="2.0.3" targetFramework="net461" />
   <package id="xunit.analyzers" version="0.10.0" targetFramework="net461" />

AgileMapper.UnitTests/AgileMapper.UnitTests.csproj

@@ -44,8 +44,8 @@
     <Reference Include="AgileObjects.NetStandardPolyfills, Version=1.4.0.0, Culture=neutral, PublicKeyToken=06131ac1c008ad4e, processorArchitecture=MSIL">
       <HintPath>..\packages\AgileObjects.NetStandardPolyfills.1.4.0\lib\net40\AgileObjects.NetStandardPolyfills.dll</HintPath>
     </Reference>
-    <Reference Include="AgileObjects.ReadableExpressions, Version=2.1.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
-      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.1.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
+    <Reference Include="AgileObjects.ReadableExpressions, Version=2.3.1.0, Culture=neutral, PublicKeyToken=9f54ad81db69da8e, processorArchitecture=MSIL">
+      <HintPath>..\packages\AgileObjects.ReadableExpressions.2.3.1\lib\net40\AgileObjects.ReadableExpressions.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.Extensions.Primitives, Version=2.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.Extensions.Primitives.2.0.0\lib\netstandard2.0\Microsoft.Extensions.Primitives.dll</HintPath>
@@ -144,6 +144,7 @@
     <Compile Include="Extensions\WhenUnflatteningFromQueryStringsViaExtensionMethods.cs" />
     <Compile Include="Extensions\WhenUnflatteningViaExtensionMethods.cs" />
     <Compile Include="MapperCloning\WhenCloningConstructorDataSources.cs" />
+    <Compile Include="MapperCloning\WhenCloningDictionarySettings.cs" />
     <Compile Include="MapperCloning\WhenCloningMemberIgnores.cs" />
     <Compile Include="Configuration\WhenConfiguringObjectTracking.cs" />
     <Compile Include="Configuration\WhenConfiguringObjectTrackingIncorrectly.cs" />
@@ -220,6 +221,7 @@
     <Compile Include="TestClasses\PaymentTypeUs.cs" />
     <Compile Include="TestClasses\PublicCtorStruct.cs" />
     <Compile Include="TestClasses\PublicImplementation.cs" />
+    <Compile Include="TestClasses\PublicIndex.cs" />
     <Compile Include="TestClasses\PublicSealed.cs" />
     <Compile Include="TestClasses\PublicPropertyStruct.cs" />
     <Compile Include="TestClasses\PublicTwoFields.cs" />
@@ -301,6 +303,7 @@
     <Compile Include="WhenMappingToNewEnumerableMembers.cs" />
     <Compile Include="WhenMappingToNewEnumerables.cs" />
     <Compile Include="Members\WhenMatchingSourceToTargetMembers.cs" />
+    <Compile Include="WhenWorkingWithQueryStrings.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config">

AgileMapper.UnitTests/Configuration/Inline/WhenConfiguringDataSourcesInline.cs

@@ -7,7 +7,9 @@
     using Common;
     using TestClasses;
 #if !NET35
+    using NetStandardPolyfills;
     using Xunit;
+    using static System.Linq.Expressions.Expression;
 #else
     using Fact = NUnit.Framework.TestAttribute;
 
@@ -317,6 +319,194 @@ public void ShouldApplyDifferingTargetTypeInlineDataSourceMemberConfig()
             }
         }
 
+        [Fact]
+        public void ShouldApplyAnInlineNullCheckedArrayIndexDataSource()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var source = new PublicProperty<PublicField<Address>[]>
+                {
+                    Value = new[]
+                    {
+                        new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        new PublicField<Address> { Value = new Address { Line1 = "1.2" } }
+                    }
+                };
+
+                var result = mapper.Map(source).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(s => s.Value[1].Value, t => t.Value));
+
+                result.Value.ShouldNotBeNull();
+                result.Value.Line1.ShouldBe("1.2");
+
+                var nullArraySource = new PublicProperty<PublicField<Address>[]> { Value = null };
+
+                var nullArrayResult = mapper.Map(nullArraySource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(s => s.Value[1].Value, t => t.Value));
+
+                nullArrayResult.Value.ShouldBeNull();
+
+                var tooSmallArraySource = new PublicProperty<PublicField<Address>[]>
+                {
+                    Value = new[]
+                    {
+                        new PublicField<Address> { Value = new Address { Line1 = "1.1" } }
+                    }
+                };
+
+                var tooSmallArrayResult = mapper.Map(tooSmallArraySource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(s => s.Value[1].Value, t => t.Value));
+
+                tooSmallArrayResult.Value.ShouldBeNull();
+
+                var nullArrayObjectSource = new PublicProperty<PublicField<Address>[]>
+                {
+                    Value = new[]
+                    {
+                        new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        new PublicField<Address> { Value = null }
+                    }
+                };
+
+                var nullArrayObjectResult = mapper.Map(nullArrayObjectSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(s => s.Value[1].Value, t => t.Value));
+
+                nullArrayObjectResult.Value.ShouldBeNull();
+            }
+        }
+
+#if !NET35
+        // System.Linq.Expressions.Expression.MakeIndex() is missing in .NET 3.5, so not much danger of this configuration:
+        [Fact]
+        public void ShouldApplyAnInlineNullCheckedIntKeyedIndexDataSource()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var source = new PublicProperty<PublicIndex<int, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<int, PublicField<Address>>
+                    {
+                        [0] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        [1] = new PublicField<Address> { Value = new Address { Line1 = "1.2" } }
+                    }
+                };
+
+                var sourceParameter = Parameter(source.GetType(), "s");
+                var sourceValueProperty = Property(sourceParameter, "Value");
+                var sourceValueIndexer = sourceValueProperty.Type.GetPublicInstanceProperty("Item");
+                var sourceValueIndex = MakeIndex(sourceValueProperty, sourceValueIndexer, new[] { Constant(1) });
+
+                var sourceLambda = Lambda<Func<PublicProperty<PublicIndex<int, PublicField<Address>>>, Address>>(
+                    Field(sourceValueIndex, "Value"),
+                    sourceParameter);
+
+                var result = mapper.Map(source).ToANew<PublicField<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                result.Value.ShouldNotBeNull();
+                result.Value.Line1.ShouldBe("1.2");
+
+                var nullIndexerSource = new PublicProperty<PublicIndex<int, PublicField<Address>>> { Value = null };
+
+                var nullIndexerResult = mapper.Map(nullIndexerSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                nullIndexerResult.Value.ShouldBeNull();
+
+                var noEntrySource = new PublicProperty<PublicIndex<int, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<int, PublicField<Address>>
+                    {
+                        [0] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } }
+                    }
+                };
+
+                var noEntryResult = mapper.Map(noEntrySource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                noEntryResult.Value.ShouldBeNull();
+
+                var nullIndexedObjectSource = new PublicProperty<PublicIndex<int, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<int, PublicField<Address>>
+                    {
+                        [0] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        [1] = new PublicField<Address> { Value = null }
+                    }
+                };
+
+                var nullIndexedObjectResult = mapper.Map(nullIndexedObjectSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                nullIndexedObjectResult.Value.ShouldBeNull();
+            }
+        }
+
+        [Fact]
+        public void ShouldApplyAnInlineNullCheckedStringKeyedIndexDataSource()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var source = new PublicProperty<PublicIndex<string, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<string, PublicField<Address>>
+                    {
+                        ["A"] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        ["B"] = new PublicField<Address> { Value = new Address { Line1 = "1.2" } }
+                    }
+                };
+
+                var sourceParameter = Parameter(source.GetType(), "s");
+                var sourceValueProperty = Property(sourceParameter, "Value");
+                var sourceValueIndexer = sourceValueProperty.Type.GetPublicInstanceProperty("Item");
+                var sourceValueIndex = MakeIndex(sourceValueProperty, sourceValueIndexer, new[] { Constant("B") });
+
+                var sourceLambda = Lambda<Func<PublicProperty<PublicIndex<string, PublicField<Address>>>, Address>>(
+                    Field(sourceValueIndex, "Value"),
+                    sourceParameter);
+
+                var result = mapper.Map(source).ToANew<PublicField<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                result.Value.ShouldNotBeNull();
+                result.Value.Line1.ShouldBe("1.2");
+
+                var nullIndexerSource = new PublicProperty<PublicIndex<string, PublicField<Address>>> { Value = null };
+
+                var nullIndexerResult = mapper.Map(nullIndexerSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                nullIndexerResult.Value.ShouldBeNull();
+
+                var noEntrySource = new PublicProperty<PublicIndex<string, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<string, PublicField<Address>>
+                    {
+                        ["A"] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } }
+                    }
+                };
+
+                var noEntryResult = mapper.Map(noEntrySource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                noEntryResult.Value.ShouldBeNull();
+
+                var nullIndexedObjectSource = new PublicProperty<PublicIndex<string, PublicField<Address>>>
+                {
+                    Value = new PublicIndex<string, PublicField<Address>>
+                    {
+                        ["A"] = new PublicField<Address> { Value = new Address { Line1 = "1.1" } },
+                        ["B"] = new PublicField<Address> { Value = null }
+                    }
+                };
+
+                var nullIndexedObjectResult = mapper.Map(nullIndexedObjectSource).ToANew<PublicProperty<Address>>(cfg => cfg
+                    .Map(sourceLambda, t => t.Value));
+
+                nullIndexedObjectResult.Value.ShouldBeNull();
+            }
+        }
+#endif
         [Fact]
         public void ShouldHandleANullSourceMember()
         {

AgileMapper.UnitTests/Configuration/WhenConfiguringEntityMapping.cs

@@ -1,5 +1,6 @@
 namespace AgileObjects.AgileMapper.UnitTests.Configuration
 {
+    using System;
     using AgileMapper.Configuration;
     using Common;
     using TestClasses;
@@ -73,6 +74,43 @@ public void ShouldIgnoreEntityKeysForASpecificSourceAndTargetType()
             }
         }
 
+        [Fact]
+        public void ShouldIgnoreEntityKeysForSpecificSourceAndTargetTypes()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                var sourceId = new { Id = 999 };
+                var sourceIdAndDate = new { Id = 999, DateCreated = DateTime.Now };
+
+                mapper.WhenMapping.MapEntityKeys();
+
+                mapper.WhenMapping
+                    .From(sourceId).To<OrderEntity>()
+                    .IgnoreEntityKeys();
+
+                mapper.WhenMapping
+                    .From(sourceIdAndDate).To<OrderEntity>()
+                    .IgnoreEntityKeys();
+
+                var sourceIdResult = mapper.Map(sourceId).ToANew<OrderEntity>();
+
+                sourceIdResult.Id.ShouldBeDefault();
+
+                var sourceIdAndDateResult = mapper.Map(sourceIdAndDate).ToANew<OrderEntity>();
+
+                sourceIdAndDateResult.Id.ShouldBeDefault();
+                sourceIdAndDateResult.DateCreated.ShouldBe(sourceIdAndDate.DateCreated);
+
+                var nonMatchingSourceResult = mapper.Map(new { Id = 987, Name = "Fred" }).ToANew<CategoryEntity>();
+
+                nonMatchingSourceResult.Id.ShouldBe(987);
+
+                var nonMatchingTargetResult = mapper.Map(sourceId).ToANew<CategoryEntity>();
+
+                nonMatchingTargetResult.Id.ShouldBe(999);
+            }
+        }
+
         [Fact]
         public void ShouldErrorIfDuplicateMapKeysConfigured()
         {

AgileMapper.UnitTests/Configuration/WhenConfiguringObjectTrackingIncorrectly.cs

@@ -125,13 +125,12 @@ public void ShouldErrorIfGlobalObjectTrackingDisabledTwice()
         }
 
         [Fact]
-        public void ShouldErrorIfObjectTrackingDisabledTwice()
+        public void ShouldErrorIfDuplicateObjectTrackingDisabled()
         {
             using (var mapper = Mapper.CreateNew())
             {
                 mapper.WhenMapping
-                    .From<PersonViewModel>()
-                    .To<Person>()
+                    .From<PersonViewModel>().To<Person>()
                     .DisableObjectTracking();
 
                 var configEx = Should.Throw<MappingConfigurationException>(() =>
@@ -146,5 +145,27 @@ public void ShouldErrorIfObjectTrackingDisabledTwice()
                 configEx.Message.ShouldContain("PersonViewModel -> Person");
             }
         }
+
+        [Fact]
+        public void ShouldErrorIfRedundantObjectTrackingDisabled()
+        {
+            using (var mapper = Mapper.CreateNew())
+            {
+                mapper.WhenMapping
+                    .To<Person>()
+                    .DisableObjectTracking();
+
+                var configEx = Should.Throw<MappingConfigurationException>(() =>
+                {
+                    mapper.WhenMapping
+                        .From<PersonViewModel>()
+                        .To<Person>()
+                        .DisableObjectTracking();
+                });
+
+                configEx.Message.ShouldContain("Object tracking is already disabled");
+                configEx.Message.ShouldContain("to Person");
+            }
+        }
     }
 }