test.testLogging {
                showStandardStreams = true
                showExceptions = true
            }
        """

        def testProjectDir = file("testTmp").tap { it.mkdirs() }

        file("src/test/groovy/my/MyTest.groovy") << """
            package my
            import org.gradle.testfixtures.*
            import org.gradle.testkit.runner.GradleRunner

    private String enumMapToString() {
        "new EnumMap([(SomeEnum.One): 'one', (SomeEnum.Two): 'two'])"
    }

    private String treeMapWithComparator() {
        "new TreeMap({ x, y -> y.compareTo(x) }).tap { putAll([a: 1, b: 2]) }"
    }

    def "keeps iteration order of #type instances"() {
        given:
        buildFile << """
            abstract class SomeTask extends DefaultTask {

    }

    def "substitutes external dependency for a subproject of the root build - #rootIsIncluded"() {
        given:
        def empty = file('empty').tap {
            it.mkdir()
        }
        mavenRepo.module("org.test", "subproject1", "2.0").publish()
        buildA.buildFile << """
            subprojects {
                apply plugin: 'java-library'

                  configure this appropriately. For example our Kubernetes and Docker
                  integrations set the ‘cali’ value, and our OpenStack integration
                  sets the ‘tap’ value. [Default: cali]'
                type: string
              interfaceRefreshInterval:
                description: InterfaceRefreshInterval is the period at which Felix

        getClassLoaderHash(_) >> TestHashCodes.hashCodeFrom(123)
    }
    def managedFactoryRegistry = Mock(ManagedFactoryRegistry)
    def valueSnapshotSerializerRegistry = new TestValueSnapshotSerializerRegistry().tap {
        register(GradleBean, new GradleBeanSerializer())
    }
    def snapshotter = new DefaultValueSnapshotter([valueSnapshotSerializerRegistry], classLoaderHasher)

        "[k1: v1] + [k2: v2]"        | { property().tap { put("k1", "v1"); put("k2", "v2") } } || "Map(String->String, {k1=v1} + {k2=v2})"
        "provider {k: v}"            | { property().value(Providers.of([k: "v"])) }            || "Map(String->String, fixed(class ${LinkedHashMap.name}, {k=v}))"

        1 * listener.accept({ it.task == task2 })
        1 * listener.accept({ it.task == task3 })
        0 * listener._
    }

    private Node requiredNode(Node... dependencies) {
        node(dependencies).tap {
            require()
            dependenciesProcessed()
        }
    }

    private Node node(Node... dependencies) {
        def action = Stub(WorkNodeAction)

	}
	if a.cfg.ProxyXDSDebugViaAgent {
		err = a.xdsProxy.initDebugInterface(a.cfg.ProxyXDSDebugViaAgentPort)
		if err != nil {
			return nil, fmt.Errorf("failed to start istio tap server: %v", err)
		}
	}

	if a.cfg.GRPCBootstrapPath != "" {
		if err := a.generateGRPCBootstrap(); err != nil {
			return nil, fmt.Errorf("failed generating gRPC XDS bootstrap: %v", err)
		}
	}

    outputFile.set(layout.buildDirectory.file("summary.txt"))
}

dependencies {
    sourceFiles(files("input.txt"))
}
'''
        def inputFile = file('input.txt').tap { write("the input file") }
        def outputFile = file('build/summary.txt')
        def expectedOutput = "input.txt: ${inputFile.length()}"
        def configurationCache = newConfigurationCacheFixture()

            nodeIdByTypedNodeId[nodeId] = nodeMatcher.nodeId
            expectedDependencyNodeIdsByTypedNodeId[nodeId] = nodeMatcher.dependencyNodeIds
        }
        def unusedMatchers = nodeMatchers.toSet().tap { it.removeAll(usedMatchers) }
        assert unusedMatchers.size() == 0

        for (def plannedNode : plannedNodes) {
            def typedNodeId = getTypedNodeId(plannedNode.nodeIdentity)