*
 * ### The response body must be closed.
 *
 * Each response body is backed by a limited resource like a socket (live network responses) or
 * an open file (for cached responses). Failing to close the response body will leak resources and
 * may ultimately cause the application to slow down or crash.
 *
 * Both this class and [Response] implement [Closeable]. Closing a response simply

/**
 * Utilities for collecting and validating tester requirements from annotations.
 *
 * @author George van den Driessche
 */
@GwtIncompatible
public final class FeatureUtil {
  /** A cache of annotated objects (typically a Class or Method) to its set of annotations. */
  private static final Map<AnnotatedElement, List<Annotation>> annotationCache = new HashMap<>();

)

// startWithConds - map which indicates if a given condition supports starts-with policy operator
var startsWithConds = map[string]bool{
	"$acl":                     true,
	"$bucket":                  false,
	"$cache-control":           true,
	"$content-type":            true,
	"$content-disposition":     true,
	"$content-encoding":        true,
	"$expires":                 true,
	"$key":                     true,

        // Previously determined to be an unsafe lock acquisition.
        // Create a new PotentialDeadlockException with the same causal chain
        // (the example cycle) as that of the cached exception.
        PotentialDeadlockException exception =
            new PotentialDeadlockException(
                acquiredLock, this, previousDeadlockException.getConflictingStackTrace());

Other HTTP libraries exist that fill that gap allowing extensive customisation including potentially
invalid requests.

Example Limitations

* Does not allow GET with a body.
* Cache is not an interface with alternative implementations.

Get a URL
---------

This program downloads a URL and prints its contents as a string. [Full source][get_example].

```java

     * Reads a byte of data from this input stream.
     *
     * @throws IOException if a network error occurs
     */

    @Override
    public int read() throws IOException {
        // need oplocks to cache otherwise use BufferedInputStream
        if (read(tmp, 0, 1) == -1) {
            return -1;
        }
        return tmp[0] & 0xFF;
    }

    /**

      } catch (e: IOException) {
        carrier.noNewExchanges()
        responseBodyComplete(TRAILERS_RESPONSE_BODY_TRUNCATED)
        throw e
      }

    /**
     * Closes the cache entry and makes the socket available for reuse. This should be invoked when
     * the end of the body has been reached.
     */
    fun responseBodyComplete(trailers: Headers) {
      if (state == STATE_CLOSED) return

        lenient().when(mockDcerpcBinding.getEndpoint()).thenReturn(TEST_ENDPOINT);
        lenient().when(mockContext.getBufferCache()).thenReturn(mockBufferCache);

        // Setup buffer cache to return buffers for sendrecv operations
        lenient().when(mockBufferCache.getBuffer()).thenReturn(new byte[8192]);
    }

    /**
     * Helper method to create a DcerpcPipeHandle with injected mocks

//		outcode(int($1), &nullgen, 0, &$3);
//	}
	NOP	F2

//	LNOP imm
//	{
//		outcode(int($1), &$2, 0, &nullgen);
//	}
	NOP	$4

//
// special
//
	SYSCALL
	BREAK
	// overloaded cache opcode:
	BREAK	R1, (R1)

//
// RET
//
//	LRETRN	comma // asm doesn't support the trailing comma.
//	{
//		outcode(int($1), &nullgen, 0, &nullgen);
//	}
	SYSCALL
	BEQ	R1, 2(PC)
	RET

`x509keypairleaf=0`.

Go 1.23 changed
[`net/http.ServeContent`](/pkg/net/http#ServeContent),
[`net/http.ServeFile`](/pkg/net/http#ServeFile), and
[`net/http.ServeFS`](/pkg/net/http#ServeFS) to
remove Cache-Control, Content-Encoding, Etag, and Last-Modified headers
when serving an error. This behavior is controlled by
the [`httpservecontentkeepheaders` setting](/pkg/net/http#ServeContent).