import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
/**
 * Create a cache which will reside in {@code directory}. This cache is lazily initialized on
 * first access and will be created if it does not exist.
 *
 * @param directory a writable directory
 * @param valueCount the number of values per cache entry. Must be positive.
 * @param maxSize the maximum number of bytes this cache should use to store
 */
public static DiskLruCache create(FileSystem fileSystem, File directory, int appVersion,
    int valueCount, long maxSize) {
  if (maxSize <= 0) {
    throw new IllegalArgumentException("maxSize <= 0");
  }
  if (valueCount <= 0) {
    throw new IllegalArgumentException("valueCount <= 0");
  }

  // Use a single background thread to evict entries.
  Executor executor = new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS,
      new LinkedBlockingQueue<Runnable>(), Util.threadFactory("OkHttp DiskLruCache", true));

  return new DiskLruCache(fileSystem, directory, appVersion, valueCount, maxSize, executor);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
@Test public void prefetchFileSystemWriteFailure() throws IOException {
  FaultyHttpCacheStore faultyCacheStore = new FaultyHttpCacheStore(FileSystem.SYSTEM);
  cacheStore.delegate = faultyCacheStore;

  faultyCacheStore.failStrategy(FaultyHttpCacheStore.FailStrategy.FAIL_HEADER_WRITE);
  server.enqueue(mockResponse("HttpCacheTestAllPlanets.json"));

  Rx2Apollo.from(apolloClient.prefetch(new AllPlanetsQuery()))
      .test()
      .awaitDone(TIME_OUT_SECONDS, TimeUnit.SECONDS)
      .assertError(Exception.class);
  checkNoCachedResponse();

  server.enqueue(mockResponse("HttpCacheTestAllPlanets.json"));
  faultyCacheStore.failStrategy(FaultyHttpCacheStore.FailStrategy.FAIL_BODY_WRITE);
  Rx2Apollo.from(apolloClient.prefetch(new AllPlanetsQuery()))
      .test()
      .awaitDone(TIME_OUT_SECONDS, TimeUnit.SECONDS)
      .assertError(Exception.class);
  checkNoCachedResponse();
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
DiskLruCache(FileSystem fileSystem, File directory, int appVersion, int valueCount, long maxSize,
    Executor executor) {
  this.fileSystem = fileSystem;
  this.directory = directory;
  this.appVersion = appVersion;
  this.journalFile = new File(directory, JOURNAL_FILE);
  this.journalFileTmp = new File(directory, JOURNAL_FILE_TEMP);
  this.journalFileBackup = new File(directory, JOURNAL_FILE_BACKUP);
  this.valueCount = valueCount;
  this.maxSize = maxSize;
  this.executor = executor;
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
@SuppressWarnings("ResultOfMethodCallIgnored")
LruDisk(File path, int version, int valueCount, int maxSize) {
    if (!path.exists()) {
        path.mkdirs();
    }
    gson = new Gson();
    diskLruCache = DiskLruCache.create(FileSystem.SYSTEM, path, version, valueCount, maxSize);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
public SimpleCache(File directory, long maxSize) {
    cache = DiskLruCache.create(FileSystem.SYSTEM, directory, VERSION, 2, maxSize);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
private static Cache createInMemoryCache() {
  try {
    final Constructor<Cache> constructor =
      Cache.class.getDeclaredConstructor(File.class, Long.TYPE, FileSystem.class);
    constructor.setAccessible(true);
    return constructor.newInstance(
      new File(".virtual"), 128*1024*1024, new InMemoryFileSystem()
    );
  }
  catch (final Exception e) {
    throw new RuntimeException(e);
  }
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
@Test public void fileSystemWriteFailure() throws Exception {
  enqueueResponse("/ShopWithCollections.json");

  FaultyCacheStore faultyCacheStore = new FaultyCacheStore(FileSystem.SYSTEM);
  cacheStore.delegate = faultyCacheStore;

  faultyCacheStore.failStrategy(FaultyCacheStore.FailStrategy.FAIL_HEADER_WRITE);
  GraphResponse response = graphClient.queryGraph(Storefront.query(new ShopWithCollectionsQuery()))
    .cachePolicy(HttpCachePolicy.NETWORK_FIRST.expireAfter(10, TimeUnit.SECONDS))
    .execute();
  assertThat(server.getRequestCount()).isEqualTo(1);
  assertThat(lastHttResponse.cacheResponse()).isNull();
  assertThat(response.hasErrors()).isFalse();
  assertThat(response.data()).isNotNull();
  checkNoCachedResponse();

  enqueueResponse("/ShopWithCollections.json");
  faultyCacheStore.failStrategy(FaultyCacheStore.FailStrategy.FAIL_BODY_WRITE);
  response = graphClient.queryGraph(Storefront.query(new ShopWithCollectionsQuery()))
    .cachePolicy(HttpCachePolicy.NETWORK_FIRST.expireAfter(10, TimeUnit.SECONDS))
    .execute();
  assertThat(server.getRequestCount()).isEqualTo(2);
  assertThat(lastHttResponse.cacheResponse()).isNull();
  assertThat(response.hasErrors()).isFalse();
  assertThat(response.data()).isNotNull();
  checkNoCachedResponse();
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
public Cache(File directory, long maxSize) {
  this(directory, maxSize, FileSystem.SYSTEM);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
public FaultyFileSystem(FileSystem delegate) {
  this.delegate = delegate;
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
public Cache(File directory, long maxSize) {
    this(directory, maxSize, FileSystem.SYSTEM);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
private PicassoCardRequestHandler() {
    File file = new File(ArcaneTrackerApplication.getContext().getCacheDir(), "cardsCache");
    cache = DiskLruCache.create(FileSystem.SYSTEM, file, VERSION, ENTRY_COUNT, 250 * 1024*1024);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
public DiskLruHttpCacheStore(@Nonnull File directory, long maxSize) {
  this.cache = DiskLruCache.create(FileSystem.SYSTEM, directory, VERSION, ENTRY_COUNT, maxSize);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
FaultyHttpCacheStore(FileSystem fileSystem) {
  this.cache = DiskLruCache.create(fileSystem, new File("/cache/"), VERSION, ENTRY_COUNT, Integer.MAX_VALUE);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
private ImageCache(Context context) {
    mDiskCache = DiskLruCache.create(FileSystem.SYSTEM, new File(context.getCacheDir(), context.getString(R.string.image_cache_name)),
            BuildConfig.VERSION_CODE, 1, R.integer.google_plus_contact_image_cache_max_size);
    mCache = new LruCache<>(R.integer.google_plus_contacts_cache_size);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
DiskLruCacheStore(@NonNull final File directory, final long maxSize) {
  this.cache = DiskLruCache.create(FileSystem.SYSTEM, directory, VERSION, ENTRY_COUNT, maxSize);
}
 

import okhttp3.internal.io.FileSystem; //导入依赖的package包/类
FaultyCacheStore(FileSystem fileSystem) {
  this.cache = DiskLruCache.create(fileSystem, new File("/cache/"), VERSION, ENTRY_COUNT, Integer.MAX_VALUE);
}