// This file was generated by github.com/nelsam/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 (
	"github.com/poy/onpar/matchers"
)

type mockTHelper struct {
	HelperCalled chan bool
}

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

type mockToMatcher struct {
	MatchCalled chan bool
	MatchInput  struct {
		Actual chan interface{}
	}
	MatchOutput struct {
		ResultValue chan interface{}
		Err         chan error
	}
}

func newMockToMatcher() *mockToMatcher {
	m := &mockToMatcher{}
	m.MatchCalled = make(chan bool, 100)
	m.MatchInput.Actual = make(chan interface{}, 100)
	m.MatchOutput.ResultValue = make(chan interface{}, 100)
	m.MatchOutput.Err = make(chan error, 100)
	return m
}
func (m *mockToMatcher) Match(actual interface{}) (resultValue interface{}, err error) {
	m.MatchCalled <- true
	m.MatchInput.Actual <- actual
	return <-m.MatchOutput.ResultValue, <-m.MatchOutput.Err
}

type mockDiffMatcher struct {
	UseDifferCalled chan bool
	UseDifferInput  struct {
		Arg0 chan matchers.Differ
	}
}

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

type mockT struct {
	FatalfCalled chan bool
	FatalfInput  struct {
		Format chan string
		Args   chan []interface{}
	}
}

func newMockT() *mockT {
	m := &mockT{}
	m.FatalfCalled = make(chan bool, 100)
	m.FatalfInput.Format = make(chan string, 100)
	m.FatalfInput.Args = make(chan []interface{}, 100)
	return m
}
func (m *mockT) Fatalf(format string, args ...interface{}) {
	m.FatalfCalled <- true
	m.FatalfInput.Format <- format
	m.FatalfInput.Args <- args
}

type mockDiffer struct {
	DiffCalled chan bool
	DiffInput  struct {
		Actual, Expected chan interface{}
	}
	DiffOutput struct {
		Ret0 chan string
	}
}

func newMockDiffer() *mockDiffer {
	m := &mockDiffer{}
	m.DiffCalled = make(chan bool, 100)
	m.DiffInput.Actual = make(chan interface{}, 100)
	m.DiffInput.Expected = make(chan interface{}, 100)
	m.DiffOutput.Ret0 = make(chan string, 100)
	return m
}
func (m *mockDiffer) Diff(actual, expected interface{}) string {
	m.DiffCalled <- true
	m.DiffInput.Actual <- actual
	m.DiffInput.Expected <- expected
	return <-m.DiffOutput.Ret0
}