// what is in exp is in got
			for k := range exp {
				if exp[k] != got[k] {
					t.Fatalf("interval %s: Expected %d values but got %d values\n", k, exp[k], got[k])
				}
			}
			// what is absent in exp is absent in got too
			for k := range got {
				if _, ok := exp[k]; !ok && got[k] > 0 {
					t.Fatalf("Unexpected interval: %s has value %d\n", k, got[k])
				}
			}
		})
	}
}

     * {@link Parser#parseInvocation(ParserRequest)} this method will return {@code true} and invoker should
     * handle this request as "early failure". In these cases, {@link #options()} usually is absent.
     */
    boolean parsingFailed();

    /**
     * Returns {@code true} if this call happens in "embedded" mode.
     *
     * @see ParserRequest#embedded()
     */
    default boolean embedded() {

     *
     * @param all the --all option value (null for absent)
     * @param infer the --infer option value (null for absent)
     * @param model the --model option value (null for absent)
     * @param plugins the --plugins option value (null for absent)
     * @param modelVersion the --model-version option value (null for absent)
     * @return configured upgrade options
     */

     *
     * <p>{@link #getModuleName(Path)} is preferred when only the module name is desired,
     * because a name may be present even if the descriptor is absent. This method is for
     * cases when more information is desired, such as the set of exported packages.</p>
     *
     * @param dependency path to the dependency for which to get the module name

	}
	if len(buf) < int(dirent.Reclen) {
		return consumed, nil, typ, fmt.Errorf("buf size %d < record length %d", len(buf), dirent.Reclen)
	}
	consumed = int(dirent.Reclen)
	if direntInode(dirent) == 0 { // File absent in directory.
		return consumed, name, typ, err
	}
	switch dirent.Type {
	case syscall.DT_REG:
		typ = 0
	case syscall.DT_DIR:
		typ = os.ModeDir
	case syscall.DT_LNK:
		typ = os.ModeSymlink

    [
        ("/items", None, 200, {"User-Agent": "testclient"}),
        ("/items", {"X-Header": "notvalid"}, 200, {"User-Agent": "testclient"}),
        ("/items", {"User-Agent": "FastAPI test"}, 200, {"User-Agent": "FastAPI test"}),
    ],
)
def test(path, headers, expected_status, expected_response, client: TestClient):
    response = client.get(path, headers=headers)
    assert response.status_code == expected_status

    assert response.status_code == 200
    assert response.json() == {
        "host": "testserver",
        "save_data": True,
        "if_modified_since": None,
        "traceparent": None,
        "x_tag": [],
    }


def test_header_param_model_invalid(client: TestClient):
    response = client.get("/items/")
    assert response.status_code == 422

    response = client.post("/files/")
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "No file sent"}


def test_post_uploadfile_no_body(client: TestClient):
    response = client.post("/uploadfile/")
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "No upload file sent"}


def test_post_file(tmp_path: Path, client: TestClient):

    if log.is_file():
        os.remove(log)  # pragma: no cover
    response = client.post("/send-notification/******@****.***")
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "Notification sent in the background"}
    with open("./log.txt") as f:

    response is already "successfully" sent back to the client, but there's still
    an error in the server afterwards, an exception is raised and captured or shown
    in the server logs.
    """
    with TestClient(app, raise_server_exceptions=False) as client:
        response = client.get("/broken")
        assert response.status_code == 200
        assert response.json() == {"message": "all good?"}