diff --git a/MockMe.sln b/MockMe.sln index 7549010..80c918b 100644 --- a/MockMe.sln +++ b/MockMe.sln @@ -29,8 +29,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MockMe.Abstractions", "src\MockMe.Abstractions\MockMe.Abstractions.csproj", "{B134418F-FADA-49D5-AC6F-6297F2C22598}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MockMe.SampleMocks", "src\MockMe.SampleMocks\MockMe.SampleMocks.csproj", "{1C8CEE11-5494-4762-A4E7-62042CE51E56}" -EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MockMe.PostBuild", "src\MockMe.PostBuild\MockMe.PostBuild.csproj", "{511CE2FA-4247-4553-BFE6-AB049DC5EB5C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MockMe.Tests.ExampleClasses", "tests\MockMe.Tests.ExampleClasses\MockMe.Tests.ExampleClasses.csproj", "{63E88E6D-9C69-4E6A-BDD4-45F84884220D}" @@ -43,7 +41,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "wiki", "wiki", "{4723EF4B-9 EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MockMe.Tests", "tests\MockMe.Tests\MockMe.Tests.csproj", "{25527E94-77F8-4FBC-B8B4-BB29C4BEBD75}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MockMe.Tests.Overloads", "tests\MockMe.Tests.Overloads\MockMe.Tests.Overloads.csproj", "{DF4654A0-0E51-47AE-95AE-0BECF958ED49}" +Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "MockMe.Tests.Overloads", "tests\MockMe.Tests.Overloads\MockMe.Tests.Overloads.shproj", "{705ED000-6380-4C9E-BF2E-71BA8C390E28}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MockMe.Tests.Overloads.Sealed", "tests\MockMe.Tests.Overloads.Sealed\MockMe.Tests.Overloads.Sealed.csproj", "{1CDE1684-1F3F-AF84-5126-85482E225FD8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MockMe.Tests.Overloads.Interface", "tests\MockMe.Tests.Overloads.Interface\MockMe.Tests.Overloads.Interface.csproj", "{E08ADBB1-7CB8-4BFF-9BAC-485DC7822719}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -63,10 +65,6 @@ Global {B134418F-FADA-49D5-AC6F-6297F2C22598}.Debug|Any CPU.Build.0 = Debug|Any CPU {B134418F-FADA-49D5-AC6F-6297F2C22598}.Release|Any CPU.ActiveCfg = Release|Any CPU {B134418F-FADA-49D5-AC6F-6297F2C22598}.Release|Any CPU.Build.0 = Release|Any CPU - {1C8CEE11-5494-4762-A4E7-62042CE51E56}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {1C8CEE11-5494-4762-A4E7-62042CE51E56}.Debug|Any CPU.Build.0 = Debug|Any CPU - {1C8CEE11-5494-4762-A4E7-62042CE51E56}.Release|Any CPU.ActiveCfg = Release|Any CPU - {1C8CEE11-5494-4762-A4E7-62042CE51E56}.Release|Any CPU.Build.0 = Release|Any CPU {511CE2FA-4247-4553-BFE6-AB049DC5EB5C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {511CE2FA-4247-4553-BFE6-AB049DC5EB5C}.Debug|Any CPU.Build.0 = Debug|Any CPU {511CE2FA-4247-4553-BFE6-AB049DC5EB5C}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -79,10 +77,14 @@ Global {25527E94-77F8-4FBC-B8B4-BB29C4BEBD75}.Debug|Any CPU.Build.0 = Debug|Any CPU {25527E94-77F8-4FBC-B8B4-BB29C4BEBD75}.Release|Any CPU.ActiveCfg = Release|Any CPU {25527E94-77F8-4FBC-B8B4-BB29C4BEBD75}.Release|Any CPU.Build.0 = Release|Any CPU - {DF4654A0-0E51-47AE-95AE-0BECF958ED49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {DF4654A0-0E51-47AE-95AE-0BECF958ED49}.Debug|Any CPU.Build.0 = Debug|Any CPU - {DF4654A0-0E51-47AE-95AE-0BECF958ED49}.Release|Any CPU.ActiveCfg = Release|Any CPU - {DF4654A0-0E51-47AE-95AE-0BECF958ED49}.Release|Any CPU.Build.0 = Release|Any CPU + {1CDE1684-1F3F-AF84-5126-85482E225FD8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1CDE1684-1F3F-AF84-5126-85482E225FD8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1CDE1684-1F3F-AF84-5126-85482E225FD8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1CDE1684-1F3F-AF84-5126-85482E225FD8}.Release|Any CPU.Build.0 = Release|Any CPU + {E08ADBB1-7CB8-4BFF-9BAC-485DC7822719}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E08ADBB1-7CB8-4BFF-9BAC-485DC7822719}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E08ADBB1-7CB8-4BFF-9BAC-485DC7822719}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E08ADBB1-7CB8-4BFF-9BAC-485DC7822719}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -91,13 +93,19 @@ Global {19024BA2-842E-4E64-968B-AE05A495BB2D} = {AB32507E-2EED-4403-946B-1D1E7EC0D6F7} {FFC11A22-7908-4ADA-997E-99201DF96F75} = {AB32507E-2EED-4403-946B-1D1E7EC0D6F7} {B134418F-FADA-49D5-AC6F-6297F2C22598} = {AB32507E-2EED-4403-946B-1D1E7EC0D6F7} - {1C8CEE11-5494-4762-A4E7-62042CE51E56} = {AB32507E-2EED-4403-946B-1D1E7EC0D6F7} {511CE2FA-4247-4553-BFE6-AB049DC5EB5C} = {AB32507E-2EED-4403-946B-1D1E7EC0D6F7} {63E88E6D-9C69-4E6A-BDD4-45F84884220D} = {134D18E2-ECAC-4571-B7BE-0C10796D5555} {25527E94-77F8-4FBC-B8B4-BB29C4BEBD75} = {134D18E2-ECAC-4571-B7BE-0C10796D5555} - {DF4654A0-0E51-47AE-95AE-0BECF958ED49} = {134D18E2-ECAC-4571-B7BE-0C10796D5555} + {705ED000-6380-4C9E-BF2E-71BA8C390E28} = {134D18E2-ECAC-4571-B7BE-0C10796D5555} + {1CDE1684-1F3F-AF84-5126-85482E225FD8} = {134D18E2-ECAC-4571-B7BE-0C10796D5555} + {E08ADBB1-7CB8-4BFF-9BAC-485DC7822719} = {134D18E2-ECAC-4571-B7BE-0C10796D5555} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {CF07A0CA-1140-44DC-9E7E-F99E65D9EF97} EndGlobalSection + GlobalSection(SharedMSBuildProjectFiles) = preSolution + tests\MockMe.Tests.Overloads\MockMe.Tests.Overloads.projitems*{1cde1684-1f3f-af84-5126-85482e225fd8}*SharedItemsImports = 5 + tests\MockMe.Tests.Overloads\MockMe.Tests.Overloads.projitems*{705ed000-6380-4c9e-bf2e-71ba8c390e28}*SharedItemsImports = 13 + tests\MockMe.Tests.Overloads\MockMe.Tests.Overloads.projitems*{e08adbb1-7cb8-4bff-9bac-485dc7822719}*SharedItemsImports = 5 + EndGlobalSection EndGlobal diff --git a/src/MockMe.Generator/MockGenerators/MethodGenerators/InitPropertyGenerator.cs b/src/MockMe.Generator/MockGenerators/MethodGenerators/InitPropertyGenerator.cs new file mode 100644 index 0000000..ab27afd --- /dev/null +++ b/src/MockMe.Generator/MockGenerators/MethodGenerators/InitPropertyGenerator.cs @@ -0,0 +1,37 @@ +using System.Collections.Generic; +using System.Text; +using Microsoft.CodeAnalysis; +using MockMe.Generator.Extensions; + +namespace MockMe.Generator.MockGenerators.MethodGenerators; + +internal class InitPropertyGenerator(IMethodSymbol methodSymbol) + : MethodMockGeneratorBase(methodSymbol) +{ + public override StringBuilder AddMethodCallTrackerToStringBuilder( + StringBuilder sb, + Dictionary callTrackerMeta + ) + { + var methodName = this.methodSymbol.GetPropertyName(); + + if (!callTrackerMeta.TryGetValue(methodName, out var propMeta)) + { + propMeta = new() { Name = methodName, ReturnType = this.returnType }; + callTrackerMeta.Add(methodName, propMeta); + } + propMeta.HasInit = true; + + return sb; + } + + public override StringBuilder AddMethodSetupToStringBuilder( + StringBuilder sb, + Dictionary setupMeta + ) => sb; + + public override StringBuilder AddMethodToAsserterClass( + StringBuilder sb, + Dictionary assertMeta + ) => sb; +} diff --git a/src/MockMe.Generator/MockGenerators/MethodGenerators/MethodGeneratorFactory.cs b/src/MockMe.Generator/MockGenerators/MethodGenerators/MethodGeneratorFactory.cs index f3334fa..f3d328d 100644 --- a/src/MockMe.Generator/MockGenerators/MethodGenerators/MethodGeneratorFactory.cs +++ b/src/MockMe.Generator/MockGenerators/MethodGenerators/MethodGeneratorFactory.cs @@ -15,8 +15,7 @@ method.MethodKind is MethodKind.PropertySet && (propertySymbol.SetMethod?.IsInitOnly ?? false) ) { - // we skip 'init' properties because they can't be set at runtime - return null; + return new InitPropertyGenerator(method); } if (propertySymbol.IsIndexer) { diff --git a/src/MockMe.Generator/MockGenerators/MethodGenerators/PropertyGenerator.cs b/src/MockMe.Generator/MockGenerators/MethodGenerators/PropertyGenerator.cs index a1bfb89..e275351 100644 --- a/src/MockMe.Generator/MockGenerators/MethodGenerators/PropertyGenerator.cs +++ b/src/MockMe.Generator/MockGenerators/MethodGenerators/PropertyGenerator.cs @@ -59,73 +59,62 @@ Dictionary callTrackerMeta this.methodSymbol.GetParametersWithOriginalTypesAndModifiers(); string paramString = this.methodSymbol.GetParametersWithoutTypesAndModifiers(); - if (this.methodSymbol.MethodKind == MethodKind.PropertyGet) - { - var methodName = this.methodSymbol.GetPropertyName(); + var methodName = this.methodSymbol.GetPropertyName(); - string? indexerType = null; - if ( - this.methodSymbol.AssociatedSymbol is IPropertySymbol propertySymbol - && propertySymbol.IsIndexer - ) - { - indexerType = propertySymbol.Type.ToFullTypeString(); - } + //string? indexerType = null; + //if ( + // this.methodSymbol.AssociatedSymbol is IPropertySymbol propertySymbol + // && propertySymbol.IsIndexer + //) + //{ + // indexerType = propertySymbol.Type.ToFullTypeString(); + //} + + if (this.methodSymbol.MethodKind == MethodKind.PropertyGet) + { if (!callTrackerMeta.TryGetValue(methodName, out var propMeta)) { propMeta = new() { Name = methodName, ReturnType = this.returnType, - IndexerType = indexerType, + //IndexerType = indexerType, }; callTrackerMeta.Add(methodName, propMeta); } - - if (string.IsNullOrEmpty(indexerType)) - { - propMeta.GetterLogic = - @$" + //if (string.IsNullOrEmpty(indexerType)) + //{ + propMeta.GetterLogic = + @$" this.{this.GetCallStoreName()}++; return {this.voidPrefix}MockCallTracker.Call{this.voidPrefix}MemberMock(this.setup.{this.GetBagStoreName()});"; - propMeta.GetterField = $"private int {this.GetCallStoreName()};"; - } - else - { - propMeta.GetterLogic = - @$" - return {this.voidPrefix}MockCallTracker.Call{this.voidPrefix}MemberMock(this.setup.{this.GetBagStoreName()}, this.{this.GetCallStoreName()} ??= new(), index);"; - propMeta.GetterField = $"private List<{indexerType}>? {this.GetCallStoreName()};"; - } + propMeta.GetterField = $"private int {this.GetCallStoreName()};"; + //} + //else + //{ + // propMeta.GetterLogic = + // @$" + //return {this.voidPrefix}MockCallTracker.Call{this.voidPrefix}MemberMock(this.setup.{this.GetBagStoreName()}, this.{this.GetCallStoreName()} ??= new(), index);"; + // propMeta.GetterField = $"private List<{indexerType}>? {this.GetCallStoreName()};"; + //} } else if (this.methodSymbol.MethodKind == MethodKind.PropertySet) { - var methodName = this.methodSymbol.GetPropertyName(); - - string? indexerType = null; - if ( - this.methodSymbol.AssociatedSymbol is IPropertySymbol propertySymbol - && propertySymbol.IsIndexer - ) - { - indexerType = propertySymbol.Type.ToFullTypeString(); - } - if (!callTrackerMeta.TryGetValue(methodName, out var propMeta)) { propMeta = new() { Name = methodName, ReturnType = this.methodSymbol.Parameters.First().Type.ToFullReturnTypeString(), - IndexerType = indexerType, + //IndexerType = indexerType, }; callTrackerMeta.Add(methodName, propMeta); } propMeta.SetterLogic = @$" - {this.voidPrefix}MockCallTracker.Call{this.voidPrefix}MemberMock(this.setup.{this.GetBagStoreName()}, this.{this.GetCallStoreName()} ??= new(){(string.IsNullOrEmpty(indexerType) ? "" : ", index")}, value);"; + {this.voidPrefix}MockCallTracker.Call{this.voidPrefix}MemberMock(this.setup.{this.GetBagStoreName()}, this.{this.GetCallStoreName()} ??= new(), value);"; propMeta.SetterField = $"private List<{this.methodSymbol.GetMethodArgumentsAsCollection()}>? {this.GetCallStoreName()};"; diff --git a/src/MockMe.Generator/PropertyMetadata.cs b/src/MockMe.Generator/PropertyMetadata.cs index 2c4a96e..3e7cd9f 100644 --- a/src/MockMe.Generator/PropertyMetadata.cs +++ b/src/MockMe.Generator/PropertyMetadata.cs @@ -12,6 +12,7 @@ public class PropertyMetadata public string? SetterField { get; set; } public virtual string? GetterLogic { get; set; } public virtual string? SetterLogic { get; set; } + public bool HasInit { get; set; } public void AddPropToSb(StringBuilder sb) { @@ -58,6 +59,16 @@ public void AddPropToSb(StringBuilder sb) }}" ); } + else if (this.HasInit) + { + sb.Append( + $@" + init + {{ + throw new global::System.NotImplementedException(); + }}" + ); + } sb.Append( @" diff --git a/src/MockMe/Asserters/MemberAsserter.cs b/src/MockMe/Asserters/MemberAsserter.cs index 65b1ab4..3a566c3 100644 --- a/src/MockMe/Asserters/MemberAsserter.cs +++ b/src/MockMe/Asserters/MemberAsserter.cs @@ -11,30 +11,62 @@ public MemberAsserter(int numTimesCalled) this.numTimesCalled = numTimesCalled; } - public void WasCalled() => this.WasCalled(NumTimes.AtLeast, 1); + public void WasCalled() => this.WasCalled(NumTimes.AtLeast(1)); - public void WasNotCalled() => this.WasCalled(NumTimes.Exactly, 0); + public void WasNotCalled() => this.WasCalled(NumTimes.Exactly(0)); - public void WasCalled(int numTimesCalled) => this.WasCalled(NumTimes.Exactly, numTimesCalled); + public void WasCalled(int numTimesCalled) => this.WasCalled(NumTimes.Exactly(numTimesCalled)); - public void WasCalled(NumTimes intComparison, int numTimesCalled) + public void WasCalled(NumTimes numTimesExpected) => + numTimesExpected.AssertSatisfied(this.numTimesCalled); +} + +public abstract class NumTimes +{ + public static NumTimes AtLeast(int numTimes) => + new SingleNumComparisonNumTimes(NumComparison.AtLeast, numTimes); + + public static NumTimes AtMost(int numTimes) => + new SingleNumComparisonNumTimes(NumComparison.AtMost, numTimes); + + public static NumTimes Exactly(int numTimes) => + new SingleNumComparisonNumTimes(NumComparison.Exactly, numTimes); + + public static NumTimes Between(int lowestValueExpected, int highestValueExpected) => + new BetweenNumTimes(lowestValueExpected, highestValueExpected); + + internal abstract void AssertSatisfied(int numTimesActuallyCalled); +} + +internal class SingleNumComparisonNumTimes : NumTimes +{ + private readonly NumComparison numComparison; + private readonly int expectedNumTimes; + + internal SingleNumComparisonNumTimes(NumComparison numComparison, int expectedNumTimes) + { + this.numComparison = numComparison; + this.expectedNumTimes = expectedNumTimes; + } + + internal override void AssertSatisfied(int numTimesActuallyCalled) { - switch (intComparison) + switch (this.numComparison) { - case NumTimes.Exactly: - if (this.numTimesCalled != numTimesCalled) + case NumComparison.Exactly: + if (numTimesActuallyCalled != this.expectedNumTimes) { throw new AssertionFailureException(); } break; - case NumTimes.AtLeast: - if (this.numTimesCalled < numTimesCalled) + case NumComparison.AtLeast: + if (numTimesActuallyCalled < this.expectedNumTimes) { throw new AssertionFailureException(); } break; - case NumTimes.AtMost: - if (this.numTimesCalled > numTimesCalled) + case NumComparison.AtMost: + if (numTimesActuallyCalled > this.expectedNumTimes) { throw new AssertionFailureException(); } @@ -45,7 +77,32 @@ public void WasCalled(NumTimes intComparison, int numTimesCalled) } } -public enum NumTimes +internal class BetweenNumTimes : NumTimes +{ + private readonly int lowestPossible; + private readonly int highestPossible; + + internal BetweenNumTimes(int lowestPossible, int highestPossible) + { + this.lowestPossible = lowestPossible; + this.highestPossible = highestPossible; + } + + internal override void AssertSatisfied(int numTimesActuallyCalled) + { + if ( + this.lowestPossible <= numTimesActuallyCalled + && numTimesActuallyCalled <= this.highestPossible + ) + { + return; + } + + throw new AssertionFailureException(); + } +} + +internal enum NumComparison { Exactly, AtLeast, diff --git a/src/MockMe/Extensions/ThrowUtils.cs b/src/MockMe/Extensions/ThrowUtils.cs new file mode 100644 index 0000000..496ba49 --- /dev/null +++ b/src/MockMe/Extensions/ThrowUtils.cs @@ -0,0 +1,122 @@ +namespace MockMe.Extensions; + +internal static class ThrowUtils +{ + public static Func ToThrow() => val => throw val; + + public static Func> ToThrow() => + val => (_) => throw val; + + public static Func> ToThrow() => + val => (_, _) => throw val; + + public static Func> ToThrow() => + val => (_, _, _) => throw val; + + public static Func> ToThrow< + T1, + T2, + T3, + T4, + TReturn + >() => val => (_, _, _, _) => throw val; + + public static Func> ToThrow< + T1, + T2, + T3, + T4, + T5, + TReturn + >() => val => (_, _, _, _, _) => throw val; + + public static Func> ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + TReturn + >() => val => (_, _, _, _, _, _) => throw val; + + public static Func> ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + TReturn + >() => val => (_, _, _, _, _, _, _) => throw val; + + public static Func> ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + TReturn + >() => val => (_, _, _, _, _, _, _, _) => throw val; + + public static Func> ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + TReturn + >() => val => (_, _, _, _, _, _, _, _, _) => throw val; + + public static Func> ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + TReturn + >() => val => (_, _, _, _, _, _, _, _, _, _) => throw val; + + public static Func< + Exception, + Func + > ToThrow() => + val => (_, _, _, _, _, _, _, _, _, _, _) => throw val; + + public static Func< + Exception, + Func + > ToThrow() => + val => (_, _, _, _, _, _, _, _, _, _, _, _) => throw val; + + public static Func< + Exception, + Func + > ToThrow() => + val => (_, _, _, _, _, _, _, _, _, _, _, _, _) => throw val; + + public static Func< + Exception, + Func + > ToThrow() => + val => (_, _, _, _, _, _, _, _, _, _, _, _, _, _) => throw val; + + public static Func< + Exception, + Func + > ToThrow() => + val => (_, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => throw val; +} diff --git a/src/MockMe/Mocks/ClassMemberMocks/MemberMockThatReturns.cs b/src/MockMe/Mocks/ClassMemberMocks/MemberMockThatReturns.cs index 8a2df06..2fc5718 100644 --- a/src/MockMe/Mocks/ClassMemberMocks/MemberMockThatReturns.cs +++ b/src/MockMe/Mocks/ClassMemberMocks/MemberMockThatReturns.cs @@ -1,3 +1,5 @@ +using MockMe.Extensions; + namespace MockMe.Mocks.ClassMemberMocks; public class MemberMock @@ -11,7 +13,7 @@ public MemberMock() internal MemberMock(ActionCallbackManager callbackManager) : base(callbackManager) { - this.returnManager = new(callbackManager); + this.returnManager = new(callbackManager, ThrowUtils.ToThrow()); } private readonly ReturnManager returnManager; @@ -22,6 +24,11 @@ public MemberMock Returns(TReturn returnThis, params TReturn[] thenRetu return this; } + public void Throws(Exception ex) + { + this.returnManager.Throws(ex); + } + TReturn? IMockReturnCallRetriever.GetReturnValue() => this.returnManager.GetReturnCall(); } diff --git a/src/MockMe/Mocks/ClassMemberMocks/MemberMockWithArgsThatReturns.cs b/src/MockMe/Mocks/ClassMemberMocks/MemberMockWithArgsThatReturns.cs index db26198..9712d80 100644 --- a/src/MockMe/Mocks/ClassMemberMocks/MemberMockWithArgsThatReturns.cs +++ b/src/MockMe/Mocks/ClassMemberMocks/MemberMockWithArgsThatReturns.cs @@ -12,11 +12,12 @@ public abstract class MemberMockWithArgsThatReturns callbackManager, - Func toReturnCall + Func toReturnCall, + Func toThrownException ) : base(callbackManager) { - this.returnManager = new(callbackManager, toReturnCall); + this.returnManager = new(callbackManager, toReturnCall, toThrownException); } public TSelf Returns(TReturnFunc returnThis, params TReturnFunc[] thenReturnThese) @@ -31,723 +32,375 @@ public TSelf Returns(TReturn returnThis, params TReturn[] thenReturnThese) return (TSelf)this; } + public void Throws(Exception ex) + { + this.returnManager.Throws(ex); + } + TReturnFunc? IMockReturnCallRetriever.GetReturnValue() => this.returnManager.GetReturnCall(); } -public class MemberMock - : MemberMockWithArgsThatReturns< - TReturn, - MemberMock, - Action, - Func - > +public class MemberMock + : MemberMockWithArgsThatReturns, Action, Func> { public MemberMock() - : base(new(ActionUtils.CallbackFunc()), FunctionUtils.ToReturnFunc()) - { } + : base( + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() + ) { } } -public class MemberMock +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TReturn - >() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9 - >() - ), - FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TReturn - >() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TReturn -> +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10 - >() - ), - FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TReturn - >() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TReturn -> +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TReturn - >, - Action, - Func + MemberMock, + Action, + Func > { public MemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11 - >() - ), - FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TReturn - >() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TReturn -> +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TReturn - >, - Action< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12 - >, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TReturn - > + MemberMock, + Action, + Func > { public MemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12 - >() - ), + new(ActionUtils.CallbackFunc()), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, TReturn - >() + >(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TReturn -> +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TReturn - >, - Action< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13 - >, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TReturn - > + MemberMock, + Action, + Func > { public MemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13 - >() - ), + new(ActionUtils.CallbackFunc()), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, TReturn - >() + >(), + ThrowUtils.ToThrow() ) { } } -public class MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TReturn -> +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TReturn - >, - Action< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14 - >, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TReturn - > + MemberMock, + Action, + Func > { public MemberMock() : base( new( ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14 + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14 >() ), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + TReturn + >(), + ThrowUtils.ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, TReturn >() ) { } } -public class MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15, - TReturn -> +public class MemberMock : MemberMockWithArgsThatReturns< TReturn, - MemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15, - TReturn - >, - Action< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15 - >, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15, - TReturn - > + MemberMock, + Action, + Func > { public MemberMock() : base( new( ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15 + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15 >() ), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + TReturn + >(), + ThrowUtils.ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, TReturn >() ) { } diff --git a/src/MockMe/Mocks/ClassMemberMocks/TaskMemberMock.cs b/src/MockMe/Mocks/ClassMemberMocks/TaskMemberMock.cs index 80fcdba..fa855a7 100644 --- a/src/MockMe/Mocks/ClassMemberMocks/TaskMemberMock.cs +++ b/src/MockMe/Mocks/ClassMemberMocks/TaskMemberMock.cs @@ -28,9 +28,10 @@ public class TaskMemberMockBase { internal TaskMemberMockBase( CallbackManager callbackManager, - Func, TReturnFunc> toReturnCall + Func, TReturnFunc> toReturnCall, + Func toThrowFunc ) - : base(callbackManager, toReturnCall) { } + : base(callbackManager, toReturnCall, toThrowFunc) { } public TSelf ReturnsAsync(TReturn returnThis, params TReturn[] thenReturnThese) { @@ -46,758 +47,418 @@ public class TaskMemberMock : TaskMemberMockBase, Action, Task> { public TaskMemberMock() - : base(new(ActionUtils.CallbackFunc()), static task => task) { } + : base( + new(ActionUtils.CallbackFunc()), + static task => task, + ThrowUtils.ToThrow>() + ) { } } -public class TaskMemberMock - : TaskMemberMockBase< - TReturn, - TaskMemberMock, - Action, - Func> - > +public class TaskMemberMock + : TaskMemberMockBase, Action, Func>> { public TaskMemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc>() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc>() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc>() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc>() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc>() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc>() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - Task - >() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new(ActionUtils.CallbackFunc()), - FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - Task - >() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9 - >() - ), - FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - Task - >() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TReturn -> +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TReturn - >, - Action, - Func> + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10 - >() - ), - FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - Task - >() + new(ActionUtils.CallbackFunc()), + FunctionUtils.ToReturnFunc>(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TReturn -> +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TReturn - >, - Action, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - Task - > + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11 - >() - ), + new(ActionUtils.CallbackFunc()), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, Task - >() + >(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TReturn -> +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TReturn - >, - Action< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12 - >, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - Task - > + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12 - >() - ), + new(ActionUtils.CallbackFunc()), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, Task - >() + >(), + ThrowUtils.ToThrow>() ) { } } -public class TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TReturn -> +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TReturn - >, - Action< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13 - >, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - Task - > + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( - new( - ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13 - >() - ), + new(ActionUtils.CallbackFunc()), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + Task + >(), + ThrowUtils.ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, Task >() ) { } } -public class TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TReturn -> +public class TaskMemberMock : TaskMemberMockBase< TReturn, - TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TReturn - >, - Action< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14 - >, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - Task - > + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( new( ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14 + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14 >() ), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + Task + >(), + ThrowUtils.ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, Task >() ) { } } public class TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, TReturn > : TaskMemberMockBase< TReturn, - TaskMemberMock< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15, - TReturn - >, - Action< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15 - >, - Func< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15, - Task - > + TaskMemberMock, + Action, + Func> > { public TaskMemberMock() : base( new( ActionUtils.CallbackFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15 + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15 >() ), FunctionUtils.ToReturnFunc< - TArg1, - TArg2, - TArg3, - TArg4, - TArg5, - TArg6, - TArg7, - TArg8, - TArg9, - TArg10, - TArg11, - TArg12, - TArg13, - TArg14, - TArg15, + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, + Task + >(), + ThrowUtils.ToThrow< + T1, + T2, + T3, + T4, + T5, + T6, + T7, + T8, + T9, + T10, + T11, + T12, + T13, + T14, + T15, Task >() ) { } diff --git a/src/MockMe/Mocks/ReturnManager.cs b/src/MockMe/Mocks/ReturnManager.cs index 8166fd8..9004555 100644 --- a/src/MockMe/Mocks/ReturnManager.cs +++ b/src/MockMe/Mocks/ReturnManager.cs @@ -1,6 +1,9 @@ namespace MockMe.Mocks; -internal class ReturnManager(CallbackManager callbackManager) +internal class ReturnManager( + CallbackManager callbackManager, + Func exceptionFuncFactory +) { internal Queue? ReturnCalls { get; set; } @@ -18,6 +21,12 @@ public void Returns(TReturnCall returnThis, params TReturnCall[]? thenReturnThes } } + public void Throws(Exception ex) + { + this.ReturnCalls ??= []; + this.ReturnCalls.Enqueue(exceptionFuncFactory(ex)); + } + internal TReturnCall? GetReturnCall() { if (this.ReturnCalls is not null && this.ReturnCalls.Count > 0) @@ -37,8 +46,9 @@ public void Returns(TReturnCall returnThis, params TReturnCall[]? thenReturnThes internal sealed class ReturnManager( CallbackManager callbackManager, - Func toReturnCall -) : ReturnManager(callbackManager) + Func toReturnCall, + Func exceptionFuncFactory +) : ReturnManager(callbackManager, exceptionFuncFactory) { public void Returns(TReturn returnThis, params TReturn[]? thenReturnThese) => this.Returns(toReturnCall(returnThis), thenReturnThese?.Select(toReturnCall).ToArray()); diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props index 139570e..2c932d7 100644 --- a/tests/Directory.Build.props +++ b/tests/Directory.Build.props @@ -5,6 +5,7 @@ 9 major + True CA1822; $(WarningsNotAsErrors) @@ -14,4 +15,23 @@ False False + + + + + + + + + + + $(MSBuildProjectDirectory)\bin\$(Configuration)\$(TargetFramework)\ + + + + + + + + diff --git a/tests/MockMe.Tests.ExampleClasses/Directory.Build.props b/tests/MockMe.Tests.ExampleClasses/Directory.Build.props new file mode 100644 index 0000000..9e4d16e --- /dev/null +++ b/tests/MockMe.Tests.ExampleClasses/Directory.Build.props @@ -0,0 +1,8 @@ + + + + False + + + + diff --git a/tests/MockMe.Tests.ExampleClasses/MockMe.Tests.ExampleClasses.csproj b/tests/MockMe.Tests.ExampleClasses/MockMe.Tests.ExampleClasses.csproj index 149e676..ca115d7 100644 --- a/tests/MockMe.Tests.ExampleClasses/MockMe.Tests.ExampleClasses.csproj +++ b/tests/MockMe.Tests.ExampleClasses/MockMe.Tests.ExampleClasses.csproj @@ -1,4 +1,4 @@ - + net6.0 @@ -6,6 +6,7 @@ + diff --git a/tests/MockMe.Tests.Overloads.Interface/MockMe.Tests.Overloads.Interface.csproj b/tests/MockMe.Tests.Overloads.Interface/MockMe.Tests.Overloads.Interface.csproj new file mode 100644 index 0000000..0e5239c --- /dev/null +++ b/tests/MockMe.Tests.Overloads.Interface/MockMe.Tests.Overloads.Interface.csproj @@ -0,0 +1,25 @@ + + + + net6.0 + enable + + false + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + diff --git a/tests/MockMe.Tests.Overloads.Interface/OverloadsClass.cs b/tests/MockMe.Tests.Overloads.Interface/OverloadsClass.cs new file mode 100644 index 0000000..17c2275 --- /dev/null +++ b/tests/MockMe.Tests.Overloads.Interface/OverloadsClass.cs @@ -0,0 +1,415 @@ +using System.Threading.Tasks; + +namespace MockMe.Tests.Overloads +{ + internal interface OverloadsClass + { + double this[double index] { set; } + string this[int index] { get; set; } + int this[string index] { get; set; } + + int Prop_GetInit { get; init; } + int Prop_GetOnly { get; } + int Prop_GetSet { get; set; } + int Prop_SetOnly { set; } + + Task AsyncOfTReturn(); + Task AsyncOfTReturn(int p1); + Task AsyncOfTReturn(int p1, int p2); + Task AsyncOfTReturn(int p1, int p2, int p3); + Task AsyncOfTReturn(int p1, int p2, int p3, int p4); + Task AsyncOfTReturn(int p1, int p2, int p3, int p4, int p5); + Task AsyncOfTReturn(int p1, int p2, int p3, int p4, int p5, int p6); + Task AsyncOfTReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7); + Task AsyncOfTReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8); + Task AsyncOfTReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9 + ); + Task AsyncOfTReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10 + ); + Task AsyncOfTReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11 + ); + Task AsyncOfTReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12 + ); + Task AsyncOfTReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13 + ); + Task AsyncOfTReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13, + int p14 + ); + Task AsyncOfTReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13, + int p14, + int p15 + ); + Task AsyncReturn(); + Task AsyncReturn(int p1); + Task AsyncReturn(int p1, int p2); + Task AsyncReturn(int p1, int p2, int p3); + Task AsyncReturn(int p1, int p2, int p3, int p4); + Task AsyncReturn(int p1, int p2, int p3, int p4, int p5); + Task AsyncReturn(int p1, int p2, int p3, int p4, int p5, int p6); + Task AsyncReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7); + Task AsyncReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8); + Task AsyncReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9); + Task AsyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10 + ); + Task AsyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11 + ); + Task AsyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12 + ); + Task AsyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13 + ); + Task AsyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13, + int p14 + ); + Task AsyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13, + int p14, + int p15 + ); + int SyncReturn(); + int SyncReturn(int p1); + int SyncReturn(int p1, int p2); + int SyncReturn(int p1, int p2, int p3); + int SyncReturn(int p1, int p2, int p3, int p4); + int SyncReturn(int p1, int p2, int p3, int p4, int p5); + int SyncReturn(int p1, int p2, int p3, int p4, int p5, int p6); + int SyncReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7); + int SyncReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8); + int SyncReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9); + int SyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10 + ); + int SyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11 + ); + int SyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12 + ); + int SyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13 + ); + int SyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13, + int p14 + ); + int SyncReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13, + int p14, + int p15 + ); + void VoidReturn(); + void VoidReturn(int p1); + void VoidReturn(int p1, int p2); + void VoidReturn(int p1, int p2, int p3); + void VoidReturn(int p1, int p2, int p3, int p4); + void VoidReturn(int p1, int p2, int p3, int p4, int p5); + void VoidReturn(int p1, int p2, int p3, int p4, int p5, int p6); + void VoidReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7); + void VoidReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8); + void VoidReturn(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9); + void VoidReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10 + ); + void VoidReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11 + ); + void VoidReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12 + ); + void VoidReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13 + ); + void VoidReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13, + int p14 + ); + void VoidReturn( + int p1, + int p2, + int p3, + int p4, + int p5, + int p6, + int p7, + int p8, + int p9, + int p10, + int p11, + int p12, + int p13, + int p14, + int p15 + ); + } +} diff --git a/tests/MockMe.Tests.Overloads.Sealed/MockMe.Tests.Overloads.Sealed.csproj b/tests/MockMe.Tests.Overloads.Sealed/MockMe.Tests.Overloads.Sealed.csproj new file mode 100644 index 0000000..04f3313 --- /dev/null +++ b/tests/MockMe.Tests.Overloads.Sealed/MockMe.Tests.Overloads.Sealed.csproj @@ -0,0 +1,26 @@ + + + + net6.0 + enable + + false + + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + diff --git a/tests/MockMe.Tests.Overloads/SealedOverloadsClass.cs b/tests/MockMe.Tests.Overloads.Sealed/OverloadsClass.cs similarity index 99% rename from tests/MockMe.Tests.Overloads/SealedOverloadsClass.cs rename to tests/MockMe.Tests.Overloads.Sealed/OverloadsClass.cs index 5cf54ce..6f12de8 100644 --- a/tests/MockMe.Tests.Overloads/SealedOverloadsClass.cs +++ b/tests/MockMe.Tests.Overloads.Sealed/OverloadsClass.cs @@ -3,7 +3,7 @@ namespace MockMe.Tests.Overloads { - internal sealed class SealedOverloadsClass + internal sealed class OverloadsClass { public int Prop_GetSet { get; set; } public int Prop_GetInit { get; init; } diff --git a/tests/MockMe.Tests.Overloads/AsyncMethodOverloadTests.cs b/tests/MockMe.Tests.Overloads/AsyncMethodOverloadTests.cs index 659c6b7..6ff3a91 100644 --- a/tests/MockMe.Tests.Overloads/AsyncMethodOverloadTests.cs +++ b/tests/MockMe.Tests.Overloads/AsyncMethodOverloadTests.cs @@ -28,7 +28,7 @@ public class AsyncMethodOverloadTests [InlineData(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)] public async Task AsyncReturnOverload_CallbackAndAssertShouldWork(params int[] ints) { - var mock = Mock.Me(null); + var mock = Mock.Me(null); int numCalls = 0; @@ -39,13 +39,13 @@ public async Task AsyncReturnOverload_CallbackAndAssertShouldWork(params int[] i var setupMethod = mock .Setup.GetType() - .GetMethod(nameof(SealedOverloadsClass.AsyncReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.AsyncReturn), argIntTypes) .Invoke(mock.Setup, boxedArgInts); Action incrementNumCalls = () => numCalls++; ((dynamic)setupMethod).Callback(incrementNumCalls); - SealedOverloadsClass sealedClass = mock; + OverloadsClass overloadsObj = mock.MockedObject; Assert.ThrowsAny( () => @@ -53,16 +53,16 @@ public async Task AsyncReturnOverload_CallbackAndAssertShouldWork(params int[] i (MemberAsserter) mock .Assert.GetType() - .GetMethod(nameof(SealedOverloadsClass.AsyncReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.AsyncReturn), argIntTypes) .Invoke(mock.Assert, boxedArgInts) ).WasCalled() ); Task ret = (Task) - sealedClass + overloadsObj .GetType() - .GetMethod(nameof(SealedOverloadsClass.AsyncReturn), intTypes) - .Invoke(sealedClass, boxedInts); + .GetMethod(nameof(OverloadsClass.AsyncReturn), intTypes) + .Invoke(overloadsObj, boxedInts); await ret; @@ -72,7 +72,7 @@ public async Task AsyncReturnOverload_CallbackAndAssertShouldWork(params int[] i (MemberAsserter) mock .Assert.GetType() - .GetMethod(nameof(SealedOverloadsClass.AsyncReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.AsyncReturn), argIntTypes) .Invoke(mock.Assert, boxedArgInts) ).WasCalled(); } diff --git a/tests/MockMe.Tests.Overloads/AsyncOfTMethodOverloadsTests.cs b/tests/MockMe.Tests.Overloads/AsyncOfTMethodOverloadsTests.cs index d1c47c7..aaa4613 100644 --- a/tests/MockMe.Tests.Overloads/AsyncOfTMethodOverloadsTests.cs +++ b/tests/MockMe.Tests.Overloads/AsyncOfTMethodOverloadsTests.cs @@ -28,7 +28,7 @@ public class AsyncOfTMethodOverloadsTests [InlineData(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)] public async Task AsyncOfTReturnOverload_CallbackAndAssertShouldWork(params int[] ints) { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; @@ -39,14 +39,14 @@ public async Task AsyncOfTReturnOverload_CallbackAndAssertShouldWork(params int[ var setupMethod = mock .Setup.GetType() - .GetMethod(nameof(SealedOverloadsClass.AsyncOfTReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.AsyncOfTReturn), argIntTypes) .Invoke(mock.Setup, boxedArgInts); Action incrementNumCalls = () => numCalls++; ((dynamic)setupMethod).Callback(incrementNumCalls); ((dynamic)setupMethod).ReturnsAsync(9999); - SealedOverloadsClass sealedClass = mock; + OverloadsClass sealedClass = mock.MockedObject; Assert.ThrowsAny( () => @@ -54,7 +54,7 @@ public async Task AsyncOfTReturnOverload_CallbackAndAssertShouldWork(params int[ (MemberAsserter) mock .Assert.GetType() - .GetMethod(nameof(SealedOverloadsClass.AsyncOfTReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.AsyncOfTReturn), argIntTypes) .Invoke(mock.Assert, boxedArgInts) ).WasCalled() ); @@ -62,7 +62,7 @@ public async Task AsyncOfTReturnOverload_CallbackAndAssertShouldWork(params int[ var ret = await (Task) sealedClass .GetType() - .GetMethod(nameof(SealedOverloadsClass.AsyncOfTReturn), intTypes) + .GetMethod(nameof(OverloadsClass.AsyncOfTReturn), intTypes) .Invoke(sealedClass, boxedInts); Assert.Equal(9999, ret); @@ -72,7 +72,7 @@ public async Task AsyncOfTReturnOverload_CallbackAndAssertShouldWork(params int[ (MemberAsserter) mock .Assert.GetType() - .GetMethod(nameof(SealedOverloadsClass.AsyncOfTReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.AsyncOfTReturn), argIntTypes) .Invoke(mock.Assert, boxedArgInts) ).WasCalled(); } diff --git a/tests/MockMe.Tests.Overloads/IndexerTests.cs b/tests/MockMe.Tests.Overloads/IndexerTests.cs index 9d3fb8d..c3a0883 100644 --- a/tests/MockMe.Tests.Overloads/IndexerTests.cs +++ b/tests/MockMe.Tests.Overloads/IndexerTests.cs @@ -8,14 +8,14 @@ public class IndexerTests [Fact] public void IndexerGetForInt_ReturnsAndCallbackShouldWork() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; mock.Setup[Arg.Any()].Get().Callback(() => numCalls++).Returns("hello indexer"); - SealedOverloadsClass sealedOverloadsClass = mock; + OverloadsClass OverloadsClass = mock.MockedObject; - var val = sealedOverloadsClass[99]; + var val = OverloadsClass[99]; Assert.Equal("hello indexer", val); Assert.Equal(1, numCalls); @@ -28,14 +28,14 @@ public void IndexerGetForInt_ReturnsAndCallbackShouldWork() [Fact] public void IndexerSetForInt_ReturnsAndCallbackShouldWork() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; mock.Setup[Arg.Any()].Set(Arg.Any()).Callback(() => numCalls++); - SealedOverloadsClass sealedOverloadsClass = mock; + OverloadsClass OverloadsClass = mock.MockedObject; - sealedOverloadsClass[99] = "hello indexer"; + OverloadsClass[99] = "hello indexer"; Assert.Equal(1, numCalls); mock.Assert[Arg.Any()].Set(Arg.Any()).WasCalled(); @@ -48,14 +48,14 @@ public void IndexerSetForInt_ReturnsAndCallbackShouldWork() [Fact] public void IndexerGetForString_ReturnsAndCallbackShouldWork() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; mock.Setup[Arg.Any()].Get().Callback(() => numCalls++).Returns(99); - SealedOverloadsClass sealedOverloadsClass = mock; + OverloadsClass OverloadsClass = mock.MockedObject; - var val = sealedOverloadsClass["hello"]; + var val = OverloadsClass["hello"]; Assert.Equal(99, val); Assert.Equal(1, numCalls); @@ -66,14 +66,14 @@ public void IndexerGetForString_ReturnsAndCallbackShouldWork() [Fact] public void SetOnlyIndexer_AssertAndCallbackShouldWork() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; mock.Setup[Arg.Any()].Set(Arg.Any()).Callback(() => numCalls++); - SealedOverloadsClass sealedOverloadsClass = mock; + OverloadsClass OverloadsClass = mock.MockedObject; - sealedOverloadsClass[9.9] = 9.9; + OverloadsClass[9.9] = 9.9; Assert.Equal(1, numCalls); mock.Assert[Arg.Any()].Set(Arg.Any()).WasCalled(); diff --git a/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.csproj b/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.csproj deleted file mode 100644 index 2635032..0000000 --- a/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.csproj +++ /dev/null @@ -1,43 +0,0 @@ - - - - net6.0 - enable - - false - - - - - - - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - - - - - - - - - - - - $(MSBuildProjectDirectory)\bin\$(Configuration)\$(TargetFramework)\ - - - - - - - - - - diff --git a/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.projitems b/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.projitems new file mode 100644 index 0000000..3917fe4 --- /dev/null +++ b/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.projitems @@ -0,0 +1,19 @@ + + + + $(MSBuildAllProjects);$(MSBuildThisFileFullPath) + true + 705ed000-6380-4c9e-bf2e-71ba8c390e28 + + + MockMe.Tests.Overloads + + + + + + + + + + \ No newline at end of file diff --git a/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.shproj b/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.shproj new file mode 100644 index 0000000..114081d --- /dev/null +++ b/tests/MockMe.Tests.Overloads/MockMe.Tests.Overloads.shproj @@ -0,0 +1,13 @@ + + + + 705ed000-6380-4c9e-bf2e-71ba8c390e28 + 14.0 + + + + + + + + diff --git a/tests/MockMe.Tests.Overloads/PropertyTests.cs b/tests/MockMe.Tests.Overloads/PropertyTests.cs index 6da8f8c..577ed1b 100644 --- a/tests/MockMe.Tests.Overloads/PropertyTests.cs +++ b/tests/MockMe.Tests.Overloads/PropertyTests.cs @@ -7,14 +7,14 @@ public class PropertyTests [Fact] public void GetInitProperty_ReturnsAndCallbackShouldWork() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; mock.Setup.Prop_GetInit.Get().Returns(99).Callback(() => numCalls++); - SealedOverloadsClass sealedOverloadsClass = mock; + OverloadsClass OverloadsClass = mock.MockedObject; - var val = sealedOverloadsClass.Prop_GetInit; + var val = OverloadsClass.Prop_GetInit; Assert.Equal(99, val); Assert.Equal(1, numCalls); @@ -24,14 +24,14 @@ public void GetInitProperty_ReturnsAndCallbackShouldWork() [Fact] public void GetOnlyProperty_ReturnsAndCallbackShouldWork() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; mock.Setup.Prop_GetOnly.Get().Returns(99).Callback(() => numCalls++); - SealedOverloadsClass sealedOverloadsClass = mock; + OverloadsClass OverloadsClass = mock.MockedObject; - var val = sealedOverloadsClass.Prop_GetOnly; + var val = OverloadsClass.Prop_GetOnly; Assert.Equal(99, val); Assert.Equal(1, numCalls); @@ -41,16 +41,16 @@ public void GetOnlyProperty_ReturnsAndCallbackShouldWork() [Fact] public void GetSetProperty_ReturnsAndCallbackShouldWork() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; mock.Setup.Prop_GetSet.Get().Returns(99).Callback(() => numCalls++); mock.Setup.Prop_GetSet.Set(Arg.Any()).Callback(() => numCalls++); - SealedOverloadsClass sealedOverloadsClass = mock; + OverloadsClass OverloadsClass = mock.MockedObject; - var val = sealedOverloadsClass.Prop_GetSet; - sealedOverloadsClass.Prop_GetSet = 999; + var val = OverloadsClass.Prop_GetSet; + OverloadsClass.Prop_GetSet = 999; Assert.Equal(99, val); Assert.Equal(2, numCalls); @@ -61,14 +61,14 @@ public void GetSetProperty_ReturnsAndCallbackShouldWork() [Fact] public void SetOnlyProperty_CallbackShouldWork() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); int numCalls = 0; mock.Setup.Prop_SetOnly.Set(Arg.Any()).Callback(() => numCalls++); - SealedOverloadsClass sealedOverloadsClass = mock; + OverloadsClass OverloadsClass = mock.MockedObject; - sealedOverloadsClass.Prop_SetOnly = 999; + OverloadsClass.Prop_SetOnly = 999; Assert.Equal(1, numCalls); mock.Assert.Prop_SetOnly.Set(999).WasCalled(); @@ -77,7 +77,7 @@ public void SetOnlyProperty_CallbackShouldWork() [Fact] public void GetInitProperty_HasNoSetter() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); var setSetter = mock.Setup.Prop_GetSet.GetType().GetMethod("Set"); var initSetter = mock.Setup.Prop_GetInit.GetType().GetMethod("Set"); @@ -89,13 +89,13 @@ public void GetInitProperty_HasNoSetter() [Fact] public void SetOnlyProperty_HasNoGetter() { - var mock = Mock.Me(default(SealedOverloadsClass)); + var mock = Mock.Me(default(OverloadsClass)); - var getGetter = mock.Setup.Prop_GetSet.GetType().GetMethod("Set"); - var setGetter = mock.Setup.Prop_SetOnly.GetType().GetMethod("Get"); + var getGetter = mock.Setup.Prop_GetSet.GetType().GetMethod("Get"); + var setOnlyGetter = mock.Setup.Prop_SetOnly.GetType().GetMethod("Get"); Assert.NotNull(getGetter); - Assert.Null(setGetter); + Assert.Null(setOnlyGetter); } } } diff --git a/tests/MockMe.Tests.Overloads/SyncMethodOverloadsTests.cs b/tests/MockMe.Tests.Overloads/SyncMethodOverloadsTests.cs index 53d9161..c2071de 100644 --- a/tests/MockMe.Tests.Overloads/SyncMethodOverloadsTests.cs +++ b/tests/MockMe.Tests.Overloads/SyncMethodOverloadsTests.cs @@ -28,7 +28,7 @@ public class SyncMethodOverloadsTests [InlineData(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)] public async Task SyncReturnOverload_CallbackAndAssertShouldWork(params int[] ints) { - var mock = Mock.Me(default); + var mock = Mock.Me(default); int numCalls = 0; @@ -39,7 +39,7 @@ public async Task SyncReturnOverload_CallbackAndAssertShouldWork(params int[] in var setupMethod = mock .Setup.GetType() - .GetMethod(nameof(SealedOverloadsClass.SyncReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.SyncReturn), argIntTypes) .Invoke(mock.Setup, boxedArgInts); Action incrementNumCalls = () => numCalls++; @@ -47,7 +47,7 @@ public async Task SyncReturnOverload_CallbackAndAssertShouldWork(params int[] in ((dynamic)setupMethod).Returns(9999); - SealedOverloadsClass sealedClass = mock; + OverloadsClass sealedClass = mock.MockedObject; Assert.ThrowsAny( () => @@ -55,14 +55,14 @@ public async Task SyncReturnOverload_CallbackAndAssertShouldWork(params int[] in (MemberAsserter) mock .Assert.GetType() - .GetMethod(nameof(SealedOverloadsClass.SyncReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.SyncReturn), argIntTypes) .Invoke(mock.Assert, boxedArgInts) ).WasCalled() ); object ret = sealedClass .GetType() - .GetMethod(nameof(SealedOverloadsClass.SyncReturn), intTypes) + .GetMethod(nameof(OverloadsClass.SyncReturn), intTypes) .Invoke(sealedClass, boxedInts); Assert.Equal(9999, (int)ret); @@ -73,7 +73,7 @@ public async Task SyncReturnOverload_CallbackAndAssertShouldWork(params int[] in (MemberAsserter) mock .Assert.GetType() - .GetMethod(nameof(SealedOverloadsClass.SyncReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.SyncReturn), argIntTypes) .Invoke(mock.Assert, boxedArgInts) ).WasCalled(); } diff --git a/tests/MockMe.Tests.Overloads/VoidMethodOverloadsTests.cs b/tests/MockMe.Tests.Overloads/VoidMethodOverloadsTests.cs index 505cc19..5e35ed2 100644 --- a/tests/MockMe.Tests.Overloads/VoidMethodOverloadsTests.cs +++ b/tests/MockMe.Tests.Overloads/VoidMethodOverloadsTests.cs @@ -27,7 +27,7 @@ public class VoidMethodOverloadsTests [InlineData(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)] public void VoidOverload_CallbackAndAssertShouldWork(params int[] ints) { - var mock = Mock.Me(null); + var mock = Mock.Me(null); int numCalls = 0; @@ -38,13 +38,13 @@ public void VoidOverload_CallbackAndAssertShouldWork(params int[] ints) var setupMethod = mock .Setup.GetType() - .GetMethod(nameof(SealedOverloadsClass.VoidReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.VoidReturn), argIntTypes) .Invoke(mock.Setup, boxedArgInts); Action incrementNumCalls = () => numCalls++; ((dynamic)setupMethod).Callback(incrementNumCalls); - SealedOverloadsClass sealedClass = mock; + OverloadsClass sealedClass = mock.MockedObject; Assert.ThrowsAny( () => @@ -52,14 +52,14 @@ public void VoidOverload_CallbackAndAssertShouldWork(params int[] ints) (MemberAsserter) mock .Assert.GetType() - .GetMethod(nameof(SealedOverloadsClass.VoidReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.VoidReturn), argIntTypes) .Invoke(mock.Assert, boxedArgInts) ).WasCalled() ); sealedClass .GetType() - .GetMethod(nameof(SealedOverloadsClass.VoidReturn), intTypes) + .GetMethod(nameof(OverloadsClass.VoidReturn), intTypes) .Invoke(sealedClass, boxedInts); Assert.Equal(1, numCalls); @@ -68,7 +68,7 @@ public void VoidOverload_CallbackAndAssertShouldWork(params int[] ints) (MemberAsserter) mock .Assert.GetType() - .GetMethod(nameof(SealedOverloadsClass.VoidReturn), argIntTypes) + .GetMethod(nameof(OverloadsClass.VoidReturn), argIntTypes) .Invoke(mock.Assert, boxedArgInts) ).WasCalled(); } diff --git a/tests/MockMe.Tests.slnf b/tests/MockMe.Tests.slnf index feb17ae..1c1f0f3 100644 --- a/tests/MockMe.Tests.slnf +++ b/tests/MockMe.Tests.slnf @@ -3,7 +3,9 @@ "path": "..\\MockMe.sln", "projects": [ "tests\\MockMe.Tests.ExampleClasses\\MockMe.Tests.ExampleClasses.csproj", - "tests\\MockMe.Tests.Overloads\\MockMe.Tests.Overloads.csproj", + "tests\\MockMe.Tests.Overloads.Interface\\MockMe.Tests.Overloads.Interface.csproj", + "tests\\MockMe.Tests.Overloads.Sealed\\MockMe.Tests.Overloads.Sealed.csproj", + "tests\\MockMe.Tests.Overloads\\MockMe.Tests.Overloads.shproj", "tests\\MockMe.Tests\\MockMe.Tests.csproj" ] } diff --git a/tests/MockMe.Tests/ArgTests.cs b/tests/MockMe.Tests/ArgTests.cs index 839a707..43cff1c 100644 --- a/tests/MockMe.Tests/ArgTests.cs +++ b/tests/MockMe.Tests/ArgTests.cs @@ -12,7 +12,7 @@ public void ArgAny_ShouldCoverAnyArgument() { var calculatorMock = Mock.Me(); - var calculator = (Calculator)calculatorMock; + Calculator calculator = calculatorMock; calculator.Add(0, 0); calculator.Add(1, -1); @@ -21,14 +21,14 @@ public void ArgAny_ShouldCoverAnyArgument() calculator.Add(-234, 567); calculator.Add(int.MaxValue, int.MinValue); - calculatorMock.Assert.Add(Arg.Any(), Arg.Any()).WasCalled(NumTimes.Exactly, 6); + calculatorMock.Assert.Add(Arg.Any(), Arg.Any()).WasCalled(NumTimes.Exactly(6)); Assert.ThrowsAny( - () => calculatorMock.Assert.Add(Arg.Any(), Arg.Any()).WasCalled(NumTimes.Exactly, 5) + () => calculatorMock.Assert.Add(Arg.Any(), Arg.Any()).WasCalled(NumTimes.Exactly(5)) ); - calculatorMock.Assert.Add(-234, Arg.Any()).WasCalled(NumTimes.Exactly, 3); + calculatorMock.Assert.Add(-234, Arg.Any()).WasCalled(NumTimes.Exactly(3)); Assert.ThrowsAny( - () => calculatorMock.Assert.Add(-234, Arg.Any()).WasCalled(NumTimes.Exactly, 5) + () => calculatorMock.Assert.Add(-234, Arg.Any()).WasCalled(NumTimes.Exactly(5)) ); } } diff --git a/tests/MockMe.Tests/AssertionTests.cs b/tests/MockMe.Tests/AssertionTests.cs index 40dd1e2..341acf1 100644 --- a/tests/MockMe.Tests/AssertionTests.cs +++ b/tests/MockMe.Tests/AssertionTests.cs @@ -23,17 +23,25 @@ public void TestWasCalled_ForMethodWithNoArgsAndNoReturnVal() calculator.TurnOff(); calculatorMock.Assert.TurnOff().WasCalled(); - calculatorMock.Assert.TurnOff().WasCalled(NumTimes.AtLeast, 5); - calculatorMock.Assert.TurnOff().WasCalled(NumTimes.AtMost, 5); - calculatorMock.Assert.TurnOff().WasCalled(NumTimes.Exactly, 5); + calculatorMock.Assert.TurnOff().WasCalled(NumTimes.AtLeast(5)); + calculatorMock.Assert.TurnOff().WasCalled(NumTimes.AtMost(5)); + calculatorMock.Assert.TurnOff().WasCalled(NumTimes.Exactly(5)); + calculatorMock.Assert.TurnOff().WasCalled(NumTimes.Between(4, 5)); + calculatorMock.Assert.TurnOff().WasCalled(NumTimes.Between(5, 6)); Assert.ThrowsAny( - () => calculatorMock.Assert.TurnOff().WasCalled(NumTimes.Exactly, 4) + () => calculatorMock.Assert.TurnOff().WasCalled(NumTimes.Exactly(4)) ); Assert.ThrowsAny( - () => calculatorMock.Assert.TurnOff().WasCalled(NumTimes.AtLeast, 6) + () => calculatorMock.Assert.TurnOff().WasCalled(NumTimes.AtLeast(6)) ); Assert.ThrowsAny( - () => calculatorMock.Assert.TurnOff().WasCalled(NumTimes.AtMost, 4) + () => calculatorMock.Assert.TurnOff().WasCalled(NumTimes.AtMost(4)) + ); + Assert.ThrowsAny( + () => calculatorMock.Assert.TurnOff().WasCalled(NumTimes.Between(1, 4)) + ); + Assert.ThrowsAny( + () => calculatorMock.Assert.TurnOff().WasCalled(NumTimes.Between(6, 10)) ); } diff --git a/tests/MockMe.Tests/MockMe.Tests.csproj b/tests/MockMe.Tests/MockMe.Tests.csproj index 88ffbd0..6eb880a 100644 --- a/tests/MockMe.Tests/MockMe.Tests.csproj +++ b/tests/MockMe.Tests/MockMe.Tests.csproj @@ -1,4 +1,4 @@ - + net6.0 @@ -21,23 +21,4 @@ - - - - - - - - - - $(MSBuildProjectDirectory)\bin\$(Configuration)\$(TargetFramework)\ - - - - - - - - - diff --git a/tests/MockMe.Tests/RandomTests.cs b/tests/MockMe.Tests/RandomTests.cs deleted file mode 100644 index 01a2143..0000000 --- a/tests/MockMe.Tests/RandomTests.cs +++ /dev/null @@ -1,285 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Reflection; -using HarmonyLib; -//using MockMe.SampleMocks.CalculatorSample; -//using MockMe.SampleMocks.CalculatorSample; -using Mono.Cecil; -using Mono.Cecil.Cil; -using Mono.Cecil.Rocks; -using MonoMod.Utils; -using Newtonsoft.Json.Linq; - -namespace MockMe.Tests -{ - public class RandomTests - { - // Uncomment to disable tests - private class FactAttribute : Attribute { } - - [Fact] - public void Test() { } - } - - internal class ConnorsCoolGenericType_1Mock - : global::MockMe.Abstractions.SealedTypeMock> - { - public ConnorsCoolGenericType_1Mock() - { - this.Setup = new ConnorsCoolGenericType_1MockSetup(); - this.CallTracker = - new MockMe.Tests.ConnorsCoolGenericType_1MockSetup.ConnorsCoolGenericType_1MockCallTracker( - this.Setup - ); - this.Assert = - new MockMe.Tests.ConnorsCoolGenericType_1MockSetup.ConnorsCoolGenericType_1MockCallTracker.ConnorsCoolGenericType_1MockAsserter( - this.CallTracker - ); - global::MockMe.MockStore>.Store.TryAdd( - this.MockedObject, - this - ); - } - - public ConnorsCoolGenericType_1MockSetup Setup { get; } - public MockMe.Tests.ConnorsCoolGenericType_1MockSetup.ConnorsCoolGenericType_1MockCallTracker.ConnorsCoolGenericType_1MockAsserter Assert { get; } - private MockMe.Tests.ConnorsCoolGenericType_1MockSetup.ConnorsCoolGenericType_1MockCallTracker CallTracker { get; } - - private T GetRandomVal() - { - if ( - global::MockMe.MockStore>.TryGetValue< - ConnorsCoolGenericType_1Mock - >(default, out var mock) - ) - { - var callTracker = mock.GetType() - .GetProperty( - "CallTracker", - global::System.Reflection.BindingFlags.NonPublic - | global::System.Reflection.BindingFlags.Instance - ) - .GetValue(mock); - - return (T) - callTracker - .GetType() - .GetMethod( - "GetRandomVal", - global::System.Reflection.BindingFlags.Public - | global::System.Reflection.BindingFlags.Instance - ) - //.MakeGenericMethod(typeof(T)) - .Invoke(callTracker, new object[] { }); - } - return default; - } - - //private T GetRandomVal() - //{ - // if (global::MockMe.MockStore>.TryGetValue< - // ConnorsCoolGenericType_1Mock - // >(default, out var mock)) - // { - // var callTracker = mock.GetType() - // .GetProperty( - // "CallTracker", - // global::System.Reflection.BindingFlags.NonPublic - // | global::System.Reflection.BindingFlags.Instance - // ) - // .GetValue(mock); - - // return (T) - // callTracker - // .GetType() - // .GetMethod( - // "GetRandomVal", - // global::System.Reflection.BindingFlags.Public - // | global::System.Reflection.BindingFlags.Instance - // ) - // //.MakeGenericMethod(typeof(T)) - // .Invoke(callTracker, new object[] { }); - // } - // return default; - //} - - internal sealed class Patch8ec79a7993df4f629bec06faf0471048 - { - private static bool Prefix( - global::MockMe.Tests.ConnorsCoolGenericType __instance, - ref T __result - ) - { - if ( - global::MockMe.MockStore>.TryGetValue< - ConnorsCoolGenericType_1Mock - >(__instance, out var mock) - ) - { - __result = mock.CallTracker.MyCoolProp; - return false; - } - return true; - } - } - - internal sealed class Patch1ec57d74711f4edca0a02202a86ef4ac - { - private static bool Prefix( - global::MockMe.Tests.ConnorsCoolGenericType __instance, - ref global::System.String __result, - T input - ) - { - if ( - global::MockMe.MockStore>.TryGetValue< - ConnorsCoolGenericType_1Mock - >(__instance, out var mock) - ) - { - __result = mock.CallTracker.TakeAT(input); - return false; - } - return true; - } - } - - static ConnorsCoolGenericType_1Mock() - { - var harmony = new global::HarmonyLib.Harmony("com.mockme.patch"); - - //var originalPatchda3d87b696c842a3b100cfdd86e2a81e = - // typeof(global::MockMe.Tests.ConnorsCoolGenericType).GetMethod( - // "GetRandomVal", - // new Type[] { } - // ); - //var Patchda3d87b696c842a3b100cfdd86e2a81e = - // typeof(Patchda3d87b696c842a3b100cfdd86e2a81e).GetMethod( - // "Prefix", - // global::System.Reflection.BindingFlags.Static - // | global::System.Reflection.BindingFlags.NonPublic - // ); - - //harmony.Patch( - // originalPatchda3d87b696c842a3b100cfdd86e2a81e, - // prefix: new HarmonyMethod(Patchda3d87b696c842a3b100cfdd86e2a81e) - //); - - var originalPatch8ec79a7993df4f629bec06faf0471048 = - typeof(global::MockMe.Tests.ConnorsCoolGenericType).GetMethod( - "get_MyCoolProp", - new Type[] { } - ); - var Patch8ec79a7993df4f629bec06faf0471048 = - typeof(Patch8ec79a7993df4f629bec06faf0471048).GetMethod( - "Prefix", - global::System.Reflection.BindingFlags.Static - | global::System.Reflection.BindingFlags.NonPublic - ); - - harmony.Patch( - originalPatch8ec79a7993df4f629bec06faf0471048, - prefix: new HarmonyMethod(Patch8ec79a7993df4f629bec06faf0471048) - ); - - var originalPatch1ec57d74711f4edca0a02202a86ef4ac = - typeof(global::MockMe.Tests.ConnorsCoolGenericType).GetMethod( - "TakeAT", - new Type[] { typeof(T) } - ); - var Patch1ec57d74711f4edca0a02202a86ef4ac = - typeof(Patch1ec57d74711f4edca0a02202a86ef4ac).GetMethod( - "Prefix", - global::System.Reflection.BindingFlags.Static - | global::System.Reflection.BindingFlags.NonPublic - ); - - harmony.Patch( - originalPatch1ec57d74711f4edca0a02202a86ef4ac, - prefix: new HarmonyMethod(Patch1ec57d74711f4edca0a02202a86ef4ac) - ); - } - } - - public class ConnorsCoolGenericType_1MockSetup - : global::MockMe.Mocks.ClassMemberMocks.Setup.MemberMockSetup - { - private global::MockMe.Mocks.ClassMemberMocks.MemberMock? GetRandomVal_BagStore; - - public global::MockMe.Mocks.ClassMemberMocks.MemberMock GetRandomVal() => - this.GetRandomVal_BagStore ??= new(); - - private List>? TakeAT_DoubleBagStore; - - public global::MockMe.Mocks.ClassMemberMocks.MemberMock TakeAT( - Arg input - ) => SetupMethod(this.TakeAT_DoubleBagStore ??= new(), input); - - private global::MockMe.Mocks.ClassMemberMocks.MemberMock? get_MyCoolProp_BagStore; - public global::MockMe.Mocks.ClassMemberMocks.GetPropertyMock MyCoolProp => - new(get_MyCoolProp_BagStore ??= new()); - - public class ConnorsCoolGenericType_1MockCallTracker : MockCallTracker - { - private readonly ConnorsCoolGenericType_1MockSetup setup; - - public ConnorsCoolGenericType_1MockCallTracker( - ConnorsCoolGenericType_1MockSetup setup - ) - { - this.setup = setup; - } - - private int GetRandomVal_CallStore; - - public T GetRandomVal() - { - this.GetRandomVal_CallStore++; - return MockCallTracker.CallMemberMock(this.setup.GetRandomVal_BagStore); - } - - private List? TakeAT_DoubleCallStore; - - public global::System.String TakeAT(T input) => - MockCallTracker.CallMemberMock( - this.setup.TakeAT_DoubleBagStore, - this.TakeAT_DoubleCallStore ??= new(), - input - ); - - private int get_MyCoolProp_CallStore; - - public T MyCoolProp - { - get - { - this.get_MyCoolProp_CallStore++; - return MockCallTracker.CallMemberMock(this.setup.get_MyCoolProp_BagStore); - } - } - - public class ConnorsCoolGenericType_1MockAsserter : MockAsserter - { - private readonly ConnorsCoolGenericType_1MockCallTracker tracker; - - public ConnorsCoolGenericType_1MockAsserter( - ConnorsCoolGenericType_1MockCallTracker tracker - ) - { - this.tracker = tracker; - } - - public global::MockMe.Asserters.MemberAsserter GetRandomVal() => - new(this.tracker.GetRandomVal_CallStore); - - public global::MockMe.Asserters.MemberAsserter TakeAT(Arg input) - { - return GetMemberAsserter(this.tracker.TakeAT_DoubleCallStore, input); - } - - public global::MockMe.Asserters.GetPropertyAsserter MyCoolProp => - new(this.tracker.get_MyCoolProp_CallStore); - } - } - } -} diff --git a/tests/MockMe.Tests/ThrowsTests.cs b/tests/MockMe.Tests/ThrowsTests.cs new file mode 100644 index 0000000..2c26a4f --- /dev/null +++ b/tests/MockMe.Tests/ThrowsTests.cs @@ -0,0 +1,53 @@ +using System; +using MockMe.Tests.ExampleClasses; +using Xunit; + +namespace MockMe.Tests +{ + public class ThrowsTests + { + [Fact] + public void Throws_ShouldThrowException() + { + var mock = Mock.Me(); + + mock.Setup.Add(Arg.Any(), Arg.Any()).Throws(new InvalidCastException()); // throw random exception + + Calculator calc = mock; + + Assert.Throws(() => calc.Add(1, 1)); + } + + [Fact] + public void ReturnFollowedByThrows_ShouldReturnThenThrowException() + { + var mock = Mock.Me(); + + mock.Setup.Add(Arg.Any(), Arg.Any()) + .Returns(9, 99, 999) + .Throws(new InvalidCastException()); // throw random exception + + Calculator calc = mock; + + Assert.Equal(9, calc.Add(1, 1)); + Assert.Equal(99, calc.Add(1, 1)); + Assert.Equal(999, calc.Add(1, 1)); + Assert.Throws(() => calc.Add(1, 1)); + } + + [Fact] + public void Throws_ShouldGiveAccurateAssertInfo() + { + var mock = Mock.Me(); + + mock.Setup.Add(Arg.Any(), Arg.Any()).Throws(new InvalidCastException()); // throw random exception + + Calculator calc = mock; + + Assert.Throws(() => calc.Add(1, 1)); + + mock.Assert.Add(1, 1).WasCalled(); + mock.Assert.Add(1, 2).WasNotCalled(); + } + } +} diff --git a/wiki/QuickStart.md b/wiki/QuickStart.md index aa0cc12..f5e4013 100644 --- a/wiki/QuickStart.md +++ b/wiki/QuickStart.md @@ -18,6 +18,9 @@ mock.Setup.Add(5, 5).Returns((x, y) => x * y); // if there isn't a public setter, then only the 'Get()' method will exist mock.Setup.CalculatorType.Get().Returns(CalculatorType.Scientific); +// configure methods to throw +mock.Setup.Add(-99, -99).Throws(new InvalidOperationException()); + // async methods can be configured with typical "Returns" or "ReturnsAsync" methods mock.Setup.AddAsync(10, 10).ReturnsAsync(-10); mock.Setup.AddAsync(20, 20).Returns(Task.FromResult(-20)); @@ -29,6 +32,7 @@ Calculator calc = mock; // convert to mocked object with implicit cast calc.Add(1, 1); // result is 99 calc.Add(5, 5); // result is 25 (5 * 5) +calc.Add(-99, -99); // throws invalidOperationException calc.AddAsync(10, 10); // result is -10 calc.AddAsync(20, 20); // result is -20 calc["string indexer"]; // result is 9.999 @@ -103,9 +107,9 @@ mock.Assert.Add(1, 1).WasCalled(); mock.Assert.Add(1, 1).WasNotCalled(); -mock.Assert.Add(1, 1).WasCalled(NumTimes.AtLeast, 3); +mock.Assert.Add(1, 1).WasCalled(NumTimes.AtLeast(3)); -mock.Assert.Add(1, 1).WasCalled(NumTimes.AtMost, 3); +mock.Assert.Add(1, 1).WasCalled(NumTimes.AtMost(3)); // assert property was set to specific value mock.Assert.CalculatorType.Set(CalculatorType.Graphing).WasCalled();