} catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        endLatch.countDown();
                    }
                }
            }).start();
        }

        startLatch.countDown();
        endLatch.await();

        // Verify all rules were added (can't check exact count due to thread-safe implementation)

                .setTransferredBytes(bytes)
                .build();
        startLatch.countDown();
        try {
            listener.transferProgressed(event);
        } catch (TransferCancelledException e) {
        }
        endLatch.countDown();
    }

                        }
                    }
                } catch (Exception e) {
                    exception.set(e);
                } finally {
                    latch.countDown();
                }
            });
        }

        latch.await(30, TimeUnit.SECONDS);
        executor.shutdown();

        if (exception.get() != null) {
            throw exception.get();

 *
 * <p>Here's an example that tests a {@code finalize} method:
 *
 * {@snippet :
 * final CountDownLatch latch = new CountDownLatch(1);
 * Object x = new MyClass() {
 *   ...
 *   protected void finalize() { latch.countDown(); ... }
 * };
 * x = null;  // Hint to the JIT that x is stack-unreachable
 * GcFinalization.await(latch);
 * }
 *
 * <p>Here's an example that uses a user-defined finalization predicate:
 *
 * {@snippet :

                computationStarted.countDown();
                cache.getUnchecked("b");
                computationComplete.countDown();
              }
            })
        .start();

    // wait for the computingEntry to be created
    computationStarted.await();
    cache.invalidateAll();
    // let the computation proceed
    computingLatch.countDown();

    return new ListenerCallQueue.Event<Object>() {
      @Override
      public void call(Object listener) {
        latch.countDown();
      }

      @Override
      public String toString() {
        return "countDown";
      }
    };
  }

    return new ListenerCallQueue.Event<Object>() {
      @Override
      public void call(Object listener) {
        latch.countDown();
      }

      @Override
      public String toString() {
        return "countDown";
      }
    };
  }

                        exceptions.add(e);
                    }
                } finally {
                    endLatch.countDown();
                }
            });
        }

        // Start all threads
        startLatch.countDown();

        // Wait for completion
        assertTrue(endLatch.await(30, TimeUnit.SECONDS), "All threads should complete");
        executor.shutdown();

                    } catch (Exception e) {
                        errorCount.incrementAndGet();
                    } finally {
                        endLatch.countDown();
                    }
                }
            });
        }

        startLatch.countDown();
        endLatch.await(10, TimeUnit.SECONDS);
        executor.shutdown();

        assertEquals(0, errorCount.get());

          outputFuture.set(RESULT_DATA);
          break;
        case SLOW_OUTPUT_VALID_INPUT_DATA:
          break; // do nothing to the result
        case SLOW_FUNC_VALID_INPUT_DATA:
          funcIsWaitingLatch.countDown();
          awaitUninterruptibly(funcCompletionLatch);
          break;
        case EXCEPTION_DATA:
          throw EXCEPTION;
      }
      return outputFuture;
    }
  }