}
        outputContains("configuring root")
        outputContains("creating model with parameter='fetch1' for root project 'root'")
        outputContains("creating model with parameter='fetch2' for root project 'root'")

        and:
        models.keySet() ==~ [":"]
        models.values().every { it.size() == 4 }

        fixture.assertStateStored {
            projectsConfigured(":buildSrc", ":b")
            buildModelCreated()
            modelsCreated(":", ":a")
        }

        outputContains("Callback before root project 'root'")
        outputContains("Callback before project ':a'")
        outputContains("Callback before project ':b'")


        when:
        withIsolatedProjects()

            rootProject.name = 'root'

            include(":lib1")
            include(":lib1:lib11")
        """

        when: "fetching without Isolated Projects"
        def expectedProjectModel = fetchModel(GradleProject)

        then:
        fixture.assertNoConfigurationCache()

        with(expectedProjectModel) {
            it.name == "root"
            it.tasks.size() > 0

                    case ROOT:
                        id = decoder.readSmallLong();
                        root = allDependencies.get(id);
                        if (root == null) {
                            throw new IllegalStateException(String.format("Unexpected root id %s. Seen ids: %s", id, allDependencies.keySet()));
                        }
                        //root should be the last entry

        InternalSession session = InternalSession.from(s);
        DependencyNode root = cast(AbstractNode.class, node, "node").getDependencyNode();
        List<DependencyNode> dependencies = session.getRepositorySystem()
                .flattenDependencyNodes(session.getSession(), root, getScopeDependencyFilter(scope));
        dependencies.remove(root);
        return map(dependencies, session::getNode);
    }

        cache.attachRootBuild(targetBuild.gradle.services.get())

        cache.initializeCacheEntry()

        // Currently, apply the decoration only to the root build, as the cache implementation is still scoped to the root build (that is, it assumes it is only applied to the root build)

        assert ((ShallowChildModel) model).getShallowMessage() == "shallow poly from 'root'"

        assert model instanceof DeepChildModel
        assert ((DeepChildModel) model).getDeepMessage() == "deep poly from 'root'"

        assert model instanceof VeryDeepChildModel
        assert ((VeryDeepChildModel) model).getVeryDeepMessage() == "very deep poly from 'root'"

        assert !(model instanceof SideModel)
    }

# See the License for the specific language governing permissions and
# limitations under the License.

WD=$(dirname "$0")
WD=$(cd "$WD"; pwd)
ROOT=$(dirname "$WD")

set -eux

# shellcheck source=prow/lib.sh
source "${ROOT}/prow/lib.sh"

setup_gcloud_credentials

# Old prow image does not set this, so needed explicitly here as this is not called through make
export GO111MODULE=on

        //of the mapping module dependency <-> resolved dependency
        modulesMap.put(dependency.getNodeId(), moduleDependency);
    }

    @Override
    public void done(DependencyGraphNode root) {
        builder.done(root.getNodeId());
    }

    @Override
    public void addChild(DependencyGraphNode parent, DependencyGraphNode child, int artifactsId) {

    static class RootBuildLocation extends DefaultExcludesLocation {

        @Override
        String includedFileName() {
            return "included-by-root-build.txt"
        }

        @Override
        String excludedFileName() {
            return "excluded-by-root-build.txt"
        }

        @Override
        void applyDefaultExcludes(AbstractIntegrationSpec spec, ScriptLanguage scriptLanguage) {