}
    }
  }

  @Throws(UnknownHostException::class)
  private fun throwBestFailure(
    hostname: String,
    failures: List<Exception>,
  ): List<InetAddress> {
    if (failures.isEmpty()) {
      throw UnknownHostException(hostname)
    }

    val failure = failures[0]

    if (failure is UnknownHostException) {
      throw failure
    }

	ClientKey  string          `json:"clientKey"`
}

// Validate WebhookArgs fields
func (w WebhookArgs) Validate() error {
	if !w.Enable {
		return nil
	}
	if w.Endpoint.IsEmpty() {
		return errors.New("endpoint empty")
	}
	if w.ClientCert != "" && w.ClientKey == "" || w.ClientCert == "" && w.ClientKey != "" {
		return errors.New("cert and key must be specified as a pair")
	}
	return nil
}

    void takeSuccessfully() {
      assertThat(takeUninterruptibly(queue)).isEqualTo(EXPECTED_TAKE);
      completed.assertCompletionExpected();
      assertTrue(queue.isEmpty());
    }

    private static void scheduleEnableReads(BlockingQueue<String> queue, long countdownInMillis) {
      Runnable toRun = new EnableReads(queue, countdownInMillis);

            @Override
            public void store(DataStoreParams paramMap, Map<String, Object> dataMap) {
                assertNotNull(paramMap);
                assertNotNull(dataMap);
                assertTrue(dataMap.isEmpty());
                storeCount.incrementAndGet();
            }

            @Override
            public long getDocumentSize() {
                return storeCount.get();
            }

    }

    // Test asMap with empty params
    @Test
    public void test_asMapEmpty() {
        Map<String, Object> map = dataStoreParams.asMap();
        assertNotNull(map);
        assertTrue(map.isEmpty());
    }

    // Test getDataMap with ParamMap
    @Test
    public void test_getDataMapWithParamMap() {
        Map<String, Object> innerMap = new HashMap<>();
        innerMap.put("key1", "value1");

        // Get pending operations from failed channel
        List<CommonServerMessageBlock> pendingOps = failedChannel.getPendingOperations();

        if (pendingOps.isEmpty()) {
            return;
        }

        log.info("Redistributing {} pending operations from failed channel", pendingOps.size());

        // Create a defensive copy to avoid ConcurrentModificationException

     * @param destZip the target zip file
     * @param srcFiles the mapping of relative path to the file
     */
    private
    fun zip(destZip: File, srcFiles: List<Pair<String, File>>) {
        if (srcFiles.isEmpty()) {
            return
        }
        destZip.parentFile.mkdirs()
        ZipOutputStream(FileOutputStream(destZip), StandardCharsets.UTF_8).use { zipOutput ->

            for (BuilderProblem.Severity s : REVERSED_ORDER) {
                if (s.ordinal() > severity.ordinal()) {
                    List<P> problems = getProblems(s);
                    while (!problems.isEmpty()) {
                        try {
                            return problems.remove(0) != null;
                        } catch (IndexOutOfBoundsException e) {
                            // empty, continue

          FactoryMethodReturnsNullException {
    if (cls.isEnum()) {
      return;
    }
    List<? extends Invokable<?, ?>> factories = Lists.reverse(getFactories(TypeToken.of(cls)));
    if (factories.isEmpty()) {
      return;
    }
    int numberOfParameters = factories.get(0).getParameters().size();
    List<ParameterNotInstantiableException> paramErrors = new ArrayList<>();

        queryRescorer = new QueryRescorer() {
            @Override
            public RescorerBuilder<?> evaluate(Map<String, Object> params) {
                if (params == null || params.isEmpty()) {
                    return null;
                }
                return createMockRescorerBuilder();
            }
        };

        assertNull(queryRescorer.evaluate(Collections.emptyMap()));