final Set<ResolvedComponentResult> out = new LinkedHashSet<>();
        eachElement(getRoot(), Actions.doNothing(), Actions.doNothing(), out);
        return out;
    }

    @Override
    public void allComponents(final Action<? super ResolvedComponentResult> action) {
        eachElement(getRoot(), action, Actions.doNothing(), new HashSet<>());
    }

    @Override
    @SuppressWarnings("rawtypes")

		pod      *v1.Pod
		expected *v1.Pod
	}{
		{
			pod:      getPod("0", "0"),
			expected: getPod("6", "4Gi"),
		},
		{
			pod:      getPod("1", "0"),
			expected: getPod("1", "4Gi"),
		},
		{
			pod:      getPod("", ""),
			expected: getPod("6", "4Gi"),
		},
		{
			pod:      getPod("0", "1Mi"),
			expected: getPod("6", "1Mi"),
		},
	}
	as := assert.New(t)
	for idx, tc := range cases {

        }
    }

    def "binding order does not affect mutation rule execution order"() {
        when:
        modelRegistry.getRoot().applyToSelf(MutationRulesWithInputs)
        modelRegistry.getRoot().applyToSelf(SecondInputCreationRule)
        modelRegistry.getRoot().applyToSelf(FirstInputCreationRule)

        then:
        modelRegistry.get("recorder", MutationRecorder).mutations == ["first", "second"]
    }

            task.getSourceFile().convention(dslReference.getRoot().file("dsl.xml"));
            task.getPluginsMetaDataFile().convention(dslReference.getRoot().file("plugins.xml"));
            task.getClassDocbookDirectory().convention(dslReference.getRoot());
            task.getClassMetaDataFile().convention(dslMetaData.flatMap(ExtractDslMetaDataTask::getDestinationFile));

    }

    static abstract class SuperBaz {
        void setBaz(int baz) {
            boom
        }

        abstract String getBoom()
    }

    static class Baz extends SuperBaz {
        void setBaz(int baz) {
            super.setBaz(baz)
        }

        String getBoom() {
            throw new Exception("boom")
        }
    }

        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override
    public ExternalResourceName toVersionListPattern(ModuleIdentifier module, IvyArtifactName artifact) {
        Map<String, String> attributes = toAttributes(module, artifact);
        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

        resolvedConf("leaf1", [])
        resolvedConf("leaf2", [])
        resolvedConf("leaf3", [])
        resolvedConf("leaf4", [])

        when:
        def result = builder.getRoot(id("root"))

        then:
        printGraph(result) == """x:root:1
  x:mid1:1 [root]
    x:leaf1:1 [mid1]
    x:leaf2:1 [mid1]
  x:mid2:1 [root]
    x:leaf3:1 [mid2]
    x:leaf4:1 [mid2]
"""
    }

        Map<String, String> attributes = toAttributes(artifact);
        String pattern = maybeSubstituteTimestamp(artifact, getBase().getPath());
        return getBase().getRoot().resolve(substituteTokens(pattern, attributes));
    }

    private String maybeSubstituteTimestamp(ModuleComponentArtifactMetadata artifact, String pattern) {

        final URL url = new File("/Program File").toURI().toURL();
        assertEquals("file:" + getRoot() + "Program File", ResourceUtil.toExternalForm(url));
    }

    /**
     * @throws Exception
     */
    public void testGetFileName() throws Exception {
        URL url = new File("/Program File").toURI().toURL();
        assertEquals(getRoot() + "Program File", ResourceUtil.getFileName(url));

            remoteRepositories = session.getService(ProjectManager.class).getRemoteProjectRepositories(project);
        } else {
            rootArtifact = request.getRootArtifact().orElse(null);
            root = request.getRoot().orElse(null);
            dependencies = request.getDependencies();
            managedDependencies = request.getManagedDependencies();
            remoteRepositories = session.getRemoteRepositories();
        }