if (!JavaVersion.current().java8Compatible) {
            forkOptions.jvmArgs = ["-XX:MaxPermSize=512m"]
        }
    }
}
<% } %>

task dependencyReport(type: DependencyReportTask) {
    outputFile = new File(buildDir, "dependencies.txt")
}

        buildOperationRunner,
        cleanupRegistry,
        deleter,
        outputChangeListener,
        outputFilesRepository,
        delegate)

    def outputFile = file("output.txt").text = "output"
    def outputFilesProducedByWork = snapshotsOf(output: outputFile)
    def afterExecutionState = Stub(AfterExecutionState) {
        getOutputFilesProducedByWork() >> outputFilesProducedByWork
    }

        buildFile << """
            task customTask {
                outputs.cacheIf { true }
                outputs.file("build/output.txt")
                def outputFile = file("build/output.txt")
                doLast {
                    outputFile.text = "Done"
                }
            }
        """

        if (expectStacktrace) {
            executer.withStackTraceChecksDisabled()
        }

        getInputProperties() >> ImmutableSortedMap.of()
        getInputFileProperties() >> ImmutableSortedMap.of()
    }

    def outputFile = file("output.txt").text = "output"
    def outputFilesProducedByWork = snapshotsOf(output: outputFile)

    def step = new StoreExecutionStateStep<IncrementalCachingContext, AfterExecutionResult>(delegate)
    def delegateResult = Mock(AfterExecutionResult)

        buildFile << """
            task cacheableTask {
                def inputFile = file("src/dummy-input.txt")
                def outputDir = file(layout.buildDirectory.dir("dummy-output"))
                def outputFile = file(layout.buildDirectory.file("dummy-output/result.txt"))

                outputs.cacheIf { true }

                inputs.files(inputFile)
                    .withPropertyName("dummy-input")

}

dependencies {
    implementation(kotlin("stdlib-js"))
}

repositories {
    mavenCentral()
}

tasks {
    compileKotlin2Js {
        kotlinOptions {
            outputFile = "${sourceSets.main.get().output.resourcesDir}/output.js"
            sourceMap = true
        }
    }
    val unpackKotlinJsStdlib by registering {
        group = "build"

            writeEnum(filePropertyType)
        }
    }
}


private
fun collectRegisteredOutputsOf(task: Task): List<RegisteredProperty.OutputFile> {

    val properties = mutableListOf<RegisteredProperty.OutputFile>()

    (task.outputs as TaskOutputsInternal).visitRegisteredProperties(object : PropertyVisitor {

        override fun visitOutputFileProperty(
            propertyName: String,

 */
package org.codelibs.fess.thumbnail.impl;

import java.io.File;

public class EmptyGenerator extends BaseThumbnailGenerator {

    @Override
    public boolean generate(final String thumbnailId, final File outputFile) {
        return false;
    }

    @Override
    public void destroy() {
        // nothing
    }

import org.gradle.api.tasks.Input
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.TaskAction
import java.io.File

abstract class CreateFileTask : DefaultTask() {
    @get:Input
    abstract val fileText: Property<String>

    @Input
    val fileName = project.rootDir.toString() + "/myfile.txt"

    @OutputFile
    val myFile: File = File(fileName)

    @TaskAction

import java.io.File;
import java.util.Map;

import org.codelibs.core.misc.Tuple3;

public interface ThumbnailGenerator {

    String getName();

    boolean generate(String thumbnailId, File outputFile);

    boolean isTarget(Map<String, Object> docMap);

    boolean isAvailable();

    void destroy();

    Tuple3<String, String, String> createTask(String path, Map<String, Object> docMap);