return Iterators.unmodifiableIterator(delegate.keySet().iterator());
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    return delegate.containsKey(key);
  }

  @Override
  @CheckForNull
  public V get(@CheckForNull Object key) {
    return delegate.get(key);
  }

  @Override

        when:
        Sign signTask = signing.sign(jar).first()

        then:
        def outputPath = jar.outputs.files.singleFile.toPath().toAbsolutePath().toString()
        signTask.signaturesByKey.containsKey(outputPath)
        signTask.signaturesByKey.get(outputPath) == signTask.singleSignature
    }

    def "files to sign that do not exist are ignored"() {
        given:
        useJavadocAndSourceJars()

      this.rowKey = checkNotNull(rowKey);
    }

    @CheckForNull Map<C, V> backingRowMap;

    final void updateBackingRowMapField() {
      if (backingRowMap == null || (backingRowMap.isEmpty() && backingMap.containsKey(rowKey))) {
        backingRowMap = computeBackingRowMap();
      }
    }

    @CheckForNull
    Map<C, V> computeBackingRowMap() {
      return backingMap.get(rowKey);
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id("org.gradle.test-retry")
}

if (System.getenv().containsKey("CI")) {
    tasks.withType<Test>().configureEach {
        retry {
            maxRetries.set(2)
        }
    }

    return delegate.keySet().spliterator();
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    return delegate.containsKey(key);
  }

  @Override
  @CheckForNull
  public V get(@CheckForNull Object key) {
    return delegate.get(key);
  }

  @Override

                    if (!currentAbsolutePath.equals(previousAbsolutePath)) {
                        if (!currentSnapshots.containsKey(previousAbsolutePath)) {
                            removed();
                        } else if (!previousSnapshots.containsKey(currentAbsolutePath)) {
                            added();
                        } else {
                            removed();

        this.templateOperationFactory = templateOperationFactory;
        add(defaultType);
        add(converter);
    }

    public void add(BuildInitializer descriptor) {
        if (registeredProjectDescriptors.containsKey(descriptor.getId())) {
            throw new GradleException(String.format("ProjectDescriptor with ID '%s' already registered.", descriptor.getId()));
        }

        when:
        def testOption = new TestOption(GRADLE_PROPERTY)
        testOption.configure(commandLineParser)

        then:
        !commandLineParser.optionsByString.containsKey(LONG_OPTION)
        !commandLineParser.optionsByString.containsKey(SHORT_OPTION)

        when:
        testOption = new TestOption(GRADLE_PROPERTY, BooleanCommandLineOptionConfiguration.create(LONG_OPTION, SHORT_OPTION, DESCRIPTION, DISABLED_DESCRIPTION))

        anyStarted = true;
        lock.lock();
        try {
            failIfStopped();
            if (!deployments.containsKey(name)) {
                return buildOperationRunner.call(new CallableBuildOperation<T>() {
                    @Override
                    public BuildOperationDescriptor.Builder description() {

        expected.each {
            String key = StringUtils.substringBefore(it, "@")
            String conf = StringUtils.substringAfter(it, "@") + "->default"
            assert dependencies.containsKey(key)
            assert dependencies[key].hasConf(conf)
        }
        true
    }

    def assertConfigurationDependsOn(String configuration, String[] expected) {