diff --git a/.gitignore b/.gitignore index 88196b6..09afc6c 100644 --- a/.gitignore +++ b/.gitignore @@ -110,3 +110,4 @@ UpgradeLog*.XML # Visual Studio 2015 cache/options directory .vs/ /Fakes.Contrib/Demo.Scenarios/FakesAssemblies +/Fakes.Contrib/Fakes.Contrib.Tests/FakesAssemblies diff --git a/Fakes.Contrib/Fakes.Contrib.Tests.Classes/ClassUnderTest.cs b/Fakes.Contrib/Fakes.Contrib.Tests.Classes/ClassUnderTest.cs new file mode 100644 index 0000000..8f4c2f1 --- /dev/null +++ b/Fakes.Contrib/Fakes.Contrib.Tests.Classes/ClassUnderTest.cs @@ -0,0 +1,124 @@ +using System; +using System.Collections.Generic; +using System.IO; + +namespace Fakes.Contrib.Tests.Classes +{ + + public class ClassUnderTest + { + public void TestMethod_ArrayOfLongs(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesArray(new long[] { long.MinValue, 0, 1, 2, 3, long.MaxValue }); + } + + public void TestMethod_LongParams(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesParams(long.MinValue, 1, 2, 3, long.MaxValue); + } + + + public void TestMethod_ArrayOfLongs(IMethodsThatTakeArrays dependancy, long[] inputs) + { + dependancy.MethodTakesArray(inputs); + } + + public void TestMethod_ArrayOfInt(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesArray(new int[] { int.MinValue, 0, 1, 2, 3, int.MaxValue }); + } + + public void TestMethod_IntParams(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesParams(int.MinValue, 1, 2, 3, int.MaxValue); + } + + + public void TestMethod_ArrayOfInt(IMethodsThatTakeArrays dependancy, int[] inputs) + { + dependancy.MethodTakesArray(inputs); + } + + public void TestMethod_ArrayOfString(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesArray(new string[] { "", "foo", "bar", "baz", "bin" }); + } + + public void TestMethod_StringParams(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesParams("", "foo", "bar", "baz", "bin"); + } + + + public void TestMethod_ArrayOfString(IMethodsThatTakeArrays dependancy, string[] inputs) + { + dependancy.MethodTakesArray(inputs); + } + + public void TestMethod_ArrayOfObject(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesArray(new object[] { new object(), "bin", new ClassUnderTest() }); + } + + public void TestMethod_ObjectParams(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesParams(new object(), "bin", new ClassUnderTest()); + } + + + public void TestMethod_ArrayOfObject(IMethodsThatTakeArrays dependancy, object[] inputs) + { + dependancy.MethodTakesArray(inputs); + } + + public void TestMethod_ArrayOfInterface(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesArray(new IDisposable[] { new StreamReader(Stream.Null), new MemoryStream() }); + } + + public void TestMethod_InterfaceParams(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesParams(new StreamReader(Stream.Null), new MemoryStream()); + } + + + public void TestMethod_ArrayOfInterface(IMethodsThatTakeArrays dependancy, IDisposable[] inputs) + { + dependancy.MethodTakesArray(inputs); + } + + public void TestMethod_ArrayOfGeneric(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesArray(new List[] { new List() { 0, 1 }, new List() { 3, 4 } }); + } + + public void TestMethod_GenericParams(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesParams(new List() { 0, 1 }, new List() { 3, 4 }); + } + + + public void TestMethod_ArrayOfGeneric(IMethodsThatTakeArrays dependancy, List[] inputs) + { + dependancy.MethodTakesArray(inputs); + } + + public void TestMethod_ArrayOfDates(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesArray(new DateTime[] { DateTime.MinValue, DateTime.MaxValue, DateTime.Now }); + } + + public void TestMethod_DateParams(IMethodsThatTakeArrays dependancy) + { + dependancy.MethodTakesParams(DateTime.MinValue, DateTime.MaxValue, DateTime.Now); + } + + + public void TestMethod_ArrayOfDates(IMethodsThatTakeArrays dependancy, DateTime[] inputs) + { + dependancy.MethodTakesArray(inputs); + } + } + + +} diff --git a/Fakes.Contrib/Fakes.Contrib.Tests.Classes/Fakes.Contrib.Tests.Classes.csproj b/Fakes.Contrib/Fakes.Contrib.Tests.Classes/Fakes.Contrib.Tests.Classes.csproj new file mode 100644 index 0000000..e06b3b2 --- /dev/null +++ b/Fakes.Contrib/Fakes.Contrib.Tests.Classes/Fakes.Contrib.Tests.Classes.csproj @@ -0,0 +1,49 @@ + + + + + Debug + AnyCPU + {4B6BC67E-4782-4838-BA96-C6F7E56C73ED} + Library + Properties + Fakes.Contrib.Tests.Classes + Fakes.Contrib.Tests.Classes + v4.5 + 512 + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Fakes.Contrib/Fakes.Contrib.Tests.Classes/MethodsThatTakeArrays.cs b/Fakes.Contrib/Fakes.Contrib.Tests.Classes/MethodsThatTakeArrays.cs new file mode 100644 index 0000000..1b3d17e --- /dev/null +++ b/Fakes.Contrib/Fakes.Contrib.Tests.Classes/MethodsThatTakeArrays.cs @@ -0,0 +1,34 @@ +namespace Fakes.Contrib.Tests.Classes +{ + public interface IMethodsThatTakeArrays + { + void MethodTakesArray(T[] inputs); + void MethodTakesParams(params T[] inputs); + } + + public class MethodsThatTakeArrays : IMethodsThatTakeArrays + { + public virtual void MethodTakesArray(T[] inputs) + { + } + + public virtual void MethodTakesParams(params T[] inputs) + { + } + + } + + public class NonVirtualMethodsThatTakeArrays : IMethodsThatTakeArrays + { + public void MethodTakesArray(T[] inputs) + { + } + + public void MethodTakesParams(params T[] inputs) + { + } + + } + + +} \ No newline at end of file diff --git a/Fakes.Contrib/Fakes.Contrib.Tests.Classes/Properties/AssemblyInfo.cs b/Fakes.Contrib/Fakes.Contrib.Tests.Classes/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..a619bfb --- /dev/null +++ b/Fakes.Contrib/Fakes.Contrib.Tests.Classes/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Fakes.Contrib.Tests.Classes")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Fakes.Contrib.Tests.Classes")] +[assembly: AssemblyCopyright("Copyright © 2018")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("4b6bc67e-4782-4838-ba96-c6f7e56c73ed")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyFileVersion("1.0")] diff --git a/Fakes.Contrib/Fakes.Contrib.Tests/Fakes.Contrib.Tests.csproj b/Fakes.Contrib/Fakes.Contrib.Tests/Fakes.Contrib.Tests.csproj index 9aedda8..67bc4d1 100644 --- a/Fakes.Contrib/Fakes.Contrib.Tests/Fakes.Contrib.Tests.csproj +++ b/Fakes.Contrib/Fakes.Contrib.Tests/Fakes.Contrib.Tests.csproj @@ -37,6 +37,9 @@ 4 + + FakesAssemblies\Fakes.Contrib.Tests.Classes.Fakes.dll + False @@ -63,11 +66,19 @@ + + + + + + {4b6bc67e-4782-4838-ba96-c6f7e56c73ed} + Fakes.Contrib.Tests.Classes + {56e2764a-8d9d-4648-bf89-e9516f4b038b} Fakes.Contrib diff --git a/Fakes.Contrib/Fakes.Contrib.Tests/Fakes/Fakes.Contrib.Tests.Classes.fakes b/Fakes.Contrib/Fakes.Contrib.Tests/Fakes/Fakes.Contrib.Tests.Classes.fakes new file mode 100644 index 0000000..a180ded Binary files /dev/null and b/Fakes.Contrib/Fakes.Contrib.Tests/Fakes/Fakes.Contrib.Tests.Classes.fakes differ diff --git a/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForClassShims.cs b/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForClassShims.cs new file mode 100644 index 0000000..1d949d9 --- /dev/null +++ b/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForClassShims.cs @@ -0,0 +1,405 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Fakes.Contrib.Tests.Classes; +using Fakes.Contrib.Tests.Classes.Fakes; +using Microsoft.QualityTools.Testing.Fakes.Shims; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Fakes.Contrib.Tests +{ + [TestClass] + public class TypeTestsForClassShims + { + + [TestMethod] + public void ArrayOfLongsTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfLongs(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesArray(With.Any())); + } + } + + [TestMethod] + public void ParamsOfLongTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_LongParams(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesParams(With.Any())); + } + } + + [TestMethod] + public void ArrayOfLongExactTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + var inputs = new long[] {long.MinValue, 0, 1, 2, 3, long.MaxValue}; + + // Act + cut.TestMethod_ArrayOfLongs(stubObj.Instance, inputs); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesArray(inputs)); + } + } + + [TestMethod] + public void ArrayOfIntsTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfInt(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesArray(With.Any())); + } + } + + + [TestMethod] + public void ParamsOfIntTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_IntParams(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesParams(With.Any())); + } + } + + + [TestMethod] + public void ArrayOfIntsExactTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + var inputs = new int[] {int.MinValue, 0, 1, 2, 3, int.MaxValue}; + + // Act + cut.TestMethod_ArrayOfInt(stubObj.Instance, inputs); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesArray(inputs)); + } + } + + [TestMethod] + public void ArrayOfStringTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfString(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesArray(With.Any())); + } + } + + [TestMethod] + public void ParamsOfStringTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_StringParams(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesParams(With.Any())); + } + } + + + [TestMethod] + public void ArrayOfStringExactTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + var inputs = new string[] {"", "foo", "bar", "baz", "bin"}; + + // Act + cut.TestMethod_ArrayOfString(stubObj.Instance, inputs); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesArray(inputs)); + } + } + + [TestMethod] + public void ArrayOfObjectTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfObject(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesArray(With.Any())); + } + } + + [TestMethod] + public void ParamsOfObjectTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ObjectParams(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesParams(With.Any())); + } + } + + [TestMethod] + public void ArrayOfObjectExactTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + var inputs = new object[] {new object(), "bin", new ClassUnderTest()}; + + // Act + cut.TestMethod_ArrayOfObject(stubObj.Instance, inputs); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesArray(inputs)); + } + } + + [TestMethod] + public void ArrayOfInterfaceTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfInterface(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesArray(With.Any())); + } + } + + [TestMethod] + public void ParamsOfInterfaceTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_InterfaceParams(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesParams(With.Any())); + } + } + + [TestMethod] + public void ArrayOfInterfaceExactTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + var inputs = new IDisposable[] {new StreamReader(Stream.Null), new MemoryStream()}; + + // Act + cut.TestMethod_ArrayOfInterface(stubObj.Instance, inputs); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesArray(inputs)); + } + } + + [TestMethod] + public void ArrayOfGenericTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfGeneric(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesArray(With.Any[]>())); + } + } + + + [TestMethod] + public void ParamsOfGenericTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_GenericParams(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesParams(With.Any[]>())); + } + } + + + [TestMethod] + public void ArrayOfGenericExactTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + var inputs = new List[] {new List() {0, 1}, new List() {3, 4}}; + + // Act + cut.TestMethod_ArrayOfGeneric(stubObj.Instance, inputs); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesArray(inputs)); + } + } + + [TestMethod] + public void ArrayOfDatesTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfDates(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesArray(With.Any())); + } + } + + + [TestMethod] + public void ParamsOfDateTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_DateParams(stubObj.Instance); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => + stub.MethodTakesParams(With.Any())); + } + } + + [TestMethod] + public void ArrayOfDateExactTest() + { + using (var context = ObservableShimsContext.Create()) + { + // Arrange + var stubObj = new ShimNonVirtualMethodsThatTakeArrays(){InstanceBehavior = ShimBehaviors.DefaultValue }; + var cut = new ClassUnderTest(); + + var inputs = new DateTime[] {DateTime.MinValue, DateTime.MaxValue, DateTime.Now}; + + // Act + cut.TestMethod_ArrayOfDates(stubObj.Instance, inputs); + + // Assert + context.AssertWasCalled((NonVirtualMethodsThatTakeArrays stub) => stub.MethodTakesArray(inputs)); + } + } + + } +} diff --git a/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForClassStubs.cs b/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForClassStubs.cs new file mode 100644 index 0000000..ec79475 --- /dev/null +++ b/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForClassStubs.cs @@ -0,0 +1,333 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Fakes.Contrib.Tests.Classes; +using Fakes.Contrib.Tests.Classes.Fakes; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Fakes.Contrib.Tests +{ + [TestClass] + public class TypeTestsForClassStubs + { + + [TestMethod] + public void ArrayOfLongsTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfLongs(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfLongTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_LongParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfLongExactTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new long[] {long.MinValue, 0, 1, 2, 3, long.MaxValue}; + + // Act + cut.TestMethod_ArrayOfLongs(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + [TestMethod] + public void ArrayOfIntsTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfInt(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfIntTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_IntParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfIntsExactTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new int[] {int.MinValue, 0, 1, 2, 3, int.MaxValue}; + + // Act + cut.TestMethod_ArrayOfInt(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + [TestMethod] + public void ArrayOfStringTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfString(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfStringTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_StringParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfStringExactTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new string[] {"", "foo", "bar", "baz", "bin"}; + + // Act + cut.TestMethod_ArrayOfString(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + [TestMethod] + public void ArrayOfObjectTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfObject(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfObjectTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ObjectParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + [TestMethod] + public void ArrayOfObjectExactTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new object[] {new object(), "bin", new ClassUnderTest()}; + + // Act + cut.TestMethod_ArrayOfObject(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + + [TestMethod] + public void ArrayOfInterfaceTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfInterface(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfInterfaceTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_InterfaceParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfInterfaceExactTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new IDisposable[] {new StreamReader(Stream.Null), new MemoryStream()}; + + // Act + cut.TestMethod_ArrayOfInterface(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + + [TestMethod] + public void ArrayOfGenericTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfGeneric(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any[]>())); + } + + [TestMethod] + public void ParamsOfGenericTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_GenericParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any[]>())); + } + + + + [TestMethod] + public void ArrayOfGenericExactTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new List[] {new List() {0, 1}, new List() {3, 4}}; + + // Act + cut.TestMethod_ArrayOfGeneric(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + + [TestMethod] + public void ArrayOfDatesTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfDates(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfDateTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_DateParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfDateExactTest() + { + // Arrange + var stubObj = new StubMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new DateTime[] { DateTime.MinValue, DateTime.MaxValue, DateTime.Now }; + + // Act + cut.TestMethod_ArrayOfDates(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + } +} diff --git a/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForInterfaceStubs.cs b/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForInterfaceStubs.cs new file mode 100644 index 0000000..7e956b1 --- /dev/null +++ b/Fakes.Contrib/Fakes.Contrib.Tests/TypeTestsForInterfaceStubs.cs @@ -0,0 +1,333 @@ +using System; +using System.Collections.Generic; +using System.IO; +using Fakes.Contrib.Tests.Classes; +using Fakes.Contrib.Tests.Classes.Fakes; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Fakes.Contrib.Tests +{ + [TestClass] + public class TypeTestsForInterfaceStubs + { + + [TestMethod] + public void ArrayOfLongsTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfLongs(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfLongTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_LongParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfLongExactTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new long[] {long.MinValue, 0, 1, 2, 3, long.MaxValue}; + + // Act + cut.TestMethod_ArrayOfLongs(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + [TestMethod] + public void ArrayOfIntsTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfInt(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfIntTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_IntParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfIntsExactTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new int[] {int.MinValue, 0, 1, 2, 3, int.MaxValue}; + + // Act + cut.TestMethod_ArrayOfInt(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + [TestMethod] + public void ArrayOfStringTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfString(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfStringTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_StringParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfStringExactTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new string[] {"", "foo", "bar", "baz", "bin"}; + + // Act + cut.TestMethod_ArrayOfString(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + [TestMethod] + public void ArrayOfObjectTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfObject(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfObjectTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ObjectParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + [TestMethod] + public void ArrayOfObjectExactTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new object[] {new object(), "bin", new ClassUnderTest()}; + + // Act + cut.TestMethod_ArrayOfObject(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + + [TestMethod] + public void ArrayOfInterfaceTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfInterface(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfInterfaceTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_InterfaceParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfInterfaceExactTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new IDisposable[] {new StreamReader(Stream.Null), new MemoryStream()}; + + // Act + cut.TestMethod_ArrayOfInterface(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + + [TestMethod] + public void ArrayOfGenericTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfGeneric(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any[]>())); + } + + [TestMethod] + public void ParamsOfGenericTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_GenericParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any[]>())); + } + + + + [TestMethod] + public void ArrayOfGenericExactTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new List[] {new List() {0, 1}, new List() {3, 4}}; + + // Act + cut.TestMethod_ArrayOfGeneric(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + + [TestMethod] + public void ArrayOfDatesTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_ArrayOfDates(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(With.Any())); + } + + [TestMethod] + public void ParamsOfDateTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + // Act + cut.TestMethod_DateParams(stubObj); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesParams(With.Any())); + } + + + [TestMethod] + public void ArrayOfDateExactTest() + { + // Arrange + var stubObj = new StubIMethodsThatTakeArrays().AsObservable(); + var cut = new ClassUnderTest(); + + var inputs = new DateTime[] { DateTime.MinValue, DateTime.MaxValue, DateTime.Now }; + + // Act + cut.TestMethod_ArrayOfDates(stubObj, inputs); + + // Assert + stubObj.AssertWasCalled(stub => stub.MethodTakesArray(inputs)); + } + + } +} diff --git a/Fakes.Contrib/Fakes.Contrib.sln b/Fakes.Contrib/Fakes.Contrib.sln index 7192516..b25e5ce 100644 --- a/Fakes.Contrib/Fakes.Contrib.sln +++ b/Fakes.Contrib/Fakes.Contrib.sln @@ -21,6 +21,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Demo.Scenarios", "Demo.Scen EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Demo", "Demo\Demo.csproj", "{74AB3BE9-E64B-4641-97D7-A823BB76F5B4}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Fakes.Contrib.Tests.Classes", "Fakes.Contrib.Tests.Classes\Fakes.Contrib.Tests.Classes.csproj", "{4B6BC67E-4782-4838-BA96-C6F7E56C73ED}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -43,6 +45,10 @@ Global {74AB3BE9-E64B-4641-97D7-A823BB76F5B4}.Debug|Any CPU.Build.0 = Debug|Any CPU {74AB3BE9-E64B-4641-97D7-A823BB76F5B4}.Release|Any CPU.ActiveCfg = Release|Any CPU {74AB3BE9-E64B-4641-97D7-A823BB76F5B4}.Release|Any CPU.Build.0 = Release|Any CPU + {4B6BC67E-4782-4838-BA96-C6F7E56C73ED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4B6BC67E-4782-4838-BA96-C6F7E56C73ED}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4B6BC67E-4782-4838-BA96-C6F7E56C73ED}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4B6BC67E-4782-4838-BA96-C6F7E56C73ED}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Fakes.Contrib/Fakes.Contrib/ObservableShimsContext.cs b/Fakes.Contrib/Fakes.Contrib/ObservableShimsContext.cs index feb200c..a4b82a4 100644 --- a/Fakes.Contrib/Fakes.Contrib/ObservableShimsContext.cs +++ b/Fakes.Contrib/Fakes.Contrib/ObservableShimsContext.cs @@ -62,6 +62,21 @@ public void AssertWasCalled(Expression(Expression> expression, string message = null, params object[] parameters) + { + if (_disposed) throw new ObjectDisposedException("ObservableShimsContext"); + + var methodCallExpression = expression.AsMethodCallExpression(); + + if (methodCallExpression == null) + { + throw new ArgumentException("The expression is not a method call expression."); + } + + AssertWasCalled(methodCallExpression, message, parameters); + } + public void Dispose() { Dispose(true); diff --git a/Fakes.Contrib/Fakes.Contrib/StubExtensions.cs b/Fakes.Contrib/Fakes.Contrib/StubExtensions.cs index e3c671e..ca5408b 100644 --- a/Fakes.Contrib/Fakes.Contrib/StubExtensions.cs +++ b/Fakes.Contrib/Fakes.Contrib/StubExtensions.cs @@ -48,7 +48,8 @@ public static void AssertWasCalled(this IStub stub, Expression> throw new ArgumentException("The expression is not a method call expression."); } - var wasCalled = observer.GetCalls().Any(call => call.IsEquivalent(methodCallExpression)); + var calls = observer.GetCalls(); + var wasCalled = calls.Any(call => call.IsEquivalent(methodCallExpression)); if (!wasCalled) {