if (denylist.contains(pin)) {
          throw new IOException("Denylisted peer certificate: " + pin);
        }
      }
      return chain.proceed(chain.request());
    }
  };

  private final OkHttpClient client = new OkHttpClient.Builder()
      .addNetworkInterceptor(CHECK_HANDSHAKE_INTERCEPTOR)
      .build();

  public void run() throws Exception {
    Request request = new Request.Builder()

        this.targetClass = targetClass
    }

    def void addMixin(String plugin, String mixinClass) {
        mixinClasses.add(new MixinMetaData(plugin, mixinClass))
    }

    def void addExtension(String plugin, String extension, String extensionClass) {
        extensionClasses.add(new ExtensionMetaData(plugin, extension, extensionClass))
    }

    checkNotNull(root);
    return new FluentIterable<T>() {
      @Override
      public UnmodifiableIterator<T> iterator() {
        return preOrderIterator(root);
      }

      @Override
      public void forEach(Consumer<? super T> action) {
        checkNotNull(action);
        new Consumer<T>() {
          @Override
          public void accept(T t) {

    return filterCollection(unfiltered.get(key), new ValuePredicate(key));
  }

  @Override
  Collection<Entry<K, V>> createEntries() {
    return filterCollection(unfiltered.entries(), predicate);
  }

  @Override
  Collection<V> createValues() {
    return new FilteredMultimapValues<>(this);
  }

  @Override
  Iterator<Entry<K, V>> entryIterator() {
    throw new AssertionError("should never be called");
  }

            }
        }

        private static final Lookup EMPTY_LOOKUP = new Lookup() {
            @Override
            public <T> T lookup(Class<T> type) {
                throw new LookupException("empty lookup");
            }

            @Override
            public <T> T lookup(Class<T> type, String name) {
                throw new LookupException("empty lookup");
            }

            @Override

    checkNotNull(columnComparator);
    return new TreeBasedTable<>(rowComparator, columnComparator);
  }

  /**
   * Creates a {@code TreeBasedTable} with the same mappings and sort order as the specified {@code
   * TreeBasedTable}.
   */
  public static <R, C, V> TreeBasedTable<R, C, V> create(TreeBasedTable<R, C, ? extends V> table) {
    TreeBasedTable<R, C, V> result =

class ContributorTest {

    @Test
    void testHashCodeNullSafe() {
        new Contributor().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Contributor().equals(null));

        new Contributor().equals(new Contributor());
    }

    @Test
    void testEqualsIdentity() {
        Contributor thing = new Contributor();
        assertTrue(thing.equals(thing));
    }

    @Test

class ExtensionTest {

    @Test
    void testHashCodeNullSafe() {
        new Extension().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Extension().equals(null));

        new Extension().equals(new Extension());
    }

    @Test
    void testEqualsIdentity() {
        Extension thing = new Extension();
        assertTrue(thing.equals(thing));
    }

    @Test

    @Test
    void testHashCodeNullSafe() {
        new PluginContainer().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new PluginContainer().equals(null));

        new PluginContainer().equals(new PluginContainer());
    }

    @Test
    void testEqualsIdentity() {
        PluginContainer thing = new PluginContainer();
        assertTrue(thing.equals(thing));
    }

class RelocationTest {

    @Test
    void testHashCodeNullSafe() {
        new Relocation().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Relocation().equals(null));

        new Relocation().equals(new Relocation());
    }

    @Test
    void testEqualsIdentity() {
        Relocation thing = new Relocation();
        assertTrue(thing.equals(thing));
    }

    @Test