failure.assertHasCause("Encryption key length is 8 bytes, but must be at least 16 bytes long")
    }

    def "new configuration cache entry if env var key changes"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        // Obtained via:

        return valueState.isExplicit();
    }

    /**
     * Creates a shallow copy of this file collection. Further changes to this file collection (via {@link #from(Object...)}, {@link #setFrom(Object...)}, or {@link #builtBy(Object...)}) do not
     * change the copy. However, the copy still reflects changes to the underlying file collections that constitute this one. Consider the following snippet:
     * <pre>

//
// The build cache correctly accounts for changes to Go source files,
// compilers, compiler options, and so on: cleaning the cache explicitly
// should not be necessary in typical use. However, the build cache
// does not detect changes to C libraries imported with cgo.
// If you have made changes to the C libraries on your system, you

   * calling {@code get(columnKey, rowKey)} on the generated table always returns the same value as
   * calling {@code get(rowKey, columnKey)} on the original table. Updating the original table
   * changes the contents of the transposed table and vice versa.
   *
   * <p>The returned table supports update operations as long as the input table supports the

                            AcceptedApiChanges.parse(listOf("{acceptedApiChanges:[]}")),
                            rootProject.files("$sourceRoots"),
                            "2.0",
                            file("test-api-changes.json"),
                            rootProject.layout.projectDirectory,
                            newUpgradedPropertiesFile.get().asFile,
                            oldUpgradedPropertiesFile.get().asFile

					reg, _ := state.f.getHome(v.ID).(*Register)
					c := state.processValue(v, slots, reg)
					changed = changed || c
				}

				if state.loggingLevel > 1 {
					state.logf("Block %v done, locs:\n%v", b, state.stateString(state.currentState))
				}

				locs.relevant = locs.relevant || changed
				if !changed {
					locs.endState = startState
				} else {
					for _, id := range state.changedSlots.contents() {

              <include>org.apache.maven.toolchain</include>
              <include>org.apache.maven.usability</include>
            </includes>
            <!-- allowed non-binary backwards compatible changes -->
            <excludes>
              <!-- START default constructor on Plexus/JSR 330 components -->
              <exclude>org.apache.maven.lifecycle.DefaultLifecycleExecutor#DefaultLifecycleExecutor()</exclude>

            projectConfigured(":")
            modelsCreated(":a")
            modelsReused(":", ":b", ":c", ":buildSrc")
        }
    }

    def "updates cached state when upstream project dependency changes"() {
        given:
        withSomeToolingModelBuilderPluginThatPerformsDependencyResolutionInBuildSrc()
        settingsFile << """
            include("a")
            include("b")
            include("c")

        checkModel(anotherResult, originalResult, [
            [{ it.allIdeaProjects }, { a, e -> checkIdeaProject(a, e) }]
        ])

        when: "fetching after change with Isolated Projects"
        file("buildC/build.gradle") << """
            println("changed root in buildC")
        """
        executer.withArguments(ENABLE_CLI)
        def afterChangeResult = runBuildAction(new FetchAllIdeaProjects())

        then:

// in the build list may have been changed (possibly to or from "none") as a
// result.
func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (changed bool, err error) {
	rs, changed, err := editRequirements(ctx, LoadModFile(ctx), add, mustSelect)
	if err != nil {
		return false, err
	}
	requirements = rs
	return changed, err
}