*
   * <p>If {@code swallowIOException} is true then we never throw {@code IOException} but merely log
   * it.
   *
   * <p>Example:
   *
   * {@snippet :
   * public void useStreamNicely() throws IOException {
   *   SomeStream stream = new SomeStream("foo");
   *   boolean threw = true;
   *   try {
   *     // ... code which does something with the stream ...
   *     threw = false;
   *   } finally {

        threads[1].join();

        // Verify no exceptions occurred (the main goal is no ConcurrentModificationException)
        assertNull(exceptions[0], "Add thread threw exception");
        assertNull(exceptions[1], "Clear thread threw exception");
    }

    /**
     * Test iteration over deleteUrlList while synchronized.
     * This simulates what happens in deleteDocuments() method.
     */
    @Test

            thread.join();
        }

        // Verify no exceptions occurred
        for (int i = 0; i < threadCount; i++) {
            assertNull(exceptions[i], "Thread " + i + " threw exception");
        }

        // Verify alive is false
        assertFalse("alive should be false after all stop() calls", dataStore.alive);
    }

    /**

   * values. This includes both successful load operations and those that threw exceptions. This is
   * defined as {@code loadSuccessCount + loadExceptionCount}.
   *
   * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is
   * guaranteed not to throw an exception). If you require specific handling, we recommend
   * implementing your own stats collector.
   */

   * values. This includes both successful load operations and those that threw exceptions. This is
   * defined as {@code loadSuccessCount + loadExceptionCount}.
   *
   * <p><b>Note:</b> the values of the metrics are undefined in case of overflow (though it is
   * guaranteed not to throw an exception). If you require specific handling, we recommend
   * implementing your own stats collector.
   */

    return eventBus;
  }

  /** Returns the event object that caused the subscriber to throw. */
  public Object getEvent() {
    return event;
  }

  /** Returns the object context that the subscriber was called on. */
  public Object getSubscriber() {
    return subscriber;
  }

  /** Returns the subscribed method that threw the exception. */
  public Method getSubscriberMethod() {
    return subscriberMethod;
  }

                    try {
                        listener.onCallRejected(this);
                    } catch (Exception ex) {
                        log.warn("Listener threw exception", ex);
                    }
                }

                throw new CircuitOpenException("Circuit breaker '" + name + "' is open");
            }

            totalRequests.incrementAndGet();

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

      throws IOException {
    try {
      Flushables.flush(flushable, swallowException);
      if (expectThrown) {
        fail("Didn't throw exception.");
      }
    } catch (IOException e) {
      if (!expectThrown) {
        fail("Threw exception");
      }
    }
    verify(flushable).flush();
  }