assertThat(connect.requestLine).isEqualTo("CONNECT any-host-name:$port HTTP/1.1")
    assertThat(connect.headers["Host"]).isEqualTo("any-host-name:$port")
    assertThat(connect.headers[":authority"]).isNull()
    val get = server.takeRequest()
    assertThat(get.requestLine).isEqualTo("GET / HTTP/1.1")
    assertThat(get.headers["Host"]).isEqualTo("any-host-name:$port")
    assertThat(get.headers[":authority"]).isNull()

		newHostPort := newHost
		if len(endpoint.Port()) > 0 {
			// Host + port
			newHostPort = newHost + ":" + endpoint.Port()
			mapIfNotPresent(hostAnonymizer, endpoint.Host, newHostPort)
			mapIfNotPresent(hostAnonymizer, schemePfx+endpoint.Host, newHostPort)
		}

		newHostPortPath := newHostPort
		if len(endpoint.Path) > 0 {
			// Host + port + path
			currentHostPortPath := endpoint.Host + endpoint.Path

        override fun createSocket(
          host: InetAddress,
          port: Int,
        ): Socket? = null

        override fun createSocket(
          address: InetAddress,
          port: Int,
          localAddress: InetAddress,
          localPort: Int,
        ): Socket? = null

        override fun createSocket(
          host: String,
          port: Int,
        ): Socket? = null

  fun requestMethodPostIsNotCached() {
    // We could support this but choose not to for implementation simplicity
    testRequestMethod("POST", false)
  }

  @Test
  fun requestMethodPostIsNotCachedUnlessOverridden() {
    // Supported via cacheUrlOverride
    testRequestMethod("POST", true, withOverride = true)
  }

  @Test
  fun requestMethodPutIsNotCached() {
    testRequestMethod("PUT", false)
  }

                        "rules": [
                         {
                          "header": {
                           "name": ":method",
                           "exact_match": "POST"
                          }
                         }
                        ]
                       }
                      },
                      {
                       "or_rules": {

                from Starlette and supported for compatibility.

                In FastAPI, you normally would use the *path operation methods*,
                like `router.get()`, `router.post()`, etc.
                """
            ),
        ] = None,
        redirect_slashes: Annotated[
            bool,
            Doc(
                """

- Kubeadm: `kubeadm upgrade node` now supports `addon` and `post-upgrade` phases. User can use `kubeadm upgrade node phase addon` to execute the addon upgrade, or use `kubeadm upgrade node --skip-phases addon` to skip the addon upgrade. Currently, the `post-upgrade` phase is no-op, and it is mainly used to handle some release specific post-upgrade tasks. ([#127242](https://github.com/kubernetes/kubernetes/pull/127242), [@SataQiu](https://github.com/SataQiu))...

                * `url`: A URL to the target host. This URL supports Server Variables
                and MAY be relative, to indicate that the host location is relative
                to the location where the OpenAPI document is being served. Variable
                substitutions will be made when a variable is named in `{`brackets`}`.
                * `description`: An optional string describing the host designated by

		BucketName:   bucket,
		Object:       oi,
		ReqParams:    extractReqParams(r),
		RespElements: extractRespElements(w),
		UserAgent:    r.UserAgent(),
		Host:         handlers.GetSourceIP(r),
	})
}

// RestoreObjectHandler - POST restore object handler.
// ----------
func (api objectAPIHandlers) PostRestoreObjectHandler(w http.ResponseWriter, r *http.Request) {
	ctx := newContext(r, w, "PostRestoreObject")

    /** The key of the message: Past 24 Hours */
    public static final String LABELS_facet_timestamp_1day = "{labels.facet_timestamp_1day}";

    /** The key of the message: Past Week */
    public static final String LABELS_facet_timestamp_1week = "{labels.facet_timestamp_1week}";

    /** The key of the message: Past Month */