public String getError(Artifact artifact, ArtifactRepository repository) {
        File touchFile = getTouchfile(artifact);
        return getError(touchFile, getRepositoryKey(repository));
    }

    public void touch(Artifact artifact, ArtifactRepository repository, String error) {
        File file = artifact.getFile();

        File touchfile = getTouchfile(artifact);

        if (file.exists()) {

# Prepare data for tests
echo -n "Preparing test data ..."
mkdir -p /tmp/data
echo "Hello world" >/tmp/data/plainfile
echo "Hello from encrypted world" >/tmp/data/encrypted
touch /tmp/data/defpartsize
shred -s 500M /tmp/data/defpartsize
touch /tmp/data/mpartobj.txt
shred -s 500M /tmp/data/mpartobj.txt
echo "done"

# Enable compression for site minio1
./mc admin config set minio1 compression enable=on extensions=".txt" --insecure

        run "wrapper", "--gradle-version", "2.2.1", "--no-validate-url"
        def testFile = file("modtime").touch()
        def originalTime = testFile.lastModified()
        when:
        // Zip file time resolution is 2 seconds
        ConcurrentTestUtil.poll {
            testFile.touch()
            assert (testFile.lastModified() - originalTime) >= 2000L
        }

# Prepare data for tests
echo -n "Preparing test data ..."
mkdir -p /tmp/data
echo "Hello world" >/tmp/data/plainfile
echo "Hello from encrypted world" >/tmp/data/encrypted
touch /tmp/data/defpartsize
shred -s 500M /tmp/data/defpartsize
touch /tmp/data/custpartsize
shred -s 500M /tmp/data/custpartsize
echo "done"

# Add replication site
./mc admin replicate add minio1 minio2 --insecure
# sleep for replication to complete

        }
    }

    /**
     * Ensures that the given file (or directory) is marked as modified. If the file
     * (or directory) does not exist, a new file is created.
     */
    public static void touch(File file) {
        try {
            if (!file.createNewFile()) {
                touchExisting(file);
            }
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }

    final URI distroZip = otherVersion.binDistribution.toURI()

    def setup() {
        toolingApi.withConnector { connector -> connector.useDistribution(distroZip) }
        settingsFile.touch()
    }

    def "tooling api reports an error when requesting a model using a gradle version that does not implement the tooling api"() {
        when:

  genman "${dest}/docs/man/man1/" "kubeadm"

  mkdir -p "${dest}/docs/yaml/kubectl/"
  genyaml "${dest}/docs/yaml/kubectl/"

  # create the list of generated files
  pushd "${dest}" > /dev/null || return 1
  touch docs/.generated_docs
  find . -type f | cut -sd / -f 2- | LC_ALL=C sort > docs/.generated_docs
  popd > /dev/null || return 1
}

# Removes previously generated docs-- we don't want to check them in. $KUBE_ROOT

        1 * cacheBuilder.open() >> { cache }
        _ * cache.getBaseDir() >> cacheDir
        1 * cache.useCache(_)
        jarFile == resolvedFile

        when:
        FileUtils.touch(jarFile)
        resolvedFile = provider.get("api") { Assert.fail("Should not be called if file already exists") }

        then:
        0 * cacheBuilderFactory.createCacheBuilder(CACHE_KEY) >> cacheBuilder

    def createObjDummy(File sourceFile) {
        def objectFile = new TestFile(namingScheme.withObjectFileNameSuffix(O_EXT).
            withOutputBaseFolder(outputDir).
            map(sourceFile))

        objectFile.touch()
        objectFile.text = sourceFile.absolutePath
    }

                    options.fork = true
                }

                group = "org.test"
                version = "1.0"
            }
        """
        child.file("settings.gradle").touch()

        buildFile << """
            dependencies {
                implementation "org.test:child:1.0"
            }
        """
        settingsFile << """
            includeBuild "child"