@app.post("/param")
        def endpoint(data: ParamModelV1):  # pragma: no cover
            return data


def test_raises_pydantic_v1_model_in_return_type() -> None:
    class ReturnModelV1(BaseModel):
        name: str

    app = FastAPI()

    with pytest.raises(PydanticV1NotSupportedError):

        @app.get("/return")
        def endpoint() -> ReturnModelV1:  # pragma: no cover

		getURL          string
		expectedStrings []string
	}{
		{getListObjectsV1URL(s.endPoint, bucketName, "", "1000", ""), []string{"<Key>foo bar 1</Key>", "<Key>foo bar 2</Key>"}},
		{getListObjectsV1URL(s.endPoint, bucketName, "", "1000", "url"), []string{"<Key>foo+bar+1</Key>", "<Key>foo+bar+2</Key>"}},
		{
			getListObjectsV2URL(s.endPoint, bucketName, "", "1000", "", "", ""),
			[]string{
				"<Key>foo bar 1</Key>",

func expandEndpoints(s string) ([]string, error) {
	var endpoints []string
	for endpoint := range strings.SplitSeq(s, ",") {
		endpoint = strings.TrimSpace(endpoint)
		if endpoint == "" {
			continue
		}
		if !ellipses.HasEllipses(endpoint) {
			endpoints = append(endpoints, endpoint)
			continue
		}

		pattern, err := ellipses.FindEllipsesPatterns(endpoint)
		if err != nil {

            }
            throw new DcerpcException("Bad endpoint: " + this.endpoint);
        }
        if (this.options == null) {
            this.options = new HashMap<>();
        }
        this.options.put(key, val);
    }

    Object getOption(final String key) {
        if (key.equals("endpoint")) {
            return this.endpoint;
        }
        if (this.options != null) {

		return nil
	} else if resp.StatusCode == http.StatusForbidden {
		return fmt.Errorf("%s returned '%s', please check if your auth token is correctly set", target.args.Endpoint, resp.Status)
	}
	return fmt.Errorf("%s returned '%s', please check your endpoint configuration", target.args.Endpoint, resp.Status)
}

// SendFromStore - reads an event from store and sends it to webhook.
func (target *WebhookTarget) SendFromStore(key store.Key) error {

        // In this test, we expect IOException when endpoint is blank
        try {
            conn.connect();
            fail("Should throw IOException when endpoint is not set");
        } catch (IOException e) {
            assertTrue(e.getMessage().contains("endpoint is blank"));
        }
    }

    /**
     * Test thread-safety of connect() method.

   * endpoint behavior.
   */
  static <T extends @Nullable Object> GeneralRange<T> upTo(
      Comparator<? super T> comparator, @ParametricNullness T endpoint, BoundType boundType) {
    return new GeneralRange<>(comparator, false, null, OPEN, true, endpoint, boundType);
  }

  /**
   * Returns everything between the endpoints relative to the specified comparator, with the

        super(buffer, access);
        this.endpoint = endpoint;

        // In real implementation, this would register the memory:
        // try {
        //     int accessFlags = convertAccessFlags(access);
        //     memoryRegister = endpoint.registerMemory(buffer, accessFlags).execute().free();
        // } catch (Exception e) {
        //     throw new RuntimeException("Failed to register memory region", e);

                }
            }
            throw new DcerpcException("Bad endpoint: " + endpoint);
        }
        if (options == null) {
            options = new HashMap();
        }
        options.put(key, val);
    }

    Object getOption(final String key) {
        if (key.equals("endpoint")) {
            return endpoint;
        }
        if (options != null) {
            return options.get(key);

- MinIO exports Prometheus compatible data by default as an authorized endpoint at `/minio/v2/metrics/cluster`. 
- MinIO exports Prometheus compatible data by default which is bucket centric as an authorized endpoint at `/minio/v2/metrics/bucket`.
- MinIO exports Prometheus compatible data by default which is node centric as an authorized endpoint at `/minio/v2/metrics/node`.