map sigbuild-r2.10-python3.9 2.10-python3.9
        map sigbuild-r2.10-python3.10 2.10-python3.10
        # TF 2.11
        map sigbuild-r2.11 2.11-python3.9
        map sigbuild-r2.11-python3.8 2.11-python3.8
        map sigbuild-r2.11-python3.9 2.11-python3.9
        map sigbuild-r2.11-python3.10 2.11-python3.10
        # WIP Clang Containers, used by TVCs
        map sigbuild-57469 57469-python3.9

  }

  @Test fun regularMappings() {
    assertThat("hello".map()).isEqualTo("hello")
    assertThat("hello-world".map()).isEqualTo("hello-world")
    assertThat("HELLO".map()).isEqualTo("hello")
    assertThat("Hello".map()).isEqualTo("hello")

    // These compound characters map their its components.
    assertThat("¼".map()).isEqualTo("1⁄4")
    assertThat("™".map()).isEqualTo("tm")
  }

        final Set<String> keySet = createTestParam(0).keySet();
        final Map<String, Object> updateMap = getUpdateMap();
        final Map<String, Object> searchBody = createSearchBody(SEARCH_ALL_NUM);
        List<Map<String, Object>> settings = getItemList(searchBody);

        for (Map<String, Object> setting : settings) {
            final Map<String, Object> requestBody = new HashMap<>(updateMap);

        assertThat(map.isEmpty(), is(false));
        assertThat(map.get(Foo.class.getTypeParameters()[0]), is(sameClass(Object.class)));
    }

    /**
     * @throws Exception
     */
    public void testGenericMethod() throws Exception {
        final Map<TypeVariable<?>, Type> map = GenericsUtil.getTypeVariableMap(Fuga.class);
        assertThat(map, is(notNullValue()));
        assertThat(map.isEmpty(), is(true));

  }

  static void checkEmpty(ConcurrentMap<?, ?> map) {
    checkEmpty(map.keySet());
    checkEmpty(map.values());
    checkEmpty(map.entrySet());
    assertEquals(ImmutableMap.of(), map);
    assertEquals(ImmutableMap.of().hashCode(), map.hashCode());
    assertEquals(ImmutableMap.of().toString(), map.toString());

    if (map instanceof LocalCache) {
      LocalCache<?, ?> cchm = (LocalCache<?, ?>) map;

    }

    private Map<String, NamedLockFactory> namedLockFactories;

    public final Map<String, NamedLockFactory> getNamedLockFactories() {
        checkClosed();
        if (namedLockFactories == null) {
            namedLockFactories = createNamedLockFactories();
        }
        return namedLockFactories;
    }

    protected Map<String, NamedLockFactory> createNamedLockFactories() {

    final Map<K, V> map;

    MapMultimap(Map<K, V> map) {
      this.map = checkNotNull(map);
    }

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

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

    @Override

        // Test: update settings api
        final Map<String, Object> updateMap = getUpdateMap();
        final Map<String, Object> searchBody = createSearchBody(SEARCH_ALL_NUM);
        List<Map<String, Object>> settings = getItemList(searchBody);

        for (Map<String, Object> setting : settings) {
            final Map<String, Object> requestBody = new HashMap<>(updateMap);

            new TestStringMapGenerator() {
              @Override
              protected Map<String, String> create(Entry<String, String>[] entries) {
                Map<String, String> map = populate(new HashMap<String, String>(), entries);
                return Collections.checkedMap(map, String.class, String.class);
              }
            })
        .named("checkedMap/HashMap")
        .withFeatures(

                      case 0:
                        map.incrementAndGet(key);
                        threadSum++;
                        break;
                      case 1:
                        map.decrementAndGet(key);
                        threadSum--;
                        break;
                      case 2:
                        map.addAndGet(key, delta);
                        threadSum += delta;