.addSubjectAlternativeName("1.1.1.1")
        .addSubjectAlternativeName("cash.app")
        .build()
    val certificate = heldCertificate.certificate
    assertThat(certificate.subjectAlternativeNames.toList()).containsExactly(
      listOf(GeneralName.iPAddress, "1.1.1.1"),
      listOf(GeneralName.dNSName, "cash.app"),
    )
  }

  @Test
  fun commonName() {
    val heldCertificate =

        expect:
        changes(strategy, emptyFingerprint, fingerprint).toList() == [
            DefaultFileChange.removed("file1.txt", "test", FileType.RegularFile, "file1.txt"),
            DefaultFileChange.removed("file2.txt", "test", FileType.RegularFile, "file2.txt")
        ]
        changes(strategy, fingerprint, emptyFingerprint).toList() == [

                    .collect(Collectors.toList()));
        }
        return result;
    }

    public static List<Map<String, String>> getAllInstalledArtifacts() {
        final PluginHelper pluginHelper = ComponentUtil.getPluginHelper();
        final List<Map<String, String>> result = new ArrayList<>();

                    List<String> classpath;
                    if (isJava9) {
                        classpath = Arrays.stream(System.getProperty("java.class.path").split(Pattern.quote(File.pathSeparator)))
                            .map(path -> new File(path).getName())
                            .collect(Collectors.toList());
                    } else {

        when:
        addToGraphAndPopulate(toList(b, c, a))

        then:
        executes(a, b, c)
    }

    def "schedules separately added tasks in order added"() {
        given:
        Task a = task("a")
        Task b = task("b")
        Task c = task("c")
        Task d = task("d")

        when:
        addToGraph(toList(c, b))
        addToGraph(toList(d, a))
        populateGraph()

                builder.withReason(reason);
            }
        }

        List<Checksum> buildChecksums() {
            return builder.values()
                .stream()
                .map(ChecksumBuilder::build)
                .sorted(Comparator.comparing(Checksum::getKind))
                .collect(Collectors.toList());
        }

        public void addTrustedKey(String key) {

        ClassInspector.inspect(Serializable).superTypes.empty
        ClassInspector.inspect(Set).superTypes.toList() == [Collection, Iterable]
    }

    def "super types ordered by their distance"() {
        expect:
        ClassInspector.inspect(HashSet).superTypes.toList() == [AbstractSet, AbstractCollection, Object, Set, Cloneable, Serializable, Collection, Iterable]
    }

    @Issue("GRADLE-3317")

                final Map<String, List<String>> searchFieldMap = entity.getSearchFieldLogList().stream()
                        .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));
                appendJson("search-field", searchFieldMap, buf).append(',');
                final Map<String, List<String>> requestHeaderMap = entity.getRequestHeaderList().stream()

        collector.afterTest(test2, result2)

        collector.afterSuite(root, new DefaultTestResult(FAILURE, 0, 500, 2, 1, 1, []))

        then:
        results.size() == 1
        def fooTest = results.values().toList().first()
        fooTest.className == 'FooTest'
        fooTest.startTime == 100
        fooTest.testsCount == 2
        fooTest.failuresCount == 1
        fooTest.duration == 200
        fooTest.results.size() == 2

        final String virtualHostKey = ComponentUtil.getVirtualHostHelper().getVirtualHostKey();
        final List<LabelTypeItem> labelList;
        if (StringUtil.isBlank(virtualHostKey)) {
            labelList =
                    labelTypeItemList.stream().filter(item -> matchLocale(requestLocale, item.getLocale())).collect(Collectors.toList());
        } else {
            labelList = labelTypeItemList.stream()