See the License for the specific language governing permissions and
limitations under the License.
*/

package testing

import (
	"errors"
	"os"
	"sync"
	"time"
)

// FakeOS mocks out certain OS calls to avoid perturbing the filesystem
// If a member of the form `*Fn` is set, that function will be called in place
// of the real call.
type FakeOS struct {
	StatFn     func(string) (os.FileInfo, error)

awkward-to-reproduce situations like 500 errors or slow-loading responses.


### Example

Use MockWebServer the same way that you use mocking frameworks like
[Mockito](https://github.com/mockito/mockito):

1. Script the mocks.
2. Run application code.
3. Verify that the expected requests were made.

Here's a complete example:

```java
public void test() throws Exception {

	f, _ := fs.Create(filepath.Join(driverPath, driverName))
	f.Close()
}

// Initializes mocks, installs a single driver in the mock fs, then initializes prober.
func initTestEnvironment(t *testing.T) (
	driverPath string,
	fs utilfs.Filesystem,
	watcher *fakeWatcher,
	prober volume.DynamicPluginProber) {
	fs = utilfs.NewTempFs()
	watcher = newFakeWatcher()
	prober = &flexVolumeProber{
		pluginDir: pluginDir,

        objectFactory = mock(),
        instantiator = mock(),
        fileSystemOperations = mock(),
        taskNodeFactory = mock(),
        ordinalGroupFactory = mock(),
        inputFingerprinter = mock(),
        buildOperationRunner = mock(),
        classLoaderHierarchyHasher = mock(),
        isolatableFactory = mock(),
        managedFactoryRegistry = mock(),
        parameterScheme = mock(),

import common.pluginPortalUrlOverride
import configurations.BaseGradleBuildType
import configurations.applyDefaults
import configurations.applyTestDefaults
import io.mockk.every
import io.mockk.impl.annotations.MockK
import io.mockk.junit5.MockKExtension
import io.mockk.mockk
import io.mockk.slot
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildSteps

        given:
        def repo1 = Mock(TestMavenArtifactRepository) { getName() >> "Maven repo 1" }
        def repo2 = Mock(TestMavenArtifactRepository) { getName() >> "Maven repo 2" }
        def repo3 = Mock(TestMavenArtifactRepository) { getName() >> "Maven repo 3" }
        def repo1Content = Mock(RepositoryContentDescriptor)
        def repo2Content = Mock(RepositoryContentDescriptor)

        given:
        def listener = Mock(ProgressListener)
        def adapter = createAdapter(listener)

        when:
        def testDescriptor = Mock(InternalTestDescriptor)
        _ * testDescriptor.getId() >> 1
        _ * testDescriptor.getName() >> 'some test suite'
        _ * testDescriptor.getParentId() >> null

        def startEvent = Mock(InternalTestStartedProgressEvent)

        mock
    }

    private FileCopyDetailsInternal dir(final String path) {
        def mock = Mock(FileCopyDetailsInternal)
        mock.getRelativePath() >> RelativePath.parse(false, path)
        mock.getLastModified() >> 1000L
        mock.isDirectory() >> true
        mock.getPermissions() >> new DefaultFilePermissions(2)
        mock
    }

        given:
        def localCandidates = Mock(LocallyAvailableResourceCandidates)
        def fileStore = Mock(CacheAwareExternalResourceAccessor.ResourceFileStore)
        def cachedMetaData = Mock(ExternalResourceMetaData)
        def remoteMetaData = Mock(ExternalResourceMetaData)
        def remoteResource = Mock(ExternalResource)
        def remoteSha1 = Mock(ExternalResource)

        def visitor = Mock(Action)

        when:
        broadcast.visitListeners(visitor)

        then:
        0 * visitor._
    }

    def 'source object notifies each listener in the added order'() {
        given:
        def listener1 = Mock(TestListener)
        def listener2 = Mock(TestListener)
        broadcast.add(listener1)
        broadcast.add(listener2)