|
|
@@ -0,0 +1,3238 @@
|
|
|
+// Code generated by counterfeiter. DO NOT EDIT.
|
|
|
+package mocks
|
|
|
+
|
|
|
+import (
|
|
|
+ "context"
|
|
|
+ "net"
|
|
|
+ "sync"
|
|
|
+ "time"
|
|
|
+
|
|
|
+ "github.com/syncthing/syncthing/lib/db"
|
|
|
+ "github.com/syncthing/syncthing/lib/model"
|
|
|
+ "github.com/syncthing/syncthing/lib/protocol"
|
|
|
+ "github.com/syncthing/syncthing/lib/stats"
|
|
|
+ "github.com/syncthing/syncthing/lib/ur/contract"
|
|
|
+ "github.com/syncthing/syncthing/lib/versioner"
|
|
|
+)
|
|
|
+
|
|
|
+type Model struct {
|
|
|
+ AddConnectionStub func(protocol.Connection, protocol.Hello)
|
|
|
+ addConnectionMutex sync.RWMutex
|
|
|
+ addConnectionArgsForCall []struct {
|
|
|
+ arg1 protocol.Connection
|
|
|
+ arg2 protocol.Hello
|
|
|
+ }
|
|
|
+ AvailabilityStub func(string, protocol.FileInfo, protocol.BlockInfo) []model.Availability
|
|
|
+ availabilityMutex sync.RWMutex
|
|
|
+ availabilityArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 protocol.FileInfo
|
|
|
+ arg3 protocol.BlockInfo
|
|
|
+ }
|
|
|
+ availabilityReturns struct {
|
|
|
+ result1 []model.Availability
|
|
|
+ }
|
|
|
+ availabilityReturnsOnCall map[int]struct {
|
|
|
+ result1 []model.Availability
|
|
|
+ }
|
|
|
+ BringToFrontStub func(string, string)
|
|
|
+ bringToFrontMutex sync.RWMutex
|
|
|
+ bringToFrontArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 string
|
|
|
+ }
|
|
|
+ ClosedStub func(protocol.Connection, error)
|
|
|
+ closedMutex sync.RWMutex
|
|
|
+ closedArgsForCall []struct {
|
|
|
+ arg1 protocol.Connection
|
|
|
+ arg2 error
|
|
|
+ }
|
|
|
+ ClusterConfigStub func(protocol.DeviceID, protocol.ClusterConfig) error
|
|
|
+ clusterConfigMutex sync.RWMutex
|
|
|
+ clusterConfigArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 protocol.ClusterConfig
|
|
|
+ }
|
|
|
+ clusterConfigReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ clusterConfigReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ CompletionStub func(protocol.DeviceID, string) model.FolderCompletion
|
|
|
+ completionMutex sync.RWMutex
|
|
|
+ completionArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ }
|
|
|
+ completionReturns struct {
|
|
|
+ result1 model.FolderCompletion
|
|
|
+ }
|
|
|
+ completionReturnsOnCall map[int]struct {
|
|
|
+ result1 model.FolderCompletion
|
|
|
+ }
|
|
|
+ ConnectionStub func(protocol.DeviceID) (protocol.Connection, bool)
|
|
|
+ connectionMutex sync.RWMutex
|
|
|
+ connectionArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ }
|
|
|
+ connectionReturns struct {
|
|
|
+ result1 protocol.Connection
|
|
|
+ result2 bool
|
|
|
+ }
|
|
|
+ connectionReturnsOnCall map[int]struct {
|
|
|
+ result1 protocol.Connection
|
|
|
+ result2 bool
|
|
|
+ }
|
|
|
+ ConnectionStatsStub func() map[string]interface{}
|
|
|
+ connectionStatsMutex sync.RWMutex
|
|
|
+ connectionStatsArgsForCall []struct {
|
|
|
+ }
|
|
|
+ connectionStatsReturns struct {
|
|
|
+ result1 map[string]interface{}
|
|
|
+ }
|
|
|
+ connectionStatsReturnsOnCall map[int]struct {
|
|
|
+ result1 map[string]interface{}
|
|
|
+ }
|
|
|
+ CurrentFolderFileStub func(string, string) (protocol.FileInfo, bool)
|
|
|
+ currentFolderFileMutex sync.RWMutex
|
|
|
+ currentFolderFileArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 string
|
|
|
+ }
|
|
|
+ currentFolderFileReturns struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ }
|
|
|
+ currentFolderFileReturnsOnCall map[int]struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ }
|
|
|
+ CurrentGlobalFileStub func(string, string) (protocol.FileInfo, bool)
|
|
|
+ currentGlobalFileMutex sync.RWMutex
|
|
|
+ currentGlobalFileArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 string
|
|
|
+ }
|
|
|
+ currentGlobalFileReturns struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ }
|
|
|
+ currentGlobalFileReturnsOnCall map[int]struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ }
|
|
|
+ CurrentIgnoresStub func(string) ([]string, []string, error)
|
|
|
+ currentIgnoresMutex sync.RWMutex
|
|
|
+ currentIgnoresArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ currentIgnoresReturns struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ }
|
|
|
+ currentIgnoresReturnsOnCall map[int]struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ }
|
|
|
+ DBSnapshotStub func(string) (*db.Snapshot, error)
|
|
|
+ dBSnapshotMutex sync.RWMutex
|
|
|
+ dBSnapshotArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ dBSnapshotReturns struct {
|
|
|
+ result1 *db.Snapshot
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ dBSnapshotReturnsOnCall map[int]struct {
|
|
|
+ result1 *db.Snapshot
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ DelayScanStub func(string, time.Duration)
|
|
|
+ delayScanMutex sync.RWMutex
|
|
|
+ delayScanArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 time.Duration
|
|
|
+ }
|
|
|
+ DeviceStatisticsStub func() (map[protocol.DeviceID]stats.DeviceStatistics, error)
|
|
|
+ deviceStatisticsMutex sync.RWMutex
|
|
|
+ deviceStatisticsArgsForCall []struct {
|
|
|
+ }
|
|
|
+ deviceStatisticsReturns struct {
|
|
|
+ result1 map[protocol.DeviceID]stats.DeviceStatistics
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ deviceStatisticsReturnsOnCall map[int]struct {
|
|
|
+ result1 map[protocol.DeviceID]stats.DeviceStatistics
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ DownloadProgressStub func(protocol.DeviceID, string, []protocol.FileDownloadProgressUpdate) error
|
|
|
+ downloadProgressMutex sync.RWMutex
|
|
|
+ downloadProgressArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ arg3 []protocol.FileDownloadProgressUpdate
|
|
|
+ }
|
|
|
+ downloadProgressReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ downloadProgressReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ FolderErrorsStub func(string) ([]model.FileError, error)
|
|
|
+ folderErrorsMutex sync.RWMutex
|
|
|
+ folderErrorsArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ folderErrorsReturns struct {
|
|
|
+ result1 []model.FileError
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ folderErrorsReturnsOnCall map[int]struct {
|
|
|
+ result1 []model.FileError
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ FolderProgressBytesCompletedStub func(string) int64
|
|
|
+ folderProgressBytesCompletedMutex sync.RWMutex
|
|
|
+ folderProgressBytesCompletedArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ folderProgressBytesCompletedReturns struct {
|
|
|
+ result1 int64
|
|
|
+ }
|
|
|
+ folderProgressBytesCompletedReturnsOnCall map[int]struct {
|
|
|
+ result1 int64
|
|
|
+ }
|
|
|
+ FolderStatisticsStub func() (map[string]stats.FolderStatistics, error)
|
|
|
+ folderStatisticsMutex sync.RWMutex
|
|
|
+ folderStatisticsArgsForCall []struct {
|
|
|
+ }
|
|
|
+ folderStatisticsReturns struct {
|
|
|
+ result1 map[string]stats.FolderStatistics
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ folderStatisticsReturnsOnCall map[int]struct {
|
|
|
+ result1 map[string]stats.FolderStatistics
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ GetFolderVersionsStub func(string) (map[string][]versioner.FileVersion, error)
|
|
|
+ getFolderVersionsMutex sync.RWMutex
|
|
|
+ getFolderVersionsArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ getFolderVersionsReturns struct {
|
|
|
+ result1 map[string][]versioner.FileVersion
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ getFolderVersionsReturnsOnCall map[int]struct {
|
|
|
+ result1 map[string][]versioner.FileVersion
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ GetHelloStub func(protocol.DeviceID) protocol.HelloIntf
|
|
|
+ getHelloMutex sync.RWMutex
|
|
|
+ getHelloArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ }
|
|
|
+ getHelloReturns struct {
|
|
|
+ result1 protocol.HelloIntf
|
|
|
+ }
|
|
|
+ getHelloReturnsOnCall map[int]struct {
|
|
|
+ result1 protocol.HelloIntf
|
|
|
+ }
|
|
|
+ GlobalDirectoryTreeStub func(string, string, int, bool) ([]*model.TreeEntry, error)
|
|
|
+ globalDirectoryTreeMutex sync.RWMutex
|
|
|
+ globalDirectoryTreeArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 string
|
|
|
+ arg3 int
|
|
|
+ arg4 bool
|
|
|
+ }
|
|
|
+ globalDirectoryTreeReturns struct {
|
|
|
+ result1 []*model.TreeEntry
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ globalDirectoryTreeReturnsOnCall map[int]struct {
|
|
|
+ result1 []*model.TreeEntry
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ IndexStub func(protocol.DeviceID, string, []protocol.FileInfo) error
|
|
|
+ indexMutex sync.RWMutex
|
|
|
+ indexArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ arg3 []protocol.FileInfo
|
|
|
+ }
|
|
|
+ indexReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ indexReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ IndexUpdateStub func(protocol.DeviceID, string, []protocol.FileInfo) error
|
|
|
+ indexUpdateMutex sync.RWMutex
|
|
|
+ indexUpdateArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ arg3 []protocol.FileInfo
|
|
|
+ }
|
|
|
+ indexUpdateReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ indexUpdateReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ LoadIgnoresStub func(string) ([]string, []string, error)
|
|
|
+ loadIgnoresMutex sync.RWMutex
|
|
|
+ loadIgnoresArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ loadIgnoresReturns struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ }
|
|
|
+ loadIgnoresReturnsOnCall map[int]struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ }
|
|
|
+ LocalChangedFolderFilesStub func(string, int, int) ([]db.FileInfoTruncated, error)
|
|
|
+ localChangedFolderFilesMutex sync.RWMutex
|
|
|
+ localChangedFolderFilesArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 int
|
|
|
+ arg3 int
|
|
|
+ }
|
|
|
+ localChangedFolderFilesReturns struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ localChangedFolderFilesReturnsOnCall map[int]struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ NeedFolderFilesStub func(string, int, int) ([]db.FileInfoTruncated, []db.FileInfoTruncated, []db.FileInfoTruncated, error)
|
|
|
+ needFolderFilesMutex sync.RWMutex
|
|
|
+ needFolderFilesArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 int
|
|
|
+ arg3 int
|
|
|
+ }
|
|
|
+ needFolderFilesReturns struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 []db.FileInfoTruncated
|
|
|
+ result3 []db.FileInfoTruncated
|
|
|
+ result4 error
|
|
|
+ }
|
|
|
+ needFolderFilesReturnsOnCall map[int]struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 []db.FileInfoTruncated
|
|
|
+ result3 []db.FileInfoTruncated
|
|
|
+ result4 error
|
|
|
+ }
|
|
|
+ NumConnectionsStub func() int
|
|
|
+ numConnectionsMutex sync.RWMutex
|
|
|
+ numConnectionsArgsForCall []struct {
|
|
|
+ }
|
|
|
+ numConnectionsReturns struct {
|
|
|
+ result1 int
|
|
|
+ }
|
|
|
+ numConnectionsReturnsOnCall map[int]struct {
|
|
|
+ result1 int
|
|
|
+ }
|
|
|
+ OnHelloStub func(protocol.DeviceID, net.Addr, protocol.Hello) error
|
|
|
+ onHelloMutex sync.RWMutex
|
|
|
+ onHelloArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 net.Addr
|
|
|
+ arg3 protocol.Hello
|
|
|
+ }
|
|
|
+ onHelloReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ onHelloReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ OverrideStub func(string)
|
|
|
+ overrideMutex sync.RWMutex
|
|
|
+ overrideArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ PendingDevicesStub func() (map[protocol.DeviceID]db.ObservedDevice, error)
|
|
|
+ pendingDevicesMutex sync.RWMutex
|
|
|
+ pendingDevicesArgsForCall []struct {
|
|
|
+ }
|
|
|
+ pendingDevicesReturns struct {
|
|
|
+ result1 map[protocol.DeviceID]db.ObservedDevice
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ pendingDevicesReturnsOnCall map[int]struct {
|
|
|
+ result1 map[protocol.DeviceID]db.ObservedDevice
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ PendingFoldersStub func(protocol.DeviceID) (map[string]db.PendingFolder, error)
|
|
|
+ pendingFoldersMutex sync.RWMutex
|
|
|
+ pendingFoldersArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ }
|
|
|
+ pendingFoldersReturns struct {
|
|
|
+ result1 map[string]db.PendingFolder
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ pendingFoldersReturnsOnCall map[int]struct {
|
|
|
+ result1 map[string]db.PendingFolder
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ RemoteNeedFolderFilesStub func(string, protocol.DeviceID, int, int) ([]db.FileInfoTruncated, error)
|
|
|
+ remoteNeedFolderFilesMutex sync.RWMutex
|
|
|
+ remoteNeedFolderFilesArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 protocol.DeviceID
|
|
|
+ arg3 int
|
|
|
+ arg4 int
|
|
|
+ }
|
|
|
+ remoteNeedFolderFilesReturns struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ remoteNeedFolderFilesReturnsOnCall map[int]struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ RequestStub func(protocol.DeviceID, string, string, int32, int32, int64, []byte, uint32, bool) (protocol.RequestResponse, error)
|
|
|
+ requestMutex sync.RWMutex
|
|
|
+ requestArgsForCall []struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ arg3 string
|
|
|
+ arg4 int32
|
|
|
+ arg5 int32
|
|
|
+ arg6 int64
|
|
|
+ arg7 []byte
|
|
|
+ arg8 uint32
|
|
|
+ arg9 bool
|
|
|
+ }
|
|
|
+ requestReturns struct {
|
|
|
+ result1 protocol.RequestResponse
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ requestReturnsOnCall map[int]struct {
|
|
|
+ result1 protocol.RequestResponse
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ ResetFolderStub func(string)
|
|
|
+ resetFolderMutex sync.RWMutex
|
|
|
+ resetFolderArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ RestoreFolderVersionsStub func(string, map[string]time.Time) (map[string]error, error)
|
|
|
+ restoreFolderVersionsMutex sync.RWMutex
|
|
|
+ restoreFolderVersionsArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 map[string]time.Time
|
|
|
+ }
|
|
|
+ restoreFolderVersionsReturns struct {
|
|
|
+ result1 map[string]error
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ restoreFolderVersionsReturnsOnCall map[int]struct {
|
|
|
+ result1 map[string]error
|
|
|
+ result2 error
|
|
|
+ }
|
|
|
+ RevertStub func(string)
|
|
|
+ revertMutex sync.RWMutex
|
|
|
+ revertArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ ScanFolderStub func(string) error
|
|
|
+ scanFolderMutex sync.RWMutex
|
|
|
+ scanFolderArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ scanFolderReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ scanFolderReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ ScanFolderSubdirsStub func(string, []string) error
|
|
|
+ scanFolderSubdirsMutex sync.RWMutex
|
|
|
+ scanFolderSubdirsArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 []string
|
|
|
+ }
|
|
|
+ scanFolderSubdirsReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ scanFolderSubdirsReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ ScanFoldersStub func() map[string]error
|
|
|
+ scanFoldersMutex sync.RWMutex
|
|
|
+ scanFoldersArgsForCall []struct {
|
|
|
+ }
|
|
|
+ scanFoldersReturns struct {
|
|
|
+ result1 map[string]error
|
|
|
+ }
|
|
|
+ scanFoldersReturnsOnCall map[int]struct {
|
|
|
+ result1 map[string]error
|
|
|
+ }
|
|
|
+ ServeStub func(context.Context) error
|
|
|
+ serveMutex sync.RWMutex
|
|
|
+ serveArgsForCall []struct {
|
|
|
+ arg1 context.Context
|
|
|
+ }
|
|
|
+ serveReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ serveReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ SetIgnoresStub func(string, []string) error
|
|
|
+ setIgnoresMutex sync.RWMutex
|
|
|
+ setIgnoresArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 []string
|
|
|
+ }
|
|
|
+ setIgnoresReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ setIgnoresReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ StartDeadlockDetectorStub func(time.Duration)
|
|
|
+ startDeadlockDetectorMutex sync.RWMutex
|
|
|
+ startDeadlockDetectorArgsForCall []struct {
|
|
|
+ arg1 time.Duration
|
|
|
+ }
|
|
|
+ StateStub func(string) (string, time.Time, error)
|
|
|
+ stateMutex sync.RWMutex
|
|
|
+ stateArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ stateReturns struct {
|
|
|
+ result1 string
|
|
|
+ result2 time.Time
|
|
|
+ result3 error
|
|
|
+ }
|
|
|
+ stateReturnsOnCall map[int]struct {
|
|
|
+ result1 string
|
|
|
+ result2 time.Time
|
|
|
+ result3 error
|
|
|
+ }
|
|
|
+ UsageReportingStatsStub func(*contract.Report, int, bool)
|
|
|
+ usageReportingStatsMutex sync.RWMutex
|
|
|
+ usageReportingStatsArgsForCall []struct {
|
|
|
+ arg1 *contract.Report
|
|
|
+ arg2 int
|
|
|
+ arg3 bool
|
|
|
+ }
|
|
|
+ WatchErrorStub func(string) error
|
|
|
+ watchErrorMutex sync.RWMutex
|
|
|
+ watchErrorArgsForCall []struct {
|
|
|
+ arg1 string
|
|
|
+ }
|
|
|
+ watchErrorReturns struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ watchErrorReturnsOnCall map[int]struct {
|
|
|
+ result1 error
|
|
|
+ }
|
|
|
+ invocations map[string][][]interface{}
|
|
|
+ invocationsMutex sync.RWMutex
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AddConnection(arg1 protocol.Connection, arg2 protocol.Hello) {
|
|
|
+ fake.addConnectionMutex.Lock()
|
|
|
+ fake.addConnectionArgsForCall = append(fake.addConnectionArgsForCall, struct {
|
|
|
+ arg1 protocol.Connection
|
|
|
+ arg2 protocol.Hello
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.AddConnectionStub
|
|
|
+ fake.recordInvocation("AddConnection", []interface{}{arg1, arg2})
|
|
|
+ fake.addConnectionMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.AddConnectionStub(arg1, arg2)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AddConnectionCallCount() int {
|
|
|
+ fake.addConnectionMutex.RLock()
|
|
|
+ defer fake.addConnectionMutex.RUnlock()
|
|
|
+ return len(fake.addConnectionArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AddConnectionCalls(stub func(protocol.Connection, protocol.Hello)) {
|
|
|
+ fake.addConnectionMutex.Lock()
|
|
|
+ defer fake.addConnectionMutex.Unlock()
|
|
|
+ fake.AddConnectionStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AddConnectionArgsForCall(i int) (protocol.Connection, protocol.Hello) {
|
|
|
+ fake.addConnectionMutex.RLock()
|
|
|
+ defer fake.addConnectionMutex.RUnlock()
|
|
|
+ argsForCall := fake.addConnectionArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Availability(arg1 string, arg2 protocol.FileInfo, arg3 protocol.BlockInfo) []model.Availability {
|
|
|
+ fake.availabilityMutex.Lock()
|
|
|
+ ret, specificReturn := fake.availabilityReturnsOnCall[len(fake.availabilityArgsForCall)]
|
|
|
+ fake.availabilityArgsForCall = append(fake.availabilityArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 protocol.FileInfo
|
|
|
+ arg3 protocol.BlockInfo
|
|
|
+ }{arg1, arg2, arg3})
|
|
|
+ stub := fake.AvailabilityStub
|
|
|
+ fakeReturns := fake.availabilityReturns
|
|
|
+ fake.recordInvocation("Availability", []interface{}{arg1, arg2, arg3})
|
|
|
+ fake.availabilityMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AvailabilityCallCount() int {
|
|
|
+ fake.availabilityMutex.RLock()
|
|
|
+ defer fake.availabilityMutex.RUnlock()
|
|
|
+ return len(fake.availabilityArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AvailabilityCalls(stub func(string, protocol.FileInfo, protocol.BlockInfo) []model.Availability) {
|
|
|
+ fake.availabilityMutex.Lock()
|
|
|
+ defer fake.availabilityMutex.Unlock()
|
|
|
+ fake.AvailabilityStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AvailabilityArgsForCall(i int) (string, protocol.FileInfo, protocol.BlockInfo) {
|
|
|
+ fake.availabilityMutex.RLock()
|
|
|
+ defer fake.availabilityMutex.RUnlock()
|
|
|
+ argsForCall := fake.availabilityArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AvailabilityReturns(result1 []model.Availability) {
|
|
|
+ fake.availabilityMutex.Lock()
|
|
|
+ defer fake.availabilityMutex.Unlock()
|
|
|
+ fake.AvailabilityStub = nil
|
|
|
+ fake.availabilityReturns = struct {
|
|
|
+ result1 []model.Availability
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) AvailabilityReturnsOnCall(i int, result1 []model.Availability) {
|
|
|
+ fake.availabilityMutex.Lock()
|
|
|
+ defer fake.availabilityMutex.Unlock()
|
|
|
+ fake.AvailabilityStub = nil
|
|
|
+ if fake.availabilityReturnsOnCall == nil {
|
|
|
+ fake.availabilityReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 []model.Availability
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.availabilityReturnsOnCall[i] = struct {
|
|
|
+ result1 []model.Availability
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) BringToFront(arg1 string, arg2 string) {
|
|
|
+ fake.bringToFrontMutex.Lock()
|
|
|
+ fake.bringToFrontArgsForCall = append(fake.bringToFrontArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 string
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.BringToFrontStub
|
|
|
+ fake.recordInvocation("BringToFront", []interface{}{arg1, arg2})
|
|
|
+ fake.bringToFrontMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.BringToFrontStub(arg1, arg2)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) BringToFrontCallCount() int {
|
|
|
+ fake.bringToFrontMutex.RLock()
|
|
|
+ defer fake.bringToFrontMutex.RUnlock()
|
|
|
+ return len(fake.bringToFrontArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) BringToFrontCalls(stub func(string, string)) {
|
|
|
+ fake.bringToFrontMutex.Lock()
|
|
|
+ defer fake.bringToFrontMutex.Unlock()
|
|
|
+ fake.BringToFrontStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) BringToFrontArgsForCall(i int) (string, string) {
|
|
|
+ fake.bringToFrontMutex.RLock()
|
|
|
+ defer fake.bringToFrontMutex.RUnlock()
|
|
|
+ argsForCall := fake.bringToFrontArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Closed(arg1 protocol.Connection, arg2 error) {
|
|
|
+ fake.closedMutex.Lock()
|
|
|
+ fake.closedArgsForCall = append(fake.closedArgsForCall, struct {
|
|
|
+ arg1 protocol.Connection
|
|
|
+ arg2 error
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.ClosedStub
|
|
|
+ fake.recordInvocation("Closed", []interface{}{arg1, arg2})
|
|
|
+ fake.closedMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.ClosedStub(arg1, arg2)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClosedCallCount() int {
|
|
|
+ fake.closedMutex.RLock()
|
|
|
+ defer fake.closedMutex.RUnlock()
|
|
|
+ return len(fake.closedArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClosedCalls(stub func(protocol.Connection, error)) {
|
|
|
+ fake.closedMutex.Lock()
|
|
|
+ defer fake.closedMutex.Unlock()
|
|
|
+ fake.ClosedStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClosedArgsForCall(i int) (protocol.Connection, error) {
|
|
|
+ fake.closedMutex.RLock()
|
|
|
+ defer fake.closedMutex.RUnlock()
|
|
|
+ argsForCall := fake.closedArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClusterConfig(arg1 protocol.DeviceID, arg2 protocol.ClusterConfig) error {
|
|
|
+ fake.clusterConfigMutex.Lock()
|
|
|
+ ret, specificReturn := fake.clusterConfigReturnsOnCall[len(fake.clusterConfigArgsForCall)]
|
|
|
+ fake.clusterConfigArgsForCall = append(fake.clusterConfigArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 protocol.ClusterConfig
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.ClusterConfigStub
|
|
|
+ fakeReturns := fake.clusterConfigReturns
|
|
|
+ fake.recordInvocation("ClusterConfig", []interface{}{arg1, arg2})
|
|
|
+ fake.clusterConfigMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClusterConfigCallCount() int {
|
|
|
+ fake.clusterConfigMutex.RLock()
|
|
|
+ defer fake.clusterConfigMutex.RUnlock()
|
|
|
+ return len(fake.clusterConfigArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClusterConfigCalls(stub func(protocol.DeviceID, protocol.ClusterConfig) error) {
|
|
|
+ fake.clusterConfigMutex.Lock()
|
|
|
+ defer fake.clusterConfigMutex.Unlock()
|
|
|
+ fake.ClusterConfigStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClusterConfigArgsForCall(i int) (protocol.DeviceID, protocol.ClusterConfig) {
|
|
|
+ fake.clusterConfigMutex.RLock()
|
|
|
+ defer fake.clusterConfigMutex.RUnlock()
|
|
|
+ argsForCall := fake.clusterConfigArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClusterConfigReturns(result1 error) {
|
|
|
+ fake.clusterConfigMutex.Lock()
|
|
|
+ defer fake.clusterConfigMutex.Unlock()
|
|
|
+ fake.ClusterConfigStub = nil
|
|
|
+ fake.clusterConfigReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ClusterConfigReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.clusterConfigMutex.Lock()
|
|
|
+ defer fake.clusterConfigMutex.Unlock()
|
|
|
+ fake.ClusterConfigStub = nil
|
|
|
+ if fake.clusterConfigReturnsOnCall == nil {
|
|
|
+ fake.clusterConfigReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.clusterConfigReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Completion(arg1 protocol.DeviceID, arg2 string) model.FolderCompletion {
|
|
|
+ fake.completionMutex.Lock()
|
|
|
+ ret, specificReturn := fake.completionReturnsOnCall[len(fake.completionArgsForCall)]
|
|
|
+ fake.completionArgsForCall = append(fake.completionArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.CompletionStub
|
|
|
+ fakeReturns := fake.completionReturns
|
|
|
+ fake.recordInvocation("Completion", []interface{}{arg1, arg2})
|
|
|
+ fake.completionMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CompletionCallCount() int {
|
|
|
+ fake.completionMutex.RLock()
|
|
|
+ defer fake.completionMutex.RUnlock()
|
|
|
+ return len(fake.completionArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CompletionCalls(stub func(protocol.DeviceID, string) model.FolderCompletion) {
|
|
|
+ fake.completionMutex.Lock()
|
|
|
+ defer fake.completionMutex.Unlock()
|
|
|
+ fake.CompletionStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CompletionArgsForCall(i int) (protocol.DeviceID, string) {
|
|
|
+ fake.completionMutex.RLock()
|
|
|
+ defer fake.completionMutex.RUnlock()
|
|
|
+ argsForCall := fake.completionArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CompletionReturns(result1 model.FolderCompletion) {
|
|
|
+ fake.completionMutex.Lock()
|
|
|
+ defer fake.completionMutex.Unlock()
|
|
|
+ fake.CompletionStub = nil
|
|
|
+ fake.completionReturns = struct {
|
|
|
+ result1 model.FolderCompletion
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CompletionReturnsOnCall(i int, result1 model.FolderCompletion) {
|
|
|
+ fake.completionMutex.Lock()
|
|
|
+ defer fake.completionMutex.Unlock()
|
|
|
+ fake.CompletionStub = nil
|
|
|
+ if fake.completionReturnsOnCall == nil {
|
|
|
+ fake.completionReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 model.FolderCompletion
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.completionReturnsOnCall[i] = struct {
|
|
|
+ result1 model.FolderCompletion
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Connection(arg1 protocol.DeviceID) (protocol.Connection, bool) {
|
|
|
+ fake.connectionMutex.Lock()
|
|
|
+ ret, specificReturn := fake.connectionReturnsOnCall[len(fake.connectionArgsForCall)]
|
|
|
+ fake.connectionArgsForCall = append(fake.connectionArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.ConnectionStub
|
|
|
+ fakeReturns := fake.connectionReturns
|
|
|
+ fake.recordInvocation("Connection", []interface{}{arg1})
|
|
|
+ fake.connectionMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionCallCount() int {
|
|
|
+ fake.connectionMutex.RLock()
|
|
|
+ defer fake.connectionMutex.RUnlock()
|
|
|
+ return len(fake.connectionArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionCalls(stub func(protocol.DeviceID) (protocol.Connection, bool)) {
|
|
|
+ fake.connectionMutex.Lock()
|
|
|
+ defer fake.connectionMutex.Unlock()
|
|
|
+ fake.ConnectionStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionArgsForCall(i int) protocol.DeviceID {
|
|
|
+ fake.connectionMutex.RLock()
|
|
|
+ defer fake.connectionMutex.RUnlock()
|
|
|
+ argsForCall := fake.connectionArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionReturns(result1 protocol.Connection, result2 bool) {
|
|
|
+ fake.connectionMutex.Lock()
|
|
|
+ defer fake.connectionMutex.Unlock()
|
|
|
+ fake.ConnectionStub = nil
|
|
|
+ fake.connectionReturns = struct {
|
|
|
+ result1 protocol.Connection
|
|
|
+ result2 bool
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionReturnsOnCall(i int, result1 protocol.Connection, result2 bool) {
|
|
|
+ fake.connectionMutex.Lock()
|
|
|
+ defer fake.connectionMutex.Unlock()
|
|
|
+ fake.ConnectionStub = nil
|
|
|
+ if fake.connectionReturnsOnCall == nil {
|
|
|
+ fake.connectionReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 protocol.Connection
|
|
|
+ result2 bool
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.connectionReturnsOnCall[i] = struct {
|
|
|
+ result1 protocol.Connection
|
|
|
+ result2 bool
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionStats() map[string]interface{} {
|
|
|
+ fake.connectionStatsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.connectionStatsReturnsOnCall[len(fake.connectionStatsArgsForCall)]
|
|
|
+ fake.connectionStatsArgsForCall = append(fake.connectionStatsArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.ConnectionStatsStub
|
|
|
+ fakeReturns := fake.connectionStatsReturns
|
|
|
+ fake.recordInvocation("ConnectionStats", []interface{}{})
|
|
|
+ fake.connectionStatsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionStatsCallCount() int {
|
|
|
+ fake.connectionStatsMutex.RLock()
|
|
|
+ defer fake.connectionStatsMutex.RUnlock()
|
|
|
+ return len(fake.connectionStatsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionStatsCalls(stub func() map[string]interface{}) {
|
|
|
+ fake.connectionStatsMutex.Lock()
|
|
|
+ defer fake.connectionStatsMutex.Unlock()
|
|
|
+ fake.ConnectionStatsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionStatsReturns(result1 map[string]interface{}) {
|
|
|
+ fake.connectionStatsMutex.Lock()
|
|
|
+ defer fake.connectionStatsMutex.Unlock()
|
|
|
+ fake.ConnectionStatsStub = nil
|
|
|
+ fake.connectionStatsReturns = struct {
|
|
|
+ result1 map[string]interface{}
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ConnectionStatsReturnsOnCall(i int, result1 map[string]interface{}) {
|
|
|
+ fake.connectionStatsMutex.Lock()
|
|
|
+ defer fake.connectionStatsMutex.Unlock()
|
|
|
+ fake.ConnectionStatsStub = nil
|
|
|
+ if fake.connectionStatsReturnsOnCall == nil {
|
|
|
+ fake.connectionStatsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 map[string]interface{}
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.connectionStatsReturnsOnCall[i] = struct {
|
|
|
+ result1 map[string]interface{}
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentFolderFile(arg1 string, arg2 string) (protocol.FileInfo, bool) {
|
|
|
+ fake.currentFolderFileMutex.Lock()
|
|
|
+ ret, specificReturn := fake.currentFolderFileReturnsOnCall[len(fake.currentFolderFileArgsForCall)]
|
|
|
+ fake.currentFolderFileArgsForCall = append(fake.currentFolderFileArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 string
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.CurrentFolderFileStub
|
|
|
+ fakeReturns := fake.currentFolderFileReturns
|
|
|
+ fake.recordInvocation("CurrentFolderFile", []interface{}{arg1, arg2})
|
|
|
+ fake.currentFolderFileMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentFolderFileCallCount() int {
|
|
|
+ fake.currentFolderFileMutex.RLock()
|
|
|
+ defer fake.currentFolderFileMutex.RUnlock()
|
|
|
+ return len(fake.currentFolderFileArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentFolderFileCalls(stub func(string, string) (protocol.FileInfo, bool)) {
|
|
|
+ fake.currentFolderFileMutex.Lock()
|
|
|
+ defer fake.currentFolderFileMutex.Unlock()
|
|
|
+ fake.CurrentFolderFileStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentFolderFileArgsForCall(i int) (string, string) {
|
|
|
+ fake.currentFolderFileMutex.RLock()
|
|
|
+ defer fake.currentFolderFileMutex.RUnlock()
|
|
|
+ argsForCall := fake.currentFolderFileArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentFolderFileReturns(result1 protocol.FileInfo, result2 bool) {
|
|
|
+ fake.currentFolderFileMutex.Lock()
|
|
|
+ defer fake.currentFolderFileMutex.Unlock()
|
|
|
+ fake.CurrentFolderFileStub = nil
|
|
|
+ fake.currentFolderFileReturns = struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentFolderFileReturnsOnCall(i int, result1 protocol.FileInfo, result2 bool) {
|
|
|
+ fake.currentFolderFileMutex.Lock()
|
|
|
+ defer fake.currentFolderFileMutex.Unlock()
|
|
|
+ fake.CurrentFolderFileStub = nil
|
|
|
+ if fake.currentFolderFileReturnsOnCall == nil {
|
|
|
+ fake.currentFolderFileReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.currentFolderFileReturnsOnCall[i] = struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentGlobalFile(arg1 string, arg2 string) (protocol.FileInfo, bool) {
|
|
|
+ fake.currentGlobalFileMutex.Lock()
|
|
|
+ ret, specificReturn := fake.currentGlobalFileReturnsOnCall[len(fake.currentGlobalFileArgsForCall)]
|
|
|
+ fake.currentGlobalFileArgsForCall = append(fake.currentGlobalFileArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 string
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.CurrentGlobalFileStub
|
|
|
+ fakeReturns := fake.currentGlobalFileReturns
|
|
|
+ fake.recordInvocation("CurrentGlobalFile", []interface{}{arg1, arg2})
|
|
|
+ fake.currentGlobalFileMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentGlobalFileCallCount() int {
|
|
|
+ fake.currentGlobalFileMutex.RLock()
|
|
|
+ defer fake.currentGlobalFileMutex.RUnlock()
|
|
|
+ return len(fake.currentGlobalFileArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentGlobalFileCalls(stub func(string, string) (protocol.FileInfo, bool)) {
|
|
|
+ fake.currentGlobalFileMutex.Lock()
|
|
|
+ defer fake.currentGlobalFileMutex.Unlock()
|
|
|
+ fake.CurrentGlobalFileStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentGlobalFileArgsForCall(i int) (string, string) {
|
|
|
+ fake.currentGlobalFileMutex.RLock()
|
|
|
+ defer fake.currentGlobalFileMutex.RUnlock()
|
|
|
+ argsForCall := fake.currentGlobalFileArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentGlobalFileReturns(result1 protocol.FileInfo, result2 bool) {
|
|
|
+ fake.currentGlobalFileMutex.Lock()
|
|
|
+ defer fake.currentGlobalFileMutex.Unlock()
|
|
|
+ fake.CurrentGlobalFileStub = nil
|
|
|
+ fake.currentGlobalFileReturns = struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentGlobalFileReturnsOnCall(i int, result1 protocol.FileInfo, result2 bool) {
|
|
|
+ fake.currentGlobalFileMutex.Lock()
|
|
|
+ defer fake.currentGlobalFileMutex.Unlock()
|
|
|
+ fake.CurrentGlobalFileStub = nil
|
|
|
+ if fake.currentGlobalFileReturnsOnCall == nil {
|
|
|
+ fake.currentGlobalFileReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.currentGlobalFileReturnsOnCall[i] = struct {
|
|
|
+ result1 protocol.FileInfo
|
|
|
+ result2 bool
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentIgnores(arg1 string) ([]string, []string, error) {
|
|
|
+ fake.currentIgnoresMutex.Lock()
|
|
|
+ ret, specificReturn := fake.currentIgnoresReturnsOnCall[len(fake.currentIgnoresArgsForCall)]
|
|
|
+ fake.currentIgnoresArgsForCall = append(fake.currentIgnoresArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.CurrentIgnoresStub
|
|
|
+ fakeReturns := fake.currentIgnoresReturns
|
|
|
+ fake.recordInvocation("CurrentIgnores", []interface{}{arg1})
|
|
|
+ fake.currentIgnoresMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2, ret.result3
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentIgnoresCallCount() int {
|
|
|
+ fake.currentIgnoresMutex.RLock()
|
|
|
+ defer fake.currentIgnoresMutex.RUnlock()
|
|
|
+ return len(fake.currentIgnoresArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentIgnoresCalls(stub func(string) ([]string, []string, error)) {
|
|
|
+ fake.currentIgnoresMutex.Lock()
|
|
|
+ defer fake.currentIgnoresMutex.Unlock()
|
|
|
+ fake.CurrentIgnoresStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentIgnoresArgsForCall(i int) string {
|
|
|
+ fake.currentIgnoresMutex.RLock()
|
|
|
+ defer fake.currentIgnoresMutex.RUnlock()
|
|
|
+ argsForCall := fake.currentIgnoresArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentIgnoresReturns(result1 []string, result2 []string, result3 error) {
|
|
|
+ fake.currentIgnoresMutex.Lock()
|
|
|
+ defer fake.currentIgnoresMutex.Unlock()
|
|
|
+ fake.CurrentIgnoresStub = nil
|
|
|
+ fake.currentIgnoresReturns = struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ }{result1, result2, result3}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) CurrentIgnoresReturnsOnCall(i int, result1 []string, result2 []string, result3 error) {
|
|
|
+ fake.currentIgnoresMutex.Lock()
|
|
|
+ defer fake.currentIgnoresMutex.Unlock()
|
|
|
+ fake.CurrentIgnoresStub = nil
|
|
|
+ if fake.currentIgnoresReturnsOnCall == nil {
|
|
|
+ fake.currentIgnoresReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.currentIgnoresReturnsOnCall[i] = struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ }{result1, result2, result3}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DBSnapshot(arg1 string) (*db.Snapshot, error) {
|
|
|
+ fake.dBSnapshotMutex.Lock()
|
|
|
+ ret, specificReturn := fake.dBSnapshotReturnsOnCall[len(fake.dBSnapshotArgsForCall)]
|
|
|
+ fake.dBSnapshotArgsForCall = append(fake.dBSnapshotArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.DBSnapshotStub
|
|
|
+ fakeReturns := fake.dBSnapshotReturns
|
|
|
+ fake.recordInvocation("DBSnapshot", []interface{}{arg1})
|
|
|
+ fake.dBSnapshotMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DBSnapshotCallCount() int {
|
|
|
+ fake.dBSnapshotMutex.RLock()
|
|
|
+ defer fake.dBSnapshotMutex.RUnlock()
|
|
|
+ return len(fake.dBSnapshotArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DBSnapshotCalls(stub func(string) (*db.Snapshot, error)) {
|
|
|
+ fake.dBSnapshotMutex.Lock()
|
|
|
+ defer fake.dBSnapshotMutex.Unlock()
|
|
|
+ fake.DBSnapshotStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DBSnapshotArgsForCall(i int) string {
|
|
|
+ fake.dBSnapshotMutex.RLock()
|
|
|
+ defer fake.dBSnapshotMutex.RUnlock()
|
|
|
+ argsForCall := fake.dBSnapshotArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DBSnapshotReturns(result1 *db.Snapshot, result2 error) {
|
|
|
+ fake.dBSnapshotMutex.Lock()
|
|
|
+ defer fake.dBSnapshotMutex.Unlock()
|
|
|
+ fake.DBSnapshotStub = nil
|
|
|
+ fake.dBSnapshotReturns = struct {
|
|
|
+ result1 *db.Snapshot
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DBSnapshotReturnsOnCall(i int, result1 *db.Snapshot, result2 error) {
|
|
|
+ fake.dBSnapshotMutex.Lock()
|
|
|
+ defer fake.dBSnapshotMutex.Unlock()
|
|
|
+ fake.DBSnapshotStub = nil
|
|
|
+ if fake.dBSnapshotReturnsOnCall == nil {
|
|
|
+ fake.dBSnapshotReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 *db.Snapshot
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.dBSnapshotReturnsOnCall[i] = struct {
|
|
|
+ result1 *db.Snapshot
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DelayScan(arg1 string, arg2 time.Duration) {
|
|
|
+ fake.delayScanMutex.Lock()
|
|
|
+ fake.delayScanArgsForCall = append(fake.delayScanArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 time.Duration
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.DelayScanStub
|
|
|
+ fake.recordInvocation("DelayScan", []interface{}{arg1, arg2})
|
|
|
+ fake.delayScanMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.DelayScanStub(arg1, arg2)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DelayScanCallCount() int {
|
|
|
+ fake.delayScanMutex.RLock()
|
|
|
+ defer fake.delayScanMutex.RUnlock()
|
|
|
+ return len(fake.delayScanArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DelayScanCalls(stub func(string, time.Duration)) {
|
|
|
+ fake.delayScanMutex.Lock()
|
|
|
+ defer fake.delayScanMutex.Unlock()
|
|
|
+ fake.DelayScanStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DelayScanArgsForCall(i int) (string, time.Duration) {
|
|
|
+ fake.delayScanMutex.RLock()
|
|
|
+ defer fake.delayScanMutex.RUnlock()
|
|
|
+ argsForCall := fake.delayScanArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DeviceStatistics() (map[protocol.DeviceID]stats.DeviceStatistics, error) {
|
|
|
+ fake.deviceStatisticsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.deviceStatisticsReturnsOnCall[len(fake.deviceStatisticsArgsForCall)]
|
|
|
+ fake.deviceStatisticsArgsForCall = append(fake.deviceStatisticsArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.DeviceStatisticsStub
|
|
|
+ fakeReturns := fake.deviceStatisticsReturns
|
|
|
+ fake.recordInvocation("DeviceStatistics", []interface{}{})
|
|
|
+ fake.deviceStatisticsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DeviceStatisticsCallCount() int {
|
|
|
+ fake.deviceStatisticsMutex.RLock()
|
|
|
+ defer fake.deviceStatisticsMutex.RUnlock()
|
|
|
+ return len(fake.deviceStatisticsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DeviceStatisticsCalls(stub func() (map[protocol.DeviceID]stats.DeviceStatistics, error)) {
|
|
|
+ fake.deviceStatisticsMutex.Lock()
|
|
|
+ defer fake.deviceStatisticsMutex.Unlock()
|
|
|
+ fake.DeviceStatisticsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DeviceStatisticsReturns(result1 map[protocol.DeviceID]stats.DeviceStatistics, result2 error) {
|
|
|
+ fake.deviceStatisticsMutex.Lock()
|
|
|
+ defer fake.deviceStatisticsMutex.Unlock()
|
|
|
+ fake.DeviceStatisticsStub = nil
|
|
|
+ fake.deviceStatisticsReturns = struct {
|
|
|
+ result1 map[protocol.DeviceID]stats.DeviceStatistics
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DeviceStatisticsReturnsOnCall(i int, result1 map[protocol.DeviceID]stats.DeviceStatistics, result2 error) {
|
|
|
+ fake.deviceStatisticsMutex.Lock()
|
|
|
+ defer fake.deviceStatisticsMutex.Unlock()
|
|
|
+ fake.DeviceStatisticsStub = nil
|
|
|
+ if fake.deviceStatisticsReturnsOnCall == nil {
|
|
|
+ fake.deviceStatisticsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 map[protocol.DeviceID]stats.DeviceStatistics
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.deviceStatisticsReturnsOnCall[i] = struct {
|
|
|
+ result1 map[protocol.DeviceID]stats.DeviceStatistics
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DownloadProgress(arg1 protocol.DeviceID, arg2 string, arg3 []protocol.FileDownloadProgressUpdate) error {
|
|
|
+ var arg3Copy []protocol.FileDownloadProgressUpdate
|
|
|
+ if arg3 != nil {
|
|
|
+ arg3Copy = make([]protocol.FileDownloadProgressUpdate, len(arg3))
|
|
|
+ copy(arg3Copy, arg3)
|
|
|
+ }
|
|
|
+ fake.downloadProgressMutex.Lock()
|
|
|
+ ret, specificReturn := fake.downloadProgressReturnsOnCall[len(fake.downloadProgressArgsForCall)]
|
|
|
+ fake.downloadProgressArgsForCall = append(fake.downloadProgressArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ arg3 []protocol.FileDownloadProgressUpdate
|
|
|
+ }{arg1, arg2, arg3Copy})
|
|
|
+ stub := fake.DownloadProgressStub
|
|
|
+ fakeReturns := fake.downloadProgressReturns
|
|
|
+ fake.recordInvocation("DownloadProgress", []interface{}{arg1, arg2, arg3Copy})
|
|
|
+ fake.downloadProgressMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DownloadProgressCallCount() int {
|
|
|
+ fake.downloadProgressMutex.RLock()
|
|
|
+ defer fake.downloadProgressMutex.RUnlock()
|
|
|
+ return len(fake.downloadProgressArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DownloadProgressCalls(stub func(protocol.DeviceID, string, []protocol.FileDownloadProgressUpdate) error) {
|
|
|
+ fake.downloadProgressMutex.Lock()
|
|
|
+ defer fake.downloadProgressMutex.Unlock()
|
|
|
+ fake.DownloadProgressStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DownloadProgressArgsForCall(i int) (protocol.DeviceID, string, []protocol.FileDownloadProgressUpdate) {
|
|
|
+ fake.downloadProgressMutex.RLock()
|
|
|
+ defer fake.downloadProgressMutex.RUnlock()
|
|
|
+ argsForCall := fake.downloadProgressArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DownloadProgressReturns(result1 error) {
|
|
|
+ fake.downloadProgressMutex.Lock()
|
|
|
+ defer fake.downloadProgressMutex.Unlock()
|
|
|
+ fake.DownloadProgressStub = nil
|
|
|
+ fake.downloadProgressReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) DownloadProgressReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.downloadProgressMutex.Lock()
|
|
|
+ defer fake.downloadProgressMutex.Unlock()
|
|
|
+ fake.DownloadProgressStub = nil
|
|
|
+ if fake.downloadProgressReturnsOnCall == nil {
|
|
|
+ fake.downloadProgressReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.downloadProgressReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderErrors(arg1 string) ([]model.FileError, error) {
|
|
|
+ fake.folderErrorsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.folderErrorsReturnsOnCall[len(fake.folderErrorsArgsForCall)]
|
|
|
+ fake.folderErrorsArgsForCall = append(fake.folderErrorsArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.FolderErrorsStub
|
|
|
+ fakeReturns := fake.folderErrorsReturns
|
|
|
+ fake.recordInvocation("FolderErrors", []interface{}{arg1})
|
|
|
+ fake.folderErrorsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderErrorsCallCount() int {
|
|
|
+ fake.folderErrorsMutex.RLock()
|
|
|
+ defer fake.folderErrorsMutex.RUnlock()
|
|
|
+ return len(fake.folderErrorsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderErrorsCalls(stub func(string) ([]model.FileError, error)) {
|
|
|
+ fake.folderErrorsMutex.Lock()
|
|
|
+ defer fake.folderErrorsMutex.Unlock()
|
|
|
+ fake.FolderErrorsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderErrorsArgsForCall(i int) string {
|
|
|
+ fake.folderErrorsMutex.RLock()
|
|
|
+ defer fake.folderErrorsMutex.RUnlock()
|
|
|
+ argsForCall := fake.folderErrorsArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderErrorsReturns(result1 []model.FileError, result2 error) {
|
|
|
+ fake.folderErrorsMutex.Lock()
|
|
|
+ defer fake.folderErrorsMutex.Unlock()
|
|
|
+ fake.FolderErrorsStub = nil
|
|
|
+ fake.folderErrorsReturns = struct {
|
|
|
+ result1 []model.FileError
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderErrorsReturnsOnCall(i int, result1 []model.FileError, result2 error) {
|
|
|
+ fake.folderErrorsMutex.Lock()
|
|
|
+ defer fake.folderErrorsMutex.Unlock()
|
|
|
+ fake.FolderErrorsStub = nil
|
|
|
+ if fake.folderErrorsReturnsOnCall == nil {
|
|
|
+ fake.folderErrorsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 []model.FileError
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.folderErrorsReturnsOnCall[i] = struct {
|
|
|
+ result1 []model.FileError
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderProgressBytesCompleted(arg1 string) int64 {
|
|
|
+ fake.folderProgressBytesCompletedMutex.Lock()
|
|
|
+ ret, specificReturn := fake.folderProgressBytesCompletedReturnsOnCall[len(fake.folderProgressBytesCompletedArgsForCall)]
|
|
|
+ fake.folderProgressBytesCompletedArgsForCall = append(fake.folderProgressBytesCompletedArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.FolderProgressBytesCompletedStub
|
|
|
+ fakeReturns := fake.folderProgressBytesCompletedReturns
|
|
|
+ fake.recordInvocation("FolderProgressBytesCompleted", []interface{}{arg1})
|
|
|
+ fake.folderProgressBytesCompletedMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderProgressBytesCompletedCallCount() int {
|
|
|
+ fake.folderProgressBytesCompletedMutex.RLock()
|
|
|
+ defer fake.folderProgressBytesCompletedMutex.RUnlock()
|
|
|
+ return len(fake.folderProgressBytesCompletedArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderProgressBytesCompletedCalls(stub func(string) int64) {
|
|
|
+ fake.folderProgressBytesCompletedMutex.Lock()
|
|
|
+ defer fake.folderProgressBytesCompletedMutex.Unlock()
|
|
|
+ fake.FolderProgressBytesCompletedStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderProgressBytesCompletedArgsForCall(i int) string {
|
|
|
+ fake.folderProgressBytesCompletedMutex.RLock()
|
|
|
+ defer fake.folderProgressBytesCompletedMutex.RUnlock()
|
|
|
+ argsForCall := fake.folderProgressBytesCompletedArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderProgressBytesCompletedReturns(result1 int64) {
|
|
|
+ fake.folderProgressBytesCompletedMutex.Lock()
|
|
|
+ defer fake.folderProgressBytesCompletedMutex.Unlock()
|
|
|
+ fake.FolderProgressBytesCompletedStub = nil
|
|
|
+ fake.folderProgressBytesCompletedReturns = struct {
|
|
|
+ result1 int64
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderProgressBytesCompletedReturnsOnCall(i int, result1 int64) {
|
|
|
+ fake.folderProgressBytesCompletedMutex.Lock()
|
|
|
+ defer fake.folderProgressBytesCompletedMutex.Unlock()
|
|
|
+ fake.FolderProgressBytesCompletedStub = nil
|
|
|
+ if fake.folderProgressBytesCompletedReturnsOnCall == nil {
|
|
|
+ fake.folderProgressBytesCompletedReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 int64
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.folderProgressBytesCompletedReturnsOnCall[i] = struct {
|
|
|
+ result1 int64
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderStatistics() (map[string]stats.FolderStatistics, error) {
|
|
|
+ fake.folderStatisticsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.folderStatisticsReturnsOnCall[len(fake.folderStatisticsArgsForCall)]
|
|
|
+ fake.folderStatisticsArgsForCall = append(fake.folderStatisticsArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.FolderStatisticsStub
|
|
|
+ fakeReturns := fake.folderStatisticsReturns
|
|
|
+ fake.recordInvocation("FolderStatistics", []interface{}{})
|
|
|
+ fake.folderStatisticsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderStatisticsCallCount() int {
|
|
|
+ fake.folderStatisticsMutex.RLock()
|
|
|
+ defer fake.folderStatisticsMutex.RUnlock()
|
|
|
+ return len(fake.folderStatisticsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderStatisticsCalls(stub func() (map[string]stats.FolderStatistics, error)) {
|
|
|
+ fake.folderStatisticsMutex.Lock()
|
|
|
+ defer fake.folderStatisticsMutex.Unlock()
|
|
|
+ fake.FolderStatisticsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderStatisticsReturns(result1 map[string]stats.FolderStatistics, result2 error) {
|
|
|
+ fake.folderStatisticsMutex.Lock()
|
|
|
+ defer fake.folderStatisticsMutex.Unlock()
|
|
|
+ fake.FolderStatisticsStub = nil
|
|
|
+ fake.folderStatisticsReturns = struct {
|
|
|
+ result1 map[string]stats.FolderStatistics
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) FolderStatisticsReturnsOnCall(i int, result1 map[string]stats.FolderStatistics, result2 error) {
|
|
|
+ fake.folderStatisticsMutex.Lock()
|
|
|
+ defer fake.folderStatisticsMutex.Unlock()
|
|
|
+ fake.FolderStatisticsStub = nil
|
|
|
+ if fake.folderStatisticsReturnsOnCall == nil {
|
|
|
+ fake.folderStatisticsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 map[string]stats.FolderStatistics
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.folderStatisticsReturnsOnCall[i] = struct {
|
|
|
+ result1 map[string]stats.FolderStatistics
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetFolderVersions(arg1 string) (map[string][]versioner.FileVersion, error) {
|
|
|
+ fake.getFolderVersionsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getFolderVersionsReturnsOnCall[len(fake.getFolderVersionsArgsForCall)]
|
|
|
+ fake.getFolderVersionsArgsForCall = append(fake.getFolderVersionsArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.GetFolderVersionsStub
|
|
|
+ fakeReturns := fake.getFolderVersionsReturns
|
|
|
+ fake.recordInvocation("GetFolderVersions", []interface{}{arg1})
|
|
|
+ fake.getFolderVersionsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetFolderVersionsCallCount() int {
|
|
|
+ fake.getFolderVersionsMutex.RLock()
|
|
|
+ defer fake.getFolderVersionsMutex.RUnlock()
|
|
|
+ return len(fake.getFolderVersionsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetFolderVersionsCalls(stub func(string) (map[string][]versioner.FileVersion, error)) {
|
|
|
+ fake.getFolderVersionsMutex.Lock()
|
|
|
+ defer fake.getFolderVersionsMutex.Unlock()
|
|
|
+ fake.GetFolderVersionsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetFolderVersionsArgsForCall(i int) string {
|
|
|
+ fake.getFolderVersionsMutex.RLock()
|
|
|
+ defer fake.getFolderVersionsMutex.RUnlock()
|
|
|
+ argsForCall := fake.getFolderVersionsArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetFolderVersionsReturns(result1 map[string][]versioner.FileVersion, result2 error) {
|
|
|
+ fake.getFolderVersionsMutex.Lock()
|
|
|
+ defer fake.getFolderVersionsMutex.Unlock()
|
|
|
+ fake.GetFolderVersionsStub = nil
|
|
|
+ fake.getFolderVersionsReturns = struct {
|
|
|
+ result1 map[string][]versioner.FileVersion
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetFolderVersionsReturnsOnCall(i int, result1 map[string][]versioner.FileVersion, result2 error) {
|
|
|
+ fake.getFolderVersionsMutex.Lock()
|
|
|
+ defer fake.getFolderVersionsMutex.Unlock()
|
|
|
+ fake.GetFolderVersionsStub = nil
|
|
|
+ if fake.getFolderVersionsReturnsOnCall == nil {
|
|
|
+ fake.getFolderVersionsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 map[string][]versioner.FileVersion
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getFolderVersionsReturnsOnCall[i] = struct {
|
|
|
+ result1 map[string][]versioner.FileVersion
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetHello(arg1 protocol.DeviceID) protocol.HelloIntf {
|
|
|
+ fake.getHelloMutex.Lock()
|
|
|
+ ret, specificReturn := fake.getHelloReturnsOnCall[len(fake.getHelloArgsForCall)]
|
|
|
+ fake.getHelloArgsForCall = append(fake.getHelloArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.GetHelloStub
|
|
|
+ fakeReturns := fake.getHelloReturns
|
|
|
+ fake.recordInvocation("GetHello", []interface{}{arg1})
|
|
|
+ fake.getHelloMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetHelloCallCount() int {
|
|
|
+ fake.getHelloMutex.RLock()
|
|
|
+ defer fake.getHelloMutex.RUnlock()
|
|
|
+ return len(fake.getHelloArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetHelloCalls(stub func(protocol.DeviceID) protocol.HelloIntf) {
|
|
|
+ fake.getHelloMutex.Lock()
|
|
|
+ defer fake.getHelloMutex.Unlock()
|
|
|
+ fake.GetHelloStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetHelloArgsForCall(i int) protocol.DeviceID {
|
|
|
+ fake.getHelloMutex.RLock()
|
|
|
+ defer fake.getHelloMutex.RUnlock()
|
|
|
+ argsForCall := fake.getHelloArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetHelloReturns(result1 protocol.HelloIntf) {
|
|
|
+ fake.getHelloMutex.Lock()
|
|
|
+ defer fake.getHelloMutex.Unlock()
|
|
|
+ fake.GetHelloStub = nil
|
|
|
+ fake.getHelloReturns = struct {
|
|
|
+ result1 protocol.HelloIntf
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GetHelloReturnsOnCall(i int, result1 protocol.HelloIntf) {
|
|
|
+ fake.getHelloMutex.Lock()
|
|
|
+ defer fake.getHelloMutex.Unlock()
|
|
|
+ fake.GetHelloStub = nil
|
|
|
+ if fake.getHelloReturnsOnCall == nil {
|
|
|
+ fake.getHelloReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 protocol.HelloIntf
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.getHelloReturnsOnCall[i] = struct {
|
|
|
+ result1 protocol.HelloIntf
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GlobalDirectoryTree(arg1 string, arg2 string, arg3 int, arg4 bool) ([]*model.TreeEntry, error) {
|
|
|
+ fake.globalDirectoryTreeMutex.Lock()
|
|
|
+ ret, specificReturn := fake.globalDirectoryTreeReturnsOnCall[len(fake.globalDirectoryTreeArgsForCall)]
|
|
|
+ fake.globalDirectoryTreeArgsForCall = append(fake.globalDirectoryTreeArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 string
|
|
|
+ arg3 int
|
|
|
+ arg4 bool
|
|
|
+ }{arg1, arg2, arg3, arg4})
|
|
|
+ stub := fake.GlobalDirectoryTreeStub
|
|
|
+ fakeReturns := fake.globalDirectoryTreeReturns
|
|
|
+ fake.recordInvocation("GlobalDirectoryTree", []interface{}{arg1, arg2, arg3, arg4})
|
|
|
+ fake.globalDirectoryTreeMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3, arg4)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GlobalDirectoryTreeCallCount() int {
|
|
|
+ fake.globalDirectoryTreeMutex.RLock()
|
|
|
+ defer fake.globalDirectoryTreeMutex.RUnlock()
|
|
|
+ return len(fake.globalDirectoryTreeArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GlobalDirectoryTreeCalls(stub func(string, string, int, bool) ([]*model.TreeEntry, error)) {
|
|
|
+ fake.globalDirectoryTreeMutex.Lock()
|
|
|
+ defer fake.globalDirectoryTreeMutex.Unlock()
|
|
|
+ fake.GlobalDirectoryTreeStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GlobalDirectoryTreeArgsForCall(i int) (string, string, int, bool) {
|
|
|
+ fake.globalDirectoryTreeMutex.RLock()
|
|
|
+ defer fake.globalDirectoryTreeMutex.RUnlock()
|
|
|
+ argsForCall := fake.globalDirectoryTreeArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GlobalDirectoryTreeReturns(result1 []*model.TreeEntry, result2 error) {
|
|
|
+ fake.globalDirectoryTreeMutex.Lock()
|
|
|
+ defer fake.globalDirectoryTreeMutex.Unlock()
|
|
|
+ fake.GlobalDirectoryTreeStub = nil
|
|
|
+ fake.globalDirectoryTreeReturns = struct {
|
|
|
+ result1 []*model.TreeEntry
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) GlobalDirectoryTreeReturnsOnCall(i int, result1 []*model.TreeEntry, result2 error) {
|
|
|
+ fake.globalDirectoryTreeMutex.Lock()
|
|
|
+ defer fake.globalDirectoryTreeMutex.Unlock()
|
|
|
+ fake.GlobalDirectoryTreeStub = nil
|
|
|
+ if fake.globalDirectoryTreeReturnsOnCall == nil {
|
|
|
+ fake.globalDirectoryTreeReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 []*model.TreeEntry
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.globalDirectoryTreeReturnsOnCall[i] = struct {
|
|
|
+ result1 []*model.TreeEntry
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Index(arg1 protocol.DeviceID, arg2 string, arg3 []protocol.FileInfo) error {
|
|
|
+ var arg3Copy []protocol.FileInfo
|
|
|
+ if arg3 != nil {
|
|
|
+ arg3Copy = make([]protocol.FileInfo, len(arg3))
|
|
|
+ copy(arg3Copy, arg3)
|
|
|
+ }
|
|
|
+ fake.indexMutex.Lock()
|
|
|
+ ret, specificReturn := fake.indexReturnsOnCall[len(fake.indexArgsForCall)]
|
|
|
+ fake.indexArgsForCall = append(fake.indexArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ arg3 []protocol.FileInfo
|
|
|
+ }{arg1, arg2, arg3Copy})
|
|
|
+ stub := fake.IndexStub
|
|
|
+ fakeReturns := fake.indexReturns
|
|
|
+ fake.recordInvocation("Index", []interface{}{arg1, arg2, arg3Copy})
|
|
|
+ fake.indexMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexCallCount() int {
|
|
|
+ fake.indexMutex.RLock()
|
|
|
+ defer fake.indexMutex.RUnlock()
|
|
|
+ return len(fake.indexArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexCalls(stub func(protocol.DeviceID, string, []protocol.FileInfo) error) {
|
|
|
+ fake.indexMutex.Lock()
|
|
|
+ defer fake.indexMutex.Unlock()
|
|
|
+ fake.IndexStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexArgsForCall(i int) (protocol.DeviceID, string, []protocol.FileInfo) {
|
|
|
+ fake.indexMutex.RLock()
|
|
|
+ defer fake.indexMutex.RUnlock()
|
|
|
+ argsForCall := fake.indexArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexReturns(result1 error) {
|
|
|
+ fake.indexMutex.Lock()
|
|
|
+ defer fake.indexMutex.Unlock()
|
|
|
+ fake.IndexStub = nil
|
|
|
+ fake.indexReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.indexMutex.Lock()
|
|
|
+ defer fake.indexMutex.Unlock()
|
|
|
+ fake.IndexStub = nil
|
|
|
+ if fake.indexReturnsOnCall == nil {
|
|
|
+ fake.indexReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.indexReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexUpdate(arg1 protocol.DeviceID, arg2 string, arg3 []protocol.FileInfo) error {
|
|
|
+ var arg3Copy []protocol.FileInfo
|
|
|
+ if arg3 != nil {
|
|
|
+ arg3Copy = make([]protocol.FileInfo, len(arg3))
|
|
|
+ copy(arg3Copy, arg3)
|
|
|
+ }
|
|
|
+ fake.indexUpdateMutex.Lock()
|
|
|
+ ret, specificReturn := fake.indexUpdateReturnsOnCall[len(fake.indexUpdateArgsForCall)]
|
|
|
+ fake.indexUpdateArgsForCall = append(fake.indexUpdateArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ arg3 []protocol.FileInfo
|
|
|
+ }{arg1, arg2, arg3Copy})
|
|
|
+ stub := fake.IndexUpdateStub
|
|
|
+ fakeReturns := fake.indexUpdateReturns
|
|
|
+ fake.recordInvocation("IndexUpdate", []interface{}{arg1, arg2, arg3Copy})
|
|
|
+ fake.indexUpdateMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexUpdateCallCount() int {
|
|
|
+ fake.indexUpdateMutex.RLock()
|
|
|
+ defer fake.indexUpdateMutex.RUnlock()
|
|
|
+ return len(fake.indexUpdateArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexUpdateCalls(stub func(protocol.DeviceID, string, []protocol.FileInfo) error) {
|
|
|
+ fake.indexUpdateMutex.Lock()
|
|
|
+ defer fake.indexUpdateMutex.Unlock()
|
|
|
+ fake.IndexUpdateStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexUpdateArgsForCall(i int) (protocol.DeviceID, string, []protocol.FileInfo) {
|
|
|
+ fake.indexUpdateMutex.RLock()
|
|
|
+ defer fake.indexUpdateMutex.RUnlock()
|
|
|
+ argsForCall := fake.indexUpdateArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexUpdateReturns(result1 error) {
|
|
|
+ fake.indexUpdateMutex.Lock()
|
|
|
+ defer fake.indexUpdateMutex.Unlock()
|
|
|
+ fake.IndexUpdateStub = nil
|
|
|
+ fake.indexUpdateReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) IndexUpdateReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.indexUpdateMutex.Lock()
|
|
|
+ defer fake.indexUpdateMutex.Unlock()
|
|
|
+ fake.IndexUpdateStub = nil
|
|
|
+ if fake.indexUpdateReturnsOnCall == nil {
|
|
|
+ fake.indexUpdateReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.indexUpdateReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LoadIgnores(arg1 string) ([]string, []string, error) {
|
|
|
+ fake.loadIgnoresMutex.Lock()
|
|
|
+ ret, specificReturn := fake.loadIgnoresReturnsOnCall[len(fake.loadIgnoresArgsForCall)]
|
|
|
+ fake.loadIgnoresArgsForCall = append(fake.loadIgnoresArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.LoadIgnoresStub
|
|
|
+ fakeReturns := fake.loadIgnoresReturns
|
|
|
+ fake.recordInvocation("LoadIgnores", []interface{}{arg1})
|
|
|
+ fake.loadIgnoresMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2, ret.result3
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LoadIgnoresCallCount() int {
|
|
|
+ fake.loadIgnoresMutex.RLock()
|
|
|
+ defer fake.loadIgnoresMutex.RUnlock()
|
|
|
+ return len(fake.loadIgnoresArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LoadIgnoresCalls(stub func(string) ([]string, []string, error)) {
|
|
|
+ fake.loadIgnoresMutex.Lock()
|
|
|
+ defer fake.loadIgnoresMutex.Unlock()
|
|
|
+ fake.LoadIgnoresStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LoadIgnoresArgsForCall(i int) string {
|
|
|
+ fake.loadIgnoresMutex.RLock()
|
|
|
+ defer fake.loadIgnoresMutex.RUnlock()
|
|
|
+ argsForCall := fake.loadIgnoresArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LoadIgnoresReturns(result1 []string, result2 []string, result3 error) {
|
|
|
+ fake.loadIgnoresMutex.Lock()
|
|
|
+ defer fake.loadIgnoresMutex.Unlock()
|
|
|
+ fake.LoadIgnoresStub = nil
|
|
|
+ fake.loadIgnoresReturns = struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ }{result1, result2, result3}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LoadIgnoresReturnsOnCall(i int, result1 []string, result2 []string, result3 error) {
|
|
|
+ fake.loadIgnoresMutex.Lock()
|
|
|
+ defer fake.loadIgnoresMutex.Unlock()
|
|
|
+ fake.LoadIgnoresStub = nil
|
|
|
+ if fake.loadIgnoresReturnsOnCall == nil {
|
|
|
+ fake.loadIgnoresReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.loadIgnoresReturnsOnCall[i] = struct {
|
|
|
+ result1 []string
|
|
|
+ result2 []string
|
|
|
+ result3 error
|
|
|
+ }{result1, result2, result3}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LocalChangedFolderFiles(arg1 string, arg2 int, arg3 int) ([]db.FileInfoTruncated, error) {
|
|
|
+ fake.localChangedFolderFilesMutex.Lock()
|
|
|
+ ret, specificReturn := fake.localChangedFolderFilesReturnsOnCall[len(fake.localChangedFolderFilesArgsForCall)]
|
|
|
+ fake.localChangedFolderFilesArgsForCall = append(fake.localChangedFolderFilesArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 int
|
|
|
+ arg3 int
|
|
|
+ }{arg1, arg2, arg3})
|
|
|
+ stub := fake.LocalChangedFolderFilesStub
|
|
|
+ fakeReturns := fake.localChangedFolderFilesReturns
|
|
|
+ fake.recordInvocation("LocalChangedFolderFiles", []interface{}{arg1, arg2, arg3})
|
|
|
+ fake.localChangedFolderFilesMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LocalChangedFolderFilesCallCount() int {
|
|
|
+ fake.localChangedFolderFilesMutex.RLock()
|
|
|
+ defer fake.localChangedFolderFilesMutex.RUnlock()
|
|
|
+ return len(fake.localChangedFolderFilesArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LocalChangedFolderFilesCalls(stub func(string, int, int) ([]db.FileInfoTruncated, error)) {
|
|
|
+ fake.localChangedFolderFilesMutex.Lock()
|
|
|
+ defer fake.localChangedFolderFilesMutex.Unlock()
|
|
|
+ fake.LocalChangedFolderFilesStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LocalChangedFolderFilesArgsForCall(i int) (string, int, int) {
|
|
|
+ fake.localChangedFolderFilesMutex.RLock()
|
|
|
+ defer fake.localChangedFolderFilesMutex.RUnlock()
|
|
|
+ argsForCall := fake.localChangedFolderFilesArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LocalChangedFolderFilesReturns(result1 []db.FileInfoTruncated, result2 error) {
|
|
|
+ fake.localChangedFolderFilesMutex.Lock()
|
|
|
+ defer fake.localChangedFolderFilesMutex.Unlock()
|
|
|
+ fake.LocalChangedFolderFilesStub = nil
|
|
|
+ fake.localChangedFolderFilesReturns = struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) LocalChangedFolderFilesReturnsOnCall(i int, result1 []db.FileInfoTruncated, result2 error) {
|
|
|
+ fake.localChangedFolderFilesMutex.Lock()
|
|
|
+ defer fake.localChangedFolderFilesMutex.Unlock()
|
|
|
+ fake.LocalChangedFolderFilesStub = nil
|
|
|
+ if fake.localChangedFolderFilesReturnsOnCall == nil {
|
|
|
+ fake.localChangedFolderFilesReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.localChangedFolderFilesReturnsOnCall[i] = struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NeedFolderFiles(arg1 string, arg2 int, arg3 int) ([]db.FileInfoTruncated, []db.FileInfoTruncated, []db.FileInfoTruncated, error) {
|
|
|
+ fake.needFolderFilesMutex.Lock()
|
|
|
+ ret, specificReturn := fake.needFolderFilesReturnsOnCall[len(fake.needFolderFilesArgsForCall)]
|
|
|
+ fake.needFolderFilesArgsForCall = append(fake.needFolderFilesArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 int
|
|
|
+ arg3 int
|
|
|
+ }{arg1, arg2, arg3})
|
|
|
+ stub := fake.NeedFolderFilesStub
|
|
|
+ fakeReturns := fake.needFolderFilesReturns
|
|
|
+ fake.recordInvocation("NeedFolderFiles", []interface{}{arg1, arg2, arg3})
|
|
|
+ fake.needFolderFilesMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2, ret.result3, ret.result4
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NeedFolderFilesCallCount() int {
|
|
|
+ fake.needFolderFilesMutex.RLock()
|
|
|
+ defer fake.needFolderFilesMutex.RUnlock()
|
|
|
+ return len(fake.needFolderFilesArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NeedFolderFilesCalls(stub func(string, int, int) ([]db.FileInfoTruncated, []db.FileInfoTruncated, []db.FileInfoTruncated, error)) {
|
|
|
+ fake.needFolderFilesMutex.Lock()
|
|
|
+ defer fake.needFolderFilesMutex.Unlock()
|
|
|
+ fake.NeedFolderFilesStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NeedFolderFilesArgsForCall(i int) (string, int, int) {
|
|
|
+ fake.needFolderFilesMutex.RLock()
|
|
|
+ defer fake.needFolderFilesMutex.RUnlock()
|
|
|
+ argsForCall := fake.needFolderFilesArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NeedFolderFilesReturns(result1 []db.FileInfoTruncated, result2 []db.FileInfoTruncated, result3 []db.FileInfoTruncated, result4 error) {
|
|
|
+ fake.needFolderFilesMutex.Lock()
|
|
|
+ defer fake.needFolderFilesMutex.Unlock()
|
|
|
+ fake.NeedFolderFilesStub = nil
|
|
|
+ fake.needFolderFilesReturns = struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 []db.FileInfoTruncated
|
|
|
+ result3 []db.FileInfoTruncated
|
|
|
+ result4 error
|
|
|
+ }{result1, result2, result3, result4}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NeedFolderFilesReturnsOnCall(i int, result1 []db.FileInfoTruncated, result2 []db.FileInfoTruncated, result3 []db.FileInfoTruncated, result4 error) {
|
|
|
+ fake.needFolderFilesMutex.Lock()
|
|
|
+ defer fake.needFolderFilesMutex.Unlock()
|
|
|
+ fake.NeedFolderFilesStub = nil
|
|
|
+ if fake.needFolderFilesReturnsOnCall == nil {
|
|
|
+ fake.needFolderFilesReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 []db.FileInfoTruncated
|
|
|
+ result3 []db.FileInfoTruncated
|
|
|
+ result4 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.needFolderFilesReturnsOnCall[i] = struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 []db.FileInfoTruncated
|
|
|
+ result3 []db.FileInfoTruncated
|
|
|
+ result4 error
|
|
|
+ }{result1, result2, result3, result4}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NumConnections() int {
|
|
|
+ fake.numConnectionsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.numConnectionsReturnsOnCall[len(fake.numConnectionsArgsForCall)]
|
|
|
+ fake.numConnectionsArgsForCall = append(fake.numConnectionsArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.NumConnectionsStub
|
|
|
+ fakeReturns := fake.numConnectionsReturns
|
|
|
+ fake.recordInvocation("NumConnections", []interface{}{})
|
|
|
+ fake.numConnectionsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NumConnectionsCallCount() int {
|
|
|
+ fake.numConnectionsMutex.RLock()
|
|
|
+ defer fake.numConnectionsMutex.RUnlock()
|
|
|
+ return len(fake.numConnectionsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NumConnectionsCalls(stub func() int) {
|
|
|
+ fake.numConnectionsMutex.Lock()
|
|
|
+ defer fake.numConnectionsMutex.Unlock()
|
|
|
+ fake.NumConnectionsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NumConnectionsReturns(result1 int) {
|
|
|
+ fake.numConnectionsMutex.Lock()
|
|
|
+ defer fake.numConnectionsMutex.Unlock()
|
|
|
+ fake.NumConnectionsStub = nil
|
|
|
+ fake.numConnectionsReturns = struct {
|
|
|
+ result1 int
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) NumConnectionsReturnsOnCall(i int, result1 int) {
|
|
|
+ fake.numConnectionsMutex.Lock()
|
|
|
+ defer fake.numConnectionsMutex.Unlock()
|
|
|
+ fake.NumConnectionsStub = nil
|
|
|
+ if fake.numConnectionsReturnsOnCall == nil {
|
|
|
+ fake.numConnectionsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 int
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.numConnectionsReturnsOnCall[i] = struct {
|
|
|
+ result1 int
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OnHello(arg1 protocol.DeviceID, arg2 net.Addr, arg3 protocol.Hello) error {
|
|
|
+ fake.onHelloMutex.Lock()
|
|
|
+ ret, specificReturn := fake.onHelloReturnsOnCall[len(fake.onHelloArgsForCall)]
|
|
|
+ fake.onHelloArgsForCall = append(fake.onHelloArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 net.Addr
|
|
|
+ arg3 protocol.Hello
|
|
|
+ }{arg1, arg2, arg3})
|
|
|
+ stub := fake.OnHelloStub
|
|
|
+ fakeReturns := fake.onHelloReturns
|
|
|
+ fake.recordInvocation("OnHello", []interface{}{arg1, arg2, arg3})
|
|
|
+ fake.onHelloMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OnHelloCallCount() int {
|
|
|
+ fake.onHelloMutex.RLock()
|
|
|
+ defer fake.onHelloMutex.RUnlock()
|
|
|
+ return len(fake.onHelloArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OnHelloCalls(stub func(protocol.DeviceID, net.Addr, protocol.Hello) error) {
|
|
|
+ fake.onHelloMutex.Lock()
|
|
|
+ defer fake.onHelloMutex.Unlock()
|
|
|
+ fake.OnHelloStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OnHelloArgsForCall(i int) (protocol.DeviceID, net.Addr, protocol.Hello) {
|
|
|
+ fake.onHelloMutex.RLock()
|
|
|
+ defer fake.onHelloMutex.RUnlock()
|
|
|
+ argsForCall := fake.onHelloArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OnHelloReturns(result1 error) {
|
|
|
+ fake.onHelloMutex.Lock()
|
|
|
+ defer fake.onHelloMutex.Unlock()
|
|
|
+ fake.OnHelloStub = nil
|
|
|
+ fake.onHelloReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OnHelloReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.onHelloMutex.Lock()
|
|
|
+ defer fake.onHelloMutex.Unlock()
|
|
|
+ fake.OnHelloStub = nil
|
|
|
+ if fake.onHelloReturnsOnCall == nil {
|
|
|
+ fake.onHelloReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.onHelloReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Override(arg1 string) {
|
|
|
+ fake.overrideMutex.Lock()
|
|
|
+ fake.overrideArgsForCall = append(fake.overrideArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.OverrideStub
|
|
|
+ fake.recordInvocation("Override", []interface{}{arg1})
|
|
|
+ fake.overrideMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.OverrideStub(arg1)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OverrideCallCount() int {
|
|
|
+ fake.overrideMutex.RLock()
|
|
|
+ defer fake.overrideMutex.RUnlock()
|
|
|
+ return len(fake.overrideArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OverrideCalls(stub func(string)) {
|
|
|
+ fake.overrideMutex.Lock()
|
|
|
+ defer fake.overrideMutex.Unlock()
|
|
|
+ fake.OverrideStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) OverrideArgsForCall(i int) string {
|
|
|
+ fake.overrideMutex.RLock()
|
|
|
+ defer fake.overrideMutex.RUnlock()
|
|
|
+ argsForCall := fake.overrideArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingDevices() (map[protocol.DeviceID]db.ObservedDevice, error) {
|
|
|
+ fake.pendingDevicesMutex.Lock()
|
|
|
+ ret, specificReturn := fake.pendingDevicesReturnsOnCall[len(fake.pendingDevicesArgsForCall)]
|
|
|
+ fake.pendingDevicesArgsForCall = append(fake.pendingDevicesArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.PendingDevicesStub
|
|
|
+ fakeReturns := fake.pendingDevicesReturns
|
|
|
+ fake.recordInvocation("PendingDevices", []interface{}{})
|
|
|
+ fake.pendingDevicesMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingDevicesCallCount() int {
|
|
|
+ fake.pendingDevicesMutex.RLock()
|
|
|
+ defer fake.pendingDevicesMutex.RUnlock()
|
|
|
+ return len(fake.pendingDevicesArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingDevicesCalls(stub func() (map[protocol.DeviceID]db.ObservedDevice, error)) {
|
|
|
+ fake.pendingDevicesMutex.Lock()
|
|
|
+ defer fake.pendingDevicesMutex.Unlock()
|
|
|
+ fake.PendingDevicesStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingDevicesReturns(result1 map[protocol.DeviceID]db.ObservedDevice, result2 error) {
|
|
|
+ fake.pendingDevicesMutex.Lock()
|
|
|
+ defer fake.pendingDevicesMutex.Unlock()
|
|
|
+ fake.PendingDevicesStub = nil
|
|
|
+ fake.pendingDevicesReturns = struct {
|
|
|
+ result1 map[protocol.DeviceID]db.ObservedDevice
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingDevicesReturnsOnCall(i int, result1 map[protocol.DeviceID]db.ObservedDevice, result2 error) {
|
|
|
+ fake.pendingDevicesMutex.Lock()
|
|
|
+ defer fake.pendingDevicesMutex.Unlock()
|
|
|
+ fake.PendingDevicesStub = nil
|
|
|
+ if fake.pendingDevicesReturnsOnCall == nil {
|
|
|
+ fake.pendingDevicesReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 map[protocol.DeviceID]db.ObservedDevice
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.pendingDevicesReturnsOnCall[i] = struct {
|
|
|
+ result1 map[protocol.DeviceID]db.ObservedDevice
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingFolders(arg1 protocol.DeviceID) (map[string]db.PendingFolder, error) {
|
|
|
+ fake.pendingFoldersMutex.Lock()
|
|
|
+ ret, specificReturn := fake.pendingFoldersReturnsOnCall[len(fake.pendingFoldersArgsForCall)]
|
|
|
+ fake.pendingFoldersArgsForCall = append(fake.pendingFoldersArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.PendingFoldersStub
|
|
|
+ fakeReturns := fake.pendingFoldersReturns
|
|
|
+ fake.recordInvocation("PendingFolders", []interface{}{arg1})
|
|
|
+ fake.pendingFoldersMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingFoldersCallCount() int {
|
|
|
+ fake.pendingFoldersMutex.RLock()
|
|
|
+ defer fake.pendingFoldersMutex.RUnlock()
|
|
|
+ return len(fake.pendingFoldersArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingFoldersCalls(stub func(protocol.DeviceID) (map[string]db.PendingFolder, error)) {
|
|
|
+ fake.pendingFoldersMutex.Lock()
|
|
|
+ defer fake.pendingFoldersMutex.Unlock()
|
|
|
+ fake.PendingFoldersStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingFoldersArgsForCall(i int) protocol.DeviceID {
|
|
|
+ fake.pendingFoldersMutex.RLock()
|
|
|
+ defer fake.pendingFoldersMutex.RUnlock()
|
|
|
+ argsForCall := fake.pendingFoldersArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingFoldersReturns(result1 map[string]db.PendingFolder, result2 error) {
|
|
|
+ fake.pendingFoldersMutex.Lock()
|
|
|
+ defer fake.pendingFoldersMutex.Unlock()
|
|
|
+ fake.PendingFoldersStub = nil
|
|
|
+ fake.pendingFoldersReturns = struct {
|
|
|
+ result1 map[string]db.PendingFolder
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) PendingFoldersReturnsOnCall(i int, result1 map[string]db.PendingFolder, result2 error) {
|
|
|
+ fake.pendingFoldersMutex.Lock()
|
|
|
+ defer fake.pendingFoldersMutex.Unlock()
|
|
|
+ fake.PendingFoldersStub = nil
|
|
|
+ if fake.pendingFoldersReturnsOnCall == nil {
|
|
|
+ fake.pendingFoldersReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 map[string]db.PendingFolder
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.pendingFoldersReturnsOnCall[i] = struct {
|
|
|
+ result1 map[string]db.PendingFolder
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RemoteNeedFolderFiles(arg1 string, arg2 protocol.DeviceID, arg3 int, arg4 int) ([]db.FileInfoTruncated, error) {
|
|
|
+ fake.remoteNeedFolderFilesMutex.Lock()
|
|
|
+ ret, specificReturn := fake.remoteNeedFolderFilesReturnsOnCall[len(fake.remoteNeedFolderFilesArgsForCall)]
|
|
|
+ fake.remoteNeedFolderFilesArgsForCall = append(fake.remoteNeedFolderFilesArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 protocol.DeviceID
|
|
|
+ arg3 int
|
|
|
+ arg4 int
|
|
|
+ }{arg1, arg2, arg3, arg4})
|
|
|
+ stub := fake.RemoteNeedFolderFilesStub
|
|
|
+ fakeReturns := fake.remoteNeedFolderFilesReturns
|
|
|
+ fake.recordInvocation("RemoteNeedFolderFiles", []interface{}{arg1, arg2, arg3, arg4})
|
|
|
+ fake.remoteNeedFolderFilesMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3, arg4)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RemoteNeedFolderFilesCallCount() int {
|
|
|
+ fake.remoteNeedFolderFilesMutex.RLock()
|
|
|
+ defer fake.remoteNeedFolderFilesMutex.RUnlock()
|
|
|
+ return len(fake.remoteNeedFolderFilesArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RemoteNeedFolderFilesCalls(stub func(string, protocol.DeviceID, int, int) ([]db.FileInfoTruncated, error)) {
|
|
|
+ fake.remoteNeedFolderFilesMutex.Lock()
|
|
|
+ defer fake.remoteNeedFolderFilesMutex.Unlock()
|
|
|
+ fake.RemoteNeedFolderFilesStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RemoteNeedFolderFilesArgsForCall(i int) (string, protocol.DeviceID, int, int) {
|
|
|
+ fake.remoteNeedFolderFilesMutex.RLock()
|
|
|
+ defer fake.remoteNeedFolderFilesMutex.RUnlock()
|
|
|
+ argsForCall := fake.remoteNeedFolderFilesArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RemoteNeedFolderFilesReturns(result1 []db.FileInfoTruncated, result2 error) {
|
|
|
+ fake.remoteNeedFolderFilesMutex.Lock()
|
|
|
+ defer fake.remoteNeedFolderFilesMutex.Unlock()
|
|
|
+ fake.RemoteNeedFolderFilesStub = nil
|
|
|
+ fake.remoteNeedFolderFilesReturns = struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RemoteNeedFolderFilesReturnsOnCall(i int, result1 []db.FileInfoTruncated, result2 error) {
|
|
|
+ fake.remoteNeedFolderFilesMutex.Lock()
|
|
|
+ defer fake.remoteNeedFolderFilesMutex.Unlock()
|
|
|
+ fake.RemoteNeedFolderFilesStub = nil
|
|
|
+ if fake.remoteNeedFolderFilesReturnsOnCall == nil {
|
|
|
+ fake.remoteNeedFolderFilesReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.remoteNeedFolderFilesReturnsOnCall[i] = struct {
|
|
|
+ result1 []db.FileInfoTruncated
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Request(arg1 protocol.DeviceID, arg2 string, arg3 string, arg4 int32, arg5 int32, arg6 int64, arg7 []byte, arg8 uint32, arg9 bool) (protocol.RequestResponse, error) {
|
|
|
+ var arg7Copy []byte
|
|
|
+ if arg7 != nil {
|
|
|
+ arg7Copy = make([]byte, len(arg7))
|
|
|
+ copy(arg7Copy, arg7)
|
|
|
+ }
|
|
|
+ fake.requestMutex.Lock()
|
|
|
+ ret, specificReturn := fake.requestReturnsOnCall[len(fake.requestArgsForCall)]
|
|
|
+ fake.requestArgsForCall = append(fake.requestArgsForCall, struct {
|
|
|
+ arg1 protocol.DeviceID
|
|
|
+ arg2 string
|
|
|
+ arg3 string
|
|
|
+ arg4 int32
|
|
|
+ arg5 int32
|
|
|
+ arg6 int64
|
|
|
+ arg7 []byte
|
|
|
+ arg8 uint32
|
|
|
+ arg9 bool
|
|
|
+ }{arg1, arg2, arg3, arg4, arg5, arg6, arg7Copy, arg8, arg9})
|
|
|
+ stub := fake.RequestStub
|
|
|
+ fakeReturns := fake.requestReturns
|
|
|
+ fake.recordInvocation("Request", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7Copy, arg8, arg9})
|
|
|
+ fake.requestMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RequestCallCount() int {
|
|
|
+ fake.requestMutex.RLock()
|
|
|
+ defer fake.requestMutex.RUnlock()
|
|
|
+ return len(fake.requestArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RequestCalls(stub func(protocol.DeviceID, string, string, int32, int32, int64, []byte, uint32, bool) (protocol.RequestResponse, error)) {
|
|
|
+ fake.requestMutex.Lock()
|
|
|
+ defer fake.requestMutex.Unlock()
|
|
|
+ fake.RequestStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RequestArgsForCall(i int) (protocol.DeviceID, string, string, int32, int32, int64, []byte, uint32, bool) {
|
|
|
+ fake.requestMutex.RLock()
|
|
|
+ defer fake.requestMutex.RUnlock()
|
|
|
+ argsForCall := fake.requestArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8, argsForCall.arg9
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RequestReturns(result1 protocol.RequestResponse, result2 error) {
|
|
|
+ fake.requestMutex.Lock()
|
|
|
+ defer fake.requestMutex.Unlock()
|
|
|
+ fake.RequestStub = nil
|
|
|
+ fake.requestReturns = struct {
|
|
|
+ result1 protocol.RequestResponse
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RequestReturnsOnCall(i int, result1 protocol.RequestResponse, result2 error) {
|
|
|
+ fake.requestMutex.Lock()
|
|
|
+ defer fake.requestMutex.Unlock()
|
|
|
+ fake.RequestStub = nil
|
|
|
+ if fake.requestReturnsOnCall == nil {
|
|
|
+ fake.requestReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 protocol.RequestResponse
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.requestReturnsOnCall[i] = struct {
|
|
|
+ result1 protocol.RequestResponse
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ResetFolder(arg1 string) {
|
|
|
+ fake.resetFolderMutex.Lock()
|
|
|
+ fake.resetFolderArgsForCall = append(fake.resetFolderArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.ResetFolderStub
|
|
|
+ fake.recordInvocation("ResetFolder", []interface{}{arg1})
|
|
|
+ fake.resetFolderMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.ResetFolderStub(arg1)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ResetFolderCallCount() int {
|
|
|
+ fake.resetFolderMutex.RLock()
|
|
|
+ defer fake.resetFolderMutex.RUnlock()
|
|
|
+ return len(fake.resetFolderArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ResetFolderCalls(stub func(string)) {
|
|
|
+ fake.resetFolderMutex.Lock()
|
|
|
+ defer fake.resetFolderMutex.Unlock()
|
|
|
+ fake.ResetFolderStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ResetFolderArgsForCall(i int) string {
|
|
|
+ fake.resetFolderMutex.RLock()
|
|
|
+ defer fake.resetFolderMutex.RUnlock()
|
|
|
+ argsForCall := fake.resetFolderArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RestoreFolderVersions(arg1 string, arg2 map[string]time.Time) (map[string]error, error) {
|
|
|
+ fake.restoreFolderVersionsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.restoreFolderVersionsReturnsOnCall[len(fake.restoreFolderVersionsArgsForCall)]
|
|
|
+ fake.restoreFolderVersionsArgsForCall = append(fake.restoreFolderVersionsArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 map[string]time.Time
|
|
|
+ }{arg1, arg2})
|
|
|
+ stub := fake.RestoreFolderVersionsStub
|
|
|
+ fakeReturns := fake.restoreFolderVersionsReturns
|
|
|
+ fake.recordInvocation("RestoreFolderVersions", []interface{}{arg1, arg2})
|
|
|
+ fake.restoreFolderVersionsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RestoreFolderVersionsCallCount() int {
|
|
|
+ fake.restoreFolderVersionsMutex.RLock()
|
|
|
+ defer fake.restoreFolderVersionsMutex.RUnlock()
|
|
|
+ return len(fake.restoreFolderVersionsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RestoreFolderVersionsCalls(stub func(string, map[string]time.Time) (map[string]error, error)) {
|
|
|
+ fake.restoreFolderVersionsMutex.Lock()
|
|
|
+ defer fake.restoreFolderVersionsMutex.Unlock()
|
|
|
+ fake.RestoreFolderVersionsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RestoreFolderVersionsArgsForCall(i int) (string, map[string]time.Time) {
|
|
|
+ fake.restoreFolderVersionsMutex.RLock()
|
|
|
+ defer fake.restoreFolderVersionsMutex.RUnlock()
|
|
|
+ argsForCall := fake.restoreFolderVersionsArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RestoreFolderVersionsReturns(result1 map[string]error, result2 error) {
|
|
|
+ fake.restoreFolderVersionsMutex.Lock()
|
|
|
+ defer fake.restoreFolderVersionsMutex.Unlock()
|
|
|
+ fake.RestoreFolderVersionsStub = nil
|
|
|
+ fake.restoreFolderVersionsReturns = struct {
|
|
|
+ result1 map[string]error
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RestoreFolderVersionsReturnsOnCall(i int, result1 map[string]error, result2 error) {
|
|
|
+ fake.restoreFolderVersionsMutex.Lock()
|
|
|
+ defer fake.restoreFolderVersionsMutex.Unlock()
|
|
|
+ fake.RestoreFolderVersionsStub = nil
|
|
|
+ if fake.restoreFolderVersionsReturnsOnCall == nil {
|
|
|
+ fake.restoreFolderVersionsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 map[string]error
|
|
|
+ result2 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.restoreFolderVersionsReturnsOnCall[i] = struct {
|
|
|
+ result1 map[string]error
|
|
|
+ result2 error
|
|
|
+ }{result1, result2}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Revert(arg1 string) {
|
|
|
+ fake.revertMutex.Lock()
|
|
|
+ fake.revertArgsForCall = append(fake.revertArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.RevertStub
|
|
|
+ fake.recordInvocation("Revert", []interface{}{arg1})
|
|
|
+ fake.revertMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.RevertStub(arg1)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RevertCallCount() int {
|
|
|
+ fake.revertMutex.RLock()
|
|
|
+ defer fake.revertMutex.RUnlock()
|
|
|
+ return len(fake.revertArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RevertCalls(stub func(string)) {
|
|
|
+ fake.revertMutex.Lock()
|
|
|
+ defer fake.revertMutex.Unlock()
|
|
|
+ fake.RevertStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) RevertArgsForCall(i int) string {
|
|
|
+ fake.revertMutex.RLock()
|
|
|
+ defer fake.revertMutex.RUnlock()
|
|
|
+ argsForCall := fake.revertArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolder(arg1 string) error {
|
|
|
+ fake.scanFolderMutex.Lock()
|
|
|
+ ret, specificReturn := fake.scanFolderReturnsOnCall[len(fake.scanFolderArgsForCall)]
|
|
|
+ fake.scanFolderArgsForCall = append(fake.scanFolderArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.ScanFolderStub
|
|
|
+ fakeReturns := fake.scanFolderReturns
|
|
|
+ fake.recordInvocation("ScanFolder", []interface{}{arg1})
|
|
|
+ fake.scanFolderMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderCallCount() int {
|
|
|
+ fake.scanFolderMutex.RLock()
|
|
|
+ defer fake.scanFolderMutex.RUnlock()
|
|
|
+ return len(fake.scanFolderArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderCalls(stub func(string) error) {
|
|
|
+ fake.scanFolderMutex.Lock()
|
|
|
+ defer fake.scanFolderMutex.Unlock()
|
|
|
+ fake.ScanFolderStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderArgsForCall(i int) string {
|
|
|
+ fake.scanFolderMutex.RLock()
|
|
|
+ defer fake.scanFolderMutex.RUnlock()
|
|
|
+ argsForCall := fake.scanFolderArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderReturns(result1 error) {
|
|
|
+ fake.scanFolderMutex.Lock()
|
|
|
+ defer fake.scanFolderMutex.Unlock()
|
|
|
+ fake.ScanFolderStub = nil
|
|
|
+ fake.scanFolderReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.scanFolderMutex.Lock()
|
|
|
+ defer fake.scanFolderMutex.Unlock()
|
|
|
+ fake.ScanFolderStub = nil
|
|
|
+ if fake.scanFolderReturnsOnCall == nil {
|
|
|
+ fake.scanFolderReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.scanFolderReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderSubdirs(arg1 string, arg2 []string) error {
|
|
|
+ var arg2Copy []string
|
|
|
+ if arg2 != nil {
|
|
|
+ arg2Copy = make([]string, len(arg2))
|
|
|
+ copy(arg2Copy, arg2)
|
|
|
+ }
|
|
|
+ fake.scanFolderSubdirsMutex.Lock()
|
|
|
+ ret, specificReturn := fake.scanFolderSubdirsReturnsOnCall[len(fake.scanFolderSubdirsArgsForCall)]
|
|
|
+ fake.scanFolderSubdirsArgsForCall = append(fake.scanFolderSubdirsArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 []string
|
|
|
+ }{arg1, arg2Copy})
|
|
|
+ stub := fake.ScanFolderSubdirsStub
|
|
|
+ fakeReturns := fake.scanFolderSubdirsReturns
|
|
|
+ fake.recordInvocation("ScanFolderSubdirs", []interface{}{arg1, arg2Copy})
|
|
|
+ fake.scanFolderSubdirsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderSubdirsCallCount() int {
|
|
|
+ fake.scanFolderSubdirsMutex.RLock()
|
|
|
+ defer fake.scanFolderSubdirsMutex.RUnlock()
|
|
|
+ return len(fake.scanFolderSubdirsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderSubdirsCalls(stub func(string, []string) error) {
|
|
|
+ fake.scanFolderSubdirsMutex.Lock()
|
|
|
+ defer fake.scanFolderSubdirsMutex.Unlock()
|
|
|
+ fake.ScanFolderSubdirsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderSubdirsArgsForCall(i int) (string, []string) {
|
|
|
+ fake.scanFolderSubdirsMutex.RLock()
|
|
|
+ defer fake.scanFolderSubdirsMutex.RUnlock()
|
|
|
+ argsForCall := fake.scanFolderSubdirsArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderSubdirsReturns(result1 error) {
|
|
|
+ fake.scanFolderSubdirsMutex.Lock()
|
|
|
+ defer fake.scanFolderSubdirsMutex.Unlock()
|
|
|
+ fake.ScanFolderSubdirsStub = nil
|
|
|
+ fake.scanFolderSubdirsReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolderSubdirsReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.scanFolderSubdirsMutex.Lock()
|
|
|
+ defer fake.scanFolderSubdirsMutex.Unlock()
|
|
|
+ fake.ScanFolderSubdirsStub = nil
|
|
|
+ if fake.scanFolderSubdirsReturnsOnCall == nil {
|
|
|
+ fake.scanFolderSubdirsReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.scanFolderSubdirsReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFolders() map[string]error {
|
|
|
+ fake.scanFoldersMutex.Lock()
|
|
|
+ ret, specificReturn := fake.scanFoldersReturnsOnCall[len(fake.scanFoldersArgsForCall)]
|
|
|
+ fake.scanFoldersArgsForCall = append(fake.scanFoldersArgsForCall, struct {
|
|
|
+ }{})
|
|
|
+ stub := fake.ScanFoldersStub
|
|
|
+ fakeReturns := fake.scanFoldersReturns
|
|
|
+ fake.recordInvocation("ScanFolders", []interface{}{})
|
|
|
+ fake.scanFoldersMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub()
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFoldersCallCount() int {
|
|
|
+ fake.scanFoldersMutex.RLock()
|
|
|
+ defer fake.scanFoldersMutex.RUnlock()
|
|
|
+ return len(fake.scanFoldersArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFoldersCalls(stub func() map[string]error) {
|
|
|
+ fake.scanFoldersMutex.Lock()
|
|
|
+ defer fake.scanFoldersMutex.Unlock()
|
|
|
+ fake.ScanFoldersStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFoldersReturns(result1 map[string]error) {
|
|
|
+ fake.scanFoldersMutex.Lock()
|
|
|
+ defer fake.scanFoldersMutex.Unlock()
|
|
|
+ fake.ScanFoldersStub = nil
|
|
|
+ fake.scanFoldersReturns = struct {
|
|
|
+ result1 map[string]error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ScanFoldersReturnsOnCall(i int, result1 map[string]error) {
|
|
|
+ fake.scanFoldersMutex.Lock()
|
|
|
+ defer fake.scanFoldersMutex.Unlock()
|
|
|
+ fake.ScanFoldersStub = nil
|
|
|
+ if fake.scanFoldersReturnsOnCall == nil {
|
|
|
+ fake.scanFoldersReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 map[string]error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.scanFoldersReturnsOnCall[i] = struct {
|
|
|
+ result1 map[string]error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Serve(arg1 context.Context) error {
|
|
|
+ fake.serveMutex.Lock()
|
|
|
+ ret, specificReturn := fake.serveReturnsOnCall[len(fake.serveArgsForCall)]
|
|
|
+ fake.serveArgsForCall = append(fake.serveArgsForCall, struct {
|
|
|
+ arg1 context.Context
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.ServeStub
|
|
|
+ fakeReturns := fake.serveReturns
|
|
|
+ fake.recordInvocation("Serve", []interface{}{arg1})
|
|
|
+ fake.serveMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ServeCallCount() int {
|
|
|
+ fake.serveMutex.RLock()
|
|
|
+ defer fake.serveMutex.RUnlock()
|
|
|
+ return len(fake.serveArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ServeCalls(stub func(context.Context) error) {
|
|
|
+ fake.serveMutex.Lock()
|
|
|
+ defer fake.serveMutex.Unlock()
|
|
|
+ fake.ServeStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ServeArgsForCall(i int) context.Context {
|
|
|
+ fake.serveMutex.RLock()
|
|
|
+ defer fake.serveMutex.RUnlock()
|
|
|
+ argsForCall := fake.serveArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ServeReturns(result1 error) {
|
|
|
+ fake.serveMutex.Lock()
|
|
|
+ defer fake.serveMutex.Unlock()
|
|
|
+ fake.ServeStub = nil
|
|
|
+ fake.serveReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) ServeReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.serveMutex.Lock()
|
|
|
+ defer fake.serveMutex.Unlock()
|
|
|
+ fake.ServeStub = nil
|
|
|
+ if fake.serveReturnsOnCall == nil {
|
|
|
+ fake.serveReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.serveReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) SetIgnores(arg1 string, arg2 []string) error {
|
|
|
+ var arg2Copy []string
|
|
|
+ if arg2 != nil {
|
|
|
+ arg2Copy = make([]string, len(arg2))
|
|
|
+ copy(arg2Copy, arg2)
|
|
|
+ }
|
|
|
+ fake.setIgnoresMutex.Lock()
|
|
|
+ ret, specificReturn := fake.setIgnoresReturnsOnCall[len(fake.setIgnoresArgsForCall)]
|
|
|
+ fake.setIgnoresArgsForCall = append(fake.setIgnoresArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ arg2 []string
|
|
|
+ }{arg1, arg2Copy})
|
|
|
+ stub := fake.SetIgnoresStub
|
|
|
+ fakeReturns := fake.setIgnoresReturns
|
|
|
+ fake.recordInvocation("SetIgnores", []interface{}{arg1, arg2Copy})
|
|
|
+ fake.setIgnoresMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1, arg2)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) SetIgnoresCallCount() int {
|
|
|
+ fake.setIgnoresMutex.RLock()
|
|
|
+ defer fake.setIgnoresMutex.RUnlock()
|
|
|
+ return len(fake.setIgnoresArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) SetIgnoresCalls(stub func(string, []string) error) {
|
|
|
+ fake.setIgnoresMutex.Lock()
|
|
|
+ defer fake.setIgnoresMutex.Unlock()
|
|
|
+ fake.SetIgnoresStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) SetIgnoresArgsForCall(i int) (string, []string) {
|
|
|
+ fake.setIgnoresMutex.RLock()
|
|
|
+ defer fake.setIgnoresMutex.RUnlock()
|
|
|
+ argsForCall := fake.setIgnoresArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) SetIgnoresReturns(result1 error) {
|
|
|
+ fake.setIgnoresMutex.Lock()
|
|
|
+ defer fake.setIgnoresMutex.Unlock()
|
|
|
+ fake.SetIgnoresStub = nil
|
|
|
+ fake.setIgnoresReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) SetIgnoresReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.setIgnoresMutex.Lock()
|
|
|
+ defer fake.setIgnoresMutex.Unlock()
|
|
|
+ fake.SetIgnoresStub = nil
|
|
|
+ if fake.setIgnoresReturnsOnCall == nil {
|
|
|
+ fake.setIgnoresReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.setIgnoresReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StartDeadlockDetector(arg1 time.Duration) {
|
|
|
+ fake.startDeadlockDetectorMutex.Lock()
|
|
|
+ fake.startDeadlockDetectorArgsForCall = append(fake.startDeadlockDetectorArgsForCall, struct {
|
|
|
+ arg1 time.Duration
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.StartDeadlockDetectorStub
|
|
|
+ fake.recordInvocation("StartDeadlockDetector", []interface{}{arg1})
|
|
|
+ fake.startDeadlockDetectorMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.StartDeadlockDetectorStub(arg1)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StartDeadlockDetectorCallCount() int {
|
|
|
+ fake.startDeadlockDetectorMutex.RLock()
|
|
|
+ defer fake.startDeadlockDetectorMutex.RUnlock()
|
|
|
+ return len(fake.startDeadlockDetectorArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StartDeadlockDetectorCalls(stub func(time.Duration)) {
|
|
|
+ fake.startDeadlockDetectorMutex.Lock()
|
|
|
+ defer fake.startDeadlockDetectorMutex.Unlock()
|
|
|
+ fake.StartDeadlockDetectorStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StartDeadlockDetectorArgsForCall(i int) time.Duration {
|
|
|
+ fake.startDeadlockDetectorMutex.RLock()
|
|
|
+ defer fake.startDeadlockDetectorMutex.RUnlock()
|
|
|
+ argsForCall := fake.startDeadlockDetectorArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) State(arg1 string) (string, time.Time, error) {
|
|
|
+ fake.stateMutex.Lock()
|
|
|
+ ret, specificReturn := fake.stateReturnsOnCall[len(fake.stateArgsForCall)]
|
|
|
+ fake.stateArgsForCall = append(fake.stateArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.StateStub
|
|
|
+ fakeReturns := fake.stateReturns
|
|
|
+ fake.recordInvocation("State", []interface{}{arg1})
|
|
|
+ fake.stateMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1, ret.result2, ret.result3
|
|
|
+ }
|
|
|
+ return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StateCallCount() int {
|
|
|
+ fake.stateMutex.RLock()
|
|
|
+ defer fake.stateMutex.RUnlock()
|
|
|
+ return len(fake.stateArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StateCalls(stub func(string) (string, time.Time, error)) {
|
|
|
+ fake.stateMutex.Lock()
|
|
|
+ defer fake.stateMutex.Unlock()
|
|
|
+ fake.StateStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StateArgsForCall(i int) string {
|
|
|
+ fake.stateMutex.RLock()
|
|
|
+ defer fake.stateMutex.RUnlock()
|
|
|
+ argsForCall := fake.stateArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StateReturns(result1 string, result2 time.Time, result3 error) {
|
|
|
+ fake.stateMutex.Lock()
|
|
|
+ defer fake.stateMutex.Unlock()
|
|
|
+ fake.StateStub = nil
|
|
|
+ fake.stateReturns = struct {
|
|
|
+ result1 string
|
|
|
+ result2 time.Time
|
|
|
+ result3 error
|
|
|
+ }{result1, result2, result3}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) StateReturnsOnCall(i int, result1 string, result2 time.Time, result3 error) {
|
|
|
+ fake.stateMutex.Lock()
|
|
|
+ defer fake.stateMutex.Unlock()
|
|
|
+ fake.StateStub = nil
|
|
|
+ if fake.stateReturnsOnCall == nil {
|
|
|
+ fake.stateReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 string
|
|
|
+ result2 time.Time
|
|
|
+ result3 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.stateReturnsOnCall[i] = struct {
|
|
|
+ result1 string
|
|
|
+ result2 time.Time
|
|
|
+ result3 error
|
|
|
+ }{result1, result2, result3}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) UsageReportingStats(arg1 *contract.Report, arg2 int, arg3 bool) {
|
|
|
+ fake.usageReportingStatsMutex.Lock()
|
|
|
+ fake.usageReportingStatsArgsForCall = append(fake.usageReportingStatsArgsForCall, struct {
|
|
|
+ arg1 *contract.Report
|
|
|
+ arg2 int
|
|
|
+ arg3 bool
|
|
|
+ }{arg1, arg2, arg3})
|
|
|
+ stub := fake.UsageReportingStatsStub
|
|
|
+ fake.recordInvocation("UsageReportingStats", []interface{}{arg1, arg2, arg3})
|
|
|
+ fake.usageReportingStatsMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ fake.UsageReportingStatsStub(arg1, arg2, arg3)
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) UsageReportingStatsCallCount() int {
|
|
|
+ fake.usageReportingStatsMutex.RLock()
|
|
|
+ defer fake.usageReportingStatsMutex.RUnlock()
|
|
|
+ return len(fake.usageReportingStatsArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) UsageReportingStatsCalls(stub func(*contract.Report, int, bool)) {
|
|
|
+ fake.usageReportingStatsMutex.Lock()
|
|
|
+ defer fake.usageReportingStatsMutex.Unlock()
|
|
|
+ fake.UsageReportingStatsStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) UsageReportingStatsArgsForCall(i int) (*contract.Report, int, bool) {
|
|
|
+ fake.usageReportingStatsMutex.RLock()
|
|
|
+ defer fake.usageReportingStatsMutex.RUnlock()
|
|
|
+ argsForCall := fake.usageReportingStatsArgsForCall[i]
|
|
|
+ return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) WatchError(arg1 string) error {
|
|
|
+ fake.watchErrorMutex.Lock()
|
|
|
+ ret, specificReturn := fake.watchErrorReturnsOnCall[len(fake.watchErrorArgsForCall)]
|
|
|
+ fake.watchErrorArgsForCall = append(fake.watchErrorArgsForCall, struct {
|
|
|
+ arg1 string
|
|
|
+ }{arg1})
|
|
|
+ stub := fake.WatchErrorStub
|
|
|
+ fakeReturns := fake.watchErrorReturns
|
|
|
+ fake.recordInvocation("WatchError", []interface{}{arg1})
|
|
|
+ fake.watchErrorMutex.Unlock()
|
|
|
+ if stub != nil {
|
|
|
+ return stub(arg1)
|
|
|
+ }
|
|
|
+ if specificReturn {
|
|
|
+ return ret.result1
|
|
|
+ }
|
|
|
+ return fakeReturns.result1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) WatchErrorCallCount() int {
|
|
|
+ fake.watchErrorMutex.RLock()
|
|
|
+ defer fake.watchErrorMutex.RUnlock()
|
|
|
+ return len(fake.watchErrorArgsForCall)
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) WatchErrorCalls(stub func(string) error) {
|
|
|
+ fake.watchErrorMutex.Lock()
|
|
|
+ defer fake.watchErrorMutex.Unlock()
|
|
|
+ fake.WatchErrorStub = stub
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) WatchErrorArgsForCall(i int) string {
|
|
|
+ fake.watchErrorMutex.RLock()
|
|
|
+ defer fake.watchErrorMutex.RUnlock()
|
|
|
+ argsForCall := fake.watchErrorArgsForCall[i]
|
|
|
+ return argsForCall.arg1
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) WatchErrorReturns(result1 error) {
|
|
|
+ fake.watchErrorMutex.Lock()
|
|
|
+ defer fake.watchErrorMutex.Unlock()
|
|
|
+ fake.WatchErrorStub = nil
|
|
|
+ fake.watchErrorReturns = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) WatchErrorReturnsOnCall(i int, result1 error) {
|
|
|
+ fake.watchErrorMutex.Lock()
|
|
|
+ defer fake.watchErrorMutex.Unlock()
|
|
|
+ fake.WatchErrorStub = nil
|
|
|
+ if fake.watchErrorReturnsOnCall == nil {
|
|
|
+ fake.watchErrorReturnsOnCall = make(map[int]struct {
|
|
|
+ result1 error
|
|
|
+ })
|
|
|
+ }
|
|
|
+ fake.watchErrorReturnsOnCall[i] = struct {
|
|
|
+ result1 error
|
|
|
+ }{result1}
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) Invocations() map[string][][]interface{} {
|
|
|
+ fake.invocationsMutex.RLock()
|
|
|
+ defer fake.invocationsMutex.RUnlock()
|
|
|
+ fake.addConnectionMutex.RLock()
|
|
|
+ defer fake.addConnectionMutex.RUnlock()
|
|
|
+ fake.availabilityMutex.RLock()
|
|
|
+ defer fake.availabilityMutex.RUnlock()
|
|
|
+ fake.bringToFrontMutex.RLock()
|
|
|
+ defer fake.bringToFrontMutex.RUnlock()
|
|
|
+ fake.closedMutex.RLock()
|
|
|
+ defer fake.closedMutex.RUnlock()
|
|
|
+ fake.clusterConfigMutex.RLock()
|
|
|
+ defer fake.clusterConfigMutex.RUnlock()
|
|
|
+ fake.completionMutex.RLock()
|
|
|
+ defer fake.completionMutex.RUnlock()
|
|
|
+ fake.connectionMutex.RLock()
|
|
|
+ defer fake.connectionMutex.RUnlock()
|
|
|
+ fake.connectionStatsMutex.RLock()
|
|
|
+ defer fake.connectionStatsMutex.RUnlock()
|
|
|
+ fake.currentFolderFileMutex.RLock()
|
|
|
+ defer fake.currentFolderFileMutex.RUnlock()
|
|
|
+ fake.currentGlobalFileMutex.RLock()
|
|
|
+ defer fake.currentGlobalFileMutex.RUnlock()
|
|
|
+ fake.currentIgnoresMutex.RLock()
|
|
|
+ defer fake.currentIgnoresMutex.RUnlock()
|
|
|
+ fake.dBSnapshotMutex.RLock()
|
|
|
+ defer fake.dBSnapshotMutex.RUnlock()
|
|
|
+ fake.delayScanMutex.RLock()
|
|
|
+ defer fake.delayScanMutex.RUnlock()
|
|
|
+ fake.deviceStatisticsMutex.RLock()
|
|
|
+ defer fake.deviceStatisticsMutex.RUnlock()
|
|
|
+ fake.downloadProgressMutex.RLock()
|
|
|
+ defer fake.downloadProgressMutex.RUnlock()
|
|
|
+ fake.folderErrorsMutex.RLock()
|
|
|
+ defer fake.folderErrorsMutex.RUnlock()
|
|
|
+ fake.folderProgressBytesCompletedMutex.RLock()
|
|
|
+ defer fake.folderProgressBytesCompletedMutex.RUnlock()
|
|
|
+ fake.folderStatisticsMutex.RLock()
|
|
|
+ defer fake.folderStatisticsMutex.RUnlock()
|
|
|
+ fake.getFolderVersionsMutex.RLock()
|
|
|
+ defer fake.getFolderVersionsMutex.RUnlock()
|
|
|
+ fake.getHelloMutex.RLock()
|
|
|
+ defer fake.getHelloMutex.RUnlock()
|
|
|
+ fake.globalDirectoryTreeMutex.RLock()
|
|
|
+ defer fake.globalDirectoryTreeMutex.RUnlock()
|
|
|
+ fake.indexMutex.RLock()
|
|
|
+ defer fake.indexMutex.RUnlock()
|
|
|
+ fake.indexUpdateMutex.RLock()
|
|
|
+ defer fake.indexUpdateMutex.RUnlock()
|
|
|
+ fake.loadIgnoresMutex.RLock()
|
|
|
+ defer fake.loadIgnoresMutex.RUnlock()
|
|
|
+ fake.localChangedFolderFilesMutex.RLock()
|
|
|
+ defer fake.localChangedFolderFilesMutex.RUnlock()
|
|
|
+ fake.needFolderFilesMutex.RLock()
|
|
|
+ defer fake.needFolderFilesMutex.RUnlock()
|
|
|
+ fake.numConnectionsMutex.RLock()
|
|
|
+ defer fake.numConnectionsMutex.RUnlock()
|
|
|
+ fake.onHelloMutex.RLock()
|
|
|
+ defer fake.onHelloMutex.RUnlock()
|
|
|
+ fake.overrideMutex.RLock()
|
|
|
+ defer fake.overrideMutex.RUnlock()
|
|
|
+ fake.pendingDevicesMutex.RLock()
|
|
|
+ defer fake.pendingDevicesMutex.RUnlock()
|
|
|
+ fake.pendingFoldersMutex.RLock()
|
|
|
+ defer fake.pendingFoldersMutex.RUnlock()
|
|
|
+ fake.remoteNeedFolderFilesMutex.RLock()
|
|
|
+ defer fake.remoteNeedFolderFilesMutex.RUnlock()
|
|
|
+ fake.requestMutex.RLock()
|
|
|
+ defer fake.requestMutex.RUnlock()
|
|
|
+ fake.resetFolderMutex.RLock()
|
|
|
+ defer fake.resetFolderMutex.RUnlock()
|
|
|
+ fake.restoreFolderVersionsMutex.RLock()
|
|
|
+ defer fake.restoreFolderVersionsMutex.RUnlock()
|
|
|
+ fake.revertMutex.RLock()
|
|
|
+ defer fake.revertMutex.RUnlock()
|
|
|
+ fake.scanFolderMutex.RLock()
|
|
|
+ defer fake.scanFolderMutex.RUnlock()
|
|
|
+ fake.scanFolderSubdirsMutex.RLock()
|
|
|
+ defer fake.scanFolderSubdirsMutex.RUnlock()
|
|
|
+ fake.scanFoldersMutex.RLock()
|
|
|
+ defer fake.scanFoldersMutex.RUnlock()
|
|
|
+ fake.serveMutex.RLock()
|
|
|
+ defer fake.serveMutex.RUnlock()
|
|
|
+ fake.setIgnoresMutex.RLock()
|
|
|
+ defer fake.setIgnoresMutex.RUnlock()
|
|
|
+ fake.startDeadlockDetectorMutex.RLock()
|
|
|
+ defer fake.startDeadlockDetectorMutex.RUnlock()
|
|
|
+ fake.stateMutex.RLock()
|
|
|
+ defer fake.stateMutex.RUnlock()
|
|
|
+ fake.usageReportingStatsMutex.RLock()
|
|
|
+ defer fake.usageReportingStatsMutex.RUnlock()
|
|
|
+ fake.watchErrorMutex.RLock()
|
|
|
+ defer fake.watchErrorMutex.RUnlock()
|
|
|
+ copiedInvocations := map[string][][]interface{}{}
|
|
|
+ for key, value := range fake.invocations {
|
|
|
+ copiedInvocations[key] = value
|
|
|
+ }
|
|
|
+ return copiedInvocations
|
|
|
+}
|
|
|
+
|
|
|
+func (fake *Model) recordInvocation(key string, args []interface{}) {
|
|
|
+ fake.invocationsMutex.Lock()
|
|
|
+ defer fake.invocationsMutex.Unlock()
|
|
|
+ if fake.invocations == nil {
|
|
|
+ fake.invocations = map[string][][]interface{}{}
|
|
|
+ }
|
|
|
+ if fake.invocations[key] == nil {
|
|
|
+ fake.invocations[key] = [][]interface{}{}
|
|
|
+ }
|
|
|
+ fake.invocations[key] = append(fake.invocations[key], args)
|
|
|
+}
|
|
|
+
|
|
|
+var _ model.Model = new(Model)
|
Simon Frei