final Map<String, Object> res = JsonPath.from(response).getMap("response.setting");
        assertTrue(res.containsKey("total_words_num"));
        assertTrue(res.containsKey("document_words_num"));
        assertTrue(res.containsKey("query_words_num"));
        assertEquals(new Integer(0), JsonPath.from(response).get("response.status"));
    }

    @Override
    protected void tearDown() {

    /**
     * @throws Exception
     */
    @Test
    public void testContainsKey() throws Exception {
        assertThat(map.containsKey("2"), is(true));
        assertThat(map.containsKey("3"), is(not(true)));
        map.put("3", null);
        assertThat(map.containsKey("3"), is(true));
    }

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

        return parent.size();
    }

    @Override
    public boolean isEmpty() {
        return parent.isEmpty();
    }

    @Override
    public boolean containsKey(final Object key) {
        return parent.containsKey(key);
    }

    @Override
    public boolean containsValue(final Object value) {
        return parent.containsValue(value);
    }

    @Override

        this.delegate = delegate;
    }

    @Override
    public synchronized <T> DefaultServiceLocator.ServiceFactory<T> findFactory(Class<T> serviceType) {
        if (serviceFactories.containsKey(serviceType)) {
            return Cast.uncheckedCast(serviceFactories.get(serviceType));
        }
        DefaultServiceLocator.ServiceFactory<T> factory = delegate.findFactory(serviceType);

            if (dependents != null && !dependents.isEmpty()) {
                for (String dependentId : dependents) {
                    if (!buildSuccessesByProject.containsKey(dependentId)
                            && !buildFailuresByProject.containsKey(dependentId)) {
                        blackList(dependentId);
                    }
                }
            }
        }
    }

    public boolean engineContainsAlias(String alias) {
        return keys.containsKey(alias) || certChains.containsKey(alias);
    }

    @Override
    public int engineSize() {
        return keys.size() + certChains.size();
    }

    @Override
    public boolean engineIsKeyEntry(String alias) {
        return keys.containsKey(alias);
    }

    @Override

      return;
    }
    assertFalse(map.containsKey(unmappedKey));
    try {
      assertFalse(map.containsKey(new IncompatibleKeyType()));
    } catch (ClassCastException tolerated) {
    }
    assertTrue(map.containsKey(map.keySet().iterator().next()));
    if (allowsNullKeys) {
      boolean unused = map.containsKey(null);
    } else {
      try {

        if (request.getUserProperties().containsKey(REVISION_PROPERTY)) {
            modelProperties.put(REVISION_PROPERTY, request.getUserProperties().get(REVISION_PROPERTY));
        }
        if (request.getUserProperties().containsKey(CHANGELIST_PROPERTY)) {
            modelProperties.put(CHANGELIST_PROPERTY, request.getUserProperties().get(CHANGELIST_PROPERTY));

        pomReader.properties.size() == 7
        !pomReader.properties.containsKey('prop1')
        !pomReader.properties.containsKey('prop3')
        pomReader.properties['prop2'] == 'myproperty2'
        !pomReader.dependencyMgt.containsKey(new MavenDependencyKey('group-two', 'artifact-two', 'jar', null))
        !pomReader.dependencyMgt.containsKey(new MavenDependencyKey('group-four', 'artifact-four', 'jar', null))

    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> {