protected Map<String, String> getMapUnderTestToRead() {
        return new AccessTrackingEnvMap(new StubEnvMap(), onAccess)
    }

    def "access to non-string element with containsKey throws"() {
        when:
        getMapUnderTestToRead().containsKey(Integer.valueOf(5))

        then:
        thrown(RuntimeException)
        0 * onAccess._
    }

    private class StubEnvMap extends ForwardingMap<String, String> {

    return delegate().remove(key);
  }

  @Override
  public void clear() {
    delegate().clear();
  }

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

  @Override
  public boolean containsValue(@CheckForNull Object value) {
    return delegate().containsValue(value);
  }

  @Override
  @CheckForNull

    assertFalse(multimap().containsKey(k0()));
    assertFalse(multimap().containsEntry(k0(), v0()));
    assertEmpty(result);

    assertTrue(result.add(v1()));
    assertTrue(result.add(v2()));

    assertContentsAnyOrder(result, v1(), v2());
    assertContentsAnyOrder(multimap().get(k0()), v1(), v2());
    assertTrue(multimap().containsKey(k0()));
    assertFalse(multimap().containsEntry(k0(), v0()));

            ThreadUtil.sleep(500);
            count++;
            final Map<String, Object> scheduler = getSchedulerItem(namePrefix);
            assertTrue(scheduler.containsKey("running"));
            isRunning = (Boolean) scheduler.get("running");
        }
        if (300 <= count) {
            logger.info("Time out: Failed to start crawler)");
            fail(); // Time Out
        }

            }
        } catch (IOException e) {
            // Should not happen reading from a StringReader
            throw new UncheckedIOException(e);
        }
        if (!defines.containsKey("__GNUC__") && !defines.containsKey("__clang__")) {
            throw new BrokenResultException(String.format("Could not determine %s metadata: %s produced unexpected output.", compilerType.getDescription(), gccBinary.getName()));
        }

        assert pomReader.dependencies.containsKey(key)
        PomReader.PomDependencyData dependency = pomReader.dependencies[key]
        assertPomDependencyValues(key, version, dependency)
    }

    protected void assertResolvedPomDependencyManagement(MavenDependencyKey key, String version) {
        assert pomReader.dependencyMgt.containsKey(key)
        PomDependencyMgt dependency = pomReader.dependencyMgt[key]

        this.listener = listener
        this.instantFactory = instantFactory
    }

    public def propertyMissing(String name) {
        synchronized (lock) {
            if (!operations.containsKey(name)) {
                throw new IllegalStateException("Operation '$name' has not been defined by any test thread.")
            }
            return operations[name]
        }
    }

        return new DataStoreParams(params);
    }

    public void putAll(final Map<String, String> map) {
        params.putAll(map);
    }

    public boolean containsKey(final String key) {
        return params.containsKey(key);
    }

    public Map<String, Object> asMap() {
        return new ParamMap<>(new HashMap<>(getDataMap(params)));
    }

    }
  }

  @CheckForNull
  final V getWithoutCaching(Object key) {
    checkNotNull(key);
    return backingMap.get(key);
  }

  final boolean containsKey(@CheckForNull Object key) {
    return getIfCached(key) != null || backingMap.containsKey(key);
  }

  final Set<K> unmodifiableKeySet() {
    return new AbstractSet<K>() {
      @Override
      public UnmodifiableIterator<K> iterator() {

            if (language == null) {
                return;
            }
        }

        for (final String f : langFields) {
            final String lf = f + "_" + language;
            if (doc.containsKey(f) && !doc.containsKey(lf)) {
                doc.put(lf, doc.get(f));
                if (logger.isDebugEnabled()) {
                    logger.debug("add {} field", lf);
                }
            }
        }
    }