this.notAfter = notAfter
    }

    /**
     * Sets the certificate to be valid immediately and until the specified duration has elapsed.
     * The precision of this field is seconds; further precision will be truncated.
     */
    fun duration(
      duration: Long,
      unit: TimeUnit,
    ) = apply {
      val now = System.currentTimeMillis()
      validityInterval(now, now + unit.toMillis(duration))
    }

      val fileBuilder = StringBuilder(key).append('.')
      val truncateTo = fileBuilder.length
      for (i in 0 until valueCount) {
        fileBuilder.append(i)
        cleanFiles += directory / fileBuilder.toString()
        fileBuilder.append(".tmp")
        dirtyFiles += directory / fileBuilder.toString()
        fileBuilder.setLength(truncateTo)
      }
    }

    val part = parts.nextPart()!!
    assertThat(part.body.readUtf8()).isEqualTo("abcd")

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

  @Test fun `truncated multipart`() {
    val multipart =
      """
      |--simple boundary
      |
      |abcd
      |efgh
      |
      """.trimMargin()
        .replace("\n", "\r\n")

    val parts =

    webServer.dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse =
          upgradeResponse(request)
            .body(Buffer().write("81".decodeHex())) // Truncated frame.
            .removeHeader("Content-Length")
            .build()
      }
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    clientListener.assertFailure(

    }
  }

  /**
   * Returns a new {@link ByteSink} for writing bytes to the given file. The given {@code modes}
   * control how the file is opened for writing. When no mode is provided, the file will be
   * truncated before writing. When the {@link FileWriteMode#APPEND APPEND} mode is provided, writes
   * will append to the end of the file without truncating it.
   *
   * @since 14.0
   */

    and `www.squareup.com`. If a server refuses such sharing it will return HTTP 421 and OkHttp will
    automatically retry on an unshared connection.
 *  Fix: Don't crash if a TLS tunnel's response body is truncated.
 *  Fix: Don't track unusable routes beyond their usefulness. We had a bug where we could track
    certain bad routes indefinitely; now we only track the ones that could be necessary.

          )
        }
      } else if (base != null) {
        this.scheme = base.scheme
      } else {
        val truncated = if (input.length > 6) input.take(6) + "..." else input
        throw IllegalArgumentException(
          "Expected URL scheme 'http' or 'https' but no scheme was found for $truncated",
        )
      }

      // Authority.
      var hasUsername = false
      var hasPassword = false

        }
      };

  /**
   * A Throwable used to record a stack trace that illustrates an example of a specific lock
   * acquisition ordering. The top of the stack trace is truncated such that it starts with the
   * acquisition of the lock in question, e.g.
   *
   * <pre>
   * com...ExampleStackTrace: LockB -&gt; LockC

        |2
        |
        |CLEAN k1 1 1
        """.trimMargin(),
      )
    }
    createNewCache()
    assertThat(cache["k1"]).isNull()

    // The journal is not corrupt when editing after a truncated line.
    set("k1", "C", "D")
    cache.close()
    createNewCache()
    assertValue("k1", "C", "D")
  }

  @ParameterizedTest
  @ArgumentsSource(FileSystemParamProvider::class)

    instead of the expected `IOException`.

 *  Fix: Don't crash with a `NullPointerException` when formatting an error message describing a
    truncated response from an HTTPS proxy.


## Version 3.14.1

_2019-04-10_

 *  Fix: Don't crash when an interceptor retries when there are no more routes. This was an