assertThat(count, is(2));
        assertThat(names, is("ab"));
        assertThat(DisposableUtil.disposables.size(), is(0));
    }

    /**
     *
     */
    public class TestDisposable implements Disposable {
        String name;

        /**
         * @param name
         */
        public TestDisposable(final String name) {
            this.name = name;
        }

        @Override

  }

  private static final class WrappedCallable<T> implements Callable<T> {
    private final Callable<T> delegate;

    WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

/**
 * LocalCache emulation for GWT.
 *
 * @param <K> the base key type
 * @param <V> the base value type
 * @author Charles Fry
 * @author Jon Donovan
 */
final class LocalCache<K, V> implements ConcurrentMap<K, V> {
  static final int UNSET_INT = CacheBuilder.UNSET_INT;

  private final Object lock = new Object();

  @GuardedBy("lock")
  private final CapacityEnforcingMap<K, V> cachingHashMap;

/**
 * A simplistic set which implements the bare minimum so that it can be used in tests without
 * relying on any specific Set implementations. Slow. Explicitly allows null elements so that they
 * can be used in the testers.
 *
 * @author Regina O'Dell
 */
@GwtCompatible
@NullMarked
public class MinimalSet<E extends @Nullable Object> extends MinimalCollection<E> implements Set<E> {

    assertTrue(runnable2.run);
    assertEquals((Integer) 3, runnableFuture2.get());
  }

  private static class TestRunnable implements Runnable {
    boolean run = false;

    @Override
    public void run() {
      run = true;
    }
  }

  private static class TestCallable implements Callable<String> {
    @Override
    public String call() {
      return "foo";
    }
  }

/**
 * A simplistic set which implements the bare minimum so that it can be used in tests without
 * relying on any specific Set implementations. Slow. Explicitly allows null elements so that they
 * can be used in the testers.
 *
 * @author Regina O'Dell
 */
@GwtCompatible
@NullMarked
public class MinimalSet<E extends @Nullable Object> extends MinimalCollection<E> implements Set<E> {

    assertTrue(runnable2.run);
    assertEquals((Integer) 3, runnableFuture2.get());
  }

  private static class TestRunnable implements Runnable {
    boolean run = false;

    @Override
    public void run() {
      run = true;
    }
  }

  private static class TestCallable implements Callable<String> {
    @Override
    public String call() {
      return "foo";
    }
  }

import org.apache.logging.log4j.Logger;
import org.codelibs.core.timer.TimeoutTarget;

/**
 * Hc4ConnectionMonitorTarget is responsible for monitoring and managing HTTP client connections
 * for Apache HttpComponents 4.x. It implements the TimeoutTarget interface to handle connection
 * expiration events.
 *
 * <p>This class uses an instance of HttpClientConnectionManager to manage the connections.

 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public final class DerivedGoogleCollectionGenerators {
  public static class MapGenerator<K extends @Nullable Object, V extends @Nullable Object>
      implements TestMapGenerator<K, V>, DerivedGenerator {

    private final OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> generator;

    public MapGenerator(

	}
	return err
}

// LimitWriter implements io.WriteCloser.
//
// This is implemented such that we want to restrict
// an enscapsulated writer upto a certain length
// and skip a certain number of bytes.
type LimitWriter struct {
	io.Writer
	skipBytes int64
	wLimit    int64
}

// Write implements the io.Writer interface limiting upto