when {
      PlatformVersion.majorVersion > 11 ->
        assertThat(s.enabledProtocols.toList()).containsExactly(
          "TLSv1.3",
          "TLSv1.2",
        )
      // Not much we can guarantee on JDK 11.
      PlatformVersion.majorVersion == 11 ->
        assertThat(s.enabledProtocols.toList()).contains(
          "TLSv1.2",
        )
      // JDK 8 291 removed older versions

            .sorted(Comparator.comparing(AssessedCandidate::getDisplayName))
            .collect(Collectors.toList());
    }

    public List<AssessedCandidate> assessResolvedVariants(List<? extends ResolvedVariant> resolvedVariants) {
        return resolvedVariants.stream()

                })
                .map(Method::getName)
                .collect(Collectors.toList());

        List<String> overriddenMethods = Stream.of(FileToRawModelMerger.class.getDeclaredMethods())
                .map(Method::getName)
                .filter(m -> m.startsWith("merge"))
                .collect(Collectors.toList());

        assertThat(overriddenMethods, hasItems(methodNames.toArray(new String[0])));
    }

        builder.dependencies(target.getDependencies().stream()
                .map(d -> mergeDependency(d, sourceIterator.next(), sourceDominant, context))
                .collect(Collectors.toList()));
    }

    @Override
    protected void mergeDependency_Exclusions(
            Dependency.Builder builder,
            Dependency target,
            Dependency source,
            boolean sourceDominant,

                map.put(KEY, e.getKeyAsString());
                map.put(COUNT, e.getDocCount());
                return map;
            }).collect(Collectors.toList());
        } else if (SearchLogPager.LOG_TYPE_FAVORITE.equalsIgnoreCase(pager.logType)) {
            list = (EsPagingResultBean<?>) favoriteLogBhv.selectPage(cb -> {

        then:
        container.names.toList() == ["thing"]
    }

    def "can remove unrealized registered element using register provider"() {
        when:
        def provider = container.register('obj')

        then:
        provider.present

        when:
        container.remove(provider)

        then:
        container.names.toList() == []

        and:

            }
            if (logger.isInfoEnabled()) {
                if (docList.getContentSize() > 0) {
                    logger.info("Sent {} docs (Doc:{process {}ms, send {}ms, size {}}, {})", docList.size(), docList.getProcessingTime(),
                            (systemHelper.getCurrentTimeAsLong() - execTime), MemoryUtil.byteCountToDisplaySize(docList.getContentSize()),
                            MemoryUtil.getMemoryUsageLog());

        ['name/some', 'name2/other'],
        ['name', 'name1/some', 'name2/other/third'],
        ['aa/b1', 'ab/a1', 'name', 'name1/some', 'name2/other/third'],
        ("a".."z").toList(),
        ("a".."z").collect { "$it/$it".toString() }.toList(),
    ]

    /**
     * The queried/updated path has no common prefix with any of the initial children of the node under test.
     *
     * E.g.
     *   path: 'name0/some

        static class B extends RuleSource {}

        static class A extends RuleSource {}
    }

    def "find model rule sources - #clazz"() {
        expect:
        detector.getDeclaredSources(clazz).toList() == expected

        where:
        clazz         | expected
        String        | []
        HasOneSource  | [HasOneSource.Source]
        HasTwoSources | [HasTwoSources.SourceOne, HasTwoSources.SourceTwo]

import org.gradle.internal.SystemProperties
import org.gradle.internal.logging.text.TestStyledTextOutputFactory
import org.gradle.util.Path
import spock.lang.Specification

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

class DryRunBuildExecutionActionTest extends Specification {
    private static final String EOL = SystemProperties.instance.lineSeparator
    def delegate = Mock(BuildWorkExecutor)