String format = "super-duper-thread-%s";
    ThreadFactory factory = builder.setNameFormat(format).build();
    for (int i = 0; i < 11; i++) {
      assertEquals(rootLocaleFormat(format, i), factory.newThread(monitoredRunnable).getName());
    }
  }

  public void testNameFormatWithPercentD_custom() {
    String format = "super-duper-thread-%d";

    String format = "super-duper-thread-%s";
    ThreadFactory factory = builder.setNameFormat(format).build();
    for (int i = 0; i < 11; i++) {
      assertEquals(rootLocaleFormat(format, i), factory.newThread(monitoredRunnable).getName());
    }
  }

  public void testNameFormatWithPercentD_custom() {
    String format = "super-duper-thread-%d";

      super(message);
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(
        String message, String a1, String a2, String a3) {
      super(message);
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(String message, Throwable antecedent) {
      super(message);
      this.antecedent = antecedent;
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(

    abstract void forEachRemaining(Consumer<? super E> action);

    abstract boolean tryAdvance(Consumer<? super E> action);

    abstract @Nullable GeneralSpliterator<E> trySplit();

    final int characteristics() {
      return spliterator.characteristics();
    }

    final long estimateSize() {
      return spliterator.estimateSize();
    }

    final Comparator<? super E> getComparator() {

  @Override
  public void testContainsKey() {
    try {
      super.testContainsKey();
    } catch (ClassCastException tolerated) {
    }
  }

  @J2ktIncompatible // https://youtrack.jetbrains.com/issue/KT-58242/ undefined behavior (crash)
  @Override
  public void testEntrySetContainsEntryIncompatibleKey() {
    try {
      super.testEntrySetContainsEntryIncompatibleKey();
    } catch (ClassCastException tolerated) {

    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return super.size();
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return super.isEmpty();
    }

    @Override
    public @Nullable V remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return super.remove(object);
    }

    @Override
    public void clear() {

  @Override
  public void testEntrySetRemoveAllNullFromEmpty() {
    try {
      super.testEntrySetRemoveAllNullFromEmpty();
    } catch (RuntimeException tolerated) {
      // GWT's HashMap.entrySet().removeAll(null) doesn't throws NPE.
    }
  }

  @Override
  public void testEntrySetRetainAllNullFromEmpty() {
    try {
      super.testEntrySetRetainAllNullFromEmpty();
    } catch (RuntimeException tolerated) {

    log("appendingSink($file)")

    return super.appendingSink(file, mustExist)
  }

  override fun atomicMove(
    source: Path,
    target: Path,
  ) {
    log("atomicMove($source, $target)")

    super.atomicMove(source, target)
  }

  override fun createDirectory(
    dir: Path,
    mustCreate: Boolean,
  ) {
    log("createDirectory($dir)")

    super.createDirectory(dir, mustCreate)
  }

    Builder(int initCapacity) {
      super(initCapacity);
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(K key, V value) {
      super.put(key, value);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(Entry<? extends K, ? extends V> entry) {
      super.put(entry);
      return this;
    }

final class TableCollectors {

  static <T extends @Nullable Object, R, C, V>
      Collector<T, ?, ImmutableTable<R, C, V>> toImmutableTable(
          Function<? super T, ? extends R> rowFunction,
          Function<? super T, ? extends C> columnFunction,
          Function<? super T, ? extends V> valueFunction) {
    checkNotNull(rowFunction, "rowFunction");
    checkNotNull(columnFunction, "columnFunction");