if (result < 0L || result > Integer.MAX_VALUE || line.isNotEmpty()) {
          throw IOException("expected an int but was \"$result$line\"")
        }
        return result.toInt()
      } catch (e: NumberFormatException) {
        throw IOException(e.message)
      }
    }

    /**
     * Returns true if none of the Vary headers have changed between [cachedRequest] and

pkg go/build, const IgnoreVendor ImportMode
pkg go/build, type Package struct, InvalidGoFiles []string
pkg go/constant, func ToComplex(Value) Value
pkg go/constant, func ToFloat(Value) Value
pkg go/constant, func ToInt(Value) Value
pkg go/constant, type Value interface, ExactString() string
pkg go/types, method (*Package) SetName(string)
pkg go/types, type ImportMode int
pkg go/types, type ImporterFrom interface { Import, ImportFrom }

  /** Returns a byte string that differs from this one by one bit. */
  private fun ByteString.offByOneBit(): ByteString {
    return Buffer()
      .write(this, 0, size - 1)
      .writeByte(this[size - 1].toInt() xor 1)
      .readByteString()
  }

  private fun date(s: String): Date {
    return SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").run {
      timeZone = TimeZone.getTimeZone("GMT")
      parse(s)

          Thread.currentThread().interrupt() // Retain interrupted status.
          throw InterruptedIOException()
        }

        toWrite = minOf(byteCount, writeBytesMaximum - writeBytesTotal).toInt()
        toWrite = minOf(toWrite, writer.maxDataLength())
        writeBytesTotal += toWrite.toLong()
      }

      byteCount -= toWrite.toLong()

    val request = server.takeRequest()
    assertThat(request.requestLine).isEqualTo("POST /foo HTTP/1.1")
    assertArrayEquals(postBytes, request.body.readByteArray())
    assertThat(request.headers["Content-Length"]!!.toInt()).isEqualTo(postBytes.size)
  }

  @ParameterizedTest
  @ArgumentsSource(ProtocolParamProvider::class)
  fun closeAfterFlush(
    protocol: Protocol,
    mockWebServer: MockWebServer,
  ) {

            requestBodySink.write(source, contentLength)
          }

          chunked -> {
            hasBody = true
            while (true) {
              val chunkSize = source.readUtf8LineStrict().trim().toInt(16)
              if (chunkSize == 0) {
                readEmptyLine(source)
                break
              }
              chunkSizes.add(chunkSize)

      // add non-stateless strategies (for which we've reserved negative ordinals; see
      // Strategy.ordinal()).
      strategyOrdinal = din.readByte();
      numHashFunctions = UnsignedBytes.toInt(din.readByte());
      dataLength = din.readInt();

      Strategy strategy = BloomFilterStrategies.values()[strategyOrdinal];

    internal var readTimeout = 10_000
    internal var writeTimeout = 10_000
    internal var pingInterval = 0
    internal var webSocketCloseTimeout = RealWebSocket.CANCEL_AFTER_CLOSE_MILLIS.toInt()
    internal var minWebSocketMessageToCompress = RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE
    internal var routeDatabase: RouteDatabase? = null
    internal var taskRunner: TaskRunner? = null

    ): Int {
      return try {
        // Canonicalize the port string to skip '\n' etc.
        val portString = input.canonicalize(pos = pos, limit = limit, encodeSet = "")
        val i = portString.toInt()
        if (i in 1..65535) i else -1
      } catch (_: NumberFormatException) {
        -1 // Invalid port.
      }
    }
  }

  companion object {

                var bytesWritten: Long = 0
                while (bytesWritten < contentLength) {
                  val byteCount = Math.min(buffer.size.toLong(), contentLength - bytesWritten).toInt()
                  bytesWritten += byteCount.toLong()
                  sink.write(buffer, 0, byteCount)
                }
              }
            },
        ),
      )