Add test DiscriminatedUnionWithMultiMapping

DiscriminatedUnionWithMultiMapping - test for check correct MultiMapping (splitOn) functionality with discriminated row parser.

Dapper.Tests/Tests.IDataReader.cs

@@ -79,6 +79,58 @@ union all
             bar.Value.IsEqualTo((float)4.0);
         }
 
+        [Fact]
+        public void DiscriminatedUnionWithMultiMapping()
+        {
+            List<DiscriminatedWithMultiMapping_BaseType> result = new List<DiscriminatedWithMultiMapping_BaseType>();
+            using (var reader = connection.ExecuteReader(@"
+select 'abc' as Name, 1 as Type, 3.0 as Value, 1 as Id, 'zxc' as Name
+union all
+select 'def' as Name, 2 as Type, 4.0 as Value, 2 as Id, 'qwe' as Name"))
+            {
+                if (reader.Read())
+                {
+                    var col = reader.GetOrdinal("Type");
+                    var splitOn = reader.GetOrdinal("Id");
+
+                    var toFoo = reader.GetRowParser<DiscriminatedWithMultiMapping_BaseType>(typeof(DiscriminatedWithMultiMapping_Foo),0, splitOn);
+                    var toBar = reader.GetRowParser<DiscriminatedWithMultiMapping_BaseType>(typeof(DiscriminatedWithMultiMapping_Bar),0, splitOn);
+                    var toHaz = reader.GetRowParser<HazNameId>(typeof(HazNameId),splitOn, reader.FieldCount - splitOn);
+
+                    do
+                    {
+                        DiscriminatedWithMultiMapping_BaseType obj = null;
+                        switch (reader.GetInt32(col))
+                        {
+                            case 1:
+                                obj = toFoo(reader);
+                            break;
+                            case 2:
+                                obj = toBar(reader);
+                            break;
+                        }
+
+                        obj.IsNotNull();
+                        obj.HazNameIdObject = toHaz(reader);
+                        result.Add(obj);
+
+                    } while (reader.Read());
+                }
+            }
+
+            result.Count.IsEqualTo(2);
+            result[0].Type.IsEqualTo(1);
+            result[1].Type.IsEqualTo(2);
+            var foo = (DiscriminatedWithMultiMapping_Foo)result[0];
+            foo.Name.IsEqualTo("abc");
+            foo.HazNameIdObject.Id.IsEqualTo(1);
+            foo.HazNameIdObject.Name.IsEqualTo("zxc");
+            var bar = (DiscriminatedWithMultiMapping_Bar)result[1];
+            bar.Value.IsEqualTo((float)4.0);
+            bar.HazNameIdObject.Id.IsEqualTo(2);
+            bar.HazNameIdObject.Name.IsEqualTo("qwe");
+        }
+
         abstract class Discriminated_BaseType
         {
             public abstract int Type { get; }
@@ -98,6 +150,31 @@ public override int Type
                 get { return 2; }
             }
         }
+
+
+        abstract class DiscriminatedWithMultiMapping_BaseType : Discriminated_BaseType
+        {
+            public abstract HazNameId HazNameIdObject { get; set; }
+        }
+        class DiscriminatedWithMultiMapping_Foo : DiscriminatedWithMultiMapping_BaseType
+        {
+            public override HazNameId HazNameIdObject { get; set; }
+            public string Name { get; set; }
+            public override int Type
+            {
+                get { return 1; }
+            }
+        }
+        class DiscriminatedWithMultiMapping_Bar : DiscriminatedWithMultiMapping_BaseType
+        {
+            public override HazNameId HazNameIdObject { get; set; }
+            public float Value { get; set; }
+            public override int Type
+            {
+                get { return 2; }
+            }
+
+        }
         public class HazNameId
         {
             public string Name { get; set; }