return methodElement.getAnnotation(InterceptInherited.class) != null;
    }

    private static List<ParameterInfo> extractParameters(ExecutableElement methodElement) {
        List<ParameterInfo> list = new ArrayList<>();
        List<? extends VariableElement> parameters = methodElement.getParameters();
        for (int i = 0; i < parameters.size(); i++) {

    server.useHttps(handshakeCertificates.sslSocketFactory())

    defaultEnabledCipherSuites =
      handshakeCertificates.sslSocketFactory().defaultCipherSuites.toList()
    defaultSupportedCipherSuites =
      handshakeCertificates.sslSocketFactory().supportedCipherSuites.toList()
  }

  @Test
  fun testDefaultHandshakeCipherSuiteOrderingTls12Restricted() {
    // We are avoiding making guarantees on ordering of secondary Platforms.

        File file = new File("f1")
        TestFileCollection collection = new TestFileCollection(file)

        expect:
        collection as Collection == toList(file)
        collection as Set == toLinkedSet(file)
        collection as List == toList(file)
    }

    void toFileTreeReturnsSingletonTreeForEachFileInCollection() {
        File file = testDir.createFile("f1")
        File file2 = testDir.createFile("f2")

        List<byte[]> actionClassLoaderHashesBytes = getActionClassLoaderHashesBytes();
        if (actionClassLoaderHashesBytes != null) {
            List<String> actionClassloaderHashes = getActionClassLoaderHashesBytes().stream()
                .map(hash -> hash == null ? null : HashCode.fromBytes(hash).toString())
                .collect(Collectors.toList());
            model.put("actionClassLoaderHashes", actionClassloaderHashes);

        final List<ReportConfiguration> legacyConfigs = data.getAllConfigs().stream()
            .filter(c -> c.isLegacy() || spec.isPurelyCorrectType(c))
            .collect(Collectors.toList());
        writeResults(data, legacyConfigs);
    }

    private void writeNonLegacyResults(ConfigurationReportModel data) {
        final List<ReportConfiguration> nonLegacyConfigs = data.getAllConfigs().stream()

        List<Exclusion> excl = Optional.ofNullable(exclusions).orElse(Collections.emptyList()).stream()
                .map(RepositoryUtils::toExclusion)
                .collect(Collectors.toList());
        return new Dependency(result, artifact.getScope(), artifact.isOptional(), excl);
    }

    public static List<RemoteRepository> toRepos(List<ArtifactRepository> repos) {

    public static class ApiSystemInfoResponse extends ApiResponse {
        protected List<Map<String, String>> envProps;
        protected List<Map<String, String>> systemProps;
        protected List<Map<String, String>> fessProps;
        protected List<Map<String, String>> bugReportProps;

        public ApiSystemInfoResponse envProps(final List<Map<String, String>> envProps) {
            this.envProps = envProps;

                })
                .collect(toList());
    }

    static class ScenarioBuilder {
        private String description;
        private List<String> activeRequiredProjects = emptyList();
        private List<String> activeOptionalProjects = emptyList();
        private List<String> inactiveRequiredProjects = emptyList();
        private List<String> inactiveOptionalProjects = emptyList();

        }
    }

    private static void rollbackStashedFiles(List<StashedFile> stashedFiles) {
        stashedFiles.forEach(StashedFile::unstash);
        if (LOG.isDebugEnabled()) {
            LOG.debug("Restoring stashed files: {}", stashedFiles.stream().map(f -> f.sourceFile.getAbsolutePath()).sorted().collect(Collectors.toList()));
        }
    }

                        performanceResults.setTasks(ResultsStoreHelper.toList(testExecutions.getObject(5)));
                        performanceResults.setArgs(ResultsStoreHelper.toList(testExecutions.getObject(6)));
                        performanceResults.setGradleOpts(ResultsStoreHelper.toList(testExecutions.getObject(7)));
                        performanceResults.setDaemon((Boolean) testExecutions.getObject(8));