private final Map<String, Object> storage = new HashMap<>();

    @Override
    public boolean has(String name) {
        return storage.containsKey(name);
    }

    @Override
    @Nullable
    public Object get(String name) {
        Object value = find(name);
        if (value == null && !has(name)) {

        map = null;
    }

    /**
     * @throws Exception
     */
    @Test
    public void testContainsKey() throws Exception {
        assertThat(map.containsKey("ONE"), is(true));
        assertThat(map.containsKey("one"), is(true));
        assertThat(map.containsKey("onex"), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGet() throws Exception {

     * @return Candidate methods named {@literal methodName} or {@literal null} if none
     */
    Map<Equivalence.Wrapper<Method>, Collection<Method>> methodsNamed(String methodName) {
        if (candidates.containsKey(methodName)) {
            return candidates.get(methodName);
        }
        return Collections.<Equivalence.Wrapper<Method>, Collection<Method>>emptyMap();
    }

    /**
     * @param methodName Method name

    }
  }

  @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() {

            withType(this.specialItemClass).containsKey("b")
            withType(Object).containsKey("a")
            withType(this.itemClass).containsKey("a")
            !withType(this.specialItemClass).containsKey("a")
            !withType(Special).containsKey("a")
            !withType(String).containsKey("a")

            withType(Object).containsKey("b")
            withType(this.itemClass).containsKey("b")

    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

        key        | expectedResult  | reportedValue
        'existing' | 'existingValue' | 'existingValue'
        'missing'  | 'defaultValue'  | null
    }


    def "containsKey(#key) is tracked"() {
        when:
        def result = getMapUnderTestToRead().containsKey(key)

        then:
        result == expectedResult
        1 * onAccess.accept(key, reportedValue)
        0 * onAccess._

        where:

            #if ( $classToFields.containsKey( $model.getClass( $class.superClass, $class.versionRange ) ) )
            $pfx is_${v}((${class.superClass}) ${var})
                #set ( $pfx = "||" )
            #end
        #end
        #foreach ( $field in $classToFields.get( $class ) )
            #if ( $field.isManyMultiplicity() )
                #if ( $classToFields.containsKey( $field.toClass ) )

        final List<Map<String, String>> dicts = JsonPath.from(response).getList("response.settings");

        for (Map<String, String> item : dicts) {
            assertTrue(item.containsKey("id"));
            assertTrue(item.containsKey("type"));
            if (getDictType().equals(item.get("type"))) {
                dictId = item.get("id");
                return;
            }
        }

        fail();
    }

        if (testClassDescriptor) {
            String description = createProgressLoggerDescription(testDescriptor);

            if (!testWorkerProgressLoggers.containsKey(description)) {
                ProgressLogger progressLogger = factory.newOperation(TestWorkerProgressListener.class, parentProgressLogger);
                progressLogger.start(description, description);