buildFile << """
		apply plugin:'java-library-distribution'

        version = 1.2

        distributions {
            main {
                distributionBaseName = 'SuperApp'
                contents {
                    from 'others/dist'
                }
            }
        }

        ${mavenCentralRepository()}
        dependencies {
            runtimeOnly 'commons-lang:commons-lang:2.6'

        1 * action.execute(task)
        0 * action._

        expect:
        elements.calculateExecutionTimeValue().hasChangingContent()
    }

    void "visits self when listener requests contents"() {
        def collection = new TestFileCollection()
        def visitor = Mock(FileCollectionStructureVisitor)

        when:
        collection.visitStructure(visitor)

        then:

        when:
        run "myTask", "--debug"
        then:
        assertWatchedHierarchies([testDirectory])
        result.assertNotPostBuildOutput("Some of the file system contents retained in the virtual file system are on file systems that Gradle doesn't support watching.")
    }

    @Requires(UnitTestPreconditions.Windows)
    def "does not start watching on unsupported file system"() {

  schedule:
    - cron: '0 5 * * *'

permissions: {}

jobs:
  CodeQL-Build:
    permissions:
      actions: read  # for github/codeql-action/init to get workflow details
      contents: read  # for actions/checkout to fetch code
      security-events: write  # for github/codeql-action/analyze to upload SARIF results
    runs-on: ubuntu-latest

    strategy:
      fail-fast: false
      matrix:

        return objectFileDir;
    }

    /**
     * Returns the header directories to be used for compilation.
     */
    @Internal("The paths for include directories are tracked via the includePaths property, the contents are tracked via discovered inputs")
    public ConfigurableFileCollection getIncludes() {
        return includes;
    }

    /**
     * Add directories where the compiler should search for header files.

        return setFoo(setBar(bar))
    }

    static String setBar(String bar) {
        return "bar = \"${bar}\"\n"
    }

    static String setFoo(String contents) {
        return "foo {\n${contents}\n}"
    }

    static String setAll(String id, String bar) {
        return setId(id) + "\n" + setFooBar(bar)
    }

    static String addToList(String item) {

        withProjectConfig("b") {
            outputFileName = "new"
            outputFileContent = "new"
        }
        succeeds(":a:resolve")

        then: // directory content has changed (file contents changed)
        result.assertTasksNotSkipped(":b:producer", ":a:resolve")
        transformed("b-dir")
        outputContains("result = [b-dir.green, c-dir.green]")

        when:
        withProjectConfig("b") {

        run("transform")

        then:
        result.assertTasksNotSkipped(":transform")
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "task dependencies are inferred from contents of input FileCollection"() {
        // Include a configuration with transitive dep on a Jar and an unmanaged Jar.
        file('settings.gradle') << 'include "a", "b"'
        file('a/build.gradle') << '''

        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    /**
     * Reads and returns file contents. If some exception is triggered the method returns information about this exception.
     * Useful for including file contents in debug trace / exception messages.
     *
     * @param file to read
     * @return content of the file or the problem description in case file cannot be read.

     *
     * @param mode the lock mode to use
     */
    CacheBuilder withInitialLockMode(FileLockManager.LockMode mode);

    /**
     * Specifies an action to execute to initialize the cache contents, if the cache does not exist or is invalid. An exclusive lock is held while the initializer is executing, to prevent
     * cross-process access.
     */