assertThat(cacheControl.isPrivate).isFalse()
    assertThat(cacheControl.isPublic).isFalse()
    assertThat(cacheControl.mustRevalidate).isFalse()
    assertThat(cacheControl.maxStaleSeconds).isEqualTo(-1)
    assertThat(cacheControl.minFreshSeconds).isEqualTo(-1)
    assertThat(cacheControl.onlyIfCached).isFalse()
    assertThat(cacheControl.mustRevalidate).isFalse()
  }

  @Test
  @Throws(Exception::class)

    assertThat(filesystem.exists(getCleanFile("g1", 0))).isFalse()
    assertThat(filesystem.exists(getCleanFile("g1", 1))).isFalse()
    assertThat(filesystem.exists(getCleanFile("g2", 0))).isFalse()
    assertThat(filesystem.exists(getCleanFile("g2", 1))).isFalse()
    assertThat(filesystem.exists(cacheDir / "otherFile0")).isFalse()
    assertThat(filesystem.exists(cacheDir / "dir1")).isFalse()
  }

  private operator fun set(

    client.webSocket!!.close(1000, "Hello!")
    // This will trigger a close response.
    assertThat(server.processNextFrame()).isFalse()
    server.listener.assertClosing(1000, "Hello!")
    server.webSocket!!.finishReader()
    server.webSocket!!.close(1000, "Goodbye!")
    assertThat(client.processNextFrame()).isFalse()
    client.listener.assertClosing(1000, "Goodbye!")
    client.webSocket!!.finishReader()

    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    // Running at time 60, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(60L)).isEqualTo(90L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    // Running at time 149, the pool returns that nothing can be evicted until time 150.

    // Verify the peer received what was expected.
    val synStream = peer.takeFrame()
    assertThat(synStream.type).isEqualTo(Http2.TYPE_HEADERS)
    assertThat(synStream.inFinished).isFalse()
    assertThat(synStream.outFinished).isFalse()
    val ping = peer.takeFrame()
    assertThat(ping.type).isEqualTo(Http2.TYPE_PING)
  }

  /**

    assertThat(a1.isExecuted()).isTrue()
    assertThat(a1.isCanceled()).isFalse()
    assertThat(a2.isExecuted()).isTrue()
    assertThat(a2.isCanceled()).isTrue()
    assertThat(a3.isExecuted()).isFalse()
    assertThat(a3.isCanceled()).isTrue()
    assertThat(a4.isExecuted()).isFalse()
    assertThat(a4.isCanceled()).isFalse()
  }

  @Test
  fun idleCallbackInvokedWhenIdle() {

 * limitations under the License.
 */
package okhttp3.internal.cache2

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNull
import assertk.assertions.isTrue
import java.io.File
import java.io.IOException
import java.util.concurrent.Callable
import java.util.concurrent.Executors

import assertk.assertions.doesNotContain
import assertk.assertions.hasMessage
import assertk.assertions.isCloseTo
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isLessThan
import assertk.assertions.isNotEmpty
import assertk.assertions.isNotNull
import assertk.assertions.isNotSameAs
import assertk.assertions.isNull
import assertk.assertions.isTrue

package okhttp3

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isCloseTo
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNotNull
import assertk.assertions.isNull
import assertk.assertions.isTrue
import java.io.IOException
import java.net.CookieManager
import java.net.HttpURLConnection

import assertk.assertThat
import assertk.assertions.contains
import assertk.assertions.hasMessage
import assertk.assertions.isCloseTo
import assertk.assertions.isEqualTo
import assertk.assertions.isFalse
import assertk.assertions.isNull
import assertk.assertions.isTrue
import assertk.fail
import java.io.IOException
import java.net.HttpURLConnection
import java.net.SocketTimeoutException
import java.time.Duration