Iterator<V> getDelegateIterator() {
        validateIterator();
        return delegateIterator;
      }
    }

    @Override
    public boolean add(@ParametricNullness V value) {
      refreshIfEmpty();
      boolean wasEmpty = delegate.isEmpty();
      boolean changed = delegate.add(value);
      if (changed) {
        totalSize++;
        if (wasEmpty) {
          addToMap();
        }
      }

  private final Comparator<? super T> comparator;
  private final boolean hasLowerBound;
  private final @Nullable T lowerEndpoint;
  private final BoundType lowerBoundType;
  private final boolean hasUpperBound;
  private final @Nullable T upperEndpoint;
  private final BoundType upperBoundType;

  private GeneralRange(
      Comparator<? super T> comparator,
      boolean hasLowerBound,
      @Nullable T lowerEndpoint,

    val isPublic: Boolean
        get() = delegate.access.isPublic

    internal
    val isDeprecated: Boolean
        get() = delegate.visibleAnnotations.has<java.lang.Deprecated>()

    internal
    val isIncubating: Boolean
        get() = delegate.visibleAnnotations.has(incubatingAnnotationTypeDescriptor)

    val isSAM: Boolean by unsafeLazy {

    }
  }

  private abstract static class MapTests extends MapInterfaceTest<String, Integer> {

    MapTests(
        boolean allowsNullValues,
        boolean supportsPut,
        boolean supportsRemove,
        boolean supportsClear,
        boolean supportsIteratorRemove) {
      super(
          false,
          allowsNullValues,
          supportsPut,
          supportsRemove,

    boolean dummy = false;
    for (int i = 0; i < reps; i++) {
      dummy ^= Ascii.equalsIgnoreCase(lhs, rhs);
    }
    return dummy;
  }

  @Benchmark
  boolean equalsIgnoreCaseJDK(int reps) {
    // This benchmark has no concept of "noWorkToDo".
    String lhs = testString;
    String rhs = testString.toUpperCase();

    boolean dummy = false;

    }

    val isMainBranch: Boolean
        get() = isMaster || isRelease
    val isMaster: Boolean
        get() = branchName == MASTER_BRANCH
    val isRelease: Boolean
        get() = branchName == RELEASE_BRANCH
    val isLegacyRelease: Boolean
        get() = OLD_RELEASE_PATTERN.matchEntire(branchName) != null
    val isExperimental: Boolean
        get() = branchName == EXPERIMENTAL_BRANCH

    }

    @Override
    public boolean contains(Object object) {
      return standardContains(object);
    }

    @Override
    public boolean containsAll(Collection<?> collection) {
      return standardContainsAll(collection);
    }

    @Override
    public boolean remove(Object object) {
      return standardRemove(object);
    }

    @Override
    public boolean removeAll(Collection<?> collection) {

    }

    @Override
    public boolean equals(@Nullable Object object) {
      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public boolean add(E element) {
      return standardAdd(element);
    }

    @Override
    public boolean addAll(Collection<? extends E> collection) {

        return repositoryLayouts.get(layoutId);
    }

    @Override
    public ArtifactRepository createDeploymentArtifactRepository(
            String id, String url, String layoutId, boolean uniqueVersion) throws UnknownRepositoryLayoutException {
        ArtifactRepositoryLayout layout = repositoryLayouts.get(layoutId);

        checkLayout(id, layoutId, layout);

    abstract val baseVersion: Property<String>

    @get:Input
    @get:Optional
    abstract val commitId: Property<String>

    @get:Input
    abstract val snapshot: Property<Boolean>

    @get:Input
    abstract val promotionBuild: Property<Boolean>

    @get:Input
    @get:Optional
    abstract val buildTimestamp: Property<Date>

    @get:OutputDirectory
    abstract val receiptFolder: DirectoryProperty