public static final List<String> ALLOW_ENVIRONMENT_VARIABLE_OVERWRITE = ImmutableList.of("--add-opens=java.base/java.util=ALL-UNNAMED");

    private final ToolchainConfiguration toolchainConfiguration = new DefaultToolchainConfiguration();
    private final File gradleUserHomeDir;

    private File baseDir;

no\ classes\ should\ call\ method\ RoleBasedConfigurationContainerInternal.resolvableDependencyScopeUnlocked(String)\ or\ should\ call\ method\ RoleBasedConfigurationContainerInternal.resolvableDependencyScopeUnlocked(String,\ Action)\ or\ should\ call\ method\ RoleBasedConfigurationContainerInternal.maybeCreateResolvableUnlocked(String)\ or\ should\ call\ method\ RoleBasedConfigurationContainerInternal.maybeCreateConsumableUnlocked(String)\...

   Failures:
      - Could not resolve org:bar:{reject all versions}.
          - Module 'org:bar' has been rejected:
               Dependency path ':insight-test:unspecified' --> 'org:bar:[1.0,)'
               Constraint path ':insight-test:unspecified' --> 'org:bar:{reject all versions}' because of the following reason: Nope, you won't use this

org:bar:{reject all versions} FAILED
\\--- compileClasspath

                value.finalizeIfNotAlready();
            } finally {
                // Don't leak the source implementation even if obtaining its value throws.
                // This is mostly a theoretical possibility, but the call above is blocking, so it can be interrupted.
                obtainedFrom = sourceRef.getAndSet(null);
            }
            Try<@org.jetbrains.annotations.Nullable T> obtained = value.getValue();

== Step 1. Understanding Caching
Incremental Builds are a great optimization that helps avoid work that is already done.
If a developer is continuously making changes in a single file, there is likely no need to rebuild all the other files in the project.

However, what happens when the same developer decides to switch to a new branch created last week?
The files are rebuilt, even though the developer is building something that has been built before.

                targetConfiguration.removeIncomingEdge(this);
            }
            targetNodes.clear();
        }
        targetNodeSelectionFailure = null;
    }

    /**
     * Call this method to attach a failure late in the process. This is typically
     * done when a failure is caused by graph validation. In that case we want to
     * perform as much resolution as possible, still have a valid graph, but in the

                config.clear()
            }
            testDirectory.file('initial-commit').createNewFile()
            git.add().addFilepattern("initial-commit").call()
            git.commit().setMessage("Initial commit").call()
        }
    }

    /**
     * Want syntax highlighting inside of IntelliJ? Consider using {@link AbstractIntegrationSpec#buildFile(String)}
     */

        then:
        UnsupportedVersionException e = thrown()
        e.message == "The version of Gradle you are using (${version}) does not support the PhasedBuildActionExecuter API. Support for this is available in Gradle 4.8 and all later versions."
    }

                doLast {
                    println 'do something'
                }
            }
        """

        when:
        executeTaskViaTAPI(":other-build:tasks", "--all")

        then:
        assertHasBuildSuccessfulLogging()
        outputContains("doSomething - Prints the message 'do something'")
    }

    def "can run help from included build"() {
        given:

    }

    public File getDownloadLocation() {
        return jdkDirectory;
    }

    private static String getNameWithoutExtension(File file) {
        //remove all extensions, for example for xxx.tar.gz files only xxx should be left
        String output = file.getName();
        String input;
        do {
            input = output;