func newMockReader(failAfter int, data byte) *mockReader {
	return &mockReader{0, data, failAfter}
}

func (r *mockReader) Read(p []byte) (n int, err error) {
	if r.pos >= r.failAfter {
		return 0, fmt.Errorf("intentionally unexpected reader error")
	}
	r.pos++
	p[0] = r.mockData
	return 1, nil
}

func TestScannerFailure(t *testing.T) {
	var (
		i         int
		failAfter = 900
		mockData  = byte(32)
	)

            assertThrows(IOException.class, () -> handle.doSendReceiveFragment(buf, 0, 50, inB));
        }

        @Test
        @DisplayName("Should throw IOException on unexpected EOF")
        void testDoSendReceiveFragment_UnexpectedEOF() throws Exception {
            DcerpcPipeHandle handle = createMockedDcerpcPipeHandle();

            byte[] buf = new byte[50];

            processMethod.setAccessible(true);

            try {
                Integer result = (Integer) processMethod.invoke(null, options);
                // Any result is acceptable as long as no unexpected exception
                assertNotNull(result);
            } catch (Exception e) {
                // Expected behavior when components are not fully initialized
                Throwable cause = e.getCause();

	// Validate that the client cannot remove any objects
	err = minioClient.RemoveObject(ctx, bucket, "someobject", minio.RemoveObjectOptions{})
	if err.Error() != "Access Denied." {
		c.Fatalf("unexpected non-access-denied err: %v", err)
	}
}

func (s *TestSuiteIAM) TestSTSWithGroupPolicy(c *check) {
	ctx, cancel := context.WithTimeout(context.Background(), testDefaultTimeout)
	defer cancel()

        int n = readn(in, buffer, bufferIndex, HEADER_LENGTH);
        if (n != HEADER_LENGTH) {
            if (n == -1) {
                return -1;
            }
            throw new IOException("unexpected EOF reading netbios session header");
        }
        return buffer[bufferIndex] & 0xFF;
    }

    int type, length;

    /**
     * Writes the packet to the specified byte array in wire format.

      apply {
        val encoded =
          host.percentDecode().toCanonicalHost()
            ?: throw IllegalArgumentException("unexpected host: $host")
        this.host = encoded
      }

    fun port(port: Int) =
      apply {
        require(port in 1..65535) { "unexpected port: $port" }
        this.port = port
      }

    fun addPathSegment(pathSegment: String) =
      apply {

      Request
        .Builder()
        .url("https://prod.idrix.eu/secure/")
        .build()

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

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

object ConsoleCallbackHandler : CallbackHandler {
  override fun handle(callbacks: Array<Callback>) {

        .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();
  }

 * <b>indiscriminately</b> to the methods of the delegate. For example, overriding {@link #get(long,
 * TimeUnit)} alone <b>will not</b> change the behavior of {@link #get()}, which can lead to
 * unexpected behavior. In this case, you should override {@code get()} as well.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code

        // 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) {