@Override
    public TestLauncher withTests(TestOperationDescriptor... testDescriptors) {
        withTests(Arrays.asList(testDescriptors));
        return this;
    }

    @Override
    public TestLauncher withTests(Iterable<? extends TestOperationDescriptor> descriptors) {
        operationDescriptors.addAll(CollectionUtils.toList(descriptors));
        return this;
    }

    @Override

                    }
                    "a1" {}
                }
                withFile("root-f1")
            }
        }

        assertThat(
            folder("root").walkReproducibly().map { it.name }.toList(),
            equalTo(
                listOf(
                    "root",
                    "root-f1", "root-f2", "a", "b", "c",
                    "a1", "a2", "b-f1", "c1",

            .collect(oxfordJoin(conjunction));
    }

    public static Collector<? super String, ?, String> oxfordJoin(String conjunction) {
        return Collectors.collectingAndThen(Collectors.toList(), stringList -> {
            switch (stringList.size()) {
                case 0:
                    return "";
                case 1:
                    return stringList.get(0);
                case 2:

                // care performance for List that the most frequent pattern
                final Object first = coll instanceof List<?> ? ((List<?>) coll).get(0) : coll.iterator().next();
                if (first instanceof Entity) {
                    data.register(key, coll.stream().map(BeanUtil::copyBeanToNewMap).collect(Collectors.toList()));
                    return;
                }
            }

dependencies {
    asciidoclet("org.asciidoctor:asciidoclet:1.+")
}

tasks.register("configureJavadoc") {
    doLast {
        tasks.javadoc {
            options.doclet = "org.asciidoctor.Asciidoclet"
            options.docletpath = asciidoclet.files.toList()
        }
    }
}

tasks.javadoc {
    dependsOn("configureJavadoc")
}
// end::using-custom-doclet[]

            )
        )
    }

    private
    fun assertClassFilePathCandidatesFor(sourceName: String, candidates: List<String>) {
        assertThat(
            classFilePathCandidatesFor(sourceName).toList(),
            equalTo(candidates)
        )
    }

    @Test
    fun `source name for class file path`() {

        assertKotlinSourceNameOf("My.class", "My")

        this.visible = visible;
        this.extendsFrom = CollectionUtils.toList(extendsFrom);
    }

    public String getName() {
        return name;
    }

    public boolean isTransitive() {
        return transitive;
    }

    public boolean isVisible() {
        return visible;
    }

    public List<String> getExtendsFrom() {
        return extendsFrom;
    }

    @Override

import org.apache.maven.api.model.Resource;
import org.apache.maven.api.services.*;
import org.apache.maven.project.MavenProject;
import org.eclipse.sisu.Typed;

import static java.util.stream.Collectors.toList;
import static org.apache.maven.internal.impl.Utils.map;
import static org.apache.maven.internal.impl.Utils.nonNull;

@Named
@Typed
@SessionScoped
public class DefaultProjectManager implements ProjectManager {

        require(classSymbolUnderCaret is KaSymbolWithMembers)

        return SymbolsData(classSymbolUnderCaret.getMemberScope().getAllSymbols().toList())
    }

    override fun KaSession.renderSymbolForComparison(symbol: KaSymbol, directives: RegisteredDirectives): String {
        return with(DebugSymbolRenderer()) { renderForSubstitutionOverrideUnwrappingTest(symbol) }

        then: writer.toString() == "-key '1\\\\2\\\\'${SystemProperties.instance.getLineSeparator()}"
    }

    def "quotes and escapes multiple values"() {
        when:
        context.writeValuesOption("key", WrapUtil.toList("a\\b", "c"), ":")

        then: writer.toString() == "-key 'a\\\\b:c'${SystemProperties.instance.getLineSeparator()}"
    }

    def "writes multiline value"() {
        when: