# Verbatim instructions from BoringCrypto build docs.
printf "set(CMAKE_C_COMPILER \"clang\")\nset(CMAKE_CXX_COMPILER \"clang++\")\n" >${HOME}/toolchain
cd boringssl
mkdir build && cd build && cmake -GNinja -DCMAKE_TOOLCHAIN_FILE=${HOME}/toolchain -DFIPS=1 -DCMAKE_BUILD_TYPE=Release ..
ninja
./crypto/crypto_test
cd ../..

if [ "$(./boringssl/build/tool/bssl isfips)" != 1 ]; then
	echo "NOT FIPS"
	exit 2

        outputContains("Hello from root build's plugin")
    }

    @ToBeFixedForConfigurationCache
    def "prefers a source mapping defined in the root build to one defined in a nested build when the nested build requests plugins"() {
        given:
        vcsMapping('org.test:first', first)
        // root build does not inject any plugins to second
        vcsMapping('org.test:second', second)

     * @throws ModelBuildingException If the effective model could not be built.
     */
    ModelBuildingResult build(ModelBuildingRequest request) throws ModelBuildingException;

    /**
     * Builds the effective model by completing the specified interim result which was produced by a previous call to
     * {@link #build(ModelBuildingRequest)} with {@link ModelBuildingRequest#isTwoPhaseBuilding()} being {@code true}.

// possible, but linkshared complicates things:
//
//  1. linkshared mode leaves the function around in the final output of
//     non-test builds.
//  2. Due of (1), the linker can't resolve the callerStartLine relocation
//     (as runtime_test isn't built for non-test builds).
//
// Thus it is simpler to just put this in its own package, imported only by
// runtime_test. We use ABIInternal as no ABI wrapper is generated for

        projects.add(project);
    }

    public Set<DefaultGradleBuild> getEditableBuilds() {
        return allBuilds;
    }

    public void addBuilds(Collection<DefaultGradleBuild> builds) {
        allBuilds.addAll(builds);
    }

    public Set<DefaultGradleBuild> getIncludedBuilds() {
        return includedBuilds;
    }

    public void addIncludedBuild(DefaultGradleBuild includedBuild) {

            }
            plugins {
                id("${build2.settingsPluginId}")
            }
            rootProject.name = "${build1.buildName}"
        """)

        then:
        succeeds()
        build2.assertSettingsPluginApplied()
        build1.assertSettingsPluginApplied()
    }

    def "second included build can not see settings plugins contributed to root by first included build"() {

description = 'The shared API for the application'

tasks.register('libs') {
    group = 'build'
    description = 'Builds the JAR'

The build is then included in the root project's _settings_ file as seen in the above snippet.
For more details about included builds, see link:{userManualPath}/composite_builds.html[Composing Builds] chapter.

The `myproject.java-conventions` plugin is then applied to the `buildSrc` build:
====
include::sample[dir="kotlin",files="buildSrc/build.gradle.kts[tags=plugins]"]

This way, the configuration time of a large multi-project build can be reduced.

The configuration-on-demand feature is _incubating_, so only some builds are guaranteed to work correctly.
The feature works well for <<#sec:decoupled_projects,decoupled>> multi-project builds.

        private PluginResolution resolveFromIncludedPluginBuilds(PluginId requestedPluginId) {
            for (IncludedBuildState build : buildIncluder.getRegisteredPluginBuilds()) {
                buildIncluder.prepareForPluginResolution(build);
                Optional<PluginResolution> pluginResolution = build.withState(gradleInternal -> LocalPluginResolution.resolvePlugin(gradleInternal, requestedPluginId));