}

  public static <T> Callable<T> callableThrowing(Exception exception) {
    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

  private static Runnable runnableThrowing(RuntimeException e) {
    return new Runnable() {
      @Override
      public void run() {
        throw e;
      }
    };
  }

        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2, 3, 4 });
        assertFalse(cos.done);
        assertTrue(cos.isInMemory());
        cos.close();
        assertFalse(cos.done);
    }

    @Test
    public void inFile() throws IOException {
        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);

    public void setUp() throws Exception {
        super.setUp();
        stemmerOverrideFile = new StemmerOverrideFile("1", "dummy", new Date());
        List<StemmerOverrideItem> itemList = new ArrayList<>();
        itemList.add(new StemmerOverrideItem(1, "aaa", "a"));
        itemList.add(new StemmerOverrideItem(2, "bbb", "b"));
        itemList.add(new StemmerOverrideItem(3, "ccc", "c"));
        stemmerOverrideFile.stemmerOverrideItemList = itemList;

        URL docResource;
        try {
            docResource = new File(myClasspathEntry).toURL();
        } catch (MalformedURLException e) {
            throw new ExpressionDocumentationException(
                    "Cannot construct expression documentation classpath" + " resource base.", e);
        }

        return new URLClassLoader(new URL[] {docResource});
    }

      throws Throwable {
    AtomicInteger count = new AtomicInteger(0);
    AtomicReference<Throwable> thrown = new AtomicReference<>(null);
    int numThreads = 3;
    Thread[] threads = new Thread[numThreads];
    long timeout = SECONDS.toNanos(60);

    Supplier<Boolean> supplier =
        new Supplier<Boolean>() {
          boolean isWaiting(Thread thread) {

    byte[] array = new byte[size];
    for (int i = 0; i < size; i++) {
      array[i] = (byte) (offset + i);
    }
    return array;
  }

  private static void copy(URL url, File file) throws IOException {
    InputStream in = url.openStream();
    try {
      OutputStream out = new FileOutputStream(file);
      try {
        byte[] buf = new byte[4096];

        DummySmbResourceLocator(String urlStr) throws MalformedURLException {
            if (urlStr == null) {
                throw new IllegalArgumentException("URL string must not be null");
            }
            if (!urlStr.startsWith("smb://")) {
                throw new MalformedURLException("Only SMB URLs are supported in the dummy implementation");
            }
            this.urlStr = urlStr;

   *
   * {@snippet :
   * static final ImmutableClassToInstanceMap<Handler> HANDLERS =
   *     new ImmutableClassToInstanceMap.Builder<Handler>()
   *         .put(FooHandler.class, new FooHandler())
   *         .put(BarHandler.class, new SubBarHandler())
   *         .put(Handler.class, new QuuxHandler())
   *         .build();
   * }
   *
   * <p>After invoking {@link #build()} it is still possible to add more entries and build again.

    assertTrue(set.isEmpty());
    set.add(new DerivedComparable("foo"), 2);
    set.add(new DerivedComparable("bar"), 3);
    assertThat(set)
        .containsExactly(
            new DerivedComparable("bar"),
            new DerivedComparable("bar"),
            new DerivedComparable("bar"),
            new DerivedComparable("foo"),
            new DerivedComparable("foo"))
        .inOrder();
  }

    private List<WitnessNotificationResponse> notifications;

    /**
     * Creates a new WitnessAsyncNotify RPC message.
     */
    public WitnessAsyncNotifyMessage() {
        super(WITNESS_ASYNC_NOTIFY);
        this.contextHandle = new byte[20];
        this.notifications = new ArrayList<>();
    }

    /**
     * Creates a new WitnessAsyncNotify RPC message with the specified context handle.
     *