func (mock *CommitLog) DeleteCalled() bool {
	lockCommitLogDelete.RLock()
	defer lockCommitLogDelete.RUnlock()
	return len(mock.calls.Delete) > 0
}
DeleteCalled returns true if at least one call was made to Delete.
package mock
import (
	"io"
	"sync"
)
var (
	lockCommitLogAppend       sync.RWMutex
	lockCommitLogDelete       sync.RWMutex
	lockCommitLogNewReader    sync.RWMutex
	lockCommitLogNewestOffset sync.RWMutex
	lockCommitLogOldestOffset sync.RWMutex
	lockCommitLogTruncate     sync.RWMutex
)
type CommitLog struct {
	AppendFunc func(in1 []byte) (int64, error)
	DeleteFunc func() error
	NewReaderFunc func(offset int64, maxBytes int32) (io.Reader, error)
	NewestOffsetFunc func() int64
	OldestOffsetFunc func() int64
	TruncateFunc func(in1 int64) error
	calls struct {
		Append []struct {
			In1 []byte
		}
		Delete []struct {
		}
		NewReader []struct {
			Offset int64
			MaxBytes int32
		}
		NewestOffset []struct {
		}
		OldestOffset []struct {
		}
		Truncate []struct {
			In1 int64
		}
	}
}
func (mock *CommitLog) Reset() {
	lockCommitLogAppend.Lock()
	mock.calls.Append = nil
	lockCommitLogAppend.Unlock()
	lockCommitLogDelete.Lock()
	mock.calls.Delete = nil
	lockCommitLogDelete.Unlock()
	lockCommitLogNewReader.Lock()
	mock.calls.NewReader = nil
	lockCommitLogNewReader.Unlock()
	lockCommitLogNewestOffset.Lock()
	mock.calls.NewestOffset = nil
	lockCommitLogNewestOffset.Unlock()
	lockCommitLogOldestOffset.Lock()
	mock.calls.OldestOffset = nil
	lockCommitLogOldestOffset.Unlock()
	lockCommitLogTruncate.Lock()
	mock.calls.Truncate = nil
	lockCommitLogTruncate.Unlock()
}
func (mock *CommitLog) Append(in1 []byte) (int64, error) {
	if mock.AppendFunc == nil {
		panic("moq: CommitLog.AppendFunc is nil but CommitLog.Append was just called")
	}
	callInfo := struct {
		In1 []byte
	}{
		In1: in1,
	}
	lockCommitLogAppend.Lock()
	mock.calls.Append = append(mock.calls.Append, callInfo)
	lockCommitLogAppend.Unlock()
	return mock.AppendFunc(in1)
}
func (mock *CommitLog) AppendCalled() bool {
	lockCommitLogAppend.RLock()
	defer lockCommitLogAppend.RUnlock()
	return len(mock.calls.Append) > 0
}
func (mock *CommitLog) AppendCalls() []struct {
	In1 []byte
} {
	var calls []struct {
		In1 []byte
	}
	lockCommitLogAppend.RLock()
	calls = mock.calls.Append
	lockCommitLogAppend.RUnlock()
	return calls
}
func (mock *CommitLog) Delete() error {
	if mock.DeleteFunc == nil {
		panic("moq: CommitLog.DeleteFunc is nil but CommitLog.Delete was just called")
	}
	callInfo := struct {
	}{}
	lockCommitLogDelete.Lock()
	mock.calls.Delete = append(mock.calls.Delete, callInfo)
	lockCommitLogDelete.Unlock()
	return mock.DeleteFunc()
}