*  Fix: Reliably update and invalidate the disk cache on windows. As originally designed our
    internal `DiskLruCache` assumes an inode-like file system, where it's fine to delete files that
    are currently being read or written. On Windows the file system forbids this so we must be more
    careful when deleting and renaming files.

  fun initialize() {
    cache.initialize()
  }

  /**
   * Closes the cache and deletes all of its stored values. This will delete all files in the cache
   * directory including files that weren't created by the cache.
   */
  @Throws(IOException::class)
  fun delete() {
    cache.delete()
  }

  /**
   * Deletes all values stored in the cache. In-flight writes to the cache will complete normally,

          assertNull(it.networkResponse)
        }

      assertEquals(1, cache.hitCount())
      assertEquals(1, cache.networkCount())
      assertEquals(2, cache.requestCount())
    } finally {
      cache.delete()
    }
  }

  private fun OkHttpClient.get(url: String) {
    val request = Request.Builder().url(url).build()
    val response = this.newCall(request).execute()

    response.use {

  }
  delete(file)
  return false
}

/** Delete file we expect but don't require to exist. */
internal fun FileSystem.deleteIfExists(path: Path) {
  try {
    delete(path)
  } catch (fnfe: FileNotFoundException) {
    return
  }
}

/** Tolerant delete, try to clear as many files as possible even after a failure. */
internal fun FileSystem.deleteContents(directory: Path) {
  var exception: IOException? = null

    assertThat(head.method).isEqualTo("HEAD")
    assertThat(head.body).isNull()

    val delete = Request.Builder().url("http://localhost/api").delete().build()
    assertThat(delete.method).isEqualTo("DELETE")
    assertThat(delete.body!!.contentLength()).isEqualTo(0L)

    val post = Request.Builder().url("http://localhost/api").post(body).build()

    open fun get(): Builder = commonGet()

    open fun head(): Builder = commonHead()

    open fun post(body: RequestBody): Builder = commonPost(body)

    @JvmOverloads
    open fun delete(body: RequestBody? = commonEmptyRequestBody): Builder = commonDelete(body)

    open fun put(body: RequestBody): Builder = commonPut(body)

    open fun patch(body: RequestBody): Builder = commonPatch(body)

    builder = builder.cacheControl(CacheControl.FORCE_CACHE)
    builder = builder.get()
    builder = builder.head()
    builder = builder.post(requestBody)
    builder = builder.delete(requestBody)
    builder = builder.delete(null)
    builder = builder.put(requestBody)
    builder = builder.patch(requestBody)
    builder = builder.method("", requestBody)
    builder = builder.method("", null)

 *  New: ConnectionSpec can now be configured to use the SSL socket's default
    cipher suites. To use, set the cipher suites to `null`.
 *  New: Support `DELETE` with a request body.
 *  New: `Headers.of(Map)` creates headers from a Map.


## Version 2.2.0

_2014-12-30_

 *  **`RequestBody.contentLength()` now throws `IOException`.**

   * end of the current session.
   *
   * This may return a value less than the current time, in which case the cookie is already
   * expired. Webservers may return expired cookies as a mechanism to delete previously set cookies
   * that may or may not themselves be expired.
   */
  @get:JvmName("expiresAt") val expiresAt: Long,
  /**

    }

    // If a bkp file exists, use it instead.
    if (fileSystem.exists(journalFileBackup)) {
      // If journal file also exists just delete backup file.
      if (fileSystem.exists(journalFile)) {
        fileSystem.delete(journalFileBackup)
      } else {
        fileSystem.atomicMove(journalFileBackup, journalFile)
      }
    }