.sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .protocols(protocols.toList())
        .build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.protocols = client.protocols
  }

  private fun assertConnectionReused(vararg requests: Request?) {

    }

    /**
     * @throws Exception
     */
    @Test
    public void testToList() throws Exception {
        final Object a = new int[] { 1, 5 };
        final List<Integer> list = ArrayUtil.toList(a);
        assertThat(list.get(0), is(Integer.valueOf(1)));
        assertThat(list.get(1), is(Integer.valueOf(5)));
    }

    /**
     *
     */
    @Test
    public void testIsArray() {

                .stream()
                .map(protwordsItem -> createEditBody(protwordsItem, dictId))
                .collect(Collectors.toList())).status(ApiResult.Status.OK).result());
    }

    /**
     * Retrieve a single character mapping entry by ID for the specified dictionary.
     *
     * @param dictId identifier of the dictionary

            protected List<String> loadDataStoreNameList() {
                // Return unsorted list to test sorting
                return List.of("Zebra", "Apple", "Banana").stream().sorted().collect(java.util.stream.Collectors.toList());
            }
        };

        List<String> names = testFactory.loadDataStoreNameList();
        assertEquals(3, names.size());
        assertEquals("Apple", names.get(0));

        final List<ElevateWord> list = elevateWordService.getElevateWordList(pager);
        return asJson(
                new ApiResult.ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                        .total(pager.getAllRecordCount())
                        .status(ApiResult.Status.OK)
                        .result());
    }

    // GET /api/admin/elevateword/{id}
    /**

      @JvmField var headerCount = 0

      @JvmField var dynamicTableByteCount = 0

      fun getAndResetHeaderList(): List<Header> {
        val result = headerList.toList()
        headerList.clear()
        return result
      }

      fun maxDynamicTableByteCount(): Int = maxDynamicTableByteCount

      private fun adjustDynamicTableByteCount() {

            insertAll(targetList.stream()
                    .filter(urlQueue -> StringUtil.isNotBlank(urlQueue.getSessionId()) && StringUtil.isNotBlank(urlQueue.getUrl()))
                    .collect(Collectors.toList()), OpType.CREATE, true);
            if (logger.isDebugEnabled()) {
                logger.debug("Offered URL: Session ID: {}, UrlQueue: {}", sessionId, targetList);
            }
        }
    }

    /**

     * the following code can be used:
     *
     * <pre>{@literal
     * List<SourceRoot> enabledRoots = project.getSourceRoots()
     *         .stream().filter(SourceRoot::enabled).toList();
     * }</pre>
     *
     * The iteration order is the order in which the sources are declared in the POM file.
     *
     * @param project the project for which to get the source roots
     */

            final Set<RequestData> urlSet = e.getChildUrlList();
            assertEquals(5, urlSet.size());
            final List<String> urlList = urlSet.stream().map(x -> x.getUrl()).sorted().toList();
            assertEquals("ftp://localhost:10021/dir1", urlList.get(0));
            assertEquals("ftp://localhost:10021/dir2", urlList.get(1));
            assertEquals("ftp://localhost:10021/text 3.txt", urlList.get(2));

                    uq.setUrl(d.getUrl());
                    uq.setWeight(d.getWeight());
                    return uq;
                })
                .collect(Collectors.toList());
        urlQueueService.offerAll(crawlerContext.sessionId, childList);
    }

    /**
     * Stores a single child URL to the crawling queue.
     * @param childUrl The child URL to store.