assertTrue("Exception handling should be fast", true);
        }
    }

    public void test_crawl_withConfigIdList_emptyList() {
        try {
            List<String> configIds = Arrays.asList("id1", "id2");
            dataIndexHelper.crawl("test-session", configIds);
            assertTrue("Should complete quickly with empty results", true);
        } catch (Exception e) {

        .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?) {

    private final String name;
    private final List<Class<?>> parameterTypes;

    MethodIdentifier(Method method) {
      this.name = method.getName();
      this.parameterTypes = Arrays.asList(method.getParameterTypes());
    }

    @Override
    public int hashCode() {
      return Objects.hash(name, parameterTypes);
    }

    @Override
    public boolean equals(@Nullable Object o) {

    }

    /**
     * @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() {

                    resultMap.put("index", index);
                    resultMap.put("ids", termsQueryBuilder.values().stream().map(Object::toString).collect(Collectors.toList()));
                    return 1;
                }
                return 0;
            }
        };
        ComponentUtil.register(client, "searchEngineClient");

        assertNotNull(result);
        assertTrue(result.isPresent());
        assertEquals(testValue, result.get());
    }

    public void test_ofNullable_withList() {
        List<String> testValue = Arrays.asList("item1", "item2", "item3");
        OptionalEntity<List<String>> result = OptionalUtil.ofNullable(testValue);

        assertNotNull(result);
        assertTrue(result.isPresent());

  - alternatives.md
  - history-design-future.md
  - benchmarks.md
  - management.md
- release-notes.md
markdown_extensions:
  abbr: null
  attr_list: null
  footnotes: null
  md_in_html: null
  tables: null
  toc:
    permalink: true
  pymdownx.betterem: null
  pymdownx.caret: null
  pymdownx.highlight:
    line_spans: __span
  pymdownx.inlinehilite: null
  pymdownx.keys: null
  pymdownx.mark: null

            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));

        newKeyManager(
          null,
          serverCert,
          serverIntermediateCa.certificate,
        )
      val trustManager =
        newTrustManager(
          null,
          Arrays.asList(serverRootCa.certificate, clientRootCa.certificate),
          emptyList(),
        )
      val sslContext = SSLContext.getInstance("TLS")
      sslContext.init(
        arrayOf<KeyManager>(keyManager),

      client
        .newBuilder()
        .protocols(Arrays.asList(Protocol.HTTP_1_1))
        .build()
    assertContent("A", getResponse(newRequest("/")))
  }

  @Test
  fun setProtocolsWithoutHttp11() {
    assertFailsWith<IllegalArgumentException> {
      OkHttpClient
        .Builder()
        .protocols(Arrays.asList(Protocol.HTTP_2))
    }
  }

  @Test