.url("https://en.wikipedia.org/w/index.php")
        .post(formBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

  public static void main(String... args) throws Exception {
    new PostForm().run();
  }

        .add("Test-Instant", expected)
        .build()
    assertThat(headers["Test-Instant"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")
    assertThat(headers.getInstant("Test-Instant")).isEqualTo(expected)
  }

  @Test fun setDate() {
    val expected = Date(1000)
    val headers =
      Headers.Builder()
        .add("testDate", Date(0L))
        .set("testDate", expected)
        .build()

      return when (javaName) {
        "TLSv1.3" -> TLS_1_3
        "TLSv1.2" -> TLS_1_2
        "TLSv1.1" -> TLS_1_1
        "TLSv1" -> TLS_1_0
        "SSLv3" -> SSL_3_0
        else -> throw IllegalArgumentException("Unexpected TLS version: $javaName")
      }
    }
  }

package jstream

import (
	"fmt"
	"strconv"
)

// Predefined errors
var (
	ErrSyntax        = DecoderError{msg: "invalid character"}
	ErrUnexpectedEOF = DecoderError{msg: "unexpected end of JSON input"}
	ErrMaxDepth      = DecoderError{msg: "maximum recursion depth exceeded"}
)

type errPos [2]int // line number, byte offset where error occurred

// DecoderError contains a detailed decoding error.
type DecoderError struct {

        url = "https://en.wikipedia.org/w/index.php".toHttpUrl(),
        body = formBody,
      )

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      println(response.body.string())
    }
  }
}

fun main() {
  PostForm().run()

      Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build()

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      for ((name, value) in response.headers) {
        println("$name: $value")
      }

      println(response.body.string())
    }
  }
}

fun main() {

	"github.com/minio/minio/internal/disk"
)

func TestFree(t *testing.T) {
	di, err := disk.GetInfo(t.TempDir(), true)
	if err != nil {
		t.Fatal(err)
	}

	if di.FSType == "UNKNOWN" {
		t.Error("Unexpected FSType", di.FSType)
	}

	"istio.io/istio/istioctl/pkg/analyze"
	"istio.io/istio/istioctl/pkg/util"
)

var KnownErrorCode = map[error]int{
	errors.New("unknown command"):                                  ExitIncorrectUsage,
	errors.New("unexpected error"):                                 ExitUnknownError,
	util.CommandParseError{Err: errors.New("command parse error")}: ExitIncorrectUsage,
	analyze.FileParseError{}:                                       ExitDataError,

	}
	return scanner.EOF
}

func (p *Parser) more() bool {
	return p.inputPos < len(p.input)
}

// get verifies that the next item has the expected type and returns it.
func (p *Parser) get(expected lex.ScanToken) lex.Token {
	p.expect(expected, expected.String())
	return p.next()
}

// expectOperandEnd verifies that the parsing state is properly at the end of an operand.

        ),
      )
      .assertLogMatch(
        Regex(