diff --git a/Docs/pages/08-analyzers.md b/Docs/pages/08-analyzers.md index 64c39a78..f8759776 100644 --- a/Docs/pages/08-analyzers.md +++ b/Docs/pages/08-analyzers.md @@ -68,8 +68,9 @@ The same applies per accessor. For a property whose accessors differ in accessib inaccessible half. The mock then overrides the accessor it can see and leaves the other one to the referenced assembly's implementation. Because writes never reach the mock, `Setup` and `Verify` expose only the getter for such a property, so a write that could never be recorded is not offered for -configuration or verification. See -[properties with only one accessor](setup/properties#properties-with-only-one-accessor) for details. +configuration or verification. The same narrowing applies to indexers. See +[properties with only one accessor](setup/properties#properties-with-only-one-accessor) and +[indexers with only one accessor](setup/indexers#indexers-with-only-one-accessor) for details. ## Mockolate0003 diff --git a/Docs/pages/setup/03-indexers.md b/Docs/pages/setup/03-indexers.md index 0f91c160..2fca4875 100644 --- a/Docs/pages/setup/03-indexers.md +++ b/Docs/pages/setup/03-indexers.md @@ -73,6 +73,54 @@ sut.Mock.Setup[It.IsAny()].OnGet .Do(() => Console.WriteLine("Execute on all odd read interactions")); ``` +## Indexers with only one accessor + +The setup and verify surfaces only offer the accessors the mock actually intercepts. +`SkippingBaseClass(…)` stays available on both, but the accessor-specific members do not: a get-only +indexer has no `OnSet`, and a set-only indexer has neither `OnGet` nor the `Returns`/`Throws` +read-sequence nor `InitializeWith`, since there is no getter to read the value back. + +```csharp +public interface IChocolateStorage +{ + int this[string shelf] { get; } // no setter + string this[int box] { set; } // no getter +} + +IChocolateStorage sut = IChocolateStorage.CreateMock(); + +sut.Mock.Setup[It.IsAny()].Returns(3); +sut.Mock.Setup[It.IsAny()].OnSet… // does not compile +sut.Mock.Setup[It.IsAny()].Returns(3).OnSet… // does not compile + +sut.Mock.Setup[It.IsAny()].OnSet.Do(value => { }); +sut.Mock.Setup[It.IsAny()].Returns("Ada")… // does not compile +sut.Mock.Setup[It.IsAny()].InitializeWith("Ada")… // does not compile +sut.Mock.Setup[It.IsAny()].OnSet.Do(value => { }).OnGet… // does not compile +``` + +The verify facade likewise offers the intercepted accessor only: + +```csharp +_ = sut["top"]; +sut[7] = "Ada"; + +await That(sut.Mock.Verify[It.Is("top")].Got()).Once(); +await That(sut.Mock.Verify[It.Is(7)].Set("Ada")).Once(); + +sut.Mock.Verify[It.Is("top")].Set(3)… // does not compile +sut.Mock.Verify[It.Is(7)].Got()… // does not compile +``` + +This also applies when the indexer declares an accessor the mock cannot see, such as +`{ get; internal set; }` on a type from an assembly that does not grant `InternalsVisibleTo`. Writes +never reach the mock in that case, so configuring or verifying one could only ever report zero +interactions. See [Mockolate0002](../analyzers#mockolate0002) for when such a type is mockable at all. + +Both facades are fully restricted: the fluent builders returned by `Returns`, `Throws`, `Do` and +`TransitionTo` stay on the narrowed surface, so no amount of chaining reaches the accessor the mock +does not intercept. Indexers with more than four keys keep the full surface. + **Notes:** - All callbacks support more advanced features like conditional execution, frequency control, parallel execution, and diff --git a/Source/Mockolate.SourceGenerators/Sources/Sources.MockClass.cs b/Source/Mockolate.SourceGenerators/Sources/Sources.MockClass.cs index af310f73..e998058d 100644 --- a/Source/Mockolate.SourceGenerators/Sources/Sources.MockClass.cs +++ b/Source/Mockolate.SourceGenerators/Sources/Sources.MockClass.cs @@ -3190,6 +3190,64 @@ private static string GetPropertyVerifyType(Property property, string verifyName _ => $"global::Mockolate.Verify.VerificationPropertyResult<{verifyName}, {property.Type.Fullname}>", }; + /// + /// Which accessors of the the narrowed setup/verify facades follow. The + /// narrowed indexer types only exist for up to keys, so indexers + /// with more keys keep the full surface regardless of . + /// + private static PropertyAccessors GetIndexerInterceptedAccessors(Property indexer) + => indexer.IndexerParameters!.Value.Count <= MaxExplicitParameters + ? GetInterceptedAccessors(indexer) + : PropertyAccessors.Both; + + /// + /// The open-generic setup facade emitted for the , narrowed to the accessors + /// classified by . The caller appends the value and key type + /// arguments and the closing angle bracket. + /// + private static string GetIndexerSetupType(Property indexer) + => GetIndexerInterceptedAccessors(indexer) switch + { + PropertyAccessors.GetOnly => "global::Mockolate.Setup.IIndexerGetterOnlySetup<", + PropertyAccessors.SetOnly => "global::Mockolate.Setup.IIndexerSetterOnlySetup<", + _ => "global::Mockolate.Setup.IndexerSetup<", + }; + + /// + /// Appends the verify facade emitted for the , narrowed to the accessors + /// classified by . The narrowed results are keyed by the + /// indexer parameters (the setter result additionally by the value type), the full + /// VerificationIndexerResult only by the value type. + /// + private static void AppendIndexerVerifyType(StringBuilder sb, Property indexer, string verifyName) + { + switch (GetIndexerInterceptedAccessors(indexer)) + { + case PropertyAccessors.GetOnly: + sb.Append("global::Mockolate.Verify.VerificationIndexerGetterResult<").Append(verifyName); + foreach (MethodParameter parameter in indexer.IndexerParameters!.Value) + { + sb.Append(", ").AppendTypeOrWrapper(parameter.Type); + } + + sb.Append('>'); + break; + case PropertyAccessors.SetOnly: + sb.Append("global::Mockolate.Verify.VerificationIndexerSetterResult<").Append(verifyName); + foreach (MethodParameter parameter in indexer.IndexerParameters!.Value) + { + sb.Append(", ").AppendTypeOrWrapper(parameter.Type); + } + + sb.Append(", ").AppendTypeOrWrapper(indexer.Type).Append('>'); + break; + default: + sb.Append("global::Mockolate.Verify.VerificationIndexerResult<").Append(verifyName).Append(", ") + .AppendTypeOrWrapper(indexer.Type).Append('>'); + break; + } + } + private static void DefineSetupInterface(StringBuilder sb, Class @class, MemberType memberType, bool hasOverloadResolutionPriority) { @@ -4222,7 +4280,7 @@ private static void AppendIndexerSetupDefinition(StringBuilder sb, Property inde .Append(valueFlags?.Count(x => !x).ToString() ?? "int.MaxValue").Append(")]").AppendLine(); } - sb.Append("\t\tglobal::Mockolate.Setup.IndexerSetup<").AppendTypeOrWrapper(indexer.Type); + sb.Append("\t\t").Append(GetIndexerSetupType(indexer)).AppendTypeOrWrapper(indexer.Type); foreach (MethodParameter parameter in indexer.IndexerParameters!) { sb.Append(", ").AppendTypeOrWrapper(parameter.Type); @@ -4299,7 +4357,7 @@ private static void AppendIndexerSetupImplementation(StringBuilder sb, Property sb.Append( "\t\t[global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)]") .AppendLine(); - sb.Append("\t\tglobal::Mockolate.Setup.IndexerSetup<").AppendTypeOrWrapper(indexer.Type); + sb.Append("\t\t").Append(GetIndexerSetupType(indexer)).AppendTypeOrWrapper(indexer.Type); foreach (MethodParameter parameter in indexer.IndexerParameters!) { sb.Append(", ").AppendTypeOrWrapper(parameter.Type); @@ -4675,8 +4733,9 @@ private static void AppendIndexerVerifyDefinition(StringBuilder sb, Property ind .Append(valueFlags?.Count(x => !x).ToString() ?? "int.MaxValue").Append(")]").AppendLine(); } - sb.Append("\t\tglobal::Mockolate.Verify.VerificationIndexerResult<").Append(verifyName).Append(", ") - .AppendTypeOrWrapper(indexer.Type).Append("> this["); + sb.Append("\t\t"); + AppendIndexerVerifyType(sb, indexer, verifyName); + sb.Append(" this["); int i = 0; foreach (MethodParameter parameter in indexer.IndexerParameters!.Value) { @@ -4731,8 +4790,9 @@ private static void AppendIndexerVerifyImplementation(StringBuilder sb, Property sb.Append( "\t\t[global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)]") .AppendLine(); - sb.Append("\t\tglobal::Mockolate.Verify.VerificationIndexerResult<").Append(verifyName).Append(", ") - .AppendTypeOrWrapper(indexer.Type).Append("> ").Append(verifyName).Append(".this["); + sb.Append("\t\t"); + AppendIndexerVerifyType(sb, indexer, verifyName); + sb.Append(' ').Append(verifyName).Append(".this["); int i = 0; foreach (MethodParameter parameter in indexer.IndexerParameters!.Value) { @@ -4767,14 +4827,35 @@ private static void AppendIndexerVerifyImplementation(StringBuilder sb, Property bool useTypedVerify = indexer.IndexerParameters.Value.Count is >= 1 and <= 4; if (useTypedVerify) { - sb.Append("\t\t\t\treturn new global::Mockolate.Verify.VerificationIndexerResult<").Append(verifyName); + PropertyAccessors interceptedAccessors = GetIndexerInterceptedAccessors(indexer); + string typedVerifyType = interceptedAccessors switch + { + PropertyAccessors.GetOnly => "VerificationIndexerGetterResult", + PropertyAccessors.SetOnly => "VerificationIndexerSetterResult", + _ => "VerificationIndexerResult", + }; + // The narrow views take only the member id of the accessor they expose. + string verifyMemberIds = interceptedAccessors switch + { + PropertyAccessors.GetOnly => indexerGetMemberId, + PropertyAccessors.SetOnly => indexerSetMemberId, + _ => $"{indexerGetMemberId}, {indexerSetMemberId}", + }; + sb.Append("\t\t\t\treturn new global::Mockolate.Verify.").Append(typedVerifyType).Append('<') + .Append(verifyName); foreach (MethodParameter parameter in indexer.IndexerParameters.Value) { sb.Append(", ").AppendTypeOrWrapper(parameter.Type); } - sb.Append(", ").AppendTypeOrWrapper(indexer.Type).Append(">(this, this.").Append(mockRegistryName) - .Append(", ").Append(indexerGetMemberId).Append(", ").Append(indexerSetMemberId).Append(",").AppendLine(); + // Only Set(...) needs the value type, so the getter-only result is keyed by the parameters alone. + if (interceptedAccessors != PropertyAccessors.GetOnly) + { + sb.Append(", ").AppendTypeOrWrapper(indexer.Type); + } + + sb.Append(">(this, this.").Append(mockRegistryName) + .Append(", ").Append(verifyMemberIds).Append(",").AppendLine(); AppendIndexerVerifyTypedMatches(sb, indexer.IndexerParameters.Value, valueFlags); } diff --git a/Source/Mockolate/Setup/IndexerSetup.cs b/Source/Mockolate/Setup/IndexerSetup.cs index 244aa3b6..e992161b 100644 --- a/Source/Mockolate/Setup/IndexerSetup.cs +++ b/Source/Mockolate/Setup/IndexerSetup.cs @@ -133,7 +133,11 @@ public class IndexerSetup(MockRegistry mockRegistry, IParameterMatch IIndexerSetupWithCallback, IIndexerGetterSetupCallbackBuilder, IIndexerSetterSetupCallbackBuilder, IIndexerSetupReturnBuilder, - IIndexerGetterSetupWithCallback, IIndexerSetterSetupWithCallback + IIndexerGetterSetupWithCallback, IIndexerSetterSetupWithCallback, + IIndexerGetterOnlySetup, IIndexerSetterOnlySetup, + IIndexerGetterOnlyGetterSetup, IIndexerSetterOnlySetterSetup, + IIndexerGetterOnlySetupCallbackBuilder, IIndexerSetterOnlySetupCallbackBuilder, + IIndexerGetterOnlySetupReturnBuilder { private Callbacks>? _getterCallbacks; private Callbacks>? _returnCallbacks; @@ -716,6 +720,272 @@ private static bool TryExtractParameter(IndexerAccess access, out T1 p1) p1 = default!; return false; } + + #region Accessor-restricted views + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.SkippingBaseClass(bool skipBaseClass) + { + SkippingBaseClass(skipBaseClass); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.InitializeWith(TValue value) + { + InitializeWith(value); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.InitializeWith(Func valueGenerator) + { + InitializeWith(valueGenerator); + return this; + } + + /// + IIndexerGetterOnlyGetterSetup IIndexerGetterOnlySetup.OnGet + => this; + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do(Action callback) + { + ((IIndexerGetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do(Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do( + Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do( + Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder IIndexerGetterOnlyGetterSetup.TransitionTo( + string scenario) + { + ((IIndexerGetterSetup)this).TransitionTo(scenario); + return this; + } + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder IIndexerGetterOnlySetupCallbackBuilder.InParallel() + { + ((IIndexerGetterSetupCallbackBuilder)this).InParallel(); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackWhenBuilder IIndexerGetterOnlySetupParallelCallbackBuilder.When( + Func predicate) + { + ((IIndexerGetterSetupParallelCallbackBuilder)this).When(predicate); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackWhenBuilder IIndexerGetterOnlySetupCallbackWhenBuilder.For( + int times) + { + ((IIndexerGetterSetupCallbackWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetupCallbackWhenBuilder.Only(int times) + { + ((IIndexerGetterSetupCallbackWhenBuilder)this).Only(times); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(TValue returnValue) + { + Returns(returnValue); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns( + Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws() + { + Throws(); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws(Exception exception) + { + Throws(exception); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws(Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws( + Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws( + Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnWhenBuilder IIndexerGetterOnlySetupReturnBuilder.When( + Func predicate) + { + ((IIndexerSetupReturnBuilder)this).When(predicate); + return this; + } + + /// + IIndexerGetterOnlySetupReturnWhenBuilder IIndexerGetterOnlySetupReturnWhenBuilder.For( + int times) + { + ((IIndexerSetupReturnWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetupReturnWhenBuilder.Only(int times) + { + ((IIndexerSetupReturnWhenBuilder)this).Only(times); + return this; + } + + /// + IIndexerSetterOnlySetup IIndexerSetterOnlySetup.SkippingBaseClass(bool skipBaseClass) + { + SkippingBaseClass(skipBaseClass); + return this; + } + + /// + IIndexerSetterOnlySetterSetup IIndexerSetterOnlySetup.OnSet + => this; + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do(Action callback) + { + ((IIndexerSetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder IIndexerSetterOnlySetterSetup.TransitionTo( + string scenario) + { + ((IIndexerSetterSetup)this).TransitionTo(scenario); + return this; + } + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder IIndexerSetterOnlySetupCallbackBuilder.InParallel() + { + ((IIndexerSetterSetupCallbackBuilder)this).InParallel(); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackWhenBuilder IIndexerSetterOnlySetupParallelCallbackBuilder.When( + Func predicate) + { + ((IIndexerSetterSetupParallelCallbackBuilder)this).When(predicate); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackWhenBuilder IIndexerSetterOnlySetupCallbackWhenBuilder.For( + int times) + { + ((IIndexerSetterSetupCallbackWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerSetterOnlySetup IIndexerSetterOnlySetupCallbackWhenBuilder.Only(int times) + { + ((IIndexerSetterSetupCallbackWhenBuilder)this).Only(times); + return this; + } + + #endregion Accessor-restricted views } /// @@ -731,7 +1001,11 @@ public class IndexerSetup( IIndexerSetupWithCallback, IIndexerGetterSetupCallbackBuilder, IIndexerSetterSetupCallbackBuilder, IIndexerSetupReturnBuilder, - IIndexerGetterSetupWithCallback, IIndexerSetterSetupWithCallback + IIndexerGetterSetupWithCallback, IIndexerSetterSetupWithCallback, + IIndexerGetterOnlySetup, IIndexerSetterOnlySetup, + IIndexerGetterOnlyGetterSetup, IIndexerSetterOnlySetterSetup, + IIndexerGetterOnlySetupCallbackBuilder, IIndexerSetterOnlySetupCallbackBuilder, + IIndexerGetterOnlySetupReturnBuilder { private Callbacks>? _getterCallbacks; private Callbacks>? _returnCallbacks; @@ -1321,6 +1595,272 @@ private static bool TryExtractParameters(IndexerAccess access, out T1 p1, out T2 p2 = default!; return false; } + + #region Accessor-restricted views + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.SkippingBaseClass(bool skipBaseClass) + { + SkippingBaseClass(skipBaseClass); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.InitializeWith(TValue value) + { + InitializeWith(value); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.InitializeWith(Func valueGenerator) + { + InitializeWith(valueGenerator); + return this; + } + + /// + IIndexerGetterOnlyGetterSetup IIndexerGetterOnlySetup.OnGet + => this; + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do(Action callback) + { + ((IIndexerGetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do(Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do( + Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do( + Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder IIndexerGetterOnlyGetterSetup.TransitionTo( + string scenario) + { + ((IIndexerGetterSetup)this).TransitionTo(scenario); + return this; + } + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder IIndexerGetterOnlySetupCallbackBuilder.InParallel() + { + ((IIndexerGetterSetupCallbackBuilder)this).InParallel(); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackWhenBuilder IIndexerGetterOnlySetupParallelCallbackBuilder.When( + Func predicate) + { + ((IIndexerGetterSetupParallelCallbackBuilder)this).When(predicate); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackWhenBuilder IIndexerGetterOnlySetupCallbackWhenBuilder.For( + int times) + { + ((IIndexerGetterSetupCallbackWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetupCallbackWhenBuilder.Only(int times) + { + ((IIndexerGetterSetupCallbackWhenBuilder)this).Only(times); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(TValue returnValue) + { + Returns(returnValue); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns( + Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws() + { + Throws(); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws(Exception exception) + { + Throws(exception); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws(Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws( + Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws( + Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnWhenBuilder IIndexerGetterOnlySetupReturnBuilder.When( + Func predicate) + { + ((IIndexerSetupReturnBuilder)this).When(predicate); + return this; + } + + /// + IIndexerGetterOnlySetupReturnWhenBuilder IIndexerGetterOnlySetupReturnWhenBuilder.For( + int times) + { + ((IIndexerSetupReturnWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetupReturnWhenBuilder.Only(int times) + { + ((IIndexerSetupReturnWhenBuilder)this).Only(times); + return this; + } + + /// + IIndexerSetterOnlySetup IIndexerSetterOnlySetup.SkippingBaseClass(bool skipBaseClass) + { + SkippingBaseClass(skipBaseClass); + return this; + } + + /// + IIndexerSetterOnlySetterSetup IIndexerSetterOnlySetup.OnSet + => this; + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do(Action callback) + { + ((IIndexerSetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder IIndexerSetterOnlySetterSetup.TransitionTo( + string scenario) + { + ((IIndexerSetterSetup)this).TransitionTo(scenario); + return this; + } + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder IIndexerSetterOnlySetupCallbackBuilder.InParallel() + { + ((IIndexerSetterSetupCallbackBuilder)this).InParallel(); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackWhenBuilder IIndexerSetterOnlySetupParallelCallbackBuilder.When( + Func predicate) + { + ((IIndexerSetterSetupParallelCallbackBuilder)this).When(predicate); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackWhenBuilder IIndexerSetterOnlySetupCallbackWhenBuilder.For( + int times) + { + ((IIndexerSetterSetupCallbackWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerSetterOnlySetup IIndexerSetterOnlySetupCallbackWhenBuilder.Only(int times) + { + ((IIndexerSetterSetupCallbackWhenBuilder)this).Only(times); + return this; + } + + #endregion Accessor-restricted views } /// @@ -1338,7 +1878,11 @@ public class IndexerSetup( IIndexerSetupWithCallback, IIndexerGetterSetupCallbackBuilder, IIndexerSetterSetupCallbackBuilder, IIndexerSetupReturnBuilder, - IIndexerGetterSetupWithCallback, IIndexerSetterSetupWithCallback + IIndexerGetterSetupWithCallback, IIndexerSetterSetupWithCallback, + IIndexerGetterOnlySetup, IIndexerSetterOnlySetup, + IIndexerGetterOnlyGetterSetup, IIndexerSetterOnlySetterSetup, + IIndexerGetterOnlySetupCallbackBuilder, IIndexerSetterOnlySetupCallbackBuilder, + IIndexerGetterOnlySetupReturnBuilder { private Callbacks>? _getterCallbacks; private Callbacks>? _returnCallbacks; @@ -1857,92 +2401,358 @@ public override void SetResult(IndexerAccess access, MockBehavior behav return; } - if (!TryCast(value, out TValue resultValue, behavior)) - { - return; - } + if (!TryCast(value, out TValue resultValue, behavior)) + { + return; + } + + if (_setterCallbacks is not null) + { + bool wasInvoked = false; + int currentSetterCallbacksIndex = _setterCallbacks.CurrentIndex; + for (int i = 0; i < _setterCallbacks.Count; i++) + { + Callback> setterCallback = + _setterCallbacks[(currentSetterCallbacksIndex + i) % _setterCallbacks.Count]; + if (setterCallback.Invoke(wasInvoked, ref _setterCallbacks.CurrentIndex, (p1, p2, p3, resultValue), + static (count, @delegate, state) => @delegate(count, state.p1, state.p2, state.p3, state.resultValue))) + { + wasInvoked = true; + } + } + } + } + + private TValue ExecuteGetterCallbacks(T1 p1, T2 p2, T3 p3, TValue currentValue) + { + if (_getterCallbacks is not null) + { + bool wasInvoked = false; + int currentGetterCallbacksIndex = _getterCallbacks.CurrentIndex; + for (int i = 0; i < _getterCallbacks.Count; i++) + { + Callback> getterCallback = + _getterCallbacks[(currentGetterCallbacksIndex + i) % _getterCallbacks.Count]; + if (getterCallback.Invoke(wasInvoked, ref _getterCallbacks.CurrentIndex, (p1, p2, p3, currentValue), + static (count, @delegate, state) => @delegate(count, state.p1, state.p2, state.p3, state.currentValue))) + { + wasInvoked = true; + } + } + } + + return currentValue; + } + + private TValue ExecuteReturnCallbacks(T1 p1, T2 p2, T3 p3, TValue currentValue) + { + if (_returnCallbacks is not null) + { + foreach (Callback> _ in _returnCallbacks) + { + Callback> returnCallback = + _returnCallbacks[_returnCallbacks.CurrentIndex % _returnCallbacks.Count]; + if (returnCallback.Invoke(ref _returnCallbacks.CurrentIndex, (p1, p2, p3, currentValue), + static (count, @delegate, state) => @delegate(count, state.p1, state.p2, state.p3, state.currentValue), + out TValue? newValue)) + { + return newValue!; + } + } + } + + return currentValue; + } + + private static bool TryExtractParameters(IndexerAccess access, out T1 p1, out T2 p2, out T3 p3) + { + if (access is IndexerGetterAccess getter) + { + p1 = getter.Parameter1; + p2 = getter.Parameter2; + p3 = getter.Parameter3; + return true; + } + + if (access is IndexerSetterAccess setter) + { + p1 = setter.Parameter1; + p2 = setter.Parameter2; + p3 = setter.Parameter3; + return true; + } + + p1 = default!; + p2 = default!; + p3 = default!; + return false; + } + + #region Accessor-restricted views + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.SkippingBaseClass(bool skipBaseClass) + { + SkippingBaseClass(skipBaseClass); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.InitializeWith(TValue value) + { + InitializeWith(value); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.InitializeWith(Func valueGenerator) + { + InitializeWith(valueGenerator); + return this; + } + + /// + IIndexerGetterOnlyGetterSetup IIndexerGetterOnlySetup.OnGet + => this; + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do(Action callback) + { + ((IIndexerGetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do(Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do( + Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do( + Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder IIndexerGetterOnlyGetterSetup.TransitionTo( + string scenario) + { + ((IIndexerGetterSetup)this).TransitionTo(scenario); + return this; + } + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder IIndexerGetterOnlySetupCallbackBuilder.InParallel() + { + ((IIndexerGetterSetupCallbackBuilder)this).InParallel(); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackWhenBuilder IIndexerGetterOnlySetupParallelCallbackBuilder.When( + Func predicate) + { + ((IIndexerGetterSetupParallelCallbackBuilder)this).When(predicate); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackWhenBuilder IIndexerGetterOnlySetupCallbackWhenBuilder.For( + int times) + { + ((IIndexerGetterSetupCallbackWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetupCallbackWhenBuilder.Only(int times) + { + ((IIndexerGetterSetupCallbackWhenBuilder)this).Only(times); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(TValue returnValue) + { + Returns(returnValue); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns( + Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws() + { + Throws(); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws(Exception exception) + { + Throws(exception); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws(Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws( + Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws( + Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnWhenBuilder IIndexerGetterOnlySetupReturnBuilder.When( + Func predicate) + { + ((IIndexerSetupReturnBuilder)this).When(predicate); + return this; + } + + /// + IIndexerGetterOnlySetupReturnWhenBuilder IIndexerGetterOnlySetupReturnWhenBuilder.For( + int times) + { + ((IIndexerSetupReturnWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetupReturnWhenBuilder.Only(int times) + { + ((IIndexerSetupReturnWhenBuilder)this).Only(times); + return this; + } + + /// + IIndexerSetterOnlySetup IIndexerSetterOnlySetup.SkippingBaseClass(bool skipBaseClass) + { + SkippingBaseClass(skipBaseClass); + return this; + } + + /// + IIndexerSetterOnlySetterSetup IIndexerSetterOnlySetup.OnSet + => this; - if (_setterCallbacks is not null) - { - bool wasInvoked = false; - int currentSetterCallbacksIndex = _setterCallbacks.CurrentIndex; - for (int i = 0; i < _setterCallbacks.Count; i++) - { - Callback> setterCallback = - _setterCallbacks[(currentSetterCallbacksIndex + i) % _setterCallbacks.Count]; - if (setterCallback.Invoke(wasInvoked, ref _setterCallbacks.CurrentIndex, (p1, p2, p3, resultValue), - static (count, @delegate, state) => @delegate(count, state.p1, state.p2, state.p3, state.resultValue))) - { - wasInvoked = true; - } - } - } + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do(Action callback) + { + ((IIndexerSetterSetup)this).Do(callback); + return this; } - private TValue ExecuteGetterCallbacks(T1 p1, T2 p2, T3 p3, TValue currentValue) + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) { - if (_getterCallbacks is not null) - { - bool wasInvoked = false; - int currentGetterCallbacksIndex = _getterCallbacks.CurrentIndex; - for (int i = 0; i < _getterCallbacks.Count; i++) - { - Callback> getterCallback = - _getterCallbacks[(currentGetterCallbacksIndex + i) % _getterCallbacks.Count]; - if (getterCallback.Invoke(wasInvoked, ref _getterCallbacks.CurrentIndex, (p1, p2, p3, currentValue), - static (count, @delegate, state) => @delegate(count, state.p1, state.p2, state.p3, state.currentValue))) - { - wasInvoked = true; - } - } - } + ((IIndexerSetterSetup)this).Do(callback); + return this; + } - return currentValue; + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetupWithCallback)this).Do(callback); + return this; } - private TValue ExecuteReturnCallbacks(T1 p1, T2 p2, T3 p3, TValue currentValue) + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) { - if (_returnCallbacks is not null) - { - foreach (Callback> _ in _returnCallbacks) - { - Callback> returnCallback = - _returnCallbacks[_returnCallbacks.CurrentIndex % _returnCallbacks.Count]; - if (returnCallback.Invoke(ref _returnCallbacks.CurrentIndex, (p1, p2, p3, currentValue), - static (count, @delegate, state) => @delegate(count, state.p1, state.p2, state.p3, state.currentValue), - out TValue? newValue)) - { - return newValue!; - } - } - } + ((IIndexerSetterSetupWithCallback)this).Do(callback); + return this; + } - return currentValue; + /// + IIndexerSetterOnlySetupParallelCallbackBuilder IIndexerSetterOnlySetterSetup.TransitionTo( + string scenario) + { + ((IIndexerSetterSetup)this).TransitionTo(scenario); + return this; } - private static bool TryExtractParameters(IndexerAccess access, out T1 p1, out T2 p2, out T3 p3) + /// + IIndexerSetterOnlySetupParallelCallbackBuilder IIndexerSetterOnlySetupCallbackBuilder.InParallel() { - if (access is IndexerGetterAccess getter) - { - p1 = getter.Parameter1; - p2 = getter.Parameter2; - p3 = getter.Parameter3; - return true; - } + ((IIndexerSetterSetupCallbackBuilder)this).InParallel(); + return this; + } - if (access is IndexerSetterAccess setter) - { - p1 = setter.Parameter1; - p2 = setter.Parameter2; - p3 = setter.Parameter3; - return true; - } + /// + IIndexerSetterOnlySetupCallbackWhenBuilder IIndexerSetterOnlySetupParallelCallbackBuilder.When( + Func predicate) + { + ((IIndexerSetterSetupParallelCallbackBuilder)this).When(predicate); + return this; + } - p1 = default!; - p2 = default!; - p3 = default!; - return false; + /// + IIndexerSetterOnlySetupCallbackWhenBuilder IIndexerSetterOnlySetupCallbackWhenBuilder.For( + int times) + { + ((IIndexerSetterSetupCallbackWhenBuilder)this).For(times); + return this; } + + /// + IIndexerSetterOnlySetup IIndexerSetterOnlySetupCallbackWhenBuilder.Only(int times) + { + ((IIndexerSetterSetupCallbackWhenBuilder)this).Only(times); + return this; + } + + #endregion Accessor-restricted views } /// @@ -1961,7 +2771,12 @@ public class IndexerSetup( IIndexerSetupWithCallback, IIndexerGetterSetupCallbackBuilder, IIndexerSetterSetupCallbackBuilder, IIndexerSetupReturnBuilder, - IIndexerGetterSetupWithCallback, IIndexerSetterSetupWithCallback + IIndexerGetterSetupWithCallback, IIndexerSetterSetupWithCallback, + IIndexerGetterOnlySetup, IIndexerSetterOnlySetup, + IIndexerGetterOnlyGetterSetup, IIndexerSetterOnlySetterSetup, + IIndexerGetterOnlySetupCallbackBuilder, + IIndexerSetterOnlySetupCallbackBuilder, + IIndexerGetterOnlySetupReturnBuilder { private Callbacks>? _getterCallbacks; private Callbacks>? _returnCallbacks; @@ -2575,4 +3390,270 @@ private static bool TryExtractParameters(IndexerAccess access, p4 = default!; return false; } + + #region Accessor-restricted views + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.SkippingBaseClass(bool skipBaseClass) + { + SkippingBaseClass(skipBaseClass); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.InitializeWith(TValue value) + { + InitializeWith(value); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetup.InitializeWith(Func valueGenerator) + { + InitializeWith(valueGenerator); + return this; + } + + /// + IIndexerGetterOnlyGetterSetup IIndexerGetterOnlySetup.OnGet + => this; + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do(Action callback) + { + ((IIndexerGetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do(Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do( + Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackBuilder IIndexerGetterOnlyGetterSetup.Do( + Action callback) + { + ((IIndexerGetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder IIndexerGetterOnlyGetterSetup.TransitionTo( + string scenario) + { + ((IIndexerGetterSetup)this).TransitionTo(scenario); + return this; + } + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder IIndexerGetterOnlySetupCallbackBuilder.InParallel() + { + ((IIndexerGetterSetupCallbackBuilder)this).InParallel(); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackWhenBuilder IIndexerGetterOnlySetupParallelCallbackBuilder.When( + Func predicate) + { + ((IIndexerGetterSetupParallelCallbackBuilder)this).When(predicate); + return this; + } + + /// + IIndexerGetterOnlySetupCallbackWhenBuilder IIndexerGetterOnlySetupCallbackWhenBuilder.For( + int times) + { + ((IIndexerGetterSetupCallbackWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetupCallbackWhenBuilder.Only(int times) + { + ((IIndexerGetterSetupCallbackWhenBuilder)this).Only(times); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(TValue returnValue) + { + Returns(returnValue); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns(Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Returns( + Func callback) + { + Returns(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws() + { + Throws(); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws(Exception exception) + { + Throws(exception); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws(Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws( + Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnBuilder IIndexerGetterOnlySetup.Throws( + Func callback) + { + Throws(callback); + return this; + } + + /// + IIndexerGetterOnlySetupReturnWhenBuilder IIndexerGetterOnlySetupReturnBuilder.When( + Func predicate) + { + ((IIndexerSetupReturnBuilder)this).When(predicate); + return this; + } + + /// + IIndexerGetterOnlySetupReturnWhenBuilder IIndexerGetterOnlySetupReturnWhenBuilder.For( + int times) + { + ((IIndexerSetupReturnWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerGetterOnlySetup IIndexerGetterOnlySetupReturnWhenBuilder.Only(int times) + { + ((IIndexerSetupReturnWhenBuilder)this).Only(times); + return this; + } + + /// + IIndexerSetterOnlySetup IIndexerSetterOnlySetup.SkippingBaseClass(bool skipBaseClass) + { + SkippingBaseClass(skipBaseClass); + return this; + } + + /// + IIndexerSetterOnlySetterSetup IIndexerSetterOnlySetup.OnSet + => this; + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do(Action callback) + { + ((IIndexerSetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetup)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackBuilder IIndexerSetterOnlySetterSetup.Do( + Action callback) + { + ((IIndexerSetterSetupWithCallback)this).Do(callback); + return this; + } + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder IIndexerSetterOnlySetterSetup.TransitionTo( + string scenario) + { + ((IIndexerSetterSetup)this).TransitionTo(scenario); + return this; + } + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder IIndexerSetterOnlySetupCallbackBuilder.InParallel() + { + ((IIndexerSetterSetupCallbackBuilder)this).InParallel(); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackWhenBuilder IIndexerSetterOnlySetupParallelCallbackBuilder.When( + Func predicate) + { + ((IIndexerSetterSetupParallelCallbackBuilder)this).When(predicate); + return this; + } + + /// + IIndexerSetterOnlySetupCallbackWhenBuilder IIndexerSetterOnlySetupCallbackWhenBuilder.For( + int times) + { + ((IIndexerSetterSetupCallbackWhenBuilder)this).For(times); + return this; + } + + /// + IIndexerSetterOnlySetup IIndexerSetterOnlySetupCallbackWhenBuilder.Only(int times) + { + ((IIndexerSetterSetupCallbackWhenBuilder)this).Only(times); + return this; + } + + #endregion Accessor-restricted views } diff --git a/Source/Mockolate/Setup/Interfaces.IndexerSetup.cs b/Source/Mockolate/Setup/Interfaces.IndexerSetup.cs index 6f4a6329..cdbe31cd 100644 --- a/Source/Mockolate/Setup/Interfaces.IndexerSetup.cs +++ b/Source/Mockolate/Setup/Interfaces.IndexerSetup.cs @@ -1456,3 +1456,917 @@ public interface IIndexerSetupReturnWhenBuilder Only(int times); } #pragma warning restore S2436 // Types and methods should not have too many generic parameters + +/// +/// Setup for a mocked indexer for that the mock only +/// reads. +/// +/// +/// Used instead of when the mock has no setter to intercept, either +/// because the indexer is declared without one or because its setter is not accessible from the mock's assembly. +/// Writes then never reach the mock, so is not offered. +/// +public interface IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlyGetterSetup OnGet { get; } + + /// + IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + + /// + /// + /// Seeds the value that reads return. Unlike a read-write indexer there is no setter to update the + /// slot afterwards, so it stays at unless a Returns entry applies. + /// + IIndexerGetterOnlySetup InitializeWith(TValue value); + + /// + IIndexerGetterOnlySetup InitializeWith(Func valueGenerator); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : Exception, new(); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Exception exception); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); +} + +/// +/// Setup for a mocked indexer for that the mock only +/// writes. +/// +/// +/// The write-only counterpart of : the mock has no getter to +/// intercept, so , InitializeWith and the +/// Returns/Throws read-sequence are not offered. +/// +public interface IIndexerSetterOnlySetup +{ + /// + IIndexerSetterOnlySetterSetup OnSet { get; } + + /// + IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); +} + +/// +/// Setup for attaching side-effects to the getter of a get-only indexer for +/// . +/// +/// +/// The counterpart of for +/// : the returned builders stay on the getter-only surface, +/// so chaining can never reach . +/// +public interface IIndexerGetterOnlyGetterSetup +{ + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); +} + +/// +/// Sets up a callback for a get-only indexer for . +/// +public interface IIndexerGetterOnlySetupCallbackBuilder + : IIndexerGetterOnlySetupParallelCallbackBuilder +{ + /// + IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); +} + +/// +/// Sets up a parallel callback for a get-only indexer for +/// . +/// +public interface IIndexerGetterOnlySetupParallelCallbackBuilder + : IIndexerGetterOnlySetupCallbackWhenBuilder +{ + /// + IIndexerGetterOnlySetupCallbackWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when callback for a get-only indexer for . +/// +public interface IIndexerGetterOnlySetupCallbackWhenBuilder + : IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + + /// + IIndexerGetterOnlySetup Only(int times); +} + +/// +/// Sets up a return/throw builder for a get-only indexer for +/// . +/// +public interface IIndexerGetterOnlySetupReturnBuilder + : IIndexerGetterOnlySetupReturnWhenBuilder +{ + /// + IIndexerGetterOnlySetupReturnWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when builder for returns/throws for a get-only indexer for +/// . +/// +public interface IIndexerGetterOnlySetupReturnWhenBuilder + : IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + + /// + IIndexerGetterOnlySetup Only(int times); +} + +/// +/// Setup for attaching side-effects to the setter of a set-only indexer for +/// . +/// +/// +/// The counterpart of for +/// : the returned builders stay on the setter-only surface, +/// so chaining can never reach or the +/// Returns/Throws read-sequence. +/// +public interface IIndexerSetterOnlySetterSetup +{ + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); +} + +/// +/// Sets up a setter callback for a set-only indexer for . +/// +public interface IIndexerSetterOnlySetupCallbackBuilder + : IIndexerSetterOnlySetupParallelCallbackBuilder +{ + /// + IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); +} + +/// +/// Sets up a parallel setter callback for a set-only indexer for +/// . +/// +public interface IIndexerSetterOnlySetupParallelCallbackBuilder + : IIndexerSetterOnlySetupCallbackWhenBuilder +{ + /// + IIndexerSetterOnlySetupCallbackWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when setter callback for a set-only indexer for +/// . +/// +public interface IIndexerSetterOnlySetupCallbackWhenBuilder + : IIndexerSetterOnlySetup +{ + /// + IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + + /// + IIndexerSetterOnlySetup Only(int times); +} + +/// +/// Setup for a mocked indexer for and +/// that the mock only reads. +/// +/// +/// Used instead of when the mock has no setter to intercept, either +/// because the indexer is declared without one or because its setter is not accessible from the mock's assembly. +/// Writes then never reach the mock, so is not offered. +/// +public interface IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlyGetterSetup OnGet { get; } + + /// + IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + + /// + /// + /// Seeds the value that reads return. Unlike a read-write indexer there is no setter to update the + /// slot afterwards, so it stays at unless a Returns entry applies. + /// + IIndexerGetterOnlySetup InitializeWith(TValue value); + + /// + IIndexerGetterOnlySetup InitializeWith(Func valueGenerator); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : Exception, new(); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Exception exception); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); +} + +/// +/// Setup for a mocked indexer for and +/// that the mock only writes. +/// +/// +/// The write-only counterpart of : the mock has no getter +/// to intercept, so , InitializeWith and the +/// Returns/Throws read-sequence are not offered. +/// +public interface IIndexerSetterOnlySetup +{ + /// + IIndexerSetterOnlySetterSetup OnSet { get; } + + /// + IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); +} + +/// +/// Setup for attaching side-effects to the getter of a get-only indexer for +/// and . +/// +/// +/// The counterpart of for +/// : the returned builders stay on the getter-only surface, +/// so chaining can never reach . +/// +public interface IIndexerGetterOnlyGetterSetup +{ + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); +} + +/// +/// Sets up a callback for a get-only indexer for and +/// . +/// +public interface IIndexerGetterOnlySetupCallbackBuilder + : IIndexerGetterOnlySetupParallelCallbackBuilder +{ + /// + IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); +} + +/// +/// Sets up a parallel callback for a get-only indexer for +/// and . +/// +public interface IIndexerGetterOnlySetupParallelCallbackBuilder + : IIndexerGetterOnlySetupCallbackWhenBuilder +{ + /// + IIndexerGetterOnlySetupCallbackWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when callback for a get-only indexer for +/// and . +/// +public interface IIndexerGetterOnlySetupCallbackWhenBuilder + : IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + + /// + IIndexerGetterOnlySetup Only(int times); +} + +/// +/// Sets up a return/throw builder for a get-only indexer for +/// and . +/// +public interface IIndexerGetterOnlySetupReturnBuilder + : IIndexerGetterOnlySetupReturnWhenBuilder +{ + /// + IIndexerGetterOnlySetupReturnWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when builder for returns/throws for a get-only indexer for +/// and . +/// +public interface IIndexerGetterOnlySetupReturnWhenBuilder + : IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + + /// + IIndexerGetterOnlySetup Only(int times); +} + +/// +/// Setup for attaching side-effects to the setter of a set-only indexer for +/// and . +/// +/// +/// The counterpart of for +/// : the returned builders stay on the setter-only surface, +/// so chaining can never reach or the +/// Returns/Throws read-sequence. +/// +public interface IIndexerSetterOnlySetterSetup +{ + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); +} + +/// +/// Sets up a setter callback for a set-only indexer for +/// and . +/// +public interface IIndexerSetterOnlySetupCallbackBuilder + : IIndexerSetterOnlySetupParallelCallbackBuilder +{ + /// + IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); +} + +/// +/// Sets up a parallel setter callback for a set-only indexer for +/// and . +/// +public interface IIndexerSetterOnlySetupParallelCallbackBuilder + : IIndexerSetterOnlySetupCallbackWhenBuilder +{ + /// + IIndexerSetterOnlySetupCallbackWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when setter callback for a set-only indexer for +/// and . +/// +public interface IIndexerSetterOnlySetupCallbackWhenBuilder + : IIndexerSetterOnlySetup +{ + /// + IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + + /// + IIndexerSetterOnlySetup Only(int times); +} + +/// +/// Setup for a mocked indexer for , +/// and that the mock only reads. +/// +/// +/// Used instead of when the mock has no setter to intercept, +/// either because the indexer is declared without one or because its setter is not accessible from the mock's +/// assembly. Writes then never reach the mock, so is not +/// offered. +/// +public interface IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlyGetterSetup OnGet { get; } + + /// + IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + + /// + /// + /// Seeds the value that reads return. Unlike a read-write indexer there is no setter to update the + /// slot afterwards, so it stays at unless a Returns entry applies. + /// + IIndexerGetterOnlySetup InitializeWith(TValue value); + + /// + IIndexerGetterOnlySetup InitializeWith(Func valueGenerator); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : Exception, new(); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Exception exception); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); +} + +/// +/// Setup for a mocked indexer for , +/// and that the mock only writes. +/// +/// +/// The write-only counterpart of : the mock has no +/// getter to intercept, so , InitializeWith and the +/// Returns/Throws read-sequence are not offered. +/// +public interface IIndexerSetterOnlySetup +{ + /// + IIndexerSetterOnlySetterSetup OnSet { get; } + + /// + IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); +} + +/// +/// Setup for attaching side-effects to the getter of a get-only indexer for +/// , and . +/// +/// +/// The counterpart of for +/// : the returned builders stay on the getter-only +/// surface, so chaining can never reach . +/// +public interface IIndexerGetterOnlyGetterSetup +{ + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); +} + +/// +/// Sets up a callback for a get-only indexer for , +/// and . +/// +public interface IIndexerGetterOnlySetupCallbackBuilder + : IIndexerGetterOnlySetupParallelCallbackBuilder +{ + /// + IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); +} + +/// +/// Sets up a parallel callback for a get-only indexer for +/// , and . +/// +public interface IIndexerGetterOnlySetupParallelCallbackBuilder + : IIndexerGetterOnlySetupCallbackWhenBuilder +{ + /// + IIndexerGetterOnlySetupCallbackWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when callback for a get-only indexer for , +/// and . +/// +public interface IIndexerGetterOnlySetupCallbackWhenBuilder + : IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + + /// + IIndexerGetterOnlySetup Only(int times); +} + +/// +/// Sets up a return/throw builder for a get-only indexer for +/// , and . +/// +public interface IIndexerGetterOnlySetupReturnBuilder + : IIndexerGetterOnlySetupReturnWhenBuilder +{ + /// + IIndexerGetterOnlySetupReturnWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when builder for returns/throws for a get-only indexer for +/// , and . +/// +public interface IIndexerGetterOnlySetupReturnWhenBuilder + : IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + + /// + IIndexerGetterOnlySetup Only(int times); +} + +/// +/// Setup for attaching side-effects to the setter of a set-only indexer for +/// , and . +/// +/// +/// The counterpart of for +/// : the returned builders stay on the setter-only +/// surface, so chaining can never reach or the +/// Returns/Throws read-sequence. +/// +public interface IIndexerSetterOnlySetterSetup +{ + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); +} + +/// +/// Sets up a setter callback for a set-only indexer for , +/// and . +/// +public interface IIndexerSetterOnlySetupCallbackBuilder + : IIndexerSetterOnlySetupParallelCallbackBuilder +{ + /// + IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); +} + +/// +/// Sets up a parallel setter callback for a set-only indexer for +/// , and . +/// +public interface IIndexerSetterOnlySetupParallelCallbackBuilder + : IIndexerSetterOnlySetupCallbackWhenBuilder +{ + /// + IIndexerSetterOnlySetupCallbackWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when setter callback for a set-only indexer for +/// , and . +/// +public interface IIndexerSetterOnlySetupCallbackWhenBuilder + : IIndexerSetterOnlySetup +{ + /// + IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + + /// + IIndexerSetterOnlySetup Only(int times); +} + +#pragma warning disable S2436 // Types and methods should not have too many generic parameters +/// +/// Setup for a mocked indexer for , +/// , and that the mock only +/// reads. +/// +/// +/// Used instead of when the mock has no setter to intercept, +/// either because the indexer is declared without one or because its setter is not accessible from the mock's +/// assembly. Writes then never reach the mock, so is +/// not offered. +/// +public interface IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlyGetterSetup OnGet { get; } + + /// + IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + + /// + /// + /// Seeds the value that reads return. Unlike a read-write indexer there is no setter to update the + /// slot afterwards, so it stays at unless a Returns entry applies. + /// + IIndexerGetterOnlySetup InitializeWith(TValue value); + + /// + IIndexerGetterOnlySetup InitializeWith(Func valueGenerator); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Returns(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : Exception, new(); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Exception exception); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); + + /// + IIndexerGetterOnlySetupReturnBuilder Throws(Func callback); +} + +/// +/// Setup for a mocked indexer for , +/// , and that the mock only +/// writes. +/// +/// +/// The write-only counterpart of : the mock has no +/// getter to intercept, so , InitializeWith and +/// the Returns/Throws read-sequence are not offered. +/// +public interface IIndexerSetterOnlySetup +{ + /// + IIndexerSetterOnlySetterSetup OnSet { get; } + + /// + IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); +} + +/// +/// Setup for attaching side-effects to the getter of a get-only indexer for +/// , , and +/// . +/// +/// +/// The counterpart of for +/// : the returned builders stay on the getter-only +/// surface, so chaining can never reach . +/// +public interface IIndexerGetterOnlyGetterSetup +{ + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); +} + +/// +/// Sets up a callback for a get-only indexer for , +/// , and . +/// +public interface IIndexerGetterOnlySetupCallbackBuilder + : IIndexerGetterOnlySetupParallelCallbackBuilder +{ + /// + IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); +} + +/// +/// Sets up a parallel callback for a get-only indexer for +/// , , and +/// . +/// +public interface IIndexerGetterOnlySetupParallelCallbackBuilder + : IIndexerGetterOnlySetupCallbackWhenBuilder +{ + /// + IIndexerGetterOnlySetupCallbackWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when callback for a get-only indexer for , +/// , and . +/// +public interface IIndexerGetterOnlySetupCallbackWhenBuilder + : IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + + /// + IIndexerGetterOnlySetup Only(int times); +} + +/// +/// Sets up a return/throw builder for a get-only indexer for +/// , , and +/// . +/// +public interface IIndexerGetterOnlySetupReturnBuilder + : IIndexerGetterOnlySetupReturnWhenBuilder +{ + /// + IIndexerGetterOnlySetupReturnWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when builder for returns/throws for a get-only indexer for +/// , , and +/// . +/// +public interface IIndexerGetterOnlySetupReturnWhenBuilder + : IIndexerGetterOnlySetup +{ + /// + IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + + /// + IIndexerGetterOnlySetup Only(int times); +} + +/// +/// Setup for attaching side-effects to the setter of a set-only indexer for +/// , , and +/// . +/// +/// +/// The counterpart of for +/// : the returned builders stay on the setter-only +/// surface, so chaining can never reach or the +/// Returns/Throws read-sequence. +/// +public interface IIndexerSetterOnlySetterSetup +{ + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupCallbackBuilder Do(Action callback); + + /// + IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); +} + +/// +/// Sets up a setter callback for a set-only indexer for , +/// , and . +/// +public interface IIndexerSetterOnlySetupCallbackBuilder + : IIndexerSetterOnlySetupParallelCallbackBuilder +{ + /// + IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); +} + +/// +/// Sets up a parallel setter callback for a set-only indexer for +/// , , and +/// . +/// +public interface IIndexerSetterOnlySetupParallelCallbackBuilder + : IIndexerSetterOnlySetupCallbackWhenBuilder +{ + /// + IIndexerSetterOnlySetupCallbackWhenBuilder When(Func predicate); +} + +/// +/// Sets up a when setter callback for a set-only indexer for +/// , , and +/// . +/// +public interface IIndexerSetterOnlySetupCallbackWhenBuilder + : IIndexerSetterOnlySetup +{ + /// + IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + + /// + IIndexerSetterOnlySetup Only(int times); +} +#pragma warning restore S2436 // Types and methods should not have too many generic parameters diff --git a/Source/Mockolate/SetupExtensions.cs b/Source/Mockolate/SetupExtensions.cs index ca5430c3..6205c1dd 100644 --- a/Source/Mockolate/SetupExtensions.cs +++ b/Source/Mockolate/SetupExtensions.cs @@ -416,6 +416,242 @@ public IIndexerSetup OnlyOnce() => setup.Only(1); } + /// + /// Extensions for setups of get-only indexers with one parameter. + /// + extension(IIndexerGetterOnlySetupReturnWhenBuilder setup) + { + /// + /// Terminates the return/throw sequence by repeating the preceding entry forever instead of cycling + /// back to the first entry once the end is reached. + /// + /// + /// Equivalent to .For(int.MaxValue). Applies only to the preceding Returns(...)/Throws(...) + /// entry; earlier entries in the sequence still run once each in order. + /// + public void Forever() + => setup.For(int.MaxValue); + + /// + /// Deactivates the preceding Returns(...)/Throws(...) entry after a single invocation, + /// so subsequent invocations fall through to the next sequence entry (or to the mock's default behaviour). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerGetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for getter callback setups of get-only indexers with one parameter. + /// + extension(IIndexerGetterOnlySetupCallbackWhenBuilder setup) + { + /// + /// Deactivates the preceding Do(...) callback after a single invocation, so subsequent invocations + /// fall through to the next callback in the sequence (or are skipped). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerGetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for setter callback setups of set-only indexers with one parameter. + /// + extension(IIndexerSetterOnlySetupCallbackWhenBuilder setup) + { + /// + /// Deactivates the preceding Do(...) callback after a single invocation, so subsequent invocations + /// fall through to the next callback in the sequence (or are skipped). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerSetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for setups of get-only indexers with two parameters. + /// + extension(IIndexerGetterOnlySetupReturnWhenBuilder setup) + { + /// + /// Terminates the return/throw sequence by repeating the preceding entry forever instead of cycling + /// back to the first entry once the end is reached. + /// + /// + /// Equivalent to .For(int.MaxValue). Applies only to the preceding Returns(...)/Throws(...) + /// entry; earlier entries in the sequence still run once each in order. + /// + public void Forever() + => setup.For(int.MaxValue); + + /// + /// Deactivates the preceding Returns(...)/Throws(...) entry after a single invocation, + /// so subsequent invocations fall through to the next sequence entry (or to the mock's default behaviour). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerGetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for getter callback setups of get-only indexers with two parameters. + /// + extension(IIndexerGetterOnlySetupCallbackWhenBuilder setup) + { + /// + /// Deactivates the preceding Do(...) callback after a single invocation, so subsequent invocations + /// fall through to the next callback in the sequence (or are skipped). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerGetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for setter callback setups of set-only indexers with two parameters. + /// + extension(IIndexerSetterOnlySetupCallbackWhenBuilder setup) + { + /// + /// Deactivates the preceding Do(...) callback after a single invocation, so subsequent invocations + /// fall through to the next callback in the sequence (or are skipped). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerSetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for setups of get-only indexers with three parameters. + /// + extension(IIndexerGetterOnlySetupReturnWhenBuilder setup) + { + /// + /// Terminates the return/throw sequence by repeating the preceding entry forever instead of cycling + /// back to the first entry once the end is reached. + /// + /// + /// Equivalent to .For(int.MaxValue). Applies only to the preceding Returns(...)/Throws(...) + /// entry; earlier entries in the sequence still run once each in order. + /// + public void Forever() + => setup.For(int.MaxValue); + + /// + /// Deactivates the preceding Returns(...)/Throws(...) entry after a single invocation, + /// so subsequent invocations fall through to the next sequence entry (or to the mock's default behaviour). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerGetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for getter callback setups of get-only indexers with three parameters. + /// + extension(IIndexerGetterOnlySetupCallbackWhenBuilder setup) + { + /// + /// Deactivates the preceding Do(...) callback after a single invocation, so subsequent invocations + /// fall through to the next callback in the sequence (or are skipped). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerGetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for setter callback setups of set-only indexers with three parameters. + /// + extension(IIndexerSetterOnlySetupCallbackWhenBuilder setup) + { + /// + /// Deactivates the preceding Do(...) callback after a single invocation, so subsequent invocations + /// fall through to the next callback in the sequence (or are skipped). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerSetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for setups of get-only indexers with four parameters. + /// + extension(IIndexerGetterOnlySetupReturnWhenBuilder setup) + { + /// + /// Terminates the return/throw sequence by repeating the preceding entry forever instead of cycling + /// back to the first entry once the end is reached. + /// + /// + /// Equivalent to .For(int.MaxValue). Applies only to the preceding Returns(...)/Throws(...) + /// entry; earlier entries in the sequence still run once each in order. + /// + public void Forever() + => setup.For(int.MaxValue); + + /// + /// Deactivates the preceding Returns(...)/Throws(...) entry after a single invocation, + /// so subsequent invocations fall through to the next sequence entry (or to the mock's default behaviour). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerGetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for getter callback setups of get-only indexers with four parameters. + /// + extension(IIndexerGetterOnlySetupCallbackWhenBuilder setup) + { + /// + /// Deactivates the preceding Do(...) callback after a single invocation, so subsequent invocations + /// fall through to the next callback in the sequence (or are skipped). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerGetterOnlySetup OnlyOnce() + => setup.Only(1); + } + + /// + /// Extensions for setter callback setups of set-only indexers with four parameters. + /// + extension(IIndexerSetterOnlySetupCallbackWhenBuilder setup) + { + /// + /// Deactivates the preceding Do(...) callback after a single invocation, so subsequent invocations + /// fall through to the next callback in the sequence (or are skipped). + /// + /// + /// Equivalent to .Only(1). + /// + public IIndexerSetterOnlySetup OnlyOnce() + => setup.Only(1); + } + /// /// Extensions for method setup returning without parameters. /// diff --git a/Source/Mockolate/Verify/VerificationIndexerResult.cs b/Source/Mockolate/Verify/VerificationIndexerResult.cs index d8ff3e20..97d1e976 100644 --- a/Source/Mockolate/Verify/VerificationIndexerResult.cs +++ b/Source/Mockolate/Verify/VerificationIndexerResult.cs @@ -288,3 +288,377 @@ public override VerificationResult Set(TParameter value, _match1, _match2, _match3, _match4, (IParameterMatch)It.Is(value, doNotPopulateThisValue), ParametersDescription); } + +/// +/// Verifications on a 1-key indexer that the mock only reads. +/// +/// +/// Used instead of when the mock has no +/// setter to intercept, either because the indexer is declared without one or because its setter is not +/// accessible from the mock's assembly. Writes then never reach the mock, so offering Set(...) here +/// would always report zero interactions. The value type is not a type parameter because only Set(...) +/// needs it. +/// +#if !DEBUG +[System.Diagnostics.DebuggerNonUserCode] +#endif +public class VerificationIndexerGetterResult +{ + private readonly int _getMemberId; + private readonly IParameterMatch _match1; + private readonly MockRegistry _mockRegistry; + private readonly Func _parametersDescription; + private readonly TSubject _subject; + + /// + /// The verification facade the result is bound to. + /// The mock registry holding the recorded interactions. + /// Member id of the indexer getter, or -1 when unknown. + /// The matcher for the first indexer parameter. + /// Factory producing the indexer-argument description used in failure messages. + public VerificationIndexerGetterResult(TSubject subject, MockRegistry mockRegistry, int getMemberId, + IParameterMatch match1, Func parametersDescription) + { + _subject = subject; + _mockRegistry = mockRegistry; + _getMemberId = getMemberId; + _match1 = match1; + _parametersDescription = parametersDescription; + } + + /// + public VerificationResult Got() + => _mockRegistry.IndexerGotTyped(_subject, _getMemberId, _match1, _parametersDescription); +} + +/// +/// Verifications on a 1-key indexer of type that the mock only writes. +/// +/// +/// The write-only counterpart of : the mock has +/// no getter to intercept, so Got() is not offered. +/// +#if !DEBUG +[System.Diagnostics.DebuggerNonUserCode] +#endif +public class VerificationIndexerSetterResult +{ + private readonly IParameterMatch _match1; + private readonly MockRegistry _mockRegistry; + private readonly Func _parametersDescription; + private readonly int _setMemberId; + private readonly TSubject _subject; + + /// + /// The verification facade the result is bound to. + /// The mock registry holding the recorded interactions. + /// Member id of the indexer setter, or -1 when unknown. + /// The matcher for the first indexer parameter. + /// Factory producing the indexer-argument description used in failure messages. + public VerificationIndexerSetterResult(TSubject subject, MockRegistry mockRegistry, int setMemberId, + IParameterMatch match1, Func parametersDescription) + { + _subject = subject; + _mockRegistry = mockRegistry; + _setMemberId = setMemberId; + _match1 = match1; + _parametersDescription = parametersDescription; + } + + /// + public VerificationResult Set(IParameter value) + => _mockRegistry.IndexerSetTyped(_subject, _setMemberId, _match1, + (IParameterMatch)value, _parametersDescription); + + /// + [OverloadResolutionPriority(1)] + public VerificationResult Set(TParameter value, + [CallerArgumentExpression(nameof(value))] + string doNotPopulateThisValue = "") + => _mockRegistry.IndexerSetTyped(_subject, _setMemberId, _match1, + (IParameterMatch)It.Is(value, doNotPopulateThisValue), _parametersDescription); +} + +/// +/// Verifications on a 2-key indexer that the mock only reads. See +/// for rationale. +/// +#if !DEBUG +[System.Diagnostics.DebuggerNonUserCode] +#endif +public class VerificationIndexerGetterResult +{ + private readonly int _getMemberId; + private readonly IParameterMatch _match1; + private readonly IParameterMatch _match2; + private readonly MockRegistry _mockRegistry; + private readonly Func _parametersDescription; + private readonly TSubject _subject; + + /// + /// The verification facade the result is bound to. + /// The mock registry holding the recorded interactions. + /// Member id of the indexer getter, or -1 when unknown. + /// The matcher for the first indexer parameter. + /// The matcher for the second indexer parameter. + /// Factory producing the indexer-argument description used in failure messages. + public VerificationIndexerGetterResult(TSubject subject, MockRegistry mockRegistry, int getMemberId, + IParameterMatch match1, IParameterMatch match2, Func parametersDescription) + { + _subject = subject; + _mockRegistry = mockRegistry; + _getMemberId = getMemberId; + _match1 = match1; + _match2 = match2; + _parametersDescription = parametersDescription; + } + + /// + public VerificationResult Got() + => _mockRegistry.IndexerGotTyped(_subject, _getMemberId, _match1, _match2, _parametersDescription); +} + +/// +/// Verifications on a 2-key indexer of type that the mock only writes. See +/// for rationale. +/// +#if !DEBUG +[System.Diagnostics.DebuggerNonUserCode] +#endif +public class VerificationIndexerSetterResult +{ + private readonly IParameterMatch _match1; + private readonly IParameterMatch _match2; + private readonly MockRegistry _mockRegistry; + private readonly Func _parametersDescription; + private readonly int _setMemberId; + private readonly TSubject _subject; + + /// + /// The verification facade the result is bound to. + /// The mock registry holding the recorded interactions. + /// Member id of the indexer setter, or -1 when unknown. + /// The matcher for the first indexer parameter. + /// The matcher for the second indexer parameter. + /// Factory producing the indexer-argument description used in failure messages. + public VerificationIndexerSetterResult(TSubject subject, MockRegistry mockRegistry, int setMemberId, + IParameterMatch match1, IParameterMatch match2, Func parametersDescription) + { + _subject = subject; + _mockRegistry = mockRegistry; + _setMemberId = setMemberId; + _match1 = match1; + _match2 = match2; + _parametersDescription = parametersDescription; + } + + /// + public VerificationResult Set(IParameter value) + => _mockRegistry.IndexerSetTyped(_subject, _setMemberId, _match1, _match2, + (IParameterMatch)value, _parametersDescription); + + /// + [OverloadResolutionPriority(1)] + public VerificationResult Set(TParameter value, + [CallerArgumentExpression(nameof(value))] + string doNotPopulateThisValue = "") + => _mockRegistry.IndexerSetTyped(_subject, _setMemberId, _match1, _match2, + (IParameterMatch)It.Is(value, doNotPopulateThisValue), _parametersDescription); +} + +/// +/// Verifications on a 3-key indexer that the mock only reads. See +/// for rationale. +/// +#if !DEBUG +[System.Diagnostics.DebuggerNonUserCode] +#endif +public class VerificationIndexerGetterResult +{ + private readonly int _getMemberId; + private readonly IParameterMatch _match1; + private readonly IParameterMatch _match2; + private readonly IParameterMatch _match3; + private readonly MockRegistry _mockRegistry; + private readonly Func _parametersDescription; + private readonly TSubject _subject; + + /// + /// The verification facade the result is bound to. + /// The mock registry holding the recorded interactions. + /// Member id of the indexer getter, or -1 when unknown. + /// The matcher for the first indexer parameter. + /// The matcher for the second indexer parameter. + /// The matcher for the third indexer parameter. + /// Factory producing the indexer-argument description used in failure messages. + public VerificationIndexerGetterResult(TSubject subject, MockRegistry mockRegistry, int getMemberId, + IParameterMatch match1, IParameterMatch match2, IParameterMatch match3, + Func parametersDescription) + { + _subject = subject; + _mockRegistry = mockRegistry; + _getMemberId = getMemberId; + _match1 = match1; + _match2 = match2; + _match3 = match3; + _parametersDescription = parametersDescription; + } + + /// + public VerificationResult Got() + => _mockRegistry.IndexerGotTyped(_subject, _getMemberId, _match1, _match2, _match3, _parametersDescription); +} + +/// +/// Verifications on a 3-key indexer of type that the mock only writes. See +/// for rationale. +/// +#if !DEBUG +[System.Diagnostics.DebuggerNonUserCode] +#endif +public class VerificationIndexerSetterResult +{ + private readonly IParameterMatch _match1; + private readonly IParameterMatch _match2; + private readonly IParameterMatch _match3; + private readonly MockRegistry _mockRegistry; + private readonly Func _parametersDescription; + private readonly int _setMemberId; + private readonly TSubject _subject; + + /// + /// The verification facade the result is bound to. + /// The mock registry holding the recorded interactions. + /// Member id of the indexer setter, or -1 when unknown. + /// The matcher for the first indexer parameter. + /// The matcher for the second indexer parameter. + /// The matcher for the third indexer parameter. + /// Factory producing the indexer-argument description used in failure messages. + public VerificationIndexerSetterResult(TSubject subject, MockRegistry mockRegistry, int setMemberId, + IParameterMatch match1, IParameterMatch match2, IParameterMatch match3, + Func parametersDescription) + { + _subject = subject; + _mockRegistry = mockRegistry; + _setMemberId = setMemberId; + _match1 = match1; + _match2 = match2; + _match3 = match3; + _parametersDescription = parametersDescription; + } + + /// + public VerificationResult Set(IParameter value) + => _mockRegistry.IndexerSetTyped(_subject, _setMemberId, _match1, _match2, _match3, + (IParameterMatch)value, _parametersDescription); + + /// + [OverloadResolutionPriority(1)] + public VerificationResult Set(TParameter value, + [CallerArgumentExpression(nameof(value))] + string doNotPopulateThisValue = "") + => _mockRegistry.IndexerSetTyped(_subject, _setMemberId, _match1, _match2, _match3, + (IParameterMatch)It.Is(value, doNotPopulateThisValue), _parametersDescription); +} + +/// +/// Verifications on a 4-key indexer that the mock only reads. See +/// for rationale. +/// +#if !DEBUG +[System.Diagnostics.DebuggerNonUserCode] +#endif +public class VerificationIndexerGetterResult +{ + private readonly int _getMemberId; + private readonly IParameterMatch _match1; + private readonly IParameterMatch _match2; + private readonly IParameterMatch _match3; + private readonly IParameterMatch _match4; + private readonly MockRegistry _mockRegistry; + private readonly Func _parametersDescription; + private readonly TSubject _subject; + + /// + /// The verification facade the result is bound to. + /// The mock registry holding the recorded interactions. + /// Member id of the indexer getter, or -1 when unknown. + /// The matcher for the first indexer parameter. + /// The matcher for the second indexer parameter. + /// The matcher for the third indexer parameter. + /// The matcher for the fourth indexer parameter. + /// Factory producing the indexer-argument description used in failure messages. + public VerificationIndexerGetterResult(TSubject subject, MockRegistry mockRegistry, int getMemberId, + IParameterMatch match1, IParameterMatch match2, IParameterMatch match3, IParameterMatch match4, + Func parametersDescription) + { + _subject = subject; + _mockRegistry = mockRegistry; + _getMemberId = getMemberId; + _match1 = match1; + _match2 = match2; + _match3 = match3; + _match4 = match4; + _parametersDescription = parametersDescription; + } + + /// + public VerificationResult Got() + => _mockRegistry.IndexerGotTyped(_subject, _getMemberId, _match1, _match2, _match3, _match4, + _parametersDescription); +} + +/// +/// Verifications on a 4-key indexer of type that the mock only writes. See +/// for rationale. +/// +#if !DEBUG +[System.Diagnostics.DebuggerNonUserCode] +#endif +public class VerificationIndexerSetterResult +{ + private readonly IParameterMatch _match1; + private readonly IParameterMatch _match2; + private readonly IParameterMatch _match3; + private readonly IParameterMatch _match4; + private readonly MockRegistry _mockRegistry; + private readonly Func _parametersDescription; + private readonly int _setMemberId; + private readonly TSubject _subject; + + /// + /// The verification facade the result is bound to. + /// The mock registry holding the recorded interactions. + /// Member id of the indexer setter, or -1 when unknown. + /// The matcher for the first indexer parameter. + /// The matcher for the second indexer parameter. + /// The matcher for the third indexer parameter. + /// The matcher for the fourth indexer parameter. + /// Factory producing the indexer-argument description used in failure messages. + public VerificationIndexerSetterResult(TSubject subject, MockRegistry mockRegistry, int setMemberId, + IParameterMatch match1, IParameterMatch match2, IParameterMatch match3, IParameterMatch match4, + Func parametersDescription) + { + _subject = subject; + _mockRegistry = mockRegistry; + _setMemberId = setMemberId; + _match1 = match1; + _match2 = match2; + _match3 = match3; + _match4 = match4; + _parametersDescription = parametersDescription; + } + + /// + public VerificationResult Set(IParameter value) + => _mockRegistry.IndexerSetTyped(_subject, _setMemberId, _match1, _match2, _match3, _match4, + (IParameterMatch)value, _parametersDescription); + + /// + [OverloadResolutionPriority(1)] + public VerificationResult Set(TParameter value, + [CallerArgumentExpression(nameof(value))] + string doNotPopulateThisValue = "") + => _mockRegistry.IndexerSetTyped(_subject, _setMemberId, _match1, _match2, _match3, _match4, + (IParameterMatch)It.Is(value, doNotPopulateThisValue), _parametersDescription); +} diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt index 06425391..4051674a 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net10.0.txt @@ -457,6 +457,58 @@ namespace Mockolate { public Mockolate.Setup.IIndexerSetup OnlyOnce() { } } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } extension(Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder? setup) { public void Forever() { } @@ -1151,6 +1203,194 @@ namespace Mockolate.Setup { Mockolate.Setup.IEventUnsubscriptionSetupCallbackWhenBuilder When(System.Func predicate); } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } public interface IIndexerGetterSetupCallbackBuilder : Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder InParallel(); @@ -1247,6 +1487,110 @@ namespace Mockolate.Setup Mockolate.Setup.IIndexerGetterSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder TransitionTo(string scenario); } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } public interface IIndexerSetterSetupCallbackBuilder : Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder InParallel(); @@ -2255,7 +2599,7 @@ namespace Mockolate.Setup protected static string FormatType(System.Type type) { } protected static bool TryCast([System.Diagnostics.CodeAnalysis.NotNullWhen(false)] object? value, out T result, Mockolate.MockBehavior behavior) { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2283,7 +2627,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2311,7 +2655,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2, Mockolate.Parameters.IParameterMatch parameter3) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2339,7 +2683,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2, Mockolate.Parameters.IParameterMatch parameter3, Mockolate.Parameters.IParameterMatch parameter4) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2936,6 +3280,26 @@ namespace Mockolate.Verify public Mockolate.Verify.VerificationResult Subscribed() { } public Mockolate.Verify.VerificationResult Unsubscribed() { } } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, Mockolate.Parameters.IParameterMatch match4, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } public class VerificationIndexerResult { public VerificationIndexerResult(TSubject subject, Mockolate.MockRegistry mockRegistry, System.Func gotPredicate, System.Func, bool> setPredicate, System.Func parametersDescription) { } @@ -2972,6 +3336,30 @@ namespace Mockolate.Verify public override Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } public override Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, Mockolate.Parameters.IParameterMatch match4, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } public class VerificationPropertyGetterResult { public VerificationPropertyGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, string propertyName) { } diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt index 9db3d608..102cc8aa 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_net8.0.txt @@ -440,6 +440,58 @@ namespace Mockolate { public Mockolate.Setup.IIndexerSetup OnlyOnce() { } } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } extension(Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder? setup) { public void Forever() { } @@ -1109,6 +1161,194 @@ namespace Mockolate.Setup { Mockolate.Setup.IEventUnsubscriptionSetupCallbackWhenBuilder When(System.Func predicate); } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } public interface IIndexerGetterSetupCallbackBuilder : Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder InParallel(); @@ -1205,6 +1445,110 @@ namespace Mockolate.Setup Mockolate.Setup.IIndexerGetterSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder TransitionTo(string scenario); } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } public interface IIndexerSetterSetupCallbackBuilder : Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder InParallel(); @@ -2017,7 +2361,7 @@ namespace Mockolate.Setup protected static string FormatType(System.Type type) { } protected static bool TryCast([System.Diagnostics.CodeAnalysis.NotNullWhen(false)] object? value, out T result, Mockolate.MockBehavior behavior) { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2045,7 +2389,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2073,7 +2417,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2, Mockolate.Parameters.IParameterMatch parameter3) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2101,7 +2445,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2, Mockolate.Parameters.IParameterMatch parameter3, Mockolate.Parameters.IParameterMatch parameter4) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2490,6 +2834,26 @@ namespace Mockolate.Verify public Mockolate.Verify.VerificationResult Subscribed() { } public Mockolate.Verify.VerificationResult Unsubscribed() { } } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, Mockolate.Parameters.IParameterMatch match4, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } public class VerificationIndexerResult { public VerificationIndexerResult(TSubject subject, Mockolate.MockRegistry mockRegistry, System.Func gotPredicate, System.Func, bool> setPredicate, System.Func parametersDescription) { } @@ -2526,6 +2890,30 @@ namespace Mockolate.Verify public override Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } public override Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, Mockolate.Parameters.IParameterMatch match4, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } public class VerificationPropertyGetterResult { public VerificationPropertyGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, string propertyName) { } diff --git a/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt b/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt index 47d186ea..f4b14e81 100644 --- a/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt +++ b/Tests/Mockolate.Api.Tests/Expected/Mockolate_netstandard2.0.txt @@ -387,6 +387,58 @@ namespace Mockolate { public Mockolate.Setup.IIndexerSetup OnlyOnce() { } } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder? setup) + { + public void Forever() { } + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerGetterOnlySetup OnlyOnce() { } + } + extension(Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder? setup) + { + public Mockolate.Setup.IIndexerSetterOnlySetup OnlyOnce() { } + } extension(Mockolate.Setup.IReturnMethodSetupReturnWhenBuilder? setup) { public void Forever() { } @@ -1052,6 +1104,194 @@ namespace Mockolate.Setup { Mockolate.Setup.IEventUnsubscriptionSetupCallbackWhenBuilder When(System.Func predicate); } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlyGetterSetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnBuilder : Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder When(System.Func predicate); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetupReturnWhenBuilder : Mockolate.Setup.IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder For(int times); + Mockolate.Setup.IIndexerGetterOnlySetup Only(int times); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } + public interface IIndexerGetterOnlySetup + { + Mockolate.Setup.IIndexerGetterOnlyGetterSetup OnGet { get; } + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(System.Func valueGenerator); + Mockolate.Setup.IIndexerGetterOnlySetup InitializeWith(TValue value); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Returns(TValue returnValue); + Mockolate.Setup.IIndexerGetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Exception exception); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws(System.Func callback); + Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder Throws() + where TException : System.Exception, new (); + } public interface IIndexerGetterSetupCallbackBuilder : Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder InParallel(); @@ -1148,6 +1388,110 @@ namespace Mockolate.Setup Mockolate.Setup.IIndexerGetterSetupCallbackBuilder Do(System.Action callback); Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder TransitionTo(string scenario); } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetterSetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder Do(System.Action callback); + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder TransitionTo(string scenario); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder InParallel(); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupCallbackWhenBuilder : Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder For(int times); + Mockolate.Setup.IIndexerSetterOnlySetup Only(int times); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetupParallelCallbackBuilder : Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder When(System.Func predicate); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } + public interface IIndexerSetterOnlySetup + { + Mockolate.Setup.IIndexerSetterOnlySetterSetup OnSet { get; } + Mockolate.Setup.IIndexerSetterOnlySetup SkippingBaseClass(bool skipBaseClass = true); + } public interface IIndexerSetterSetupCallbackBuilder : Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder InParallel(); @@ -1960,7 +2304,7 @@ namespace Mockolate.Setup protected static string FormatType(System.Type type) { } protected static bool TryCast([System.Diagnostics.CodeAnalysis.NotNullWhen(false)] object? value, out T result, Mockolate.MockBehavior behavior) { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -1988,7 +2332,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2016,7 +2360,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2, Mockolate.Parameters.IParameterMatch parameter3) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2044,7 +2388,7 @@ namespace Mockolate.Setup where TException : System.Exception, new () { } public override string ToString() { } } - public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup + public class IndexerSetup : Mockolate.Setup.IndexerSetup, Mockolate.Setup.IIndexerGetterOnlyGetterSetup, Mockolate.Setup.IIndexerGetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnBuilder, Mockolate.Setup.IIndexerGetterOnlySetupReturnWhenBuilder, Mockolate.Setup.IIndexerGetterOnlySetup, Mockolate.Setup.IIndexerGetterSetupCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerGetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerGetterSetupWithCallback, Mockolate.Setup.IIndexerGetterSetup, Mockolate.Setup.IIndexerSetterOnlySetterSetup, Mockolate.Setup.IIndexerSetterOnlySetupCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterOnlySetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterOnlySetup, Mockolate.Setup.IIndexerSetterSetupCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupCallbackWhenBuilder, Mockolate.Setup.IIndexerSetterSetupParallelCallbackBuilder, Mockolate.Setup.IIndexerSetterSetupWithCallback, Mockolate.Setup.IIndexerSetterSetup, Mockolate.Setup.IIndexerSetupReturnBuilder, Mockolate.Setup.IIndexerSetupReturnWhenBuilder, Mockolate.Setup.IIndexerSetupWithCallback, Mockolate.Setup.IIndexerSetup { public IndexerSetup(Mockolate.MockRegistry mockRegistry, Mockolate.Parameters.IParameterMatch parameter1, Mockolate.Parameters.IParameterMatch parameter2, Mockolate.Parameters.IParameterMatch parameter3, Mockolate.Parameters.IParameterMatch parameter4) { } public Mockolate.Setup.IIndexerGetterSetupWithCallback OnGet { get; } @@ -2419,6 +2763,26 @@ namespace Mockolate.Verify public Mockolate.Verify.VerificationResult Subscribed() { } public Mockolate.Verify.VerificationResult Unsubscribed() { } } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } + public class VerificationIndexerGetterResult + { + public VerificationIndexerGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, Mockolate.Parameters.IParameterMatch match4, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Got() { } + } public class VerificationIndexerResult { public VerificationIndexerResult(TSubject subject, Mockolate.MockRegistry mockRegistry, System.Func gotPredicate, System.Func, bool> setPredicate, System.Func parametersDescription) { } @@ -2455,6 +2819,30 @@ namespace Mockolate.Verify public override Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } public override Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } + public class VerificationIndexerSetterResult + { + public VerificationIndexerSetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int setMemberId, Mockolate.Parameters.IParameterMatch match1, Mockolate.Parameters.IParameterMatch match2, Mockolate.Parameters.IParameterMatch match3, Mockolate.Parameters.IParameterMatch match4, System.Func parametersDescription) { } + public Mockolate.Verify.VerificationResult Set(Mockolate.Parameters.IParameter value) { } + public Mockolate.Verify.VerificationResult Set(TParameter value, [System.Runtime.CompilerServices.CallerArgumentExpression("value")] string doNotPopulateThisValue = "") { } + } public class VerificationPropertyGetterResult { public VerificationPropertyGetterResult(TSubject subject, Mockolate.MockRegistry mockRegistry, int getMemberId, string propertyName) { } diff --git a/Tests/Mockolate.SourceGenerators.Tests/MockTests.ClassTests.IndexerTests.cs b/Tests/Mockolate.SourceGenerators.Tests/MockTests.ClassTests.IndexerTests.cs index dbdc2f44..fa6f49ab 100644 --- a/Tests/Mockolate.SourceGenerators.Tests/MockTests.ClassTests.IndexerTests.cs +++ b/Tests/Mockolate.SourceGenerators.Tests/MockTests.ClassTests.IndexerTests.cs @@ -6,6 +6,99 @@ public sealed partial class ClassTests { public sealed class IndexerTests { + [Theory] + [InlineData("string this[int key] { get; }", + "Setup.IIndexerGetterOnlySetup", + "Verify.VerificationIndexerGetterResult", + "Setup.IndexerSetup", + "Verify.VerificationIndexerResult")] + [InlineData("string this[int key] { set; }", + "Setup.IIndexerSetterOnlySetup", + "Verify.VerificationIndexerSetterResult", + "Setup.IndexerSetup", + "Verify.VerificationIndexerResult")] + [InlineData("string this[int key] { get; set; }", + "Setup.IndexerSetup", + "Verify.VerificationIndexerResult", + "Setup.IIndexerGetterOnlySetup", + "Verify.VerificationIndexerGetterResult")] + [InlineData("string this[int key, bool flag] { get; }", + "Setup.IIndexerGetterOnlySetup", + "Verify.VerificationIndexerGetterResult", + "Setup.IndexerSetup", + "Verify.VerificationIndexerResult")] + [InlineData("string this[int key, bool flag] { set; }", + "Setup.IIndexerSetterOnlySetup", + "Verify.VerificationIndexerSetterResult", + "Setup.IndexerSetup", + "Verify.VerificationIndexerResult")] + public async Task IndexerSurface_ShouldOnlyExposeTheAccessorsTheMockIntercepts( + string indexer, string expectedSetupType, string expectedVerifyType, + string unexpectedSetupType, string unexpectedVerifyType) + { + GeneratorResult result = Generator + .Run($$""" + using Mockolate; + + namespace MyCode; + public class Program + { + public static void Main(string[] args) + { + _ = IMyService.CreateMock(); + } + } + + public interface IMyService + { + {{indexer}} + } + """); + + await That(result.Diagnostics).IsEmpty(); + await That(result.Sources["Mock.IMyService.g.cs"]) + .Contains($"global::Mockolate.{expectedSetupType} this[").And + .Contains($"global::Mockolate.{expectedVerifyType} this[").And + .DoesNotContain($"global::Mockolate.{unexpectedSetupType} this[").And + .DoesNotContain($"global::Mockolate.{unexpectedVerifyType} this[") + .Because("a widened facade would silently re-expose an accessor the mock never intercepts"); + } + + [Theory] + [InlineData("string this[int a, int b, int c, int d, int e] { get; }")] + [InlineData("string this[int a, int b, int c, int d, int e] { set; }")] + public async Task IndexerWithMoreThanFourKeys_ShouldKeepTheFullSurface(string indexer) + { + GeneratorResult result = Generator + .Run($$""" + using Mockolate; + + namespace MyCode; + public class Program + { + public static void Main(string[] args) + { + _ = IMyService.CreateMock(); + } + } + + public interface IMyService + { + {{indexer}} + } + """); + + await That(result.Diagnostics).IsEmpty(); + await That(result.Sources["Mock.IMyService.g.cs"]) + .Contains("global::Mockolate.Setup.IndexerSetup this[").And + .Contains("global::Mockolate.Verify.VerificationIndexerResult this[").And + .DoesNotContain("IIndexerGetterOnlySetup").And + .DoesNotContain("IIndexerSetterOnlySetup").And + .DoesNotContain("VerificationIndexerGetterResult").And + .DoesNotContain("VerificationIndexerSetterResult") + .Because("the narrowed indexer types only exist for up to four keys, so a wider indexer keeps the full surface"); + } + [Fact] public async Task InterfaceIndexerWithParameterNamedLikeLocal_ShouldGenerateUniqueLocalVariableName() { diff --git a/Tests/Mockolate.SourceGenerators.Tests/MockTests.CrossAssemblyTests.cs b/Tests/Mockolate.SourceGenerators.Tests/MockTests.CrossAssemblyTests.cs index 8a0f0be7..81dddfb0 100644 --- a/Tests/Mockolate.SourceGenerators.Tests/MockTests.CrossAssemblyTests.cs +++ b/Tests/Mockolate.SourceGenerators.Tests/MockTests.CrossAssemblyTests.cs @@ -364,10 +364,42 @@ public abstract class MyExternalType : MyBaseType await That(result.Diagnostics).IsEmpty(); await That(result.Sources["Mock.MyExternalType.g.cs"]) .Contains("public override int this[int index]").And + .Contains("global::Mockolate.Setup.IIndexerGetterOnlySetup this[").And + .Contains("global::Mockolate.Verify.VerificationIndexerGetterResult this[").And + .DoesNotContain("global::Mockolate.Setup.IndexerSetup this[").And .DoesNotContain("internal set") .Because("the setter is invisible to the mock's assembly, so only the getter may be overridden"); } + [Fact] + public async Task MixedAccessorIndexerSlotAlreadyOverridden_WithOnlyTheSetterReachable_ShouldBeMockedWithTheSetter() + { + MetadataReference external = ExternalAssembly.Compile(""" + namespace Ext; + + public abstract class MyBaseType + { + public abstract int this[int index] { internal get; set; } + } + + public abstract class MyExternalType : MyBaseType + { + public override int this[int index] { internal get => 0; set { } } + } + """); + + GeneratorResult result = Generator.RunWithReferences(CreateMockForMyExternalType, [external,]); + + await That(result.Diagnostics).IsEmpty(); + await That(result.Sources["Mock.MyExternalType.g.cs"]) + .Contains("public override int this[int index]").And + .Contains("global::Mockolate.Setup.IIndexerSetterOnlySetup this[").And + .Contains("global::Mockolate.Verify.VerificationIndexerSetterResult this[").And + .DoesNotContain("global::Mockolate.Setup.IndexerSetup this[").And + .DoesNotContain("internal get") + .Because("the getter is invisible to the mock's assembly, so only the setter may be overridden"); + } + [Fact] public async Task MixedAccessorSlotFilledByAnIntermediateType_ShouldBeMockedWithTheAccessibleAccessorOnly() { diff --git a/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/ComprehensiveInterface_CanBeCreated/Mock.IComprehensiveInterface.g.cs b/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/ComprehensiveInterface_CanBeCreated/Mock.IComprehensiveInterface.g.cs index 4dec103f..02d92600 100644 --- a/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/ComprehensiveInterface_CanBeCreated/Mock.IComprehensiveInterface.g.cs +++ b/Tests/Mockolate.SourceGenerators.Tests/Snapshot/Expected/ComprehensiveInterface_CanBeCreated/Mock.IComprehensiveInterface.g.cs @@ -43,36 +43,40 @@ internal class IComprehensiveInterface : internal const int MemberId_Indexer_int_Set = 19; internal const int MemberId_Indexer_int_int_int_int_int_Get = 20; internal const int MemberId_Indexer_int_int_int_int_int_Set = 21; - internal const int MemberId_StaticAbstractMethod = 22; - internal const int MemberId_WithModifiers = 23; - internal const int MemberId_WithDefaults = 24; - internal const int MemberId_WithCollidingNames = 25; - internal const int MemberId_GetMaybeNull = 26; - internal const int MemberId_TakeObject = 27; - internal const int MemberId_TakeTwoObjects = 28; - internal const int MemberId_TakeIntAndObject = 29; - internal const int MemberId_DoTask = 30; - internal const int MemberId_DoTaskOf = 31; - internal const int MemberId_DoVT = 32; - internal const int MemberId_DoVTOf = 33; - internal const int MemberId_GetTuple = 34; - internal const int MemberId_GetNullable = 35; - internal const int MemberId_GetSpan = 36; - internal const int MemberId_GetROSpan = 37; - internal const int MemberId_GetByRef = 38; - internal const int MemberId_GetByRefReadonly = 39; - internal const int MemberId_G1_T_ = 40; - internal const int MemberId_G2_T_ = 41; - internal const int MemberId_G3_T_ = 42; - internal const int MemberId_G4_T_ = 43; - internal const int MemberId_G5_T_ = 44; - internal const int MemberId_G6_T_ = 45; - internal const int MemberId_G7_T_ = 46; - internal const int MemberId_G8_T_ = 47; - internal const int MemberId_Five = 48; - internal const int MemberId_Seventeen = 49; - internal const int MemberId_SeventeenVoid = 50; - internal const int MemberCount = 51; + internal const int MemberId_Indexer_double_Get = 22; + internal const int MemberId_Indexer_double_Set = 23; + internal const int MemberId_Indexer_char_Get = 24; + internal const int MemberId_Indexer_char_Set = 25; + internal const int MemberId_StaticAbstractMethod = 26; + internal const int MemberId_WithModifiers = 27; + internal const int MemberId_WithDefaults = 28; + internal const int MemberId_WithCollidingNames = 29; + internal const int MemberId_GetMaybeNull = 30; + internal const int MemberId_TakeObject = 31; + internal const int MemberId_TakeTwoObjects = 32; + internal const int MemberId_TakeIntAndObject = 33; + internal const int MemberId_DoTask = 34; + internal const int MemberId_DoTaskOf = 35; + internal const int MemberId_DoVT = 36; + internal const int MemberId_DoVTOf = 37; + internal const int MemberId_GetTuple = 38; + internal const int MemberId_GetNullable = 39; + internal const int MemberId_GetSpan = 40; + internal const int MemberId_GetROSpan = 41; + internal const int MemberId_GetByRef = 42; + internal const int MemberId_GetByRefReadonly = 43; + internal const int MemberId_G1_T_ = 44; + internal const int MemberId_G2_T_ = 45; + internal const int MemberId_G3_T_ = 46; + internal const int MemberId_G4_T_ = 47; + internal const int MemberId_G5_T_ = 48; + internal const int MemberId_G6_T_ = 49; + internal const int MemberId_G7_T_ = 50; + internal const int MemberId_G8_T_ = 51; + internal const int MemberId_Five = 52; + internal const int MemberId_Seventeen = 53; + internal const int MemberId_SeventeenVoid = 54; + internal const int MemberCount = 55; internal static readonly global::Mockolate.Interactions.PropertyGetterAccess PropertyAccess_GetSet_Get = new global::Mockolate.Interactions.PropertyGetterAccess("global::Mockolate.Tests.GeneratorCoverage.IComprehensiveInterface.GetSet"); internal static readonly global::Mockolate.Interactions.PropertyGetterAccess PropertyAccess_GetOnly_Get = new global::Mockolate.Interactions.PropertyGetterAccess("global::Mockolate.Tests.GeneratorCoverage.IComprehensiveInterface.GetOnly"); internal static readonly global::Mockolate.Interactions.PropertyGetterAccess PropertyAccess_SetOnly_Get = new global::Mockolate.Interactions.PropertyGetterAccess("global::Mockolate.Tests.GeneratorCoverage.IComprehensiveInterface.SetOnly"); @@ -111,6 +115,18 @@ internal class IComprehensiveInterface : private global::Mockolate.Interactions.FastIndexerSetterBuffer MockolateBuffer_Indexer_int_Set => field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer>(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_int_Set, static fast => new global::Mockolate.Interactions.FastIndexerSetterBuffer(fast))); [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + private global::Mockolate.Interactions.FastIndexerGetterBuffer MockolateBuffer_Indexer_double_Get + => field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer>(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, static fast => new global::Mockolate.Interactions.FastIndexerGetterBuffer(fast))); + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + private global::Mockolate.Interactions.FastIndexerSetterBuffer MockolateBuffer_Indexer_double_Set + => field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer>(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Set, static fast => new global::Mockolate.Interactions.FastIndexerSetterBuffer(fast))); + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + private global::Mockolate.Interactions.FastIndexerGetterBuffer MockolateBuffer_Indexer_char_Get + => field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer>(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Get, static fast => new global::Mockolate.Interactions.FastIndexerGetterBuffer(fast))); + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + private global::Mockolate.Interactions.FastIndexerSetterBuffer MockolateBuffer_Indexer_char_Set + => field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer>(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Set, static fast => new global::Mockolate.Interactions.FastIndexerSetterBuffer(fast))); + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] private global::Mockolate.Interactions.FastMethod4Buffer MockolateBuffer_WithModifiers => field ?? (field = ((global::Mockolate.Interactions.FastMockInteractions)this.MockRegistry.Interactions).GetOrCreateBuffer>(global::Mockolate.Mock.IComprehensiveInterface.MemberId_WithModifiers, static fast => new global::Mockolate.Interactions.FastMethod4Buffer(fast))); [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] @@ -506,6 +522,79 @@ public string this[int i] } } + /// + public string this[double key] + { + get + { + if (this.MockRegistry.Behavior.SkipInteractionRecording == false) + { + this.MockolateBuffer_Indexer_double_Get.Append(key); + } + global::Mockolate.Setup.IndexerSetup? setup = null; + if (string.IsNullOrEmpty(this.MockRegistry.Scenario)) + { + global::Mockolate.Setup.IndexerSetup[]? snapshot_setup = this.MockRegistry.GetIndexerSetupSnapshot(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get); + if (snapshot_setup is not null) + { + for (int i_setup = snapshot_setup.Length - 1; i_setup >= 0; i_setup--) + { + if (snapshot_setup[i_setup] is global::Mockolate.Setup.IndexerSetup s_setup && s_setup.Matches(key)) + { + setup = s_setup; + break; + } + } + } + } + global::Mockolate.Interactions.IndexerGetterAccess access = new(key); + setup ??= this.MockRegistry.GetIndexerSetup>(access); + if (this.MockRegistry.Wraps is not global::Mockolate.Tests.GeneratorCoverage.IComprehensiveInterface wraps) + { + return setup is null + ? this.MockRegistry.GetIndexerFallback(access, 2) + : this.MockRegistry.ApplyIndexerSetup(access, setup, 2); + } + string baseResult = wraps[key]; + return this.MockRegistry.ApplyIndexerGetter(access, setup, baseResult, 2); + } + } + + /// + public string this[char key] + { + set + { + if (this.MockRegistry.Behavior.SkipInteractionRecording == false) + { + this.MockolateBuffer_Indexer_char_Set.Append(key, value); + } + global::Mockolate.Setup.IndexerSetup? setup = null; + if (string.IsNullOrEmpty(this.MockRegistry.Scenario)) + { + global::Mockolate.Setup.IndexerSetup[]? snapshot_setup = this.MockRegistry.GetIndexerSetupSnapshot(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Get); + if (snapshot_setup is not null) + { + for (int i_setup = snapshot_setup.Length - 1; i_setup >= 0; i_setup--) + { + if (snapshot_setup[i_setup] is global::Mockolate.Setup.IndexerSetup s_setup && s_setup.Matches(key, value)) + { + setup = s_setup; + break; + } + } + } + } + global::Mockolate.Interactions.IndexerSetterAccess access = new(key, value); + setup ??= this.MockRegistry.GetIndexerSetup>(access); + this.MockRegistry.ApplyIndexerSetter(access, setup, value, 3); + if (this.MockRegistry.Wraps is global::Mockolate.Tests.GeneratorCoverage.IComprehensiveInterface wraps) + { + wraps[key] = value; + } + } + } + /// public static int StaticAbstractValue { @@ -2334,6 +2423,54 @@ public void SeventeenVoid(int a1, int a2, int a3, int a4, int a5, int a6, int a7 } } + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Setup.IIndexerGetterOnlySetup global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.this[global::Mockolate.Parameters.IParameter? parameter1] + { + get + { + var indexerSetup = new global::Mockolate.Setup.IndexerSetup(MockRegistry, CovariantParameterAdapter.Wrap(parameter1 ?? global::Mockolate.It.IsNull("null"))); + this.MockRegistry.SetupIndexer(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, indexerSetup); + return indexerSetup; + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Setup.IIndexerGetterOnlySetup global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.this[double parameter1] + { + get + { + var indexerSetup = new global::Mockolate.Setup.IndexerSetup(MockRegistry, (global::Mockolate.Parameters.IParameterMatch)global::Mockolate.It.IsValue(parameter1)); + this.MockRegistry.SetupIndexer(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, indexerSetup); + return indexerSetup; + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Setup.IIndexerSetterOnlySetup global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.this[global::Mockolate.Parameters.IParameter? parameter1] + { + get + { + var indexerSetup = new global::Mockolate.Setup.IndexerSetup(MockRegistry, CovariantParameterAdapter.Wrap(parameter1 ?? global::Mockolate.It.IsNull("null"))); + this.MockRegistry.SetupIndexer(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Get, indexerSetup); + return indexerSetup; + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Setup.IIndexerSetterOnlySetup global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.this[char parameter1] + { + get + { + var indexerSetup = new global::Mockolate.Setup.IndexerSetup(MockRegistry, (global::Mockolate.Parameters.IParameterMatch)global::Mockolate.It.IsValue(parameter1)); + this.MockRegistry.SetupIndexer(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Get, indexerSetup); + return indexerSetup; + } + } + /// global::Mockolate.Setup.IVoidMethodSetupWithCallback global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.WithModifiers(global::Mockolate.Parameters.IParameters parameters) { @@ -2974,6 +3111,54 @@ void IMockRaiseOnIComprehensiveInterface.CustomEvent(global::Mockolate.Parameter } } + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Verify.VerificationIndexerGetterResult IMockVerifyForIComprehensiveInterface.this[global::Mockolate.Parameters.IParameter? key] + { + get + { + return new global::Mockolate.Verify.VerificationIndexerGetterResult(this, this.MockRegistry, global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, + CovariantParameterAdapter.Wrap(key ?? global::Mockolate.It.IsNull("null")), + () => global::System.String.Format("[{0}]", (object?)key ?? "null")); + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Verify.VerificationIndexerGetterResult IMockVerifyForIComprehensiveInterface.this[double key] + { + get + { + return new global::Mockolate.Verify.VerificationIndexerGetterResult(this, this.MockRegistry, global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, + (global::Mockolate.Parameters.IParameterMatch)global::Mockolate.It.Is(key, "key"), + () => global::System.String.Format("[{0}]", (object?)key)); + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Verify.VerificationIndexerSetterResult IMockVerifyForIComprehensiveInterface.this[global::Mockolate.Parameters.IParameter? key] + { + get + { + return new global::Mockolate.Verify.VerificationIndexerSetterResult(this, this.MockRegistry, global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Set, + CovariantParameterAdapter.Wrap(key ?? global::Mockolate.It.IsNull("null")), + () => global::System.String.Format("[{0}]", (object?)key ?? "null")); + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Verify.VerificationIndexerSetterResult IMockVerifyForIComprehensiveInterface.this[char key] + { + get + { + return new global::Mockolate.Verify.VerificationIndexerSetterResult(this, this.MockRegistry, global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Set, + (global::Mockolate.Parameters.IParameterMatch)global::Mockolate.It.Is(key, "key"), + () => global::System.String.Format("[{0}]", (object?)key)); + } + } + /// global::Mockolate.Verify.VerificationResult IMockVerifyForIComprehensiveInterface.WithModifiers(global::Mockolate.Parameters.IParameters parameters) => this.MockRegistry.VerifyMethod>(this, global::Mockolate.Mock.IComprehensiveInterface.MemberId_WithModifiers, "global::Mockolate.Tests.GeneratorCoverage.IComprehensiveInterface.WithModifiers", __i => parameters switch @@ -3504,6 +3689,54 @@ private sealed class VerifyMonitorIComprehensiveInterface(global::Mockolate.Mock } } + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Verify.VerificationIndexerGetterResult IMockVerifyForIComprehensiveInterface.this[global::Mockolate.Parameters.IParameter? key] + { + get + { + return new global::Mockolate.Verify.VerificationIndexerGetterResult(this, this.MockRegistry, global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, + CovariantParameterAdapter.Wrap(key ?? global::Mockolate.It.IsNull("null")), + () => global::System.String.Format("[{0}]", (object?)key ?? "null")); + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Verify.VerificationIndexerGetterResult IMockVerifyForIComprehensiveInterface.this[double key] + { + get + { + return new global::Mockolate.Verify.VerificationIndexerGetterResult(this, this.MockRegistry, global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, + (global::Mockolate.Parameters.IParameterMatch)global::Mockolate.It.Is(key, "key"), + () => global::System.String.Format("[{0}]", (object?)key)); + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Verify.VerificationIndexerSetterResult IMockVerifyForIComprehensiveInterface.this[global::Mockolate.Parameters.IParameter? key] + { + get + { + return new global::Mockolate.Verify.VerificationIndexerSetterResult(this, this.MockRegistry, global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Set, + CovariantParameterAdapter.Wrap(key ?? global::Mockolate.It.IsNull("null")), + () => global::System.String.Format("[{0}]", (object?)key ?? "null")); + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Verify.VerificationIndexerSetterResult IMockVerifyForIComprehensiveInterface.this[char key] + { + get + { + return new global::Mockolate.Verify.VerificationIndexerSetterResult(this, this.MockRegistry, global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Set, + (global::Mockolate.Parameters.IParameterMatch)global::Mockolate.It.Is(key, "key"), + () => global::System.String.Format("[{0}]", (object?)key)); + } + } + /// global::Mockolate.Verify.VerificationResult IMockVerifyForIComprehensiveInterface.WithModifiers(global::Mockolate.Parameters.IParameters parameters) => this.MockRegistry.VerifyMethod>(this, global::Mockolate.Mock.IComprehensiveInterface.MemberId_WithModifiers, "global::Mockolate.Tests.GeneratorCoverage.IComprehensiveInterface.WithModifiers", __i => parameters switch @@ -4072,6 +4305,54 @@ public MockInScenarioForIComprehensiveInterface(global::Mockolate.MockRegistry m } } + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Setup.IIndexerGetterOnlySetup global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.this[global::Mockolate.Parameters.IParameter? parameter1] + { + get + { + var indexerSetup = new global::Mockolate.Setup.IndexerSetup(MockRegistry, CovariantParameterAdapter.Wrap(parameter1 ?? global::Mockolate.It.IsNull("null"))); + this.MockRegistry.SetupIndexer(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, _scenarioName, indexerSetup); + return indexerSetup; + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Setup.IIndexerGetterOnlySetup global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.this[double parameter1] + { + get + { + var indexerSetup = new global::Mockolate.Setup.IndexerSetup(MockRegistry, (global::Mockolate.Parameters.IParameterMatch)global::Mockolate.It.IsValue(parameter1)); + this.MockRegistry.SetupIndexer(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_double_Get, _scenarioName, indexerSetup); + return indexerSetup; + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Setup.IIndexerSetterOnlySetup global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.this[global::Mockolate.Parameters.IParameter? parameter1] + { + get + { + var indexerSetup = new global::Mockolate.Setup.IndexerSetup(MockRegistry, CovariantParameterAdapter.Wrap(parameter1 ?? global::Mockolate.It.IsNull("null"))); + this.MockRegistry.SetupIndexer(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Get, _scenarioName, indexerSetup); + return indexerSetup; + } + } + + /// + [global::System.Diagnostics.DebuggerBrowsable(global::System.Diagnostics.DebuggerBrowsableState.Never)] + global::Mockolate.Setup.IIndexerSetterOnlySetup global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.this[char parameter1] + { + get + { + var indexerSetup = new global::Mockolate.Setup.IndexerSetup(MockRegistry, (global::Mockolate.Parameters.IParameterMatch)global::Mockolate.It.IsValue(parameter1)); + this.MockRegistry.SetupIndexer(global::Mockolate.Mock.IComprehensiveInterface.MemberId_Indexer_char_Get, _scenarioName, indexerSetup); + return indexerSetup; + } + } + /// global::Mockolate.Setup.IVoidMethodSetupWithCallback global::Mockolate.Mock.IMockSetupForIComprehensiveInterface.WithModifiers(global::Mockolate.Parameters.IParameters parameters) { @@ -4759,6 +5040,42 @@ internal interface IMockSetupForIComprehensiveInterface [global::System.Runtime.CompilerServices.OverloadResolutionPriority(0)] global::Mockolate.Setup.IndexerSetup this[int parameter1, int parameter2, int parameter3, int parameter4, int parameter5] { get; } + /// + /// Setup for the string indexer this[double] + /// + /// + /// This overload takes It argument matchers (e.g. It.IsAny<T>(), It.Is<T>(value)) for every parameter. + /// + [global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue)] + global::Mockolate.Setup.IIndexerGetterOnlySetup this[global::Mockolate.Parameters.IParameter? parameter1] { get; } + + /// + /// Setup for the string indexer this[double] + /// + /// + /// This overload accepts direct values for every parameter; each is treated as It.Is<T>(value). + /// + [global::System.Runtime.CompilerServices.OverloadResolutionPriority(0)] + global::Mockolate.Setup.IIndexerGetterOnlySetup this[double parameter1] { get; } + + /// + /// Setup for the string indexer this[char] + /// + /// + /// This overload takes It argument matchers (e.g. It.IsAny<T>(), It.Is<T>(value)) for every parameter. + /// + [global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue)] + global::Mockolate.Setup.IIndexerSetterOnlySetup this[global::Mockolate.Parameters.IParameter? parameter1] { get; } + + /// + /// Setup for the string indexer this[char] + /// + /// + /// This overload accepts direct values for every parameter; each is treated as It.Is<T>(value). + /// + [global::System.Runtime.CompilerServices.OverloadResolutionPriority(0)] + global::Mockolate.Setup.IIndexerSetterOnlySetup this[char parameter1] { get; } + /// /// Setup for the method WithModifiers(ref int, out string, in long, int[]) with the given . /// @@ -5363,6 +5680,42 @@ internal interface IMockVerifyForIComprehensiveInterface [global::System.Runtime.CompilerServices.OverloadResolutionPriority(0)] global::Mockolate.Verify.VerificationIndexerResult this[int a, int b, int c, int d, int e] { get; } + /// + /// Verify interactions with the string indexer this[double]. + /// + /// + /// This overload takes It argument matchers (e.g. It.IsAny<T>(), It.Is<T>(value)) for every parameter. + /// + [global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue)] + global::Mockolate.Verify.VerificationIndexerGetterResult this[global::Mockolate.Parameters.IParameter? key] { get; } + + /// + /// Verify interactions with the string indexer this[double]. + /// + /// + /// This overload accepts direct values for every parameter and returns a VerificationResult<TVerify>.IgnoreParameters whose VerificationResult<TVerify>.AnyParameters() drops per-parameter matching entirely. + /// + [global::System.Runtime.CompilerServices.OverloadResolutionPriority(0)] + global::Mockolate.Verify.VerificationIndexerGetterResult this[double key] { get; } + + /// + /// Verify interactions with the string indexer this[char]. + /// + /// + /// This overload takes It argument matchers (e.g. It.IsAny<T>(), It.Is<T>(value)) for every parameter. + /// + [global::System.Runtime.CompilerServices.OverloadResolutionPriority(int.MaxValue)] + global::Mockolate.Verify.VerificationIndexerSetterResult this[global::Mockolate.Parameters.IParameter? key] { get; } + + /// + /// Verify interactions with the string indexer this[char]. + /// + /// + /// This overload accepts direct values for every parameter and returns a VerificationResult<TVerify>.IgnoreParameters whose VerificationResult<TVerify>.AnyParameters() drops per-parameter matching entirely. + /// + [global::System.Runtime.CompilerServices.OverloadResolutionPriority(0)] + global::Mockolate.Verify.VerificationIndexerSetterResult this[char key] { get; } + /// /// Verify invocations for the method WithModifiers(ref int, out string, in long, int[]) with the given . /// diff --git a/Tests/Mockolate.Tests/GeneratorCoverage/IComprehensiveInterface.cs b/Tests/Mockolate.Tests/GeneratorCoverage/IComprehensiveInterface.cs index 2c27058c..113b9076 100644 --- a/Tests/Mockolate.Tests/GeneratorCoverage/IComprehensiveInterface.cs +++ b/Tests/Mockolate.Tests/GeneratorCoverage/IComprehensiveInterface.cs @@ -6,7 +6,7 @@ namespace Mockolate.Tests.GeneratorCoverage; /// /// Squeezes every interface-shaped generator branch we can fit into a single type: -/// property accessor combinations, indexers (single + arity-5), all three event flavors, +/// property accessor combinations, indexers (single + arity-5, get-only + set-only), all three event flavors, /// static abstract members, every parameter modifier, every default-value kind, /// every "reserved" parameter name, nullable annotations, async returns, special return /// shapes (Span/ReadOnlySpan/ref/ref-readonly/tuple/Nullable<T>), @@ -23,6 +23,8 @@ public interface IComprehensiveInterface string this[int i] { get; set; } string this[int a, int b, int c, int d, int e] { get; set; } + string this[double key] { get; } + string this[char key] { set; } static abstract int StaticAbstractValue { get; } diff --git a/Tests/Mockolate.Tests/MockIndexers/SetupIndexerTests.AccessorRestrictedTests.cs b/Tests/Mockolate.Tests/MockIndexers/SetupIndexerTests.AccessorRestrictedTests.cs new file mode 100644 index 00000000..e72d6559 --- /dev/null +++ b/Tests/Mockolate.Tests/MockIndexers/SetupIndexerTests.AccessorRestrictedTests.cs @@ -0,0 +1,400 @@ +using System.Collections.Generic; +using Mockolate.Setup; + +namespace Mockolate.Tests.MockIndexers; + +public sealed partial class SetupIndexerTests +{ + public sealed class AccessorRestrictedTests + { + [Fact] + public async Task SetOnlyIndexer_OnSet_ShouldFireAndRecordTheWrite() + { + IAccessorService sut = IAccessorService.CreateMock(); + List written = new(); + sut.Mock.Setup[It.IsAny()].OnSet.Do(value => written.Add(value)); + + sut["name"] = "Ada"; + + await That(written).IsEqualTo(["Ada",]); + await That(sut.Mock.Verify[It.Is("name")].Set("Ada")).Once() + .Because("the setter facade must be keyed on the setter member id, not the getter's"); + } + + [Fact] + public async Task SetOnlyIndexer_VerifyOtherValue_ShouldNotMatch() + { + IAccessorService sut = IAccessorService.CreateMock(); + + sut["name"] = "Ada"; + + await That(sut.Mock.Verify[It.Is("name")].Set("Grace")).Never(); + } + + [Fact] + public async Task SetOnlyIndexer_VerifyWithParameterMatcher_ShouldMatch() + { + IAccessorService sut = IAccessorService.CreateMock(); + + sut["name"] = "Ada"; + + await That(sut.Mock.Verify[It.IsAny()].Set(It.IsAny())).Once(); + } + + [Theory] + [InlineData(false, 1)] + [InlineData(true, 0)] + public async Task SetOnlyClassIndexer_ShouldSkipCallingBaseWhenRequested(bool skipBaseClass, + int expectedCallCount) + { + AccessorService sut = AccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()].SkippingBaseClass(skipBaseClass); + + sut[4] = 1; + + await That(sut.SetterCallCount).IsEqualTo(expectedCallCount); + } + + [Fact] + public async Task GetOnlyIndexer_ChainedReturns_ShouldStayOnGetterOnlySurface() + { + IAccessorService sut = IAccessorService.CreateMock(); + IIndexerGetterOnlySetup chained = sut.Mock.Setup[It.IsAny()] + .Returns(1).OnlyOnce(); + chained.Returns(() => 2); + + await That(sut[1]).IsEqualTo(1); + await That(sut[1]).IsEqualTo(2); + } + + [Fact] + public async Task GetOnlyIndexer_ReturnsForever_ShouldUseTheLastValueForever() + { + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .Returns(2) + .Returns(4).Forever(); + + int[] result = new int[4]; + for (int i = 0; i < 4; i++) + { + result[i] = sut[i]; + } + + await That(result).IsEqualTo([2, 4, 4, 4,]); + } + + [Fact] + public async Task GetOnlyIndexer_ReturnsWhen_ShouldOnlyUseValueWhenPredicateIsTrue() + { + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .Returns(() => 4).When(i => i > 0); + + int result1 = sut[1]; + int result2 = sut[1]; + + await That(result1).IsEqualTo(0); + await That(result2).IsEqualTo(4); + } + + [Fact] + public async Task GetOnlyIndexer_ReturnsCallbackWithValue_ShouldReturnExpectedValue() + { + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .InitializeWith(3) + .Returns((_, v) => 4 * v); + + int result = sut[7]; + + await That(result).IsEqualTo(12); + } + + [Fact] + public async Task GetOnlyIndexer_InitializeWithGenerator_ShouldSeedTheReadValue() + { + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .InitializeWith(key => 10 * key); + + await That(sut[3]).IsEqualTo(30); + await That(sut[5]).IsEqualTo(50); + } + + [Fact] + public async Task GetOnlyIndexer_Throws_ShouldIterateThroughAllRegisteredExceptions() + { + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .Throws() + .Throws(new Exception("foo")) + .Throws(() => new Exception("bar")) + .Throws(k => new Exception($"baz-{k}")) + .Throws((k, v) => new Exception($"qux-{k}-{v}")); + + void Act() => _ = sut[6]; + + await That(Act).Throws(); + Exception? result2 = Record.Exception(Act); + Exception? result3 = Record.Exception(Act); + Exception? result4 = Record.Exception(Act); + Exception? result5 = Record.Exception(Act); + await That(result2).HasMessage("foo"); + await That(result3).HasMessage("bar"); + await That(result4).HasMessage("baz-6"); + await That(result5).HasMessage("qux-6-0"); + } + + [Fact] + public async Task GetOnlyIndexer_OnGetChain_ShouldStayOnGetterOnlySurface() + { + int callCount1 = 0; + int callCount2 = 0; + IAccessorService sut = IAccessorService.CreateMock(); + IIndexerGetterOnlySetup chained = sut.Mock.Setup[It.IsAny()] + .OnGet.Do(() => { callCount1++; }) + .OnGet.Do(k => { callCount2++; }).OnlyOnce(); + chained.Returns(9); + + int result = sut[1]; + _ = sut[2]; + _ = sut[3]; + _ = sut[4]; + + await That(result).IsEqualTo(9); + await That(callCount1).IsEqualTo(3); + await That(callCount2).IsEqualTo(1); + } + + [Fact] + public async Task GetOnlyIndexer_OnGetWhen_ShouldOnlyInvokeCallbackWhenPredicateIsTrue() + { + int callCount = 0; + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .OnGet.Do(() => { callCount++; }).When(i => i > 0); + + _ = sut[1]; + _ = sut[1]; + _ = sut[1]; + + await That(callCount).IsEqualTo(2); + } + + [Fact] + public async Task GetOnlyIndexer_OnGetInParallel_ShouldInvokeParallelCallbacksAlways() + { + int callCount1 = 0; + int callCount2 = 0; + int callCount3 = 0; + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .OnGet.Do(() => { callCount1++; }) + .OnGet.Do(k => { callCount2++; }).InParallel() + .OnGet.Do((k, v) => { callCount3++; }); + + _ = sut[1]; + _ = sut[2]; + _ = sut[3]; + _ = sut[4]; + + await That(callCount1).IsEqualTo(2); + await That(callCount2).IsEqualTo(4); + await That(callCount3).IsEqualTo(2); + } + + [Fact] + public async Task GetOnlyIndexer_OnGetFor_ShouldRepeatCallbackTheGivenNumberOfTimes() + { + int callCount1 = 0; + int callCount2 = 0; + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .OnGet.Do(() => { callCount1++; }).For(2) + .OnGet.Do(() => { callCount2++; }); + + for (int i = 0; i < 6; i++) + { + _ = sut[1]; + } + + await That(callCount1).IsEqualTo(4); + await That(callCount2).IsEqualTo(2); + } + + [Fact] + public async Task GetOnlyIndexer_OnGetTransitionTo_ShouldSwitchScenario() + { + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.InScenario("a").Setup[It.IsAny()] + .OnGet.Do(() => { }) + .OnGet.TransitionTo("b"); + sut.Mock.TransitionTo("a"); + + _ = sut[1]; + + await That(((IMock)sut).MockRegistry.Scenario).IsEqualTo("b"); + } + + [Fact] + public async Task SetOnlyIndexer_OnSetChain_ShouldStayOnSetterOnlySurface() + { + int callCount1 = 0; + int callCount2 = 0; + IAccessorService sut = IAccessorService.CreateMock(); + IIndexerSetterOnlySetup chained = sut.Mock.Setup[It.IsAny()] + .OnSet.Do(() => { callCount1++; }) + .OnSet.Do(v => { callCount2++; }).OnlyOnce(); + chained.SkippingBaseClass(); + + sut["k"] = "a"; + sut["k"] = "b"; + sut["k"] = "c"; + sut["k"] = "d"; + + await That(callCount1).IsEqualTo(3); + await That(callCount2).IsEqualTo(1); + } + + [Fact] + public async Task SetOnlyIndexer_OnSetWhen_ShouldOnlyInvokeCallbackWhenPredicateIsTrue() + { + int callCount = 0; + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .OnSet.Do(() => { callCount++; }).When(i => i > 0); + + sut["k"] = "a"; + sut["k"] = "b"; + sut["k"] = "c"; + + await That(callCount).IsEqualTo(2); + } + + [Fact] + public async Task SetOnlyIndexer_OnSetInParallel_ShouldInvokeParallelCallbacksAlways() + { + int callCount1 = 0; + int callCount2 = 0; + int callCount3 = 0; + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .OnSet.Do(() => { callCount1++; }) + .OnSet.Do((k, v) => { callCount2++; }).InParallel() + .OnSet.Do(() => { callCount3++; }); + + sut["k"] = "a"; + sut["k"] = "b"; + sut["k"] = "c"; + sut["k"] = "d"; + + await That(callCount1).IsEqualTo(2); + await That(callCount2).IsEqualTo(4); + await That(callCount3).IsEqualTo(2); + } + + [Fact] + public async Task SetOnlyIndexer_OnSetFor_ShouldRepeatCallbackTheGivenNumberOfTimes() + { + int callCount1 = 0; + int callCount2 = 0; + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny()] + .OnSet.Do(() => { callCount1++; }).For(2) + .OnSet.Do(() => { callCount2++; }); + + for (int i = 0; i < 6; i++) + { + sut["k"] = "a"; + } + + await That(callCount1).IsEqualTo(4); + await That(callCount2).IsEqualTo(2); + } + + [Fact] + public async Task SetOnlyIndexer_OnSetTransitionTo_ShouldSwitchScenario() + { + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.InScenario("a").Setup[It.IsAny()] + .OnSet.Do(() => { }) + .OnSet.TransitionTo("b"); + sut.Mock.TransitionTo("a"); + + sut["k"] = "x"; + + await That(((IMock)sut).MockRegistry.Scenario).IsEqualTo("b"); + } + + [Fact] + public async Task GetOnlyIndexer_Got_ShouldMatchOnlyMatchingKeys() + { + IAccessorService sut = IAccessorService.CreateMock(); + + _ = sut[1]; + + await That(sut.Mock.Verify[It.Is(1)].Got()).Once(); + await That(sut.Mock.Verify[It.Is(2)].Got()).Never(); + } + + [Fact] + public async Task GetOnlyTwoKeyIndexer_ReturnsAndGot_ShouldUseTheNarrowedSurface() + { + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny(), It.IsAny()] + .Returns((k1, k2) => k1 + k2); + + int result = sut[20, 22]; + + await That(result).IsEqualTo(42); + await That(sut.Mock.Verify[It.Is(20), It.Is(22)].Got()).Once(); + await That(sut.Mock.Verify[It.Is(20), It.Is(23)].Got()).Never(); + } + + [Fact] + public async Task SetOnlyTwoKeyIndexer_OnSetAndVerify_ShouldUseTheNarrowedSurface() + { + List written = new(); + IAccessorService sut = IAccessorService.CreateMock(); + sut.Mock.Setup[It.IsAny(), It.IsAny()] + .OnSet.Do((k1, k2, v) => written.Add($"{k1}-{k2}-{v}")); + + sut["a", "b"] = "c"; + + await That(written).IsEqualTo(["a-b-c",]); + await That(sut.Mock.Verify[It.Is("a"), It.Is("b")].Set("c")).Once(); + await That(sut.Mock.Verify[It.Is("a"), It.Is("b")].Set("d")).Never(); + } + + [Fact] + public async Task SetOnlyFourKeyIndexer_Set_ShouldVerifyTheWrite() + { + IAccessorService sut = IAccessorService.CreateMock(); + + sut[1, 2, 3, 4] = "x"; + + await That(sut.Mock.Verify[It.Is(1), It.Is(2), It.Is(3), It.Is(4)].Set("x")).Once(); + await That(sut.Mock.Verify[It.Is(1), It.Is(2), It.Is(3), It.Is(5)].Set(It.IsAny())).Never(); + } + + public interface IAccessorService + { + int this[int key] { get; } + string this[string key] { set; } + int this[int key1, int key2] { get; } + string this[string key1, string key2] { set; } + string this[int key1, int key2, int key3, int key4] { set; } + } + + public class AccessorService + { + public int SetterCallCount { get; private set; } + + public virtual int this[int key] + { + set => SetterCallCount += value; + } + } + } +}