assertTrue(table.containsValue('b'));
    assertTrue(table.containsValue('c'));
    assertFalse(table.containsValue('x'));
    assertFalse(table.containsValue(null));
  }

  public void testGet() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertEquals((Character) 'a', table.get("foo", 1));
    assertEquals((Character) 'b', table.get("bar", 1));

            for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) {
              if (entry.getKey().isConnected(subRange)
                  && !entry.getKey().intersection(subRange).isEmpty()) {
                expectedBuilder.put(entry.getKey().intersection(subRange), entry.getValue());
              }
            }

    return comparator;
  }

  @Override
  public @Nullable K firstKey() {
    return sortedDelegate.firstKey();
  }

  @Override
  public @Nullable K lastKey() {
    return sortedDelegate.lastKey();
  }

  @Nullable K higher(K k) {
    Iterator<K> iterator = keySet().tailSet(k).iterator();
    while (iterator.hasNext()) {
      K tmp = iterator.next();

        } catch (final ClIndexOutOfBoundsException ex) {
            System.out.println(ex);
        }
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGet() throws Exception {
        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        assertThat(list.get(0), is("1"));
        assertThat(list.get(1), is("2"));

    @Override
    @ParametricNullness
    public K firstKey() {
      return sortedMap().firstKey();
    }

    @Override
    @ParametricNullness
    public K lastKey() {
      return sortedMap().lastKey();
    }

    @Override
    public SortedMap<K, Collection<V>> headMap(@ParametricNullness K toKey) {
      return new SortedAsMap(sortedMap().headMap(toKey));
    }

        assertTrue(localLogMsg.get().contains("\"event.dataset\":\"test-dataset\""));
    }

    @Test
    public void test_setEnvMap() {
        Map<String, String> testEnv = new HashMap<>();
        testEnv.put("TEST_KEY", "TEST_VALUE");
        activityHelper.setEnvMap(testEnv);
        assertEquals(testEnv, activityHelper.getEnvMap());
    }

    @Test
    public void test_getEnvMap_withoutCustomMap() {

### Testé { #tested }

* 100 % de <dfn title="La quantité de code testée automatiquement">couverture de test</dfn>.

    @Test
    public void testEntrySet() throws Exception {
        Iterator<Map.Entry<String, String>> i = map.entrySet().iterator();
        assertThat(i.next().getKey(), is(nullValue()));
        assertThat(i.next().getKey(), is("1"));
        assertThat(i.next().getKey(), is("2"));
    }

    /**
     * Test method for {@link org.seasar.util.collection.ArrayIterator#remove()}
     * .
     */
    @Test

    Entry<String, Collection<Integer>> entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("foo");
    assertThat(entry.getValue()).containsExactly(1, 3, 7);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("google");
    assertThat(entry.getValue()).containsExactly(2, 6);
    entry = iterator.next();
    assertThat(entry.getKey()).isEqualTo("tree");
    assertThat(entry.getValue()).containsExactly(0, 4);
  }

import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
import org.elasticsearch.gradle.Version
import org.elasticsearch.gradle.fixtures.AbstractRestResourcesFuncTest
import org.elasticsearch.gradle.VersionProperties
import org.gradle.testkit.runner.TaskOutcome

class YamlRestCompatTestPluginFuncTest extends AbstractRestResourcesFuncTest {

    def compatibleVersion = Version.fromString(VersionProperties.getVersions().get("elasticsearch")).getMajor() - 1