throw new IORuntimeException(e);
                    }
                } else if (url.contains("plugin/repo2")) {
                    try (InputStream is = ResourceUtil.getResourceAsStream(url)) {
                        return new String(InputStreamUtil.getBytes(is), Constants.UTF_8);
                    } catch (IOException e) {
                        throw new IORuntimeException(e);
                    }

            try {
              ready.countDown()
              waiting.await()
            } catch (e: InterruptedException) {
              throw AssertionError()
            }
            throw IOException()
          },
        ).build()
    val a1 = client.newCall(newRequest("http://a/1"))
    val a2 = client.newCall(newRequest("http://a/2"))

        return;
      } catch (InterruptedException ie) {
        throw new RuntimeException("Unexpected interrupt while waiting for future", ie);
      } catch (TimeoutException tryHarder) {
        /* OK */
      }
    } while (System.nanoTime() - deadline < 0);
    throw formatRuntimeException("Future not done within %d second timeout", timeoutSeconds);
  }

  /**

                }
                if (!foundKerberos) {
                    throw new SmbUnsupportedOperationException("Server does not support kerberos authentication");
                }
            }
        } catch (SmbException e) {
            throw e;
        } catch (IOException e1) {
            log.debug("Ignoring invalid initial token", e1);
        }

        try {

                languageHelper.getReindexScriptSource());
    }

    public void test_init() {
        try {
            languageHelper.init();
            // Should not throw exception
        } catch (Exception e) {
            fail("init() should not throw an exception: " + e.getMessage());
        }
    }

    public void test_updateDocument_withExistingLang() {
        Map<String, Object> doc = new HashMap<>();

        // When
        int bytesRead = response.readBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesRead);
    }

    @DisplayName("Should throw exception for invalid structure size")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 3, 5, 10, 100, 65535 })
    void testReadBytesWireFormatInvalidStructureSize(int structureSize) {
        // Given

                        file = new File(targetFile, paths[i] + "_" + j);
                        if (!file.exists()) {
                            if (!file.mkdirs()) {
                                throw new CrawlerSystemException("Could not create " + file.getAbsolutePath());
                            }
                            break;
                        }
                        if (file.isDirectory()) {

                }
            }
            throw new ChildUrlsException(requestDataSet, this.getClass().getName() + "#process");
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidAggregationCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {
            String msg = "Cannot register null or empty query collection: name=" + name + " values=" + values;
            throw new InvalidQueryRegisteredException(msg);
        }

        final Decodable out = getOutputData();

        if (out == null) {
            throw new SmbException("Failed to decode output data");
        }

        if (!responseType.isAssignableFrom(out.getClass())) {
            throw new SmbException("Incompatible response data " + out.getClass());
        }
        return (T) out;
    }