String key1 = "key1";
    String key2 = "key2";

    assertThat(
            cache.get(
                key1,
                new CacheLoader<String, String>() {
                  @Override
                  public String load(String key) throws Exception {
                    return cache.get(key2, identityLoader()); // loads a different key, should work
                  }

    String key1 = "key1";
    String key2 = "key2";

    assertThat(
            cache.get(
                key1,
                new CacheLoader<String, String>() {
                  @Override
                  public String load(String key) throws Exception {
                    return cache.get(key2, identityLoader()); // loads a different key, should work
                  }

      }
    };
  }

  /**
   * Returns an immutable map whose keys are the distinct elements of {@code keys} and whose value
   * for each key was computed by {@code valueFunction}. The map's iteration order is the order of
   * the first appearance of each key in {@code keys}.
   *
   * <p>When there are multiple instances of a key in {@code keys}, it is unspecified whether {@code

      }
    };
  }

  /**
   * Returns an immutable map whose keys are the distinct elements of {@code keys} and whose value
   * for each key was computed by {@code valueFunction}. The map's iteration order is the order of
   * the first appearance of each key in {@code keys}.
   *
   * <p>When there are multiple instances of a key in {@code keys}, it is unspecified whether {@code

	for i := range sz {
		var key []byte
		key, buf, err = msgp.ReadMapKeyZC(buf)
		if err != nil {
			return keys, err
		}
		if len(key) == 0 {
			return keys, fmt.Errorf("xlMetaInlineData: key %d is length 0", i)
		}
		keys = append(keys, string(key))
		// Skip data...
		_, buf, err = msgp.ReadBytesZC(buf)
		if err != nil {
			return keys, err
		}
	}
	return keys, nil
}

        // Create test data
        DataConfig config = new DataConfig();
        config.setName("test-config");

        DataStoreParams params = new DataStoreParams();
        params.put("key1", "value1");
        params.put("key2", "value2");

        IndexUpdateCallback callback = new TestIndexUpdateCallback();

        // Execute store method
        dataStore.store(config, callback, params);

	}

	keys := store.List()
	if len(keys) != 1 {
		t.Fatalf("expected len(keys)=1, but found %d", len(keys))
	}

	key := keys[0]
	if !key.Compress {
		t.Fatal("expected the item to be compressed")
	}
	if key.ItemCount != 10 {
		t.Fatalf("expected itemcount=10 but found %v", key.ItemCount)
	}

	raw, err := store.GetRaw(key)
	if err != nil {

	}
	key := keys[0]
	if !key.Compress {
		t.Fatal("expected key.Compress=true; but got false")
	}
	if key.ItemCount != int(limit) {
		t.Fatalf("expected key.ItemCount=%d; but got %v", limit, key.ItemCount)
	}
	items, err := store.GetMultiple(key)
	if err != nil {
		t.Fatalf("unable to read key %v; %v", key.String(), err)
	}
	if len(items) != int(limit) {

/**
 * A collection that associates an ordered pair of keys, called a row key and a column key, with a
 * single value. A table may be sparse, with only a small fraction of row key / column key pairs
 * possessing a corresponding value.
 *
 * <p>The mappings corresponding to a given row key may be viewed as a {@link Map} whose keys are
 * the columns. The reverse is also available, associating a column with a row key / value map. Note

   *
   * @param keys the unique, non-null keys whose values should be loaded
   * @return a map from each key in {@code keys} to the value associated with that key; <b>may not
   *     contain null values</b>
   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is