}
    Set<E> delegate = delegateOrNull();
    return (delegate != null)
        ? delegate.spliterator()
        : Spliterators.spliterator(
            requireElements(), 0, size, Spliterator.DISTINCT | Spliterator.ORDERED);
  }

  @Override
  public void forEach(Consumer<? super E> action) {
    checkNotNull(action);
    Set<E> delegate = delegateOrNull();
    if (delegate != null) {

    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;

    WrappedRunnable(Runnable delegate) {

        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> ListMultimap<K, V> wrap(ListMultimap<K, V> delegate) {
    return new ForwardingListMultimap<K, V>() {
      @Override
      protected ListMultimap<K, V> delegate() {
        return delegate;
      }
    };
  }

  private static class SimpleForwardingSortedMap<K, V> extends ForwardingSortedMap<K, V> {
    final SortedMap<K, V> delegate;

    SimpleForwardingSortedMap(SortedMap<K, V> delegate) {
      this.delegate = delegate;
    }

    @Override
    protected SortedMap<K, V> delegate() {
      return delegate;
    }
  }

  public ForwardingSortedMapImplementsMapTest() {
    super(true, true, true, true, true);
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    return (delegate != null) ? delegate.containsKey(key) : indexOf(key) != -1;
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Map<K, V> delegate = delegateOrNull();
    if (delegate != null) {
      return delegate.get(key);
    }
    int index = indexOf(key);
    if (index == -1) {

  @Override
  protected abstract Queue<E> delegate();

  @CanIgnoreReturnValue // TODO(cpovirk): Consider removing this?
  @Override
  public boolean offer(@ParametricNullness E o) {
    return delegate().offer(o);
  }

  @CanIgnoreReturnValue // TODO(cpovirk): Consider removing this?
  @Override
  public @Nullable E poll() {
    return delegate().poll();
  }

  @CanIgnoreReturnValue
  @Override

        return toolchain instanceof ToolchainWrapperV3 v3tc ? v3tc.delegate : new ToolchainWrapperV4(toolchain);
    }

    private ToolchainPrivate getToolchainV3(org.apache.maven.api.Toolchain toolchain) {
        return toolchain instanceof ToolchainWrapperV4 v3tc ? v3tc.delegate : new ToolchainWrapperV3(toolchain);
    }

    private record ToolchainWrapperV4(ToolchainPrivate delegate) implements org.apache.maven.api.Toolchain {

    return delegate().remove(element, occurrences);
  }

  @Override
  public Set<E> elementSet() {
    return delegate().elementSet();
  }

  @Override
  public Set<Entry<E>> entrySet() {
    return delegate().entrySet();
  }

  @Override
  public boolean equals(@Nullable Object object) {
    return object == this || delegate().equals(object);
  }

  @Override

              @Override
              public Collection apply(Collection delegate) {
                return wrap(delegate);
              }
            });
  }

  private static <T> Collection<T> wrap(Collection<T> delegate) {
    return new ForwardingCollection<T>() {
      @Override
      protected Collection<T> delegate() {
        return delegate;
      }
    };
  }

              @Override
              public Queue apply(Queue delegate) {
                return wrap(delegate);
              }
            });
  }

  private static <T> Queue<T> wrap(Queue<T> delegate) {
    return new ForwardingQueue<T>() {
      @Override
      protected Queue<T> delegate() {
        return delegate;
      }
    };
  }