Interface_With_Async_Methods.verified.txt

// <auto-generated/>
#pragma warning disable
#nullable enable

public sealed class IAsyncServiceMock : global::TUnit.Mocks.Mock<global::IAsyncService>, global::IAsyncService
{
    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
    internal IAsyncServiceMock(global::IAsyncService mockObject, global::TUnit.Mocks.MockEngine<global::IAsyncService> engine)
        : base(mockObject, engine) { }

    global::System.Threading.Tasks.Task<string> global::IAsyncService.GetValueAsync(string key) => Object.GetValueAsync(key);

    global::System.Threading.Tasks.Task global::IAsyncService.DoWorkAsync() => Object.DoWorkAsync();

    global::System.Threading.Tasks.ValueTask<int> global::IAsyncService.ComputeAsync(int input) => Object.ComputeAsync(input);

    global::System.Threading.Tasks.ValueTask global::IAsyncService.InitializeAsync(global::System.Threading.CancellationToken ct) => Object.InitializeAsync(ct);
}


// ===== FILE SEPARATOR =====

// <auto-generated/>
#pragma warning disable
#nullable enable

file sealed class IAsyncServiceMockImpl : global::IAsyncService, global::TUnit.Mocks.IRaisable, global::TUnit.Mocks.IMockObject
{
    private readonly global::TUnit.Mocks.MockEngine<global::IAsyncService> _engine;

    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
    global::TUnit.Mocks.IMock? global::TUnit.Mocks.IMockObject.MockWrapper { get; set; }

    internal IAsyncServiceMockImpl(global::TUnit.Mocks.MockEngine<global::IAsyncService> engine)
    {
        _engine = engine;
    }

    public global::System.Threading.Tasks.Task<string> GetValueAsync(string key)
    {
        try
        {
            var __result = _engine.HandleCallWithReturn<string, string>(0, "GetValueAsync", key, "");
            if (global::TUnit.Mocks.Setup.RawReturnContext.TryConsume(out var __rawAsync))
            {
                if (__rawAsync is global::System.Threading.Tasks.Task<string> __typedAsync) return __typedAsync;
                throw new global::System.InvalidOperationException($"ReturnsAsync: expected global::System.Threading.Tasks.Task<string> but got {__rawAsync?.GetType().Name ?? "null"}");
            }
            return global::System.Threading.Tasks.Task.FromResult<string>(__result);
        }
        catch (global::System.Exception __ex)
        {
            return global::System.Threading.Tasks.Task.FromException<string>(__ex);
        }
    }

    public global::System.Threading.Tasks.Task DoWorkAsync()
    {
        try
        {
            _engine.HandleCall(1, "DoWorkAsync", global::System.Array.Empty<object?>());
            if (global::TUnit.Mocks.Setup.RawReturnContext.TryConsume(out var __rawAsync))
            {
                if (__rawAsync is global::System.Threading.Tasks.Task __typedAsync) return __typedAsync;
                throw new global::System.InvalidOperationException($"ReturnsAsync: expected global::System.Threading.Tasks.Task but got {__rawAsync?.GetType().Name ?? "null"}");
            }
            return global::System.Threading.Tasks.Task.CompletedTask;
        }
        catch (global::System.Exception __ex)
        {
            return global::System.Threading.Tasks.Task.FromException(__ex);
        }
    }

    public global::System.Threading.Tasks.ValueTask<int> ComputeAsync(int input)
    {
        try
        {
            var __result = _engine.HandleCallWithReturn<int, int>(2, "ComputeAsync", input, default);
            if (global::TUnit.Mocks.Setup.RawReturnContext.TryConsume(out var __rawAsync))
            {
                if (__rawAsync is global::System.Threading.Tasks.ValueTask<int> __typedAsync) return __typedAsync;
                throw new global::System.InvalidOperationException($"ReturnsAsync: expected global::System.Threading.Tasks.ValueTask<int> but got {__rawAsync?.GetType().Name ?? "null"}");
            }
            return new global::System.Threading.Tasks.ValueTask<int>(__result);
        }
        catch (global::System.Exception __ex)
        {
            return new global::System.Threading.Tasks.ValueTask<int>(global::System.Threading.Tasks.Task.FromException<int>(__ex));
        }
    }

    public global::System.Threading.Tasks.ValueTask InitializeAsync(global::System.Threading.CancellationToken ct)
    {
        try
        {
            _engine.HandleCall<global::System.Threading.CancellationToken>(3, "InitializeAsync", ct);
            if (global::TUnit.Mocks.Setup.RawReturnContext.TryConsume(out var __rawAsync))
            {
                if (__rawAsync is global::System.Threading.Tasks.ValueTask __typedAsync) return __typedAsync;
                throw new global::System.InvalidOperationException($"ReturnsAsync: expected global::System.Threading.Tasks.ValueTask but got {__rawAsync?.GetType().Name ?? "null"}");
            }
            return default(global::System.Threading.Tasks.ValueTask);
        }
        catch (global::System.Exception __ex)
        {
            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(__ex));
        }
    }

    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
    public void RaiseEvent(string eventName, object? args)
    {
        throw new global::System.InvalidOperationException($"No event named '{eventName}' exists on this mock.");
    }
}

internal static class IAsyncServiceMockFactory
{
    [global::System.Runtime.CompilerServices.ModuleInitializer]
    internal static void Register()
    {
        global::TUnit.Mocks.MockRegistry.RegisterFactory<global::IAsyncService>(Create);
    }

    internal static global::TUnit.Mocks.Mock<global::IAsyncService> CreateAutoMock(global::TUnit.Mocks.MockBehavior behavior)
    {
        var engine = new global::TUnit.Mocks.MockEngine<global::IAsyncService>(behavior);
        var impl = new IAsyncServiceMockImpl(engine);
        engine.Raisable = impl;
        var mock = new IAsyncServiceMock(impl, engine);
        return mock;
    }

    internal static global::TUnit.Mocks.Mock<global::IAsyncService> Create(global::TUnit.Mocks.MockBehavior behavior, object[] constructorArgs)
    {
        if (constructorArgs.Length > 0) throw new global::System.ArgumentException($"Interface mock 'global::IAsyncService' does not support constructor arguments, but {constructorArgs.Length} were provided.");
        var engine = new global::TUnit.Mocks.MockEngine<global::IAsyncService>(behavior);
        var impl = new IAsyncServiceMockImpl(engine);
        engine.Raisable = impl;
        var mock = new IAsyncServiceMock(impl, engine);
        return mock;
    }
}


// ===== FILE SEPARATOR =====

// <auto-generated/>
#pragma warning disable
#nullable enable

public static class IAsyncService_MockMemberExtensions
{
    public static IAsyncService_GetValueAsync_M0_MockCall GetValueAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::TUnit.Mocks.Arguments.Arg<string> key)
    {
        var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { key.Matcher };
        return new IAsyncService_GetValueAsync_M0_MockCall(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 0, "GetValueAsync", matchers);
    }

    public static IAsyncService_GetValueAsync_M0_MockCall GetValueAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::System.Func<string, bool> key)
    {
        global::TUnit.Mocks.Arguments.Arg<string> __fa_key = key;
        var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { __fa_key.Matcher };
        return new IAsyncService_GetValueAsync_M0_MockCall(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 0, "GetValueAsync", matchers);
    }

    public static IAsyncService_DoWorkAsync_M1_MockCall DoWorkAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock)
    {
        var matchers = global::System.Array.Empty<global::TUnit.Mocks.Arguments.IArgumentMatcher>();
        return new IAsyncService_DoWorkAsync_M1_MockCall(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 1, "DoWorkAsync", matchers);
    }

    public static IAsyncService_ComputeAsync_M2_MockCall ComputeAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::TUnit.Mocks.Arguments.Arg<int> input)
    {
        var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { input.Matcher };
        return new IAsyncService_ComputeAsync_M2_MockCall(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 2, "ComputeAsync", matchers);
    }

    public static IAsyncService_ComputeAsync_M2_MockCall ComputeAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::System.Func<int, bool> input)
    {
        global::TUnit.Mocks.Arguments.Arg<int> __fa_input = input;
        var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { __fa_input.Matcher };
        return new IAsyncService_ComputeAsync_M2_MockCall(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 2, "ComputeAsync", matchers);
    }

    public static IAsyncService_InitializeAsync_M3_MockCall InitializeAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::TUnit.Mocks.Arguments.Arg<global::System.Threading.CancellationToken> ct)
    {
        var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { ct.Matcher };
        return new IAsyncService_InitializeAsync_M3_MockCall(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 3, "InitializeAsync", matchers);
    }

    public static IAsyncService_InitializeAsync_M3_MockCall InitializeAsync(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, global::System.Func<global::System.Threading.CancellationToken, bool> ct)
    {
        global::TUnit.Mocks.Arguments.Arg<global::System.Threading.CancellationToken> __fa_ct = ct;
        var matchers = new global::TUnit.Mocks.Arguments.IArgumentMatcher[] { __fa_ct.Matcher };
        return new IAsyncService_InitializeAsync_M3_MockCall(global::TUnit.Mocks.MockRegistry.GetEngine(mock), 3, "InitializeAsync", matchers);
    }

    #if NET9_0_OR_GREATER
    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
    public static void Reset(this global::TUnit.Mocks.Mock<global::IAsyncService> mock)
        => global::TUnit.Mocks.Mock.Reset(mock);

    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
    public static void VerifyAll(this global::TUnit.Mocks.Mock<global::IAsyncService> mock)
        => global::TUnit.Mocks.Mock.VerifyAll(mock);

    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
    public static void VerifyNoOtherCalls(this global::TUnit.Mocks.Mock<global::IAsyncService> mock)
        => global::TUnit.Mocks.Mock.VerifyNoOtherCalls(mock);

    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
    public static void SetupAllProperties(this global::TUnit.Mocks.Mock<global::IAsyncService> mock)
        => global::TUnit.Mocks.Mock.SetupAllProperties(mock);

    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
    public static global::TUnit.Mocks.Diagnostics.MockDiagnostics GetDiagnostics(this global::TUnit.Mocks.Mock<global::IAsyncService> mock)
        => global::TUnit.Mocks.Mock.GetDiagnostics(mock);

    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
    public static void SetState(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, string? stateName)
        => global::TUnit.Mocks.Mock.SetState(mock, stateName);

    [global::System.Runtime.CompilerServices.OverloadResolutionPriority(-1)]
    public static void InState(this global::TUnit.Mocks.Mock<global::IAsyncService> mock, string stateName, global::System.Action<global::TUnit.Mocks.Mock<global::IAsyncService>> configure)
        => global::TUnit.Mocks.Mock.InState(mock, stateName, configure);

    extension(global::TUnit.Mocks.Mock<global::IAsyncService> mock)
    {
        public global::System.Collections.Generic.IReadOnlyList<global::TUnit.Mocks.Verification.CallRecord> Invocations => global::TUnit.Mocks.Mock.Invocations(mock);

        public global::TUnit.Mocks.MockBehavior Behavior => global::TUnit.Mocks.Mock.Behavior(mock);

        public global::TUnit.Mocks.IDefaultValueProvider? DefaultValueProvider
        {
            get => global::TUnit.Mocks.Mock.GetDefaultValueProvider(mock);
            set => global::TUnit.Mocks.Mock.SetDefaultValueProvider(mock, value);
        }
    }
    #endif
}

[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
public sealed class IAsyncService_GetValueAsync_M0_MockCall : global::TUnit.Mocks.Verification.ICallVerification
{
    private readonly global::TUnit.Mocks.IMockEngineAccess _engine;
    private readonly int _memberId;
    private readonly string _memberName;
    private readonly global::TUnit.Mocks.Arguments.IArgumentMatcher[] _matchers;
    private global::TUnit.Mocks.Setup.MethodSetupBuilder<string>? _builder;

    internal IAsyncService_GetValueAsync_M0_MockCall(global::TUnit.Mocks.IMockEngineAccess engine, int memberId, string memberName, global::TUnit.Mocks.Arguments.IArgumentMatcher[] matchers)
    {
        _engine = engine;
        _memberId = memberId;
        _memberName = memberName;
        _matchers = matchers;
    }

    private global::TUnit.Mocks.Setup.MethodSetupBuilder<string> EnsureSetup()
    {
        var existing = global::System.Threading.Volatile.Read(ref _builder);
        if (existing is not null) return existing;
        return EnsureSetupSlow();
    }

    [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
    private global::TUnit.Mocks.Setup.MethodSetupBuilder<string> EnsureSetupSlow()
    {
        var setup = new global::TUnit.Mocks.Setup.MethodSetup(_memberId, _matchers, _memberName);
        var fresh = new global::TUnit.Mocks.Setup.MethodSetupBuilder<string>(setup);
        var prev = global::System.Threading.Interlocked.CompareExchange(ref _builder, fresh, null);
        if (prev is not null) return prev;
        // AddSetup runs only on the CAS winner. Setup is sequential in practice,
        // so a concurrent loser observing the builder before registration is benign.
        _engine.AddSetup(setup);
        return fresh;
    }

    /// <inheritdoc />
    public IAsyncService_GetValueAsync_M0_MockCall Returns(string value) { EnsureSetup().Returns(value); return this; }
    /// <inheritdoc />
    public IAsyncService_GetValueAsync_M0_MockCall Returns(global::System.Func<string> factory) { EnsureSetup().Returns(factory); return this; }
    /// <inheritdoc />
    public IAsyncService_GetValueAsync_M0_MockCall ReturnsSequentially(params string[] values) { EnsureSetup().ReturnsSequentially(values); return this; }
    /// <inheritdoc />
    public IAsyncService_GetValueAsync_M0_MockCall Throws<TException>() where TException : global::System.Exception, new() { EnsureSetup().Throws<TException>(); return this; }
    /// <inheritdoc />
    public IAsyncService_GetValueAsync_M0_MockCall Throws(global::System.Exception exception) { EnsureSetup().Throws(exception); return this; }
    /// <inheritdoc />
    public IAsyncService_GetValueAsync_M0_MockCall Callback(global::System.Action callback) { EnsureSetup().Callback(callback); return this; }
    /// <inheritdoc />
    public IAsyncService_GetValueAsync_M0_MockCall TransitionsTo(string stateName) { EnsureSetup().TransitionsTo(stateName); return this; }
    /// <inheritdoc />
    public IAsyncService_GetValueAsync_M0_MockCall Then() { EnsureSetup().Then(); return this; }

    /// <summary>Return a pre-built Task directly (e.g., from a TaskCompletionSource).</summary>
    public IAsyncService_GetValueAsync_M0_MockCall ReturnsAsync(global::System.Threading.Tasks.Task<string> task) { EnsureSetup().ReturnsRaw(task); return this; }
    /// <summary>Return a pre-built Task from a factory, invoked on each call.</summary>
    public IAsyncService_GetValueAsync_M0_MockCall ReturnsAsync(global::System.Func<global::System.Threading.Tasks.Task<string>> taskFactory) { EnsureSetup().ReturnsRaw(() => (object?)taskFactory()); return this; }

    /// <summary>Configure a typed computed return value using the actual method parameters.</summary>
    public IAsyncService_GetValueAsync_M0_MockCall Returns(global::System.Func<string, string> factory)
    {
        EnsureSetup().Returns(args => factory((string)args[0]!));
        return this;
    }

    /// <summary>Configure a typed computed async return value using the actual method parameters.</summary>
    public IAsyncService_GetValueAsync_M0_MockCall ReturnsAsync(global::System.Func<string, global::System.Threading.Tasks.Task<string>> factory)
    {
        EnsureSetup().ReturnsRaw(args => (object?)factory((string)args[0]!));
        return this;
    }

    /// <summary>Execute a typed callback using the actual method parameters.</summary>
    public IAsyncService_GetValueAsync_M0_MockCall Callback(global::System.Action<string> callback)
    {
        EnsureSetup().Callback(callback);
        return this;
    }

    /// <summary>Configure a typed computed exception using the actual method parameters.</summary>
    public IAsyncService_GetValueAsync_M0_MockCall Throws(global::System.Func<string, global::System.Exception> exceptionFactory)
    {
        EnsureSetup().Throws(args => exceptionFactory((string)args[0]!));
        return this;
    }

    // ICallVerification
    /// <inheritdoc />
    public void WasCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled();
    /// <inheritdoc />
    public void WasCalled(global::TUnit.Mocks.Times times) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times);
    /// <inheritdoc />
    public void WasCalled(global::TUnit.Mocks.Times times, string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times, message);
    /// <inheritdoc />
    public void WasCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(message);
    /// <inheritdoc />
    public void WasNeverCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled();
    /// <inheritdoc />
    public void WasNeverCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled(message);
}

[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
public sealed class IAsyncService_DoWorkAsync_M1_MockCall : global::TUnit.Mocks.Verification.ICallVerification
{
    private readonly global::TUnit.Mocks.IMockEngineAccess _engine;
    private readonly int _memberId;
    private readonly string _memberName;
    private readonly global::TUnit.Mocks.Arguments.IArgumentMatcher[] _matchers;
    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder? _builder;

    internal IAsyncService_DoWorkAsync_M1_MockCall(global::TUnit.Mocks.IMockEngineAccess engine, int memberId, string memberName, global::TUnit.Mocks.Arguments.IArgumentMatcher[] matchers)
    {
        _engine = engine;
        _memberId = memberId;
        _memberName = memberName;
        _matchers = matchers;
        _ = EnsureSetup();
    }

    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder EnsureSetup()
    {
        var existing = global::System.Threading.Volatile.Read(ref _builder);
        if (existing is not null) return existing;
        return EnsureSetupSlow();
    }

    [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder EnsureSetupSlow()
    {
        var setup = new global::TUnit.Mocks.Setup.MethodSetup(_memberId, _matchers, _memberName);
        var fresh = new global::TUnit.Mocks.Setup.VoidMethodSetupBuilder(setup);
        var prev = global::System.Threading.Interlocked.CompareExchange(ref _builder, fresh, null);
        if (prev is not null) return prev;
        // AddSetup runs only on the CAS winner. Setup is sequential in practice,
        // so a concurrent loser observing the builder before registration is benign.
        _engine.AddSetup(setup);
        return fresh;
    }

    /// <inheritdoc />
    public IAsyncService_DoWorkAsync_M1_MockCall Returns() { EnsureSetup().Returns(); return this; }
    /// <inheritdoc />
    public IAsyncService_DoWorkAsync_M1_MockCall Throws<TException>() where TException : global::System.Exception, new() { EnsureSetup().Throws<TException>(); return this; }
    /// <inheritdoc />
    public IAsyncService_DoWorkAsync_M1_MockCall Throws(global::System.Exception exception) { EnsureSetup().Throws(exception); return this; }
    /// <inheritdoc />
    public IAsyncService_DoWorkAsync_M1_MockCall Callback(global::System.Action callback) { EnsureSetup().Callback(callback); return this; }
    /// <inheritdoc />
    public IAsyncService_DoWorkAsync_M1_MockCall TransitionsTo(string stateName) { EnsureSetup().TransitionsTo(stateName); return this; }
    /// <inheritdoc />
    public IAsyncService_DoWorkAsync_M1_MockCall Then() { EnsureSetup().Then(); return this; }

    /// <summary>Return a pre-built Task directly (e.g., from a TaskCompletionSource).</summary>
    public IAsyncService_DoWorkAsync_M1_MockCall ReturnsAsync(global::System.Threading.Tasks.Task task) { EnsureSetup().ReturnsRaw(task); return this; }
    /// <summary>Return a pre-built Task from a factory, invoked on each call.</summary>
    public IAsyncService_DoWorkAsync_M1_MockCall ReturnsAsync(global::System.Func<global::System.Threading.Tasks.Task> taskFactory) { EnsureSetup().ReturnsRaw(() => (object?)taskFactory()); return this; }

    // ICallVerification
    /// <inheritdoc />
    public void WasCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled();
    /// <inheritdoc />
    public void WasCalled(global::TUnit.Mocks.Times times) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times);
    /// <inheritdoc />
    public void WasCalled(global::TUnit.Mocks.Times times, string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times, message);
    /// <inheritdoc />
    public void WasCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(message);
    /// <inheritdoc />
    public void WasNeverCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled();
    /// <inheritdoc />
    public void WasNeverCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled(message);
}

[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
public sealed class IAsyncService_ComputeAsync_M2_MockCall : global::TUnit.Mocks.Verification.ICallVerification
{
    private readonly global::TUnit.Mocks.IMockEngineAccess _engine;
    private readonly int _memberId;
    private readonly string _memberName;
    private readonly global::TUnit.Mocks.Arguments.IArgumentMatcher[] _matchers;
    private global::TUnit.Mocks.Setup.MethodSetupBuilder<int>? _builder;

    internal IAsyncService_ComputeAsync_M2_MockCall(global::TUnit.Mocks.IMockEngineAccess engine, int memberId, string memberName, global::TUnit.Mocks.Arguments.IArgumentMatcher[] matchers)
    {
        _engine = engine;
        _memberId = memberId;
        _memberName = memberName;
        _matchers = matchers;
    }

    private global::TUnit.Mocks.Setup.MethodSetupBuilder<int> EnsureSetup()
    {
        var existing = global::System.Threading.Volatile.Read(ref _builder);
        if (existing is not null) return existing;
        return EnsureSetupSlow();
    }

    [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
    private global::TUnit.Mocks.Setup.MethodSetupBuilder<int> EnsureSetupSlow()
    {
        var setup = new global::TUnit.Mocks.Setup.MethodSetup(_memberId, _matchers, _memberName);
        var fresh = new global::TUnit.Mocks.Setup.MethodSetupBuilder<int>(setup);
        var prev = global::System.Threading.Interlocked.CompareExchange(ref _builder, fresh, null);
        if (prev is not null) return prev;
        // AddSetup runs only on the CAS winner. Setup is sequential in practice,
        // so a concurrent loser observing the builder before registration is benign.
        _engine.AddSetup(setup);
        return fresh;
    }

    /// <inheritdoc />
    public IAsyncService_ComputeAsync_M2_MockCall Returns(int value) { EnsureSetup().Returns(value); return this; }
    /// <inheritdoc />
    public IAsyncService_ComputeAsync_M2_MockCall Returns(global::System.Func<int> factory) { EnsureSetup().Returns(factory); return this; }
    /// <inheritdoc />
    public IAsyncService_ComputeAsync_M2_MockCall ReturnsSequentially(params int[] values) { EnsureSetup().ReturnsSequentially(values); return this; }
    /// <inheritdoc />
    public IAsyncService_ComputeAsync_M2_MockCall Throws<TException>() where TException : global::System.Exception, new() { EnsureSetup().Throws<TException>(); return this; }
    /// <inheritdoc />
    public IAsyncService_ComputeAsync_M2_MockCall Throws(global::System.Exception exception) { EnsureSetup().Throws(exception); return this; }
    /// <inheritdoc />
    public IAsyncService_ComputeAsync_M2_MockCall Callback(global::System.Action callback) { EnsureSetup().Callback(callback); return this; }
    /// <inheritdoc />
    public IAsyncService_ComputeAsync_M2_MockCall TransitionsTo(string stateName) { EnsureSetup().TransitionsTo(stateName); return this; }
    /// <inheritdoc />
    public IAsyncService_ComputeAsync_M2_MockCall Then() { EnsureSetup().Then(); return this; }

    /// <summary>Return a pre-built ValueTask directly (e.g., from a TaskCompletionSource).</summary>
    /// <remarks>The same ValueTask instance is returned on every call. Since ValueTask may only be awaited once,
    /// use the factory overload if the mock will be called multiple times, or ensure the ValueTask is backed by a Task.</remarks>
    public IAsyncService_ComputeAsync_M2_MockCall ReturnsAsync(global::System.Threading.Tasks.ValueTask<int> task) { EnsureSetup().ReturnsRaw(task); return this; }
    /// <summary>Return a pre-built ValueTask from a factory, invoked on each call.</summary>
    public IAsyncService_ComputeAsync_M2_MockCall ReturnsAsync(global::System.Func<global::System.Threading.Tasks.ValueTask<int>> taskFactory) { EnsureSetup().ReturnsRaw(() => (object?)taskFactory()); return this; }

    /// <summary>Configure a typed computed return value using the actual method parameters.</summary>
    public IAsyncService_ComputeAsync_M2_MockCall Returns(global::System.Func<int, int> factory)
    {
        EnsureSetup().Returns(args => factory((int)args[0]!));
        return this;
    }

    /// <summary>Configure a typed computed async return value using the actual method parameters.</summary>
    public IAsyncService_ComputeAsync_M2_MockCall ReturnsAsync(global::System.Func<int, global::System.Threading.Tasks.ValueTask<int>> factory)
    {
        EnsureSetup().ReturnsRaw(args => (object?)factory((int)args[0]!));
        return this;
    }

    /// <summary>Execute a typed callback using the actual method parameters.</summary>
    public IAsyncService_ComputeAsync_M2_MockCall Callback(global::System.Action<int> callback)
    {
        EnsureSetup().Callback(callback);
        return this;
    }

    /// <summary>Configure a typed computed exception using the actual method parameters.</summary>
    public IAsyncService_ComputeAsync_M2_MockCall Throws(global::System.Func<int, global::System.Exception> exceptionFactory)
    {
        EnsureSetup().Throws(args => exceptionFactory((int)args[0]!));
        return this;
    }

    // ICallVerification
    /// <inheritdoc />
    public void WasCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled();
    /// <inheritdoc />
    public void WasCalled(global::TUnit.Mocks.Times times) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times);
    /// <inheritdoc />
    public void WasCalled(global::TUnit.Mocks.Times times, string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times, message);
    /// <inheritdoc />
    public void WasCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(message);
    /// <inheritdoc />
    public void WasNeverCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled();
    /// <inheritdoc />
    public void WasNeverCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled(message);
}

[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
public sealed class IAsyncService_InitializeAsync_M3_MockCall : global::TUnit.Mocks.Verification.ICallVerification
{
    private readonly global::TUnit.Mocks.IMockEngineAccess _engine;
    private readonly int _memberId;
    private readonly string _memberName;
    private readonly global::TUnit.Mocks.Arguments.IArgumentMatcher[] _matchers;
    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder? _builder;

    internal IAsyncService_InitializeAsync_M3_MockCall(global::TUnit.Mocks.IMockEngineAccess engine, int memberId, string memberName, global::TUnit.Mocks.Arguments.IArgumentMatcher[] matchers)
    {
        _engine = engine;
        _memberId = memberId;
        _memberName = memberName;
        _matchers = matchers;
        _ = EnsureSetup();
    }

    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder EnsureSetup()
    {
        var existing = global::System.Threading.Volatile.Read(ref _builder);
        if (existing is not null) return existing;
        return EnsureSetupSlow();
    }

    [global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
    private global::TUnit.Mocks.Setup.VoidMethodSetupBuilder EnsureSetupSlow()
    {
        var setup = new global::TUnit.Mocks.Setup.MethodSetup(_memberId, _matchers, _memberName);
        var fresh = new global::TUnit.Mocks.Setup.VoidMethodSetupBuilder(setup);
        var prev = global::System.Threading.Interlocked.CompareExchange(ref _builder, fresh, null);
        if (prev is not null) return prev;
        // AddSetup runs only on the CAS winner. Setup is sequential in practice,
        // so a concurrent loser observing the builder before registration is benign.
        _engine.AddSetup(setup);
        return fresh;
    }

    /// <inheritdoc />
    public IAsyncService_InitializeAsync_M3_MockCall Returns() { EnsureSetup().Returns(); return this; }
    /// <inheritdoc />
    public IAsyncService_InitializeAsync_M3_MockCall Throws<TException>() where TException : global::System.Exception, new() { EnsureSetup().Throws<TException>(); return this; }
    /// <inheritdoc />
    public IAsyncService_InitializeAsync_M3_MockCall Throws(global::System.Exception exception) { EnsureSetup().Throws(exception); return this; }
    /// <inheritdoc />
    public IAsyncService_InitializeAsync_M3_MockCall Callback(global::System.Action callback) { EnsureSetup().Callback(callback); return this; }
    /// <inheritdoc />
    public IAsyncService_InitializeAsync_M3_MockCall TransitionsTo(string stateName) { EnsureSetup().TransitionsTo(stateName); return this; }
    /// <inheritdoc />
    public IAsyncService_InitializeAsync_M3_MockCall Then() { EnsureSetup().Then(); return this; }

    /// <summary>Return a pre-built ValueTask directly (e.g., from a TaskCompletionSource).</summary>
    /// <remarks>The same ValueTask instance is returned on every call. Since ValueTask may only be awaited once,
    /// use the factory overload if the mock will be called multiple times, or ensure the ValueTask is backed by a Task.</remarks>
    public IAsyncService_InitializeAsync_M3_MockCall ReturnsAsync(global::System.Threading.Tasks.ValueTask task) { EnsureSetup().ReturnsRaw(task); return this; }
    /// <summary>Return a pre-built ValueTask from a factory, invoked on each call.</summary>
    public IAsyncService_InitializeAsync_M3_MockCall ReturnsAsync(global::System.Func<global::System.Threading.Tasks.ValueTask> taskFactory) { EnsureSetup().ReturnsRaw(() => (object?)taskFactory()); return this; }

    /// <summary>Execute a typed callback using the actual method parameters.</summary>
    public IAsyncService_InitializeAsync_M3_MockCall Callback(global::System.Action<global::System.Threading.CancellationToken> callback)
    {
        EnsureSetup().Callback(callback);
        return this;
    }

    /// <summary>Configure a typed computed exception using the actual method parameters.</summary>
    public IAsyncService_InitializeAsync_M3_MockCall Throws(global::System.Func<global::System.Threading.CancellationToken, global::System.Exception> exceptionFactory)
    {
        EnsureSetup().Throws(args => exceptionFactory((global::System.Threading.CancellationToken)args[0]!));
        return this;
    }

    // ICallVerification
    /// <inheritdoc />
    public void WasCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled();
    /// <inheritdoc />
    public void WasCalled(global::TUnit.Mocks.Times times) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times);
    /// <inheritdoc />
    public void WasCalled(global::TUnit.Mocks.Times times, string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(times, message);
    /// <inheritdoc />
    public void WasCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasCalled(message);
    /// <inheritdoc />
    public void WasNeverCalled() => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled();
    /// <inheritdoc />
    public void WasNeverCalled(string? message) => _engine.CreateVerification(_memberId, _memberName, _matchers).WasNeverCalled(message);
}


// ===== FILE SEPARATOR =====

// <auto-generated/>
#pragma warning disable
#nullable enable

namespace TUnit.Mocks
{
    public static class IAsyncService_MockStaticExtension
    {
        extension(global::IAsyncService _)
        {
            public static global::IAsyncServiceMock Mock()
            {
                return (global::IAsyncServiceMock)global::IAsyncServiceMockFactory.CreateAutoMock(global::TUnit.Mocks.Mock.DefaultBehavior);
            }

            public static global::IAsyncServiceMock Mock(global::TUnit.Mocks.MockBehavior behavior)
            {
                return (global::IAsyncServiceMock)global::IAsyncServiceMockFactory.CreateAutoMock(behavior);
            }
        }
    }
}


// ===== FILE SEPARATOR =====

// <auto-generated/>
#pragma warning disable
#nullable enable

namespace TUnit.Mocks.Generated;