// Code generated by git.sr.ht/~nelsam/hel. DO NOT EDIT.
//
// This file contains mocks generated by hel. Do not edit this code by
// hand unless you *really* know what you're doing. Expect any changes
// made manually to be overwritten the next time hel regenerates this
// file.

package expect_test

import (
	"time"

	"git.sr.ht/~nelsam/hel/vegr"
	"github.com/poy/onpar/matchers"
)

type mockToMatcher struct {
	t           vegr.T
	timeout     time.Duration
	MatchCalled chan bool
	MatchInput  struct {
		Actual chan any
	}
	MatchOutput struct {
		ResultValue chan any
		Err         chan error
	}
}

func newMockToMatcher(t vegr.T, timeout time.Duration) *mockToMatcher {
	m := &mockToMatcher{t: t, timeout: timeout}
	m.MatchCalled = make(chan bool, 100)
	m.MatchInput.Actual = make(chan any, 100)
	m.MatchOutput.ResultValue = make(chan any, 100)
	m.MatchOutput.Err = make(chan error, 100)
	return m
}
func (m *mockToMatcher) Match(actual any) (resultValue any, err error) {
	m.t.Helper()
	m.MatchCalled <- true
	m.MatchInput.Actual <- actual
	vegr.PopulateReturns(m.t, "Match", m.timeout, m.MatchOutput, &resultValue, &err)
	return resultValue, err
}

type mockDiffMatcher struct {
	t               vegr.T
	timeout         time.Duration
	UseDifferCalled chan bool
	UseDifferInput  struct {
		Arg0 chan matchers.Differ
	}
}

func newMockDiffMatcher(t vegr.T, timeout time.Duration) *mockDiffMatcher {
	m := &mockDiffMatcher{t: t, timeout: timeout}
	m.UseDifferCalled = make(chan bool, 100)
	m.UseDifferInput.Arg0 = make(chan matchers.Differ, 100)
	return m
}
func (m *mockDiffMatcher) UseDiffer(arg0 matchers.Differ) {
	m.t.Helper()
	m.UseDifferCalled <- true
	m.UseDifferInput.Arg0 <- arg0
}

type mockT struct {
	t            vegr.T
	timeout      time.Duration
	FatalfCalled chan bool
	FatalfInput  struct {
		Format chan string
		Args   chan []any
	}
}

func newMockT(t vegr.T, timeout time.Duration) *mockT {
	m := &mockT{t: t, timeout: timeout}
	m.FatalfCalled = make(chan bool, 100)
	m.FatalfInput.Format = make(chan string, 100)
	m.FatalfInput.Args = make(chan []any, 100)
	return m
}
func (m *mockT) Fatalf(format string, args ...any) {
	m.t.Helper()
	m.FatalfCalled <- true
	m.FatalfInput.Format <- format
	m.FatalfInput.Args <- args
}

type mockTHelper struct {
	t            vegr.T
	timeout      time.Duration
	HelperCalled chan bool
}

func newMockTHelper(t vegr.T, timeout time.Duration) *mockTHelper {
	m := &mockTHelper{t: t, timeout: timeout}
	m.HelperCalled = make(chan bool, 100)
	return m
}
func (m *mockTHelper) Helper() {
	m.t.Helper()
	m.HelperCalled <- true
}

type mockDiffer struct {
	t          vegr.T
	timeout    time.Duration
	DiffCalled chan bool
	DiffInput  struct {
		Actual, Expected chan any
	}
	DiffOutput struct {
		Ret0 chan string
	}
}

func newMockDiffer(t vegr.T, timeout time.Duration) *mockDiffer {
	m := &mockDiffer{t: t, timeout: timeout}
	m.DiffCalled = make(chan bool, 100)
	m.DiffInput.Actual = make(chan any, 100)
	m.DiffInput.Expected = make(chan any, 100)
	m.DiffOutput.Ret0 = make(chan string, 100)
	return m
}
func (m *mockDiffer) Diff(actual, expected any) (ret0 string) {
	m.t.Helper()
	m.DiffCalled <- true
	m.DiffInput.Actual <- actual
	m.DiffInput.Expected <- expected
	vegr.PopulateReturns(m.t, "Diff", m.timeout, m.DiffOutput, &ret0)
	return ret0
}

type mockMatcher struct {
	t           vegr.T
	timeout     time.Duration
	MatchCalled chan bool
	MatchInput  struct {
		Actual chan any
	}
	MatchOutput struct {
		ResultValue chan any
		Err         chan error
	}
}

func newMockMatcher(t vegr.T, timeout time.Duration) *mockMatcher {
	m := &mockMatcher{t: t, timeout: timeout}
	m.MatchCalled = make(chan bool, 100)
	m.MatchInput.Actual = make(chan any, 100)
	m.MatchOutput.ResultValue = make(chan any, 100)
	m.MatchOutput.Err = make(chan error, 100)
	return m
}
func (m *mockMatcher) Match(actual any) (resultValue any, err error) {
	m.t.Helper()
	m.MatchCalled <- true
	m.MatchInput.Actual <- actual
	vegr.PopulateReturns(m.t, "Match", m.timeout, m.MatchOutput, &resultValue, &err)
	return resultValue, err
}
