foo:////://///  s:foo p:////://///
c:/foo  s:c p:/foo
//foo/bar  s:http h:foo p:/bar
http://foo/path;a??e#f#g  s:http h:foo p:/path;a q:??e f:#f#g
http://foo/abcd?efgh?ijkl  s:http h:foo p:/abcd q:?efgh?ijkl
http://foo/abcd#foo?bar  s:http h:foo p:/abcd f:#foo?bar
[61:24:74]:98  s:http h:example.org p:/foo/[61:24:74]:98
http:[61:27]/:foo  s:http h:example.org p:/foo/[61:27]/:foo
http://[1::2]:3:4
http://2001::1
http://2001::1]

		tests: []testFnc{
			testReadFrom{fileOps{"ab", int64(3), "cde"}, 7, errMissData},
			testRemaining{1, 0},
		},
	}, {
		maker: makeSparse{makeReg{6, "abcde"}, sparseHoles{{2, 3}}, 8},
		tests: []testFnc{
			testReadFrom{fileOps{"ab", int64(3), "cde"}, 8, errUnrefData},
			testRemaining{0, 1},
		},
	}, {

  }

  @Test
  fun hostnameLowercaseCharactersMappedDirectly() {
    assertThat(parse("http://abcd").host).isEqualTo("abcd")
    assertThat(parse("http://σ").host).isEqualTo("xn--4xa")
  }

  @Test
  fun hostnameUppercaseCharactersConvertedToLowercase() {
    assertThat(parse("http://ABCD").host).isEqualTo("abcd")
    assertThat(parse("http://Σ").host).isEqualTo("xn--4xa")
  }

  @Test

	return true, ""
}

func TestCmpReaders(t *testing.T) {
	{
		r1 := bytes.NewReader([]byte("abc"))
		r2 := bytes.NewReader([]byte("abc"))
		ok, msg := cmpReaders(r1, r2)
		if !(ok && msg == "") {
			t.Fatalf("unexpected")
		}
	}

	{
		r1 := bytes.NewReader([]byte("abc"))
		r2 := bytes.NewReader([]byte("abcd"))
		ok, _ := cmpReaders(r1, r2)
		if ok {
			t.Fatalf("unexpected")
		}
	}

		expected string
	}{
		{bytes.NewBuffer([]byte("")), 0, ""},
		{bytes.NewBuffer([]byte("")), 1, ""},
		{bytes.NewBuffer([]byte("abc")), 0, "abc"},
		{bytes.NewBuffer([]byte("abc")), 1, "bc"},
		{bytes.NewBuffer([]byte("abc")), 2, "c"},
		{bytes.NewBuffer([]byte("abc")), 3, ""},
		{bytes.NewBuffer([]byte("abc")), 4, ""},
	}
	for i, testCase := range testCases {
		r := NewSkipReader(testCase.src, testCase.skipLen)

    }
    assertEquals(expected, builder.toString());
  }

  static final CharSource BROKEN_READ_SOURCE = new TestCharSource("ABC", READ_THROWS);
  static final CharSource BROKEN_CLOSE_SOURCE = new TestCharSource("ABC", CLOSE_THROWS);
  static final CharSource BROKEN_OPEN_SOURCE = new TestCharSource("ABC", OPEN_THROWS);
  static final CharSink BROKEN_WRITE_SINK = new TestCharSink(WRITE_THROWS);

		// Creating sequence of parts for same uploadID.
		{bucketName, objectName, uploadIDs[0], 1, "abcd", "e2fc714c4727ee9395f324cd2e7f331f", int64(len("abcd"))},
		{bucketName, objectName, uploadIDs[0], 2, "efgh", "1f7690ebdd9b4caf8fab49ca1757bf27", int64(len("efgh"))},
		{bucketName, objectName, uploadIDs[0], 3, "ijkl", "09a0877d04abf8759f99adec02baf579", int64(len("abcd"))},

  }

  @Test
  fun byteArrayRange() {
    val contentType = "text/plain".toMediaType()
    val body: RequestBody = ".abcd".toByteArray().toRequestBody(contentType, 1, 3)
    assertThat(body.contentType()).isEqualTo(contentType)
    assertThat(body.contentLength()).isEqualTo(3)
    assertThat(bodyToHex(body)).isEqualTo("616263")
    assertThat(bodyToHex(body), "Retransmit body").isEqualTo("616263")

		},
		// Empty filename name. - 11
		{
			volume, "", 14, 1, nil, errIsNotRegular,
		},
		// Non existent volume name - 12
		{
			"abcd", "", 14, 1, nil, errVolumeNotFound,
		},
		// Non existent filename - 13
		{
			volume, "abcd", 14, 1, nil, errFileNotFound,
		},
	}

	// Create all files needed during testing.
	appendFiles := testCases[:4]

    protocol: Protocol,
    mockWebServer: MockWebServer,
  ) {
    setUp(protocol, mockWebServer)
    server.enqueue(MockResponse(body = "ABCDE"))
    val call = client.newCall(Request(server.url("/foo")))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("ABCDE")
    assertThat(response.code).isEqualTo(200)
    assertThat(response.message).isEqualTo("")
    assertThat(response.protocol).isEqualTo(protocol)