Merge pull request #17 from in-async/release/v0.4.0

in-async · web-flow · commit dcdca50ab926 · 2020-04-02T12:17:33.000+09:00
Release/v0.4.0 * Fix #15 ターゲット型がインターフェースの場合に継承メンバーを比較しない不具合を修正。 * ターゲット型に同名のデータメンバーが存在した場合、一意に解決できない為 CS0229 相当とみなし、ArgumentException をスローするよう対応。 cf. #15 (comment)
diff --git a/Inasync.PrimitiveAssert.Tests/IssueTests.cs b/Inasync.PrimitiveAssert.Tests/IssueTests.cs
@@ -0,0 +1,99 @@
+﻿using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Inasync.Tests {
+
+    [TestClass]
+    public class IssueTests {
+
+        [TestMethod]
+        public void Issue15_Test() => Issue15.Test();
+
+        private static class Issue15 {
+
+            public static void Test() {
+                IDerived x = new Derived { V0 = 0, V1 = 1 };
+
+                Action TestCase(int testNo, object y, Type? expectedException = null) => () => {
+                    TestAA
+                        .Act(() => x.AssertIs(y))
+                        .Assert(expectedException, message: $"No.{testNo}");
+                };
+
+                new[] {
+                    TestCase( 0, y: new { V1 = 1 }, expectedException: typeof(PrimitiveAssertFailedException)),  // y が IDerived のデータメンバーを全て実装していないので失敗すべき。
+                    TestCase( 1, y: new { V0 = 0, V1 = 1 }),
+                }.Invoke();
+            }
+
+            private interface IBase {
+                int V0 { get; }
+            }
+
+            private interface IDerived : IBase {
+                int V1 { get; }
+            }
+
+            private class Derived : IDerived {
+                public int V0 { get; set; }
+                public int V1 { get; set; }
+            }
+        }
+
+        [TestMethod]
+        public void Issue15_2_Test() => Issue15_2.Test();
+
+        private static class Issue15_2 {
+
+            public static void Test() {
+                var x = new FooBar(foo: 1, bar: 2, value: "foo bar", fooValue: "foo", barValue: "bar");
+
+                static Action TestCase<T>(int testNo, T x, object y, Type? expectedException = null) => () => {
+                    TestAA
+                        .Act(() => x.AssertIs(y))
+                        .Assert(expectedException, message: $"No.{testNo}");
+                };
+
+                new[] {
+                    TestCase( 0, (FooBar)x , y: new { Foo = 1, Bar = 2, Value = "foo bar" }),
+                    TestCase( 1, (IFoo)x   , y: new { Foo = 1, Value = "foo" }),
+                    TestCase( 2, (IBar)x   , y: new { Bar = 2, Value = "bar" }),
+                    TestCase( 3, (IFooBar)x, y: new { Foo = 1, Bar = 2, Value = "foo bar" }, expectedException: typeof(ArgumentException)),  // CS0229 相当: IFoo.Value と IBar.Value 間があいまい
+                    TestCase( 4, (IFooBar)x, y: new FooBar(foo: 1, bar: 2, value: "foo bar", fooValue: "foo", barValue: "bar"), expectedException: typeof(ArgumentException)),  // 実体が等価に見えても、ターゲット型 IFooBar の Value があいまいなまま
+                    TestCase( 5, (IFooBar)x, y: x),  // 参照等価であれば、IFooBar.Value のあいまいさを解決する必要が無いので、成功
+                }.Invoke();
+            }
+
+            private interface IFoo {
+                int Foo { get; }
+                string Value { get; }
+            }
+
+            private interface IBar {
+                int Bar { get; }
+                string Value { get; }
+            }
+
+            private interface IFooBar : IFoo, IBar { }
+
+            private sealed class FooBar : IFooBar {
+                private readonly string _fooValue;
+                private readonly string _barValue;
+
+                public FooBar(int foo, int bar, string value, string fooValue, string barValue) {
+                    Foo = foo;
+                    Bar = bar;
+                    Value = value;
+                    _fooValue = fooValue;
+                    _barValue = barValue;
+                }
+
+                public int Foo { get; }
+                public int Bar { get; }
+                public string Value { get; }
+                string IFoo.Value => _fooValue;
+                string IBar.Value => _barValue;
+            }
+        }
+    }
+}
diff --git a/Inasync.PrimitiveAssert.Tests/PrimitiveAssertTests_AssertIs.cs b/Inasync.PrimitiveAssert.Tests/PrimitiveAssertTests_AssertIs.cs
@@ -187,6 +187,12 @@ Action TestCase<T>(int testNo, T x, object y, Type? expectedException = null) =>
                 TestCase( 5, x: new Dictionary<int, int>{ { 1, 2 } }, y: new Dictionary<int, int>{ { 1, 2 } }),  // issue #8: Dictionary<> のような型引数と要素型が一致しないコレクションでも、各要素を要素型で等値アサートできる。
                 TestCase( 6, x: new CirculatedClass()               , y: new CirculatedClass()               ),  // issue #9: 循環参照しているデータ メンバーは循環先のパスで比較。
                 TestCase( 7, x: new { Obj = new CirculatedClass() } , y: new { Obj = new CirculatedClass() } ),  // issue #9: 循環参照しているデータ メンバーは循環先のパスで比較。
+                TestCase( 8, x: (IBase)   new Derived{ V0 = 0, V1 = 1 }, y: new { V0 = 0         }),
+                TestCase( 9, x: (IDerived)new Derived{ V0 = 0, V1 = 1 }, y: new { V0 = 0         }, expectedException: typeof(PrimitiveAssertFailedException)),  // issue #15: expected が IDerived のデータメンバーを全て実装していないので失敗すべき。
+                TestCase(10, x: (IDerived)new Derived{ V0 = 0, V1 = 1 }, y: new {         V1 = 1 }, expectedException: typeof(PrimitiveAssertFailedException)),  // issue #15: expected が IDerived のデータメンバーを全て実装していないので失敗すべき。
+                TestCase(11, x: (IDerived)new Derived{ V0 = 0, V1 = 1 }, y: new { V0 = 0, V1 = 1 }),
+                TestCase(12, x: new{ Foo=1 }, y: new{ Foo=1m }),
+                TestCase(13, x: new{ Foo=1 }, y: new{ Foo=2m }, expectedException: typeof(PrimitiveAssertFailedException)),
             }.Invoke();
         }
 
@@ -215,6 +221,19 @@ private class CirculatedClass {
             public CirculatedClass Self => this;
         }
 
+        private interface IBase {
+            int V0 { get; }
+        }
+
+        private interface IDerived : IBase {
+            int V1 { get; }
+        }
+
+        private sealed class Derived : IDerived {
+            public int V0 { get; set; }
+            public int V1 { get; set; }
+        }
+
         #endregion Helper
     }
 }
diff --git a/Inasync.PrimitiveAssert/Commons/DictionaryExtensions.cs b/Inasync.PrimitiveAssert/Commons/DictionaryExtensions.cs
@@ -0,0 +1,13 @@
+﻿using System.Collections.Generic;
+
+namespace Inasync {
+
+    internal static class DictionaryExtensions {
+
+        public static bool TryRemove<TKey, TValue>(this IDictionary<TKey, TValue> source, TKey key, out TValue value) {
+            if (!source.TryGetValue(key, out value)) { return false; }
+            source.Remove(key);
+            return true;
+        }
+    }
+}
diff --git a/Inasync.PrimitiveAssert/Commons/TypeExtensions.cs b/Inasync.PrimitiveAssert/Commons/TypeExtensions.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 
 namespace Commons {
 
@@ -38,5 +39,21 @@ public static bool IsNullable(this Type type) {
 
             return null;
         }
+
+        /// <summary>
+        /// 指定された型が備えるプロパティを全て返します。
+        /// <paramref name="type"/> がインターフェースの場合は、そのインターフェースが実装する全てのインターフェースのプロパティも含みます。
+        /// </summary>
+        /// <remarks>https://stackoverflow.com/questions/358835/getproperties-to-return-all-properties-for-an-interface-inheritance-hierarchy/26766221#26766221</remarks>
+        public static IEnumerable<PropertyInfo> GetPropertiesEx(this Type type, BindingFlags bindingAttr) {
+            if (!type.IsInterface) {
+                return type.GetProperties(bindingAttr);
+            }
+
+            return new[] { type }
+                   .Concat(type.GetInterfaces())
+                   .SelectMany(x => x.GetProperties(bindingAttr))
+                   ;
+        }
     }
 }
diff --git a/Inasync.PrimitiveAssert/Inasync.PrimitiveAssert.csproj b/Inasync.PrimitiveAssert/Inasync.PrimitiveAssert.csproj
@@ -9,7 +9,7 @@
     <PackageProjectUrl>https://github.com/in-async/PrimitiveAssert</PackageProjectUrl>
     <PackageLicenseUrl>https://github.com/in-async/PrimitiveAssert/blob/master/LICENSE</PackageLicenseUrl>
     <PackageTags>library test unittest assert deep</PackageTags>
-    <Version>0.3.4</Version>
+    <Version>0.4.0</Version>
   </PropertyGroup>
 
 </Project>
diff --git a/Inasync.PrimitiveAssert/Internals/AssertIsImpl.cs b/Inasync.PrimitiveAssert/Internals/AssertIsImpl.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections;
+using System.Linq;
 using Commons;
 
 namespace Inasync {
@@ -13,6 +14,7 @@ public AssertIsImpl(string? message, Action<string>? logger) {
             _logger = logger;
         }
 
+        /// <exception cref="ArgumentException">ターゲット型に同じ名前のデータメンバーが 2 つ以上存在します。</exception>
         public void AssertIs(AssertNode node) {
             var targetType = node.TargetType;
             var actual = node.Actual;
@@ -131,6 +133,7 @@ private bool TryCollectionAssertIs(Type targetType, object actual, object expect
             return false;
         }
 
+        /// <exception cref="ArgumentException">ターゲット型に同じ名前のデータメンバーが 2 つ以上存在します。</exception>
         private bool TryCompositeAssertIs(Type targetType, object actual, object expected, AssertNode node) {
             targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;
 
@@ -151,10 +154,21 @@ private bool TryCompositeAssertIs(Type targetType, object actual, object expecte
                 return true;
             }
 
+            // ターゲット型に同じ名前のデータメンバーが含まれていない事をチェック。
+            // 同じ名前のデータメンバーが 2 つ以上存在する場合、アサート対象を解決できない為 (CS0229 相当)。
+            var targetDataMembers = targetType.GetDataMembers().ToArray();
+            var duplicateMember = targetDataMembers.ToLookup(x => x.Name).FirstOrDefault(g => g.Count() > 1);
+            if (duplicateMember != null) {
+                var duplicateMemberNames = duplicateMember.Select(x => $"'{x.DeclaringType.Name}.{x.Name}'");
+                throw new ArgumentException(message: $"ターゲット型 '{targetType.Name}' に含まれる {string.Join(" と ", duplicateMemberNames)} があいまいです。");
+            }
+
             // 各データ メンバーの比較
-            foreach (var member in targetType.GetDataMembers()) {
-                if (!actualType.TryGetDataMember(member.Name, out var actualMember)) { throw new PrimitiveAssertFailedException(node, $"actual にデータ メンバー {member.Name} が見つかりません。", _message); }
-                if (!expectedType.TryGetDataMember(member.Name, out var expectedMember)) { throw new PrimitiveAssertFailedException(node, $"expected にデータ メンバー {member.Name} が見つかりません。", _message); }
+            var actualMemberMap = actualType.GetDataMembers().ToDictionary(x => x.Name);
+            var expectedMemberMap = expectedType.GetDataMembers().ToDictionary(x => x.Name);
+            foreach (var member in targetDataMembers) {
+                if (!actualMemberMap.TryRemove(member.Name, out var actualMember)) { throw new PrimitiveAssertFailedException(node, $"actual にデータ メンバー {member.Name} が見つかりません。", _message); }
+                if (!expectedMemberMap.TryRemove(member.Name, out var expectedMember)) { throw new PrimitiveAssertFailedException(node, $"expected にデータ メンバー {member.Name} が見つかりません。", _message); }
 
                 var actualMemberValue = actualMember.GetValue(actual);
                 var expectedMemberValue = expectedMember.GetValue(expected);
diff --git a/Inasync.PrimitiveAssert/Internals/DataMember.cs b/Inasync.PrimitiveAssert/Internals/DataMember.cs
@@ -12,19 +12,22 @@ internal readonly struct DataMember {
 
         public readonly string Name;
         public readonly Type DataType;
+        public readonly Type DeclaringType;
 
         public DataMember(PropertyInfo prop) {
             _prop = prop;
             _field = null;
             Name = prop.Name;
             DataType = prop.PropertyType;
+            DeclaringType = prop.DeclaringType;
         }
 
         public DataMember(FieldInfo field) {
             _prop = null;
             _field = field;
             Name = field.Name;
             DataType = field.FieldType;
+            DeclaringType = field.DeclaringType;
         }
 
         public object GetValue(object? obj) {
diff --git a/Inasync.PrimitiveAssert/Internals/Numeric.cs b/Inasync.PrimitiveAssert/Internals/Numeric.cs
@@ -19,6 +19,7 @@ public static bool IsNumeric(Type type) {
                 || type == typeof(float)
                 || type == typeof(double)
                 || type == typeof(decimal)
+                || type == typeof(Numeric)
                 || Nullable.GetUnderlyingType(type) is Type underingType && IsNumeric(underingType)
                 ;
         }
diff --git a/Inasync.PrimitiveAssert/Internals/TypeExtensions.cs b/Inasync.PrimitiveAssert/Internals/TypeExtensions.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using Commons;
 
 namespace Inasync {
 
@@ -58,42 +59,28 @@ public static bool IsSystemCollection(this Type type) {
         /// <summary>
         /// インスタンスかつパブリックな <see cref="DataMember"/> の一覧を返します。
         /// </summary>
+        /// <remarks>
+        /// 多重継承したインターフェース等が指定された場合に、同じ名前のデータメンバーが列挙される可能性があります。
+        /// これを一意に識別する場合は、宣言された型 (DeclaringType) も併せて識別子として下さい。
+        /// </remarks>
         public static IEnumerable<DataMember> GetDataMembers(this Type type) {
+            const BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
+
             var props = (
-                from prop in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
+                from prop in type.GetPropertiesEx(bindingFlags)
                 where prop.GetIndexParameters().Length == 0
                 where prop.GetGetMethod() != null
                 select new DataMember(prop)
             );
 
             var fields = (
-                from field in type.GetFields(BindingFlags.Instance | BindingFlags.Public)
+                from field in type.GetFields(bindingFlags)
                 select new DataMember(field)
             );
 
             return props.Concat(fields);
         }
 
-        /// <summary>
-        /// 指定した名前の、インスタンスかつパブリックな <see cref="DataMember"/> を探します。
-        /// </summary>
-        public static bool TryGetDataMember(this Type type, string name, out DataMember result) {
-            var prop = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public);
-            if (prop != null) {
-                result = new DataMember(prop);
-                return true;
-            }
-
-            var field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public);
-            if (field != null) {
-                result = new DataMember(field);
-                return true;
-            }
-
-            result = default;
-            return false;
-        }
-
         /// <summary>
         /// <paramref name="duckType"/> のインスタンスかつパブリックな <see cref="DataMember"/> が全て実装されているかどうか。
         /// </summary>
diff --git a/Inasync.PrimitiveAssert/PrimitiveAssert.cs b/Inasync.PrimitiveAssert/PrimitiveAssert.cs
@@ -22,6 +22,7 @@ public static class PrimitiveAssert {
         /// <param name="expected">比較対象となる期待値。</param>
         /// <param name="message">検証に失敗した際に、例外に含まれるメッセージ。</param>
         /// <exception cref="PrimitiveAssertFailedException"><paramref name="actual"/> と <paramref name="expected"/> が等価ではありません。</exception>
+        /// <exception cref="ArgumentException">ターゲット型に同じ名前のデータメンバーが 2 つ以上存在します。</exception>
         public static void AssertIs<TTarget>(this TTarget actual, object? expected, string? message = null) {
             actual.AssertIs(typeof(TTarget), expected, message);
         }
@@ -35,6 +36,7 @@ public static void AssertIs<TTarget>(this TTarget actual, object? expected, stri
         /// <param name="expected">比較対象となる期待値。</param>
         /// <param name="message">検証に失敗した際に、例外に含まれるメッセージ。</param>
         /// <exception cref="PrimitiveAssertFailedException"><paramref name="actual"/> と <paramref name="expected"/> が等価ではありません。</exception>
+        /// <exception cref="ArgumentException">ターゲット型に同じ名前のデータメンバーが 2 つ以上存在します。</exception>
         /// <remarks><paramref name="actual"/> と <paramref name="expected"/> に対して対称式となります。</remarks>
         public static void AssertIs<TTarget>(this object? actual, object? expected, string? message = null) {
             actual.AssertIs(typeof(TTarget), expected, message);
@@ -49,6 +51,7 @@ public static void AssertIs<TTarget>(this object? actual, object? expected, stri
         /// <param name="expected">比較対象となる期待値。</param>
         /// <param name="message">検証に失敗した際に、例外に含まれるメッセージ。</param>
         /// <exception cref="PrimitiveAssertFailedException"><paramref name="actual"/> と <paramref name="expected"/> が等価ではありません。</exception>
+        /// <exception cref="ArgumentException">ターゲット型に同じ名前のデータメンバーが 2 つ以上存在します。</exception>
         /// <remarks><paramref name="actual"/> と <paramref name="expected"/> に対して対称式となります。</remarks>
         public static void AssertIs(this object? actual, Type? targetType, object? expected, string? message = null) {
             var assert = new AssertIsImpl(message, ConsoleLogging ? _consoleLogger : null);
diff --git a/appveyor.yml b/appveyor.yml
@@ -16,6 +16,6 @@ deploy:
     appveyor_repo_tag: true
 - provider: NuGet
   api_key:
-    secure: BALHaadczQv8zymdHUSqGwig4bjvW3sWI1SUgOKwh7CBkrH97uurPZT3aD7wNllz
+    secure: EoZxNktAkUB1WAqUGi03AWD1Xg6vNK5MfpWn9ifG/tRZmz+z3vNceafx1VjBRgTL
   on:
     appveyor_repo_tag: true

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ public static bool IsNumeric(Type type) {`
`19`	`19`	`\|\| type == typeof(float)`
`20`	`20`	`\|\| type == typeof(double)`
`21`	`21`	`\|\| type == typeof(decimal)`
	`22`	`+ \|\| type == typeof(Numeric)`
`22`	`23`	`\|\| Nullable.GetUnderlyingType(type) is Type underingType && IsNumeric(underingType)`
`23`	`24`	`;`
`24`	`25`	`}`