return standardContainsValue(value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> map) {
      standardPutAll(map);
    }

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

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

    @Override

        assertEquals("true", returned.get("refreshKrb5Config"));
        verify(spyOpts, never()).put(any(), any());
        verify(spyOpts, never()).remove(any());
        verify(spyOpts, never()).clear();
    }

                for (Iterator<Artifact> it = missing.iterator(); it.hasNext(); ) {
                    String key = ArtifactUtils.key(it.next());
                    if (projectIds.contains(key)) {
                        it.remove();
                    }
                }

                if (!missing.isEmpty()) {
                    throw e;
                }
            }

            resolved.addAll(result.getArtifacts());

        if (systemProperties != null) {
            this.systemProperties = new Properties();
            synchronized (
                    systemProperties) { // avoid concurrentmodification if someone else sets/removes an unrelated system
                // property
                this.systemProperties.putAll(systemProperties);
            }
        } else {
            this.systemProperties = null;
        }

            } else {
                logger.warn("Unexpected value: value={}", s);
            }
        }));

        final List<Pair<String, String>> headerList = responseHeaderMap.remove("*");
        if (headerList != null) {
            defaultResponseHeaders = headerList;
        } else {
            defaultResponseHeaders = Collections.emptyList();
        }
    }

    @Override

}

// https://github.com/gradle/gradle-private/issues/4527
// https://github.com/gradle/gradle-private/issues/4528
// Trigger ReadyForNightly and ReadyForRelease for provider-api-migration/public-api-changes branch
// TODO: remove this after the branch is merged
const val PROVIDER_API_MIGRATION_BRANCH = "gradle10/provider-api-migration"
const val BOT_DAILY_UPGRADLE_WRAPPER_BRANCH = "devprod/upgrade-to-latest-wrapper"

    public boolean isEmpty() {
      return standardIsEmpty();
    }

    @Override
    public Iterator<E> iterator() {
      return standardIterator();
    }

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

    @Override
    public boolean removeAll(Collection<?> collection) {
      return standardRemoveAll(collection);
    }

            }
            haveBeenCalled = true;
            return 0;
          }
        };

    assertEquals(0, (int) iter.next());

    assertThrows(UnsupportedOperationException.class, iter::remove);
  }


  @GwtIncompatible // weak references
  @J2ktIncompatible
  public void testFreesNextReference() {
    Iterator<Object> itr =
        new AbstractIterator<Object>() {
          @Override

            effectiveScope = Artifact.SCOPE_SYSTEM;
        } else if (Artifact.SCOPE_COMPILE.equals(originalScope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
            // added to retain compile scope. Remove if you want to compile inherited as runtime
            effectiveScope = Artifact.SCOPE_COMPILE;
        } else if (Artifact.SCOPE_TEST.equals(inheritedScope)) {
            effectiveScope = Artifact.SCOPE_TEST;

	if e.replCfg == nil {
		return false
	}
	if e.replCfg.HasActiveRules(obj.Name, true) && !obj.VersionPurgeStatus.Empty() {
		return true
	}

	return false
}

// IsObjectLocked checks if it is appropriate to remove an
// object according to locking configuration when this is lifecycle/ bucket quota asking.
// (copied over from enforceRetentionForDeletion)
func (e *Evaluator) IsObjectLocked(obj ObjectOpts) bool {