x - x-men
        x - x-avengers
        """
    response = client.post("/items/", content=yaml_data)
    assert response.status_code == 422, response.text
    assert response.json() == {"detail": "Invalid YAML"}


@needs_pydanticv1
def test_post_invalid(client: TestClient):
    yaml_data = """
        name: Deadpoolio
        tags:
        - x-force
        - x-men
        - x-avengers

     * @return a new {@link DependencyCoordinates} object
     *
     * @throws IllegalArgumentException if {@code request} is null or
     *         if {@code request.getSession()} is null or invalid
     */
    @Nonnull
    DependencyCoordinates create(@Nonnull DependencyCoordinatesFactoryRequest request);

    @Nonnull

    DependencyResolutionResult getDependencyResolutionResult();

    // for each exception
    // - knowing what artifacts are missing
    // - project building exception
    // - invalid project model exception: list of markers
    // - xmlpull parser exception
    List<Throwable> getExceptions();

    MavenExecutionResult addException(Throwable e);

    boolean hasExceptions();

    /**

      // OkHttp does not reject invalid Punycode.
      "xn--a",
      "xn--a.ß",
      "xn--a.xn--zca",
      "xn--a-yoc",
      // OkHttp doesn't reject U+FFFD encoded in Punycode.
      "xn--zn7c.com",

			t.Fatalf("expected: %d, got: %d", successCase.offsetBegin, start)
		}

		if start+length-1 != successCase.offsetEnd {
			t.Fatalf("expected: %d, got: %d", successCase.offsetEnd, start+length-1)
		}
	}

	// Test invalid range strings.
	invalidRangeStrings := []string{
		"bytes=8",
		"bytes=5-2",
		"bytes=+2-5",
		"bytes=2-+5",
		"bytes=2--5",
		"bytes=-",
		"2-5",
		"bytes = 2-5",
		"bytes=2 - 5",
		"bytes=0-0,-1",

		},
		3: {bucketName: "a", objName: "obj", inputData: []byte(""), expectedError: BucketNameInvalid{Bucket: "a"}},

		// Case with invalid object names.
		4: {bucketName: bucket, inputData: []byte(""), expectedError: ObjectNameInvalid{Bucket: bucket, Object: ""}},

		// Valid object and bucket names but non-existent bucket.
		5: {bucketName: "abc", objName: "def", inputData: []byte(""), expectedError: BucketNotFound{Bucket: "abc"}},

        if ( rpc == null ) {
            return false;
        }

        boolean valid = false;
        for ( int hash : rpc.getHashAlgos() ) {
            if ( hash == pc.getHashAlgos()[ 0 ] ) {
                valid = true;
            }
        }
        if ( !valid ) {
            log.error("Server returned invalid hash selection");
            return false;
        }
        return true;
    }

  // occur from CEL expression parse errors, type check errors, runtime errors and invalid
  // or mis-configured policy definitions or bindings.
  //
  // A policy is invalid if spec.paramKind refers to a non-existent Kind.
  // A binding is invalid if spec.paramRef.name refers to a non-existent resource.
  //

            }
            if (values.length == 1 && !BEARER.equals(values[0])) {
                return values[0];
            }
            throw new InvalidAccessTokenException("invalid_request", "Invalid format: " + token);
        }
        final String name = ComponentUtil.getFessConfig().getApiAccessTokenRequestParameter();
        if (StringUtil.isNotBlank(name)) {
            return request.getParameter(name);
        }

async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
    user = fake_decode_token(token)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid authentication credentials",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return user


async def get_current_active_user(
    current_user: Annotated[User, Depends(get_current_user)],
):