for (String row : elements) {
      table.put(row, 1, 'a');
      table.put(row, 2, 'b');
    }
  }

  private static void populateForColumnKeySet(
      Table<Integer, String, Character> table, String[] elements) {
    for (String column : elements) {
      table.put(1, column, 'a');
      table.put(2, column, 'b');
    }
  }

  private static void populateForValues(

		b = reedsolomon.AllocAligned(1, bp.wcap)[0][:bp.w]
	}
	return b
}

// Put returns the given Buffer to the BytePool.
func (bp *BytePoolCap) Put(b []byte) {
	if bp == nil {
		return
	}

	if cap(b) != bp.wcap {
		// someone tried to put back buffer which is not part of this buffer pool
		// we simply don't put this back into pool, a modified buffer provided

      @Nullable Integer nullValue) {
    multimap.clear();
    multimap.put("foo", 1);
    multimap.put("foo", 2);
    multimap.put("foo", 3);
    multimap.put("bar", 5);
    multimap.put("bar", -1);
    multimap.put(nullKey, nullValue);
    multimap.put("foo", nullValue);
    multimap.put(nullKey, 5);
    multimap.put("foo", 2);

    if (permitsDuplicates) {
      assertEquals(9, multimap.size());

            // Create properties with specific insertion order using LinkedHashMap
            Map<String, String> orderedMap = new LinkedHashMap<>();
            orderedMap.put("third", "3");
            orderedMap.put("first", "1");
            orderedMap.put("second", "2");

            // Create model and set properties
            Model model = new Model();
            Properties props = model.getProperties();

                .put("number_of_shards", 1)
                .put("number_of_replicas", 0)
                .put("analysis.analyzer.test_reading_analyzer.type", "custom")
                .put("analysis.analyzer.test_reading_analyzer.tokenizer", "standard")
                .put("analysis.analyzer.test_reading_term_analyzer.type", "custom")

  }

  public void testUpdates() {
    cache.put(key, "1");
    // simultaneous update for same key, some null, some non-null
    doParallelCacheOp(
        count,
        n -> {
          cache.asMap().compute(key, (k, v) -> n % 2 == 0 ? v + delimiter + n : null);
        });
    assertThat(cache.size()).isAtMost(1);
  }

  public void testCompute() {
    cache.put(key, "1");
    // simultaneous deletion

  }

  @Override
  protected SortedMap<String, Map<Integer, Character>> makePopulatedMap() {
    RowSortedTable<String, Integer, Character> table = TreeBasedTable.create();
    table.put("foo", 1, 'a');
    table.put("bar", 1, 'b');
    table.put("foo", 3, 'c');
    return unmodifiableRowSortedTable(table).rowMap();
  }

  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<String, Integer, Character> table = HashBasedTable.create();
    table.put("foo", 1, 'a');
    table.put("bar", 1, 'b');
    table.put("foo", 3, 'c');
    return unmodifiableTable(table).rowMap();
  }

        CurlResponse response = new CurlResponse();
        Map<String, List<String>> headers = new HashMap<>();
        headers.put("Content-Type", Arrays.asList("application/json"));
        headers.put("CONTENT-LENGTH", Arrays.asList("100"));
        headers.put("accept-encoding", Arrays.asList("gzip"));
        response.setHeaders(headers);

        // All header access should be case-insensitive

  protected Map<String, Collection<Integer>> makePopulatedMap() {
    TreeMultimap<String, Integer> multimap = createMultimap();
    multimap.put("f", 1);
    multimap.put("f", 2);
    multimap.put("g", 3);
    multimap.put("h", 4);
    return multimap.asMap().subMap("e", "p");
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "a";
  }

  @Override