@Test
  public void testCacheLoader() {
    final CacheLoader<String, Integer> cacheLoader =
        new CacheLoader<String, Integer>() {
          @Override
          public Integer load(String key) throws CacheLoaderException {
            return Integer.valueOf(key);
          }

          @Override
          public Map<String, Integer> loadAll(Iterable<? extends String> keys)
              throws CacheLoaderException {
            Map<String, Integer> map = new HashMap<>();

            for (String key : keys) {
              map.put(key, Integer.valueOf(key));
            }

            return map;
          }
        };

    try (CachingProvider cachingProvider =
        Caching.getCachingProvider(GuavaCachingProvider.class.getName())) {
      CacheManager cacheManager = cachingProvider.getCacheManager();

      MutableConfiguration<String, Integer> custom = new MutableConfiguration<>();

      custom.setStoreByValue(false);
      custom.setTypes(String.class, Integer.class);
      custom.setReadThrough(true);
      custom.setCacheLoaderFactory(
          new Factory<CacheLoader<String, Integer>>() {
            @Override
            public CacheLoader<String, Integer> create() {
              return cacheLoader;
            }
          });

      Cache<String, Integer> loadingCache = cacheManager.createCache("loadingCache", custom);

      assertEquals(Integer.valueOf(1), loadingCache.get("1"));
      assertEquals(Integer.valueOf(2), loadingCache.get("2"));
      assertEquals(Integer.valueOf(3), loadingCache.get("3"));

      Set<String> keys = Sets.newHashSet("4", "5", "6");

      Map<String, Integer> map = loadingCache.getAll(keys);

      assertEquals(3, map.size());
      assertEquals(Integer.valueOf(4), map.get("4"));
      assertEquals(Integer.valueOf(5), map.get("5"));
      assertEquals(Integer.valueOf(6), map.get("6"));
    }
  }
 @SuppressWarnings("rawtypes")
 @Override
 public Map getAll(Collection keys) {
   return cache.getAll(keys);
 }