e.errorCode == ErrorCode.CANCEL && call.isCanceled() -> {
            // Permit any number of CANCEL errors on locally-canceled calls.
          }

          else -> {
            // Everything else wants a fresh connection.
            noNewExchangesEvent = !noNewExchanges
            noNewExchanges = true
            routeFailureCount++
          }
        }

      )

    assertThat(parts.nextPart()).isNotNull()
    assertThat(parts.nextPart()).isNull()
    assertThat(parts.nextPart()).isNull()
  }

  @Test fun `empty source`() {
    val parts =
      MultipartReader(
        boundary = "simple boundary",
        source = Buffer(),
      )

    assertFailsWith<EOFException> {
      parts.nextPart()
    }
  }

 *    IP address (`74.122.190.80`), or a hostname pattern (`*.api.squareup.com`).
 *
 *  * **A validity interval.** A certificate should not be used before its validity interval starts
 *    or after it ends.
 *
 *  * **A public key.** This cryptographic key is used for asymmetric encryption digital signatures.
 *    Note that the private key is not a part of the certificate!
 *

          return 0
        }
      }

    /**
     * Holds interned instances. This needs to be above the init() calls below so that it's
     * initialized by the time those parts of `<clinit>()` run. Guarded by CipherSuite.class.
     */
    private val INSTANCES = mutableMapOf<String, CipherSuite>()

    // Last updated 2016-07-03 using cipher suites from Android 24 and Java 9.

    assertThat(body.boundary).isEqualTo("123")
    assertThat(body.type).isEqualTo(MultipartBody.MIXED)
    assertThat(body.contentType().toString())
      .isEqualTo("multipart/mixed; boundary=123")
    assertThat(body.parts.size).isEqualTo(1)
    assertThat(body.contentLength()).isEqualTo(33L)
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(body.contentLength()).isEqualTo(buffer.size)

   * possibility for your response.
   */
  @Throws(IOException::class)
  fun byteString() = commonByteString()

  /**
   * Returns the response as a character stream.
   *
   * If the response starts with a
   * [Byte Order Mark (BOM)](https://en.wikipedia.org/wiki/Byte_order_mark), it is consumed and
   * used to determine the charset of the response bytes.
   *

    val type: MediaType = multipartBody.type()
    val boundary: String = multipartBody.boundary()
    val size: Int = multipartBody.size()
    val parts: List<MultipartBody.Part> = multipartBody.parts()
  }

  @Test @Disabled
  fun multipartBodyPart() {
    val multipartBody: MultipartBody = MultipartBody.Builder().build()
    val part: MultipartBody.Part = multipartBody.part(0)

      }

      val now = backend.nanoTime()
      var minDelayNanos = Long.MAX_VALUE
      var readyTask: Task? = null
      var multipleReadyTasks = false

      // Decide what to run. This loop's goal wants to:
      //  * Find out what this thread should do (either run a task or sleep)
      //  * Find out if there's enough work to start another thread.
      eachQueue@ for (queue in readyQueues) {

  @get:JvmName("minFreshSeconds") val minFreshSeconds: Int,
  /**
   * This field's name "only-if-cached" is misleading. It actually means "do not use the network".
   * It is set by a client who only wants to make a request if it can be fully satisfied by the
   * cache. Cached responses that would require validation (ie. conditional gets) are not permitted
   * if this header is set.
   */

    level = DeprecationLevel.ERROR,
  )
  fun size(): Int = size

  @JvmName("-deprecated_parts")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "parts"),
    level = DeprecationLevel.ERROR,
  )
  fun parts(): List<Part> = parts

  @Throws(IOException::class)
  override fun contentLength(): Long {
    var result = contentLength
    if (result == -1L) {