// Check tests have run
        def result = new DefaultTestExecutionResult(projectDir)
        result.assertTestClassesExecuted('org.gradle.sample.PersonSpec')

        // Check contents of Jar
        TestFile jarContents = file('jar')
        projectDir.file("build/libs/quickstart.jar").unzipTo(jarContents)
        jarContents.assertHasDescendants(
                'META-INF/MANIFEST.MF',

    }

    public ResolutionHost resolutionHost(String displayName) {
        return new NameBackedResolutionHost(displayName);
    }

    /**
     * Presents the contents of the given artifacts as a partial {@link FileCollectionInternal} implementation.
     *
     * <p>This produces only a minimal implementation to use for artifact sets loaded from the configuration cache

        // Check tests have run
        def result = new DefaultTestExecutionResult(projectDir)
        result.assertTestClassesExecuted('org.gradle.sample.PersonSpec')

        // Check contents of Jar
        TestFile jarContents = file('jar')
        projectDir.file("build/libs/mixed-java-and-scala-1.0.jar").unzipTo(jarContents)
        jarContents.assertHasDescendants(
            'META-INF/MANIFEST.MF',

            }
        });
    }

    protected void writeArray(String name, Contents contents) throws IOException {
        jsonWriter.name(name);
        writeArray(contents);
    }

    protected void writeArray(Contents contents) throws IOException {
        jsonWriter.beginArray();
        contents.write();
        endArray();
    }

    protected void beginArray(String name) throws IOException {

            /**
             * Creates a set that selects the artifacts from this set that match the given criteria.
             * Implementations are lazy, so that the selection happens only when the contents are queried.
             *
             * @param dependencySpec Select only those artifacts reachable from first level dependencies that match the given spec.
             */

import java.io.IOException;

/**
 * A lossy attribute container serializer. It's lossy because it doesn't preserve the attribute
 * types: it will serialize the contents as strings, and read them as strings, only for reporting
 * purposes.
 */
@ServiceScope(Scope.BuildSession.class)

        } else if (isFileInfo(value)) {
            return invokeMethod(value, "getPath", String.class);
        } else {
            return value.toString();
        }
    }

    /**
     * Returns the contents of a {@code FileInfo} or null if the value is not a {@code FileInfo}.
     */
    @Nullable
    private static byte[] getContentsOrNull(@Nullable Object value) throws Exception {
        if (isFileInfo(value)) {

    public void renderSections() {
        contents.append("<div class=\"uk-container uk-container-expand\">\n")
            .append("        <ul uk-accordion>\n");
        boolean first = true;
        for (Section section : sections.values()) {
            if (first) {
                contents.append("            <li class=\"uk-open\">\n");
            } else {
                contents.append("            <li>\n");
            }

        expect:
        outputContains "Using local directory build cache for the root build (location = ${cacheDir}, removeUnusedEntriesAfter = 7 days)."
    }

    def "cache entry contains expected contents"() {
        buildFile << defineCacheableTask()
        when:
        withBuildCache().run("cacheable")
        then:
        def cacheKey = cacheOperations.getCacheKeyForTask(":cacheable")

            outputVisitor.visitOutputProperty("output", TreeType.FILE, UnitOfWork.OutputFileValueSupplier.fromStatic(root, contents))
        }
        1 * fileCollectionSnapshotter.snapshot(contents) >> Stub(FileCollectionSnapshotter.Result) {
            snapshot >> outputSnapshot
        }
        0 * _

        then:
        result as Map == ["output": outputSnapshot]