How to use com.bumptech.glide.load.engine.cache

 @Override
 public DiskCache build() {
  return new DiskCacheAdapter();
 }
}

/**
 * Create a new DiskCache in the given directory with a specified max size.
 *
 * @param directory The directory for the disk cache
 * @param maxSize   The max size for the disk cache
 * @return The new disk cache with the given arguments
 */
@SuppressWarnings("deprecation")
public static DiskCache create(File directory, long maxSize) {
 return new DiskLruCacheWrapper(directory, maxSize);
}

 @Override
 public DiskCache getDiskCache() {
  if (diskCache == null) {
   synchronized (this) {
    if (diskCache == null) {
     diskCache = factory.build();
    }
    if (diskCache == null) {
     diskCache = new DiskCacheAdapter();
    }
   }
  }
  return diskCache;
 }
}

MemorySizeCalculator getCalculator() {
 when(screenDimensions.getWidthPixels()).thenReturn(pixelSize);
 when(screenDimensions.getHeightPixels()).thenReturn(pixelSize);
 return new MemorySizeCalculator.Builder(RuntimeEnvironment.application)
   .setMemoryCacheScreens(memoryCacheScreens)
   .setBitmapPoolScreens(bitmapPoolScreens)
   .setMaxSizeMultiplier(sizeMultiplier)
   .setActivityManager(activityManager)
   .setScreenDimensions(screenDimensions)
   .setArrayPoolSize(byteArrayPoolSizeBytes)
   .build();
}

 @Test
 public void get_afterDeleteDirectoryOutsideGlideAndClose_doesNotThrow() {
  assumeTrue("A file handle is likely open, so cannot delete dir", !Util.isWindows());
  DiskCache cache = DiskLruCacheWrapper.create(dir, 1024 * 1024);
  cache.get(mock(Key.class));
  deleteRecursive(dir);
  cache.clear();

  cache.get(mock(Key.class));
 }
}

private long getFreeMemoryCacheBytes() {
 return memoryCache.getMaxSize() - memoryCache.getCurrentSize();
}

@Test
public void testTrimMemoryModerate() {
 TrimClearMemoryCacheHarness harness = new TrimClearMemoryCacheHarness();
 harness.resourceCache.trimMemory(ComponentCallbacks2.TRIM_MEMORY_MODERATE);
 verify(harness.listener).onResourceRemoved(harness.first);
 verify(harness.listener).onResourceRemoved(harness.second);
}

 @Override
 public DiskCache build() {
  File cacheDir = cacheDirectoryGetter.getCacheDirectory();

  if (cacheDir == null) {
   return null;
  }

  if (!cacheDir.mkdirs() && (!cacheDir.exists() || !cacheDir.isDirectory())) {
   return null;
  }

  return DiskLruCacheWrapper.create(cacheDir, diskCacheSize);
 }
}

@Test
public void clearMemory_afterPutWithExistingItem_evictsOnlyNewItem() {
 PutWithExistingEntryHarness harness = new PutWithExistingEntryHarness();
 harness.cache.put(harness.key, harness.first);
 harness.cache.put(harness.key, harness.second);
 verify(harness.listener).onResourceRemoved(harness.first);
 verify(harness.listener, never()).onResourceRemoved(harness.second);
 harness.cache.clearMemory();
 verify(harness.listener, times(1)).onResourceRemoved(harness.first);
 verify(harness.listener).onResourceRemoved(harness.second);
}

@Override
public void delete(Key key) {
 String safeKey = safeKeyGenerator.getSafeKey(key);
 try {
  getDiskCache().remove(safeKey);
 } catch (IOException e) {
  if (Log.isLoggable(TAG, Log.WARN)) {
   Log.w(TAG, "Unable to delete from disk cache", e);
  }
 }
}

@Test
public void onItemEvicted_withNullValue_doesNotNotifyListener() {
 PutWithExistingEntryHarness harness = new PutWithExistingEntryHarness();
 harness.cache.onItemEvicted(new MockKey(), null);
 verify(harness.listener, never()).onResourceRemoved(anyResource());
}

@Test
public void testByteArrayPoolSize_withLowRamDevice_isHalfTheSpecifiedBytes() {
 LowRamActivityManager activityManager = Shadow.extract(harness.activityManager);
 activityManager.setMemoryClass(getLargeEnoughMemoryClass());
 activityManager.setIsLowRam();
 int byteArrayPoolSize = harness.getCalculator().getArrayPoolSizeInBytes();
 assertThat(byteArrayPoolSize).isEqualTo(harness.byteArrayPoolSizeBytes / 2);
}

private String getRandomKeyFromGenerator() {
 return keyGenerator.getSafeKey(new MockKey(getNextId()));
}

@Test
public void put_withExistingItem_evictsExistingItem() {
 PutWithExistingEntryHarness harness = new PutWithExistingEntryHarness();
 harness.cache.put(harness.key, harness.first);
 harness.cache.put(harness.key, harness.second);
 verify(harness.listener).onResourceRemoved(harness.first);
}

 public MemorySizeCalculator build() {
  return new MemorySizeCalculator(this);
 }
}

@After
public void tearDown() {
 try {
  cache.clear();
 } finally {
  deleteRecursive(dir);
 }
}

@Test
public void clearDiskCache_afterOpeningDiskCache_andDeleteDirectoryOutsideGlide_doesNotThrow() {
 assumeTrue("A file handle is likely open, so cannot delete dir", !Util.isWindows());
 DiskCache cache = DiskLruCacheWrapper.create(dir, 1024 * 1024);
 cache.get(mock(Key.class));
 deleteRecursive(dir);
 cache.clear();
}

@Test
public void testTrimMemoryRunningCritical() {
 TrimClearMemoryCacheHarness harness = new TrimClearMemoryCacheHarness();
 harness.resourceCache.trimMemory(ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL);
 verify(harness.listener).onResourceRemoved(harness.first);
 verify(harness.listener, never()).onResourceRemoved(harness.second);
}

@Test
public void testTrimMemoryUiHidden() {
 TrimClearMemoryCacheHarness harness = new TrimClearMemoryCacheHarness();
 harness.resourceCache.trimMemory(ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);
 verify(harness.listener).onResourceRemoved(harness.first);
 verify(harness.listener, never()).onResourceRemoved(harness.second);
}

@Test
public void testTrimMemoryBackground() {
 TrimClearMemoryCacheHarness harness = new TrimClearMemoryCacheHarness();
 harness.resourceCache.trimMemory(ComponentCallbacks2.TRIM_MEMORY_BACKGROUND);
 verify(harness.listener).onResourceRemoved(eq(harness.first));
 verify(harness.listener).onResourceRemoved(eq(harness.second));
}