LOG.info("Problems generating Javadoc."
                    + "\n  Command line issued: " + execAction.getCommandLine()
                    + "\n  Generated Javadoc options file has following contents:\n------\n{}------", GFileUtils.readFileQuietly(spec.getOptionsFile()));

import org.gradle.internal.execution.history.changes.CompareStrategy.ChangeDetector;

import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

/**
 * Compares by absolute paths and file contents. Order does not matter.
 */
public class AbsolutePathChangeDetector<S> implements ChangeDetector<S> {

    private final ItemComparator<S> itemComparator;
    private final CompareStrategy.ChangeFactory<S> changeFactory;

    /**
     * Attaches the work that this graph will run. Fires events and no further tasks should be added.
     */
    void populate(FinalizedExecutionPlan plan);

    /**
     * Executes the given work. Discards the contents of this graph when completed. Should call {@link #populate)} prior to
     * calling this method.
     */
    ExecutionResult<Void> execute(FinalizedExecutionPlan plan);

    /**
     * Set of requested tasks.

                //at least, it will work out of the box on linux or mac environments.
                //on windows, the options file will have correct contents according to the javadoc spec but it may not work (the failure will be exactly the same as if we didn't replace line breaks)

     * groovy} configuration will be returned.
     *
     * <p>The returned class path may be empty, or may fail to resolve when asked for its contents.
     *
     * @param classpath a class path containing Groovy Jars

        final FileTreeInternal filtered2 = Mock()
        final PatternSet patterns = Mock()

        when:
        FileTree filtered = tree.matching(action)

        then: // action is applied each time the contents are queried
        0 * _

        when:
        def sourceCollections = (filtered as CompositeFileTree).sourceCollections

        then:
        sourceCollections == [filtered1, filtered2]

        and:

        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'

  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:

        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') << '''

     *
     * @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.
     */