_, err := io.Copy(io.Discard, req.Body)
			if !errors.Is(err, os.ErrDeadlineExceeded) {
				t.Errorf("server timed out reading request body: got err %v; want os.ErrDeadlineExceeded", err)
			}
			res.Write([]byte(respBody))
		}), func(ts *httptest.Server) {
			ts.Config.ReadHeaderTimeout = -1 // don't time out while reading headers
			ts.Config.ReadTimeout = timeout
			t.Logf("Server.Config.ReadTimeout = %v", timeout)
		})

          "type": "boolean"
        },
        "secretFile": {
          "description": "Optional: SecretFile is the path to key ring for User, default is /etc/ceph/user.secret More info: https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it",
          "type": "string"
        },
        "secretRef": {

	// WriteHeader, to make sure we don't consume the
	// remaining request body to try to advance to the next HTTP
	// request. Instead, when this is set, we stop reading
	// subsequent requests on this connection and stop reading
	// input from it.
	requestBodyLimitHit bool

	// trailers are the headers to be sent after the handler
	// finishes writing the body. This field is initialized from

* Add a check for file size if the reading content returns empty ([#33976](https://github.com/kubernetes/kubernetes/pull/33976), [@jingxu97](https://github.com/jingxu97))
* Add a retry when reading a file content from a container ([#35560](https://github.com/kubernetes/kubernetes/pull/35560), [@jingxu97](https://github.com/jingxu97))

		t.Fatalf("Do error = %v; want something containing %q", err, fakeErr.Error())
	}
	if err := <-readBody; err == nil {
		t.Errorf("Unexpected success reading request body from handler; want 'unexpected EOF reading trailer'")
	}
	select {
	case <-didClose:
	default:
		t.Errorf("didn't see Body.Close")
	}
}

func TestTransportDialTLS(t *testing.T) {

    /** The key of the message: Purge User Before */
    public static final String LABELS_PURGE_USER_INFO_DAY = "{labels.purgeUserInfoDay}";

    /** The key of the message: Reading */
    public static final String LABELS_READING = "{labels.reading}";

    /** The key of the message: Role ID */
    public static final String LABELS_ROLE_TYPE_IDS = "{labels.roleTypeIds}";

    /** The key of the message: Script */

	}

	// For attachable volume types, lets check if volume is attached by reading from node lister.
	// This would avoid exponential back-off and creation of goroutine unnecessarily. We still
	// verify status of attached volume by directly reading from API server later on.This is necessarily
	// to ensure any race conditions because of cached state in the informer.

		}
		// read the response body.
		actualContent, err := io.ReadAll(rec.Body)
		if err != nil {
			t.Fatalf("Test %d: %s: Failed reading response body: <ERROR> %v", i+1, instanceType, err)
		}

		if rec.Code == http.StatusOK || rec.Code == http.StatusPartialContent {
			if !bytes.Equal(testCase.expectedContent, actualContent) {

}

func (b *Builder) loadCachedVet(a *Action) error {
	c := cache.Default()
	list, _, err := cache.GetBytes(c, cache.Subkey(a.actionID, "srcfiles"))
	if err != nil {
		return fmt.Errorf("reading srcfiles list: %w", err)
	}
	var srcfiles []string
	for _, name := range strings.Split(string(list), "\n") {
		if name == "" { // end of list
			continue
		}
		if strings.HasPrefix(name, "./") {

    val response = call.execute()
    val inputStream = response.body.byteStream()
    assertThat(inputStream.read().toChar()).isEqualTo('A')
    call.cancel()
    assertFailsWith<IOException> {
      // Reading 'B' may succeed if it's buffered.
      inputStream.read()

      // But 'C' shouldn't be buffered (the response is throttled) and this should fail.
      inputStream.read()
    }
    inputStream.close()