final String[] hosts =
                split(address, ",").get(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        final Settings settings = Settings.builder().putList("http.hosts", hosts).build();
        return new HttpClient(settings, null);
    }

    /**
     * Executes an OpenSearch operation with retry logic.
     *
     * @param <T> The response type.

                split(host, ",").get(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        final Builder builder = Settings.builder()
                .putList("http.hosts", hosts)
                .put("processors", fessConfig.availableProcessors())
                .put("http.heartbeat_interval", fessConfig.getFesenHeartbeatInterval());

        System.clearProperty("lasta.env");
        final List<String> ptList = pathMappingHelper.getProcessTypeList();
        assertEquals(2, ptList.size());
        assertTrue(ptList.contains(Constants.PROCESS_TYPE_DISPLAYING));
        assertTrue(ptList.contains(Constants.PROCESS_TYPE_BOTH));
    }

    @Test
    public void test_getProcessTypeList_nonCrawlerMode() {

        final List<String> ptList = new ArrayList<>();
        final String executeType = System.getProperty("lasta.env");
        if (Constants.EXECUTE_TYPE_CRAWLER.equalsIgnoreCase(executeType)) {
            ptList.add(Constants.PROCESS_TYPE_REPLACE);
        } else {
            ptList.add(Constants.PROCESS_TYPE_DISPLAYING);
            ptList.add(Constants.PROCESS_TYPE_BOTH);
        }

    public Hasher putShort(short s) {
      ensureCapacity(Short.BYTES);
      buffer.putShort(s);
      return this;
    }

    @Override
    public Hasher putInt(int i) {
      ensureCapacity(Integer.BYTES);
      buffer.putInt(i);
      return this;
    }

    @Override
    public Hasher putLong(long l) {
      ensureCapacity(Long.BYTES);
      buffer.putLong(l);
      return this;

            // setup path mapping
            final List<String> ptList = new ArrayList<>();
            ptList.add(Constants.PROCESS_TYPE_CRAWLING);
            ptList.add(Constants.PROCESS_TYPE_BOTH);
            pathMappingHelper.setPathMappingList(options.sessionId, pathMappingService.getPathMappingList(ptList));

            // duplicate host
            try {

    TestHasher hasher = new TestHasher();
    hasher.putShort((short) 0x0201);
    hasher.assertBytes(new byte[] {1, 2});
  }

  public void testInt() {
    TestHasher hasher = new TestHasher();
    hasher.putInt(0x04030201);
    hasher.assertBytes(new byte[] {1, 2, 3, 4});
  }

  public void testLong() {
    TestHasher hasher = new TestHasher();
    hasher.putLong(0x0807060504030201L);

      buffer.order(ByteOrder.LITTLE_ENDIAN);
      while (buffer.remaining() >= 4) {
        putInt(buffer.getInt());
      }
      while (buffer.hasRemaining()) {
        putByte(buffer.get());
      }
      buffer.order(bo);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putInt(int i) {
      update(4, i);
      return this;
    }

    @CanIgnoreReturnValue

        .isEqualTo(
            "07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6");
    assertThrows(IllegalStateException.class, () -> hasher.putInt(42));
  }

  public void testHashTwice() {
    Hasher hasher = sha512().newHasher();

    assertThat(
            hasher
                .putString("The quick brown fox jumps over the lazy dog", UTF_8)

    }
  }

  public void testForInts() {
    Integer value = 1234;
    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);
    integerFunnel().funnel(value, primitiveSink);
    verify(primitiveSink).putInt(1234);
  }

  public void testForInts_null() {
    assertNullsThrowException(integerFunnel());
  }

  public void testForLongs() {
    Long value = 1234L;