return new BasicPredicate(null, scope, null, matcher);
            }
        };
    }

    public static NodePredicate allDescendants() {
        return allDescendants(Predicates.<MutableModelNode>alwaysTrue());
    }

    public static NodePredicate allDescendants(Predicate<? super MutableModelNode> predicate) {
        return new NodePredicate(predicate) {
            @Override

                    if (isLastRun(context, invocationSettings) && checkIfCacheUsed) {
                        assert !(buildCacheServer.cacheDir.allDescendants().empty && cacheDir.allDescendants().isEmpty())
                        assert pushToRemote || buildCacheServer.cacheDir.allDescendants().empty
                    }
                }
            }
        }
    }

    }

    @Override
    void assertSampleSpecificOutcome(String dsl) {
        assert TextUtil.normaliseFileSeparators(result.output).contains("Created ${workerExecutorSample(dsl).file("sources").allDescendants().size()} reversed files in build/reversed")
    }

        } finally {
            zipFile.close()
        }
    }

    @Override
    def hasDescendants(String... relativePaths) {
        String[] allDescendants = relativePaths + JarFile.MANIFEST_NAME
        return super.hasDescendants(allDescendants)
    }

    JavaVersion getJavaVersion() {
        JarFile jarFile = new JarFile(file)
        try {
            //take the first class file

            assert !outputDir.allDescendants().contains("first-file")
            assert !outputDir.allDescendants().contains("second-file")
        }

        void staleFilesAreStillPresent() {
            assert outputFile.exists()
            assert outputDir.allDescendants().contains("first-file")
            assert outputDir.allDescendants().contains("second-file")
        }

    implementation 'org.gradle.test:compile:1.0'
    compileOnly 'org.gradle.test:compileOnly:1.0'
}
"""
        when:
        run "installDist"

        then:
        file('build/install/sample/lib').allDescendants() == ['compile-1.0.jar'] as Set
    }

    compileOnly 'org.gradle.test:compileOnly:1.0'
}
"""

        when:
        run "installDist"

        then:
        file('build/install/sample/lib').allDescendants() == ['sample.jar', 'compile-1.0.jar'] as Set
    }

    def "executables can be placed at the root of the distribution"() {
        given:
        buildFile << """
application.executableDir = ''
"""

    }

    Map<String, TestFile.Snapshot> snapshotObjects(TestFile projectDir) {
        def objDir = projectDir.file('build/obj')
        def objects = objDir.allDescendants()
        def snapshots = objects.collectEntries { path ->
            def obj = objDir.file(path)
            if (!obj.isFile()) {
                return null
            }
            [(path): obj.snapshot()]

        def confCacheDir = file("./app/.gradle/configuration-cache")
        confCacheDir.isDirectory()
        def confCacheFiles = confCacheDir.allDescendants().findAll { it != 'configuration-cache.lock' && it != 'gc.properties' }
        confCacheFiles.size() == 5 // header, 2 * fingerprint, root build state file, included build state file

        Bytes.indexOf(contents, toFind) >= 0
    }

    private TestFile findRequiredKeystoreFile(boolean required = true) {
        def keyStoreDirFiles = keyStoreDir.allDescendants()
        def keyStorePath = keyStoreDirFiles.find { it.endsWith('gradle.keystore') }
        assert !required || keyStorePath != null
        return keyStorePath?.with { keyStoreDir.file(keyStorePath) }
    }