*/
    public static String toArray(List<String> list) {
        return list == null ? null : "(" + String.join(",", list) + ")";
    }

    public static List<String> toList(Object[] objects) {
        return Stream.of(objects).map(Object::toString).map(String::trim).collect(Collectors.toList());
    }

    /**

    @Test public void canOverwriteProperties() {
        final List conventionList1 = toList("a");
        conventionAware.map("list1", new Callable<Object>() {
            public Object call() {
                return conventionList1;
            }
        });
        assertSame(conventionList1, conventionAware.getConventionValue(null, "list1", false));
        List expectedList1 = toList("b");

        List<GenerationResult> results = generators.stream().map(generators -> generators.generateCodeForRequestedInterceptors(interceptionRequests)).collect(Collectors.toList());

        List<HasFailures> failures = results.stream().filter(it -> it instanceof HasFailures).map(it -> (HasFailures) it).collect(Collectors.toList());
        if (!failures.isEmpty()) {

    }

    protected static @Nullable <T> List<T> rationalizeInput(@Nullable T[] arguments) {
        return arguments != null && arguments.length > 0 ? Arrays.asList(arguments) : null;
    }

    protected static @Nullable <T> List<T> rationalizeInput(@Nullable Iterable<? extends T> arguments) {
        return arguments != null && arguments.iterator().hasNext() ? CollectionUtils.toList(arguments) : null;
    }

    @Override

        rootDir.file("subdir2/file2.txt").write("content");
        archiveFileToRoot(getArchiveFile());

        assertVisits(getTree(), toList("subdir/file1.txt", "subdir2/file2.txt"), toList("subdir", "subdir2"));
        assertSetContainsForAllTypes(getTree(), toList("subdir/file1.txt", "subdir2/file2.txt"));
    }

    @Test
    public void canStopVisitingFiles() {

        
        then:
        output1.exists() && output2.exists()
        [input1, input2] == operation.filesToSign.files.toList()[0..1]
        [output1, output2] == operation.signatureFiles.files.toList()[0..1]
        [output1, output2] == operation.signatures*.file.toList()
    }

    def "sign multiple artifacts with defaults"() {
        when:
        def operation = signing.sign(input1Artifact, input2Artifact)

        MinimalFileTree tree = tree("file.txt", action);

        assertVisits(tree, toList("file.txt"), Collections.<String>emptyList());

        TestFile file = rootDir.file("file.txt");

        file.assertContents(equalTo("content"));
        file.makeOlder();
        TestFile.Snapshot snapshot = file.snapshot();

        assertVisits(tree, toList("file.txt"), Collections.<String>emptyList());

        rootDir.file("subdir2/file2.txt").write("content");
        rootDir.tgzTo(tgz);

        TarFileTree tree = tarTree(tgz);

        assertVisits(tree, toList("subdir/file1.txt", "subdir2/file2.txt"), toList("subdir", "subdir2"));
        assertSetContainsForAllTypes(tree, toList("subdir/file1.txt", "subdir2/file2.txt"));
    }

    @Test
    public void readsBzippedTarFile() {

    @Override
    public List<ComponentArtifactIdentifier> transform(Collection<ResolvedArtifactResult> artifacts) {
        return artifacts.stream().map(ResolvedArtifactResult::getId).collect(Collectors.toList());
    }
}
// end::listResolvedArtifacts[]

    static class VariantExtractor implements Transformer<List<ResolvedVariantResult>, Collection<ResolvedArtifactResult>> {
        @Override

        expect:
        path.toString() == "<root>"
        path.toList() == []
        path.name == ""
        path.size() == 0
        path.parent == null
        path.rootParent == null
    }

    def "path with single component is top level"() {
        def path = ModelPath.path("p")

        expect:
        path.toString() == "p"
        path.toList() == ["p"]
        path.name == "p"
        path.size() == 1