content={"detail": jsonable_encoder(exc.errors())},
    )


async def websocket_request_validation_exception_handler(
    websocket: WebSocket, exc: WebSocketRequestValidationError
) -> None:
    await websocket.close(
        code=WS_1008_POLICY_VIOLATION, reason=jsonable_encoder(exc.errors())

    legacy_request_state_context_var.reset(contextvar_token)


@app.middleware("http")
async def custom_middleware(
    request: Request, call_next: Callable[[Request], Awaitable[Response]]
):
    response = await call_next(request)
    response.headers["custom"] = "foo"
    return response


@app.get("/user", dependencies=[Depends(set_up_request_state_dependency)])
def get_user():

          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
        ) {
          try {
            // Wait for request2 to guarantee we make 2 separate connections to the server.
            latch1.await()
          } catch (e: InterruptedException) {
            throw AssertionError(e)
          }
        }

        override fun connectionAcquired(
          call: Call,
          connection: Connection,

                  allExceptions.add(e)
                }
                latch.countDown()
              }
            },
          )
        }

        latch.await()

        // No mutations should be possible after this point
        if (allAddresses.isEmpty()) {
          val first = allExceptions.firstOrNull() ?: UnknownHostException("No results for $hostname")

    val dispatcher: Dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse {
          if (request.path == firstRequest) {
            latch.await()
          }
          return MockResponse()
        }
      }
    mockWebServer.dispatcher = dispatcher
    val startsFirst = buildRequestThread(firstRequest, firstResponseCode)
    startsFirst.start()

			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z AccElem) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "Total"
	err = en.Append(0x83, 0xa5, 0x54, 0x6f, 0x74, 0x61, 0x6c)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.Total)
	if err != nil {

}

// CloseWithError closes the writer; reads will return
// no bytes and the error err, or EOF if err is nil.
//
// CloseWithError never overwrites the previous error if it exists
// and always returns nil.
func (r *RingBuffer) CloseWithError(err error) {
	if err == nil {
		err = io.EOF
	}
	r.setErr(err, false)
}

// CloseWriter closes the writer.
// Reads will return any remaining bytes and io.EOF.

import java.io.Serializable;
import java.nio.ByteBuffer;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

/**
 * {@link HashFunction} adapter for {@link MessageDigest} instances.
 *
 * @author Kevin Bourrillion
 * @author Dimitris Andreou
 */
@Immutable
@ElementTypesAreNonnullByDefault

pkg archive/zip, type Compressor func(io.Writer) (io.WriteCloser, error)
pkg archive/zip, type Decompressor func(io.Reader) io.ReadCloser
pkg bufio, method (*Reader) Reset(io.Reader)
pkg bufio, method (*Writer) Reset(io.Writer)
pkg compress/flate, method (*Writer) Reset(io.Writer)
pkg compress/gzip, method (*Writer) Reset(io.Writer)
pkg compress/zlib, method (*Writer) Reset(io.Writer)
pkg container/heap, func Fix(Interface, int)

		// Write method in io.Writer
		if m != nBytes {
			return n, io.ErrShortWrite
		}
	}
	// Buffer is now empty; reset.
	b.Reset()
	return n, nil
}

// WriteByte appends the byte c to the buffer, growing the buffer as needed.
// The returned error is always nil, but is included to match [bufio.Writer]'s
// WriteByte. If the buffer becomes too large, WriteByte will panic with