pkcs8Base64 = match.groups[2]!!.value // Include the contents only for PKCS8.
          }
          else -> {
            throw IllegalArgumentException("unexpected type: $label")
          }
        }
      }
      require(certificatePem != null) { "string does not include a certificate" }
      require(pkcs8Base64 != null) { "string does not include a private key" }

			continue
		}

		for idx := range result.Objects {
			if result.Objects[idx].Name != testCase.objectsAfterDelete[idx] {
				t.Errorf("Test %d: %s: Unexpected object found after delete, found = `%v`", i+1, instanceType, result.Objects[idx].Name)
			}
		}
	}

      }

      exchange.responseHeadersEnd(response)

      val isUpgradeCode = code == HTTP_SWITCHING_PROTOCOLS
      if (isUpgradeCode && exchange.connection.isMultiplexed) {
        throw ProtocolException("Unexpected $HTTP_SWITCHING_PROTOCOLS code on HTTP/2 connection")
      }

      val isUpgradeResponse =
        isUpgradeCode &&
          "upgrade".equals(response.header("Connection"), ignoreCase = true)

        .post(jsonRequestBody)
        .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 RequestBodyCompression().run();
  }

        // but the method should not throw NullPointerException
        try {
            method.invoke(multiChannelManager, localhost, loopback);
            // If it doesn't throw, that's unexpected for localhost
            fail("Expected CIFSException for localhost multi-channel attempt");
        } catch (java.lang.reflect.InvocationTargetException e) {

    @Override
    public void decode(final NdrBuffer buf) throws NdrException {
        decode_header(buf);

        if (ptype != 12 && ptype != 2 && ptype != 3 && ptype != 13) {
            throw new NdrException("Unexpected ptype: " + ptype);
        }

        if (ptype == 2 || ptype == 3) { /* Response or Fault */
            alloc_hint = buf.dec_ndr_long();
            buf.dec_ndr_short(); /* context id */

        assertEquals("true", returned.get("useKeyTab"));
        assertEquals("true", returned.get("storeKey"));
        assertEquals("******@****.***", returned.get("principal"));
        // Ensure no unexpected extra options
        assertEquals(3, returned.size(), "Only provided options are expected");
    }

    @Test

	}
	testCases := []testCase{
		// Test - 1 - small bufio reader.
		{
			bufio.NewReaderSize(readers[0], 16),
			errLineTooLong,
			nil,
			nil,
		},
		// Test - 2 - unexpected end of the reader.
		{
			bufio.NewReader(readers[1]),
			io.ErrUnexpectedEOF,
			nil,
			nil,
		},
		// Test - 3 - line too long bigger than 4k+1
		{
			bufio.NewReader(readers[2]),
			errLineTooLong,

	{"(1<<63)>>2", "right shift of value with high bit set"},
	{"(1<<62)>>2", ""},
	{`'\x80'`, "illegal UTF-8 encoding for character constant"},
	{"(23*4", "missing closing paren"},
	{")23*4", "unexpected ) evaluating expression"},
	{"18446744073709551616", "value out of range"},
}

func TestBadExpr(t *testing.T) {
	for i, test := range badExprTests {
		err := runBadTest(i, test, t)
		if err == nil {

      Headers
        .Builder()
        .addUnsafeNonAscii("héader1", "value1")
        .build()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Unexpected char 0xe9 at 1 in header name: héader1")
    }
  }

  @Test fun addUnsafeNonAsciiAcceptsUnicodeValue() {
    val headers =
      Headers
        .Builder()
        .addUnsafeNonAscii("header1", "valué1")