public void testAsMap() {
    CacheBuilder<Object, Object> builder = createCacheBuilder();
    LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader());
    assertThat(cache.stats()).isEqualTo(EMPTY_STATS);

    Object one = new Object();
    Object two = new Object();
    Object three = new Object();

    ConcurrentMap<Object, Object> map = cache.asMap();
    assertThat(map.put(one, two)).isNull();

        Object result = data.getDataMap().get("entities");
        assertNotNull(result);
        assertTrue(result instanceof List);
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> resultList = (List<Map<String, Object>>) result;
        assertEquals(2, resultList.size());

        Map<String, Object> map1 = resultList.get(0);

        assertFalse(docMap.isEmpty());

        Set<Map.Entry<String, Object>> actual = docMap.entrySet();
        assertTrue(actual.size() == keys.size());
        docMap.clear();

        assertTrue(docMap.isEmpty());
    }

    @Test
    public void test_constructor() {
        Map<String, Object> parentMap = new HashMap<>();
        DocMap docMap = new DocMap(parentMap);

    for (LoadingCache<Object, Object> cache : caches()) {
      Set<Entry<Object, Object>> entries = cache.asMap().entrySet();
      assertThrows(
          NullPointerException.class, () -> entries.toArray((Entry<Object, Object>[]) null));
      checkEmpty(cache);
    }
  }

  public void testEntrySet_addNotSupported() {
    for (LoadingCache<Object, Object> cache : caches()) {
      assertThrows(

    Object cachedKey = new Object();
    Object cachedValue = new Object();
    Cache<Object, Object> cache =
        new AbstractCache<Object, Object>() {
          @Override
          public @Nullable Object getIfPresent(Object key) {
            return cachedKey.equals(key) ? cachedValue : null;
          }
        };

    assertThat(cache.getAllPresent(ImmutableList.of(cachedKey, new Object())))

    Object one = new Object();
    Object two = new Object();
    CacheLoader<Object, Object> loader =
        new CacheLoader<Object, Object>() {
          @Override
          public Object load(Object key) {
            return one;
          }

          @Override
          public ListenableFuture<Object> reload(Object key, Object oldValue) {
            return immediateFuture(two);

		Headers: http.Header{
			"X-Amz-Server-Side-Encryption-Customer-Algorithm": []string{"AES256"},
			"X-Amz-Server-Side-Encryption-Customer-Key":       []string{"MzJieXRlc2xvbmdzZWNyZXRrZXltdXN0cHJvdmlkZWQ="},
			"X-Amz-Server-Side-Encryption-Customer-Key-Md5":   []string{"7PpPLAK26ONlVUGOWlusfg=="},
		},
		Bucket: "bucket",
		Object: "object",
		Metadata: map[string]string{

    }
    Platform.checkCast(type, object); // behave badly
    return asList(contents).contains(object);
  }

  @Override
  public boolean containsAll(Collection<?> collection) {
    if (!allowNulls) {
      for (Object object : collection) {
        // behave badly
        if (object == null) {
          throw new NullPointerException();
        }
      }
    }
    return super.containsAll(collection);
  }

  @Override

 * <li><code>merge<i>Classname</i>( <i>Classname</i> target, <i>Classname</i> source, boolean sourceDominant,
 * Map&lt;Object, Object&gt; context )</code> for each model class</li>
 * <li><code>merge<i>Classname</i>_<i>FieldName</i>( <i>Classname</i> target, <i>Classname</i> source, boolean

   * be declared as a {@code List}.
   *
   * @return the re-serialized object
   * @throws RuntimeException if the specified object was not successfully serialized or
   *     deserialized
   */
  @CanIgnoreReturnValue
  public static <T> T reserialize(T object) {
    return Platform.reserialize(object);
  }

  /**