diff --git a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ComVariantMarshallerTests.cs b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ComVariantMarshallerTests.cs index 1e7e38610310e4..4a9163d824588e 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ComVariantMarshallerTests.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/System.Runtime.InteropServices.UnitTests/System/Runtime/InteropServices/ComVariantMarshallerTests.cs @@ -30,109 +30,184 @@ public void DBNull_Marshals_To_Null() Assert.Same(DBNull.Value, ComVariantMarshaller.ConvertToManaged(ComVariant.Null)); } - [Fact] - public void String_Marshals_To_BStr() + [Theory] + [InlineData(null, VarEnum.VT_EMPTY)] // Null strings are _not_ BSTRs, compare to BStrWrapper. + [InlineData("", VarEnum.VT_BSTR)] + [InlineData("Hello", VarEnum.VT_BSTR)] + public void String_Marshals_To_BStr(string value, VarEnum expected) { - string value = "Hello"; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); - Assert.Equal(VarEnum.VT_BSTR, variant.VarType); + Assert.Equal(expected, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void BStrWrapper_Marshals_To_BStr() + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData("Hello")] + public void BStrWrapper_Marshals_To_BStr(string value) { - string value = "Hello"; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(new BStrWrapper(value)); Assert.Equal(VarEnum.VT_BSTR, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void Int32_Marshals_To_I4() + public static IEnumerable ValidIntValues() + { + yield return new object[] { int.MinValue }; + yield return new object[] { -1 }; + yield return new object[] { 0 }; + yield return new object[] { 1 }; + yield return new object[] { int.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidIntValues))] + public void Int32_Marshals_To_I4(int value) { - int value = 42; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); Assert.Equal(VarEnum.VT_I4, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void UInt32_Marshals_To_UI4() + public static IEnumerable ValidUIntValues() + { + yield return new object[] { uint.MinValue }; + yield return new object[] { (uint)0 }; + yield return new object[] { (uint)1 }; + yield return new object[] { uint.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidUIntValues))] + public void UInt32_Marshals_To_UI4(uint value) { - uint value = 42; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); Assert.Equal(VarEnum.VT_UI4, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void Int16_Marshals_To_I2() + public static IEnumerable ValidShortValues() + { + yield return new object[] { short.MinValue }; + yield return new object[] { (short)-1 }; + yield return new object[] { (short)0 }; + yield return new object[] { (short)1 }; + yield return new object[] { short.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidShortValues))] + public void Int16_Marshals_To_I2(short value) { - short value = 42; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); Assert.Equal(VarEnum.VT_I2, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void UInt16_Marshals_To_UI2() + public static IEnumerable ValidUShortValues() + { + yield return new object[] { ushort.MinValue }; + yield return new object[] { (ushort)0 }; + yield return new object[] { (ushort)1 }; + yield return new object[] { ushort.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidUShortValues))] + public void UInt16_Marshals_To_UI2(ushort value) { - ushort value = 42; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); Assert.Equal(VarEnum.VT_UI2, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void Byte_Marshals_To_UI1() + public static IEnumerable ValidSByteValues() + { + yield return new object[] { sbyte.MinValue }; + yield return new object[] { (sbyte)-1 }; + yield return new object[] { (sbyte)0 }; + yield return new object[] { (sbyte)1 }; + yield return new object[] { sbyte.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidSByteValues))] + public void SByte_Marshals_To_I1(sbyte value) { - byte value = 42; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); - Assert.Equal(VarEnum.VT_UI1, variant.VarType); + Assert.Equal(VarEnum.VT_I1, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void SByte_Marshals_To_I1() + public static IEnumerable ValidByteValues() + { + yield return new object[] { byte.MinValue }; + yield return new object[] { (byte)0 }; + yield return new object[] { (byte)1 }; + yield return new object[] { byte.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidByteValues))] + public void Byte_Marshals_To_UI1(byte value) { - sbyte value = 42; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); - Assert.Equal(VarEnum.VT_I1, variant.VarType); + Assert.Equal(VarEnum.VT_UI1, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void Double_Marshals_To_R8() + public static IEnumerable ValidDoubleValues() + { + yield return new object[] { double.NaN }; + yield return new object[] { double.MinValue }; + yield return new object[] { -1.0 }; + yield return new object[] { 0.0 }; + yield return new object[] { 1.0 }; + yield return new object[] { double.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidDoubleValues))] + public void Double_Marshals_To_R8(double value) { - double value = 42.0; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); Assert.Equal(VarEnum.VT_R8, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } - [Fact] - public void Single_Marshals_To_R4() + public static IEnumerable ValidFloatValues() + { + yield return new object[] { float.NaN }; + yield return new object[] { float.MinValue }; + yield return new object[] { -1.0f }; + yield return new object[] { 0.0f }; + yield return new object[] { 1.0f }; + yield return new object[] { float.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidFloatValues))] + public void Single_Marshals_To_R4(float value) { - float value = 42.0f; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); Assert.Equal(VarEnum.VT_R4, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); ComVariantMarshaller.Free(variant); } + [Theory] [InlineData(true)] [InlineData(false)] - [Theory] public void Boolean_Marshals_To_BOOL(bool value) { ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); @@ -141,27 +216,48 @@ public void Boolean_Marshals_To_BOOL(bool value) ComVariantMarshaller.Free(variant); } - [Fact] - public void ErrorWrapper_Maps_To_VT_ERROR() + [Theory] + [InlineData(0)] // S_OK + [InlineData(1)] // S_FALSE + [InlineData(unchecked((int)0x80004005))] // E_FAIL + [InlineData(unchecked((int)0x80070005))] // E_ACCESSDENIED + public void ErrorWrapper_Maps_To_VT_ERROR(int hr) { - ErrorWrapper errorWrapper = new ErrorWrapper(42); + ErrorWrapper errorWrapper = new ErrorWrapper(hr); ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(errorWrapper); Assert.Equal(VarEnum.VT_ERROR, variant.VarType); Assert.Equal(errorWrapper.ErrorCode, Assert.IsType(ComVariantMarshaller.ConvertToManaged(variant))); ComVariantMarshaller.Free(variant); } - [Fact] - public void VariantWrapper_Throws() + public static IEnumerable InvalidVariantValues() { - VariantWrapper wrapper = new VariantWrapper(42); + yield return new object[] { null }; + yield return new object[] { new object() }; + yield return new object[] { new int[] { } }; + } + + [Theory] + [MemberData(nameof(InvalidVariantValues))] + public void VariantWrapper_Throws(object obj) + { + VariantWrapper wrapper = new VariantWrapper(obj); Assert.Throws("managed", () => ComVariantMarshaller.ConvertToUnmanaged(wrapper)); } - [Fact] - public void Decimal_Marshals_To_DECIMAL() + public static IEnumerable ValidDecimalValues() + { + yield return new object[] { decimal.MinValue }; + yield return new object[] { decimal.MinusOne }; + yield return new object[] { decimal.Zero }; + yield return new object[] { decimal.One }; + yield return new object[] { decimal.MaxValue }; + } + + [Theory] + [MemberData(nameof(ValidDecimalValues))] + public void Decimal_Marshals_To_DECIMAL(decimal value) { - decimal value = 42.0m; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(value); Assert.Equal(VarEnum.VT_DECIMAL, variant.VarType); Assert.Equal(value, ComVariantMarshaller.ConvertToManaged(variant)); @@ -181,10 +277,19 @@ public void Date_Marshals_To_DATE() } #pragma warning disable CS0618 // Type or member is obsolete - [Fact] - public void CurrentyWrapper_Marshals_To_CY() + public static IEnumerable ValidCurrencyValues() + { + yield return new object[] { decimal.FromOACurrency(long.MinValue) }; + yield return new object[] { decimal.MinusOne }; + yield return new object[] { decimal.Zero }; + yield return new object[] { decimal.One }; + yield return new object[] { decimal.FromOACurrency(long.MaxValue) }; + } + + [Theory] + [MemberData(nameof(ValidCurrencyValues))] + public void CurrencyWrapper_Marshals_To_CY(decimal value) { - decimal value = 42.0m; ComVariant variant = ComVariantMarshaller.ConvertToUnmanaged(new CurrencyWrapper(value)); Assert.Equal(VarEnum.VT_CY, variant.VarType); Assert.Equal(value, Assert.IsType(ComVariantMarshaller.ConvertToManaged(variant))); @@ -234,18 +339,20 @@ public void UnknownWrapper_Of_GeneratedComInterfaceType_Marshals_To_UNKNOWN() ComVariantMarshaller.Free(variant); } - [Fact] - public void INT_Marshals_as_Int() + [Theory] + [MemberData(nameof(ValidIntValues))] + public void INT_Marshals_as_Int(int n) { - ComVariant variant = ComVariant.CreateRaw(VarEnum.VT_INT, 42); - Assert.Equal(42, Assert.IsType(ComVariantMarshaller.ConvertToManaged(variant))); + ComVariant variant = ComVariant.CreateRaw(VarEnum.VT_INT, n); + Assert.Equal(n, Assert.IsType(ComVariantMarshaller.ConvertToManaged(variant))); } - [Fact] - public void UINT_Marshals_as_UInt() + [Theory] + [MemberData(nameof(ValidUIntValues))] + public void UINT_Marshals_as_UInt(uint n) { - ComVariant variant = ComVariant.CreateRaw(VarEnum.VT_UINT, 42u); - Assert.Equal(42u, Assert.IsType(ComVariantMarshaller.ConvertToManaged(variant))); + ComVariant variant = ComVariant.CreateRaw(VarEnum.VT_UINT, n); + Assert.Equal(n, Assert.IsType(ComVariantMarshaller.ConvertToManaged(variant))); } [InlineData(VarEnum.VT_I1, (byte)42)]