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

        val callables = typeScope.getCallableSignatures().toList()
        return prettyPrint {
            callables.forEach {
                appendLine(stringRepresentation(it))
            }
        }
    }

    private fun KaSession.prettyPrintForTests(typeScope: KaTypeScope): String {
        val callables = typeScope.getCallableSignatures().toList()
        return prettyPrint {
            callables.forEach {

                        .filter(trustedKey -> trustedKey.getKeyId().equals(e.getKey()))
                        .noneMatch(entry::checkAndMarkSatisfiedBy))
                    .collect(Collectors.toList());
                if (pgpKeys.size() > 1) {
                    // if there's only one entry, we won't "normalize" into globally trusted keys
                    List<ModuleComponentIdentifier> moduleComponentIds = pgpKeys.stream()

        List<RemoteRepository> repos =
                toAdd.stream().map(session::createRemoteRepository).toList();
        if (replace) {
            Set<String> ids = repos.stream().map(RemoteRepository::getId).collect(Collectors.toSet());
            repositories =
                    repositories.stream().filter(r -> !ids.contains(r.getId())).toList();
            pomRepositories = pomRepositories.stream()

            .collect(Collectors.toList());

        final List<ReportCapability> explicitCapabilities = configuration.getOutgoing().getCapabilities().stream()
            .map(this::convertCapability)
            .sorted(Comparator.comparing(ReportCapability::toGAV))
            .collect(Collectors.toList());
        final List<ReportCapability> capabilities;

        final List<Map<String, Object>> logList = readJobLog(NAME_PREFIX);
        logger.info("logList: {}", logList);
        assertEquals(1, logList.size());
    }

    private void testDeleteJobLog() {
        final List<Map<String, Object>> logList = readJobLog(NAME_PREFIX);
        logger.info("logList: {}", logList);
        for (Map<String, Object> elem : logList) {

        List<? extends PerformanceTestExecution> currentExecutions = executionsOfSameCommit.isEmpty()
            ? history.getExecutions().stream().limit(3).collect(toList())
            : executionsOfSameCommit;
        return new PerformanceReportScenario(
            Collections.singletonList(execution),

 */
package org.gradle.api.internal

import groovy.test.NotYetImplemented
import org.gradle.api.Action
import org.gradle.util.TestUtil

import static org.gradle.util.internal.WrapUtil.toList

class DefaultDomainObjectSetTest extends AbstractDomainObjectCollectionSpec<CharSequence> {
    DefaultDomainObjectSet<CharSequence> set = new DefaultDomainObjectSet<CharSequence>(CharSequence, callbackActionDecorator)

        override fun getMemberScope(analysisSession: KaSession, symbol: KaSymbolWithMembers): List<KaDeclarationSymbol> {
            with(analysisSession) {
                return symbol.getCombinedDeclaredMemberScope().getAllSymbols().toList()
            }
        }
    }

    public object ALL_DECLARED : KaRendererBodyMemberScopeProvider {

        synchronized (docList) {
            docList.add(ingest(paramMap, dataMap));
            final long contentSize = indexingHelper.calculateDocumentSize(dataMap);
            docList.addContentSize(contentSize);
            final long processingTime = systemHelper.getCurrentTimeAsLong() - startTime;
            docList.addProcessingTime(processingTime);
            if (logger.isDebugEnabled()) {