.url("https://www.google.ca/")
          .build(),
      )
    val response = call.execute()
    try {
      println(response.code)
      println("PROTOCOL ${response.protocol}")
      var line: String?
      while (response.body.source().readUtf8Line().also { line = it } != null) {
        println(line)
      }
    } finally {
      response.body.close()
    }
    client.connectionPool.evictAll()
  }

 * subsequent bytes.
 */
internal class TriggerSink(
  private val delegate: Sink,
  private val triggerByteCount: Long,
  private val trigger: () -> Unit,
) : Sink by delegate {
  private var bytesWritten = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount == 0L) return // Avoid double-triggering.

    if (bytesWritten == triggerByteCount) {

import okhttp3.testing.PlatformRule
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension

class PlatformTest {
  @RegisterExtension
  var platform = PlatformRule()

  @Test
  fun alwaysBuilds() {
    Platform()
  }

  /** Guard against the default value changing by accident.  */
  @Test
  fun defaultPrefix() {

func HammerRWMutex(gomaxprocs, numReaders, numIterations int) {
	runtime.GOMAXPROCS(gomaxprocs)
	// Number of active readers + 10000 * number of active writers.
	var activity int32
	rwm := NewLRWMutex()
	cdone := make(chan bool)
	go writer(rwm, numIterations, &activity, cdone)
	var i int
	for i = 0; i < numReaders/2; i++ {
		go reader(rwm, numIterations, &activity, cdone)
	}
	go writer(rwm, numIterations, &activity, cdone)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package bufio

// Exported for testing only.
import (
	"unicode/utf8"
)

var IsSpace = isSpace

const DefaultBufSize = defaultBufSize

func (s *Scanner) MaxTokenSize(n int) {
	if n < utf8.UTFMax || n > 1e9 {
		panic("bad max token size")
	}
	if n < len(s.buf) {
		s.buf = make([]byte, n)

func getCanonicalHeaders(signedHeaders http.Header) string {
	var headers []string
	vals := make(http.Header)
	for k, vv := range signedHeaders {
		k = strings.ToLower(k)
		headers = append(headers, k)
		vals[k] = vv
	}
	sort.Strings(headers)

	var buf bytes.Buffer
	for _, k := range headers {
		buf.WriteString(k)
		buf.WriteByte(':')
		for idx, v := range vals[k] {

			} else {
				src = etag.Wrap(r, src)
			}
		} else {
			src = r
		}
	} else if _, ok := src.(etag.Tagger); !ok {
		if !disableMD5 {
			src = etag.NewReader(ctx, src, MD5, forceMD5)
		}
	}
	var h hash.Hash
	if len(SHA256) != 0 {
		h = sha256.New()
	}
	return &Reader{
		src:           src,
		size:          size,
		actualSize:    actualSize,
		checksum:      MD5,
		contentSHA256: SHA256,

pkg bufio, var ErrBadReadCount error
pkg crypto, method (Hash) String() string
pkg crypto/ecdsa, func SignASN1(io.Reader, *PrivateKey, []uint8) ([]uint8, error)
pkg crypto/ecdsa, func VerifyASN1(*PublicKey, []uint8, []uint8) bool
pkg crypto/ecdsa, method (*PrivateKey) Equal(crypto.PrivateKey) bool
pkg crypto/ecdsa, method (*PublicKey) Equal(crypto.PublicKey) bool
pkg crypto/ed25519, method (PrivateKey) Equal(crypto.PrivateKey) bool

		formData[k] = v
	}

	// Create the multipart form.
	var buf bytes.Buffer
	w := multipart.NewWriter(&buf)

	// Set the normal formData
	for k, v := range formData {
		w.WriteField(k, v)
	}
	// Set the File formData but don't if we want send an incomplete multipart request
	if !corruptedMultipart {
		var writer io.Writer
		var err error
		if noFilename {
			writer, err = w.CreateFormField("file")

                                    "runtime": "envoy.wasm.runtime.v8",
                                    "code": {
                                        "local": {
                                            "filename": "/var/lib/istio/data/fe482be5ac123d3d387b0c68b9ed7f8ed65824e7d0bbc88a9a9a71dd8391d96c/d8ef3957b4cf09da9ed25e88bc75ac397ea875d88c5cbed356872f936a86d928.wasm"
                                        }
                                    },