assert response.json() == {
        "openapi": "3.1.0",
        "info": {"title": "FastAPI", "version": "0.1.0"},
        "paths": {
            "/override1": {
                "get": {
                    "tags": ["path1a", "path1b"],
                    "summary": "Path1 Override",
                    "operationId": "path1_override_override1_get",
                    "parameters": [
                        {

  def test_get_dir_size(self):
    self.assertEqual(testing.get_dir_size(self.path_a), 4)
    self.assertEqual(testing.get_dir_size(self.path_b), 8)

  def test_get_size_ratio(self):
    self.assertEqual(testing.get_size_ratio(self.path_a, self.path_b), 0.5)
    self.assertEqual(testing.get_size_ratio(self.path_b, self.path_a), 2.0)


if __name__ == '__main__':

def get_size_ratio(path_a: str, path_b: str) -> float:
  """Return the size ratio of the given paths.

  Args:
    path_a: Path of a directory or a file to be the nominator of the ratio.
    path_b: Path of a directory or a file to be the denominator of the ratio.

  Returns:
    Ratio of size of path_a / size of path_b.
  """
  size_a = get_dir_size(path_a)
  size_b = get_dir_size(path_b)

	EscapedPathSeparator = "\\" + PathSeparator
)

// ValidKeyRegex is a regex for a valid path key element.
var ValidKeyRegex = regexp.MustCompile("^[a-zA-Z0-9_-]*$")

// Path is a path in slice form.
type Path []string

// PathFromString converts a string path of form a.b.c to a string slice representation.
func PathFromString(path string) Path {
	path = filepath.Clean(path)

// If the path is empty, Base returns ".".
// If the path consists entirely of slashes, Base returns "/".
func Base(path string) string {
	if path == "" {
		return "."
	}
	// Strip trailing slashes.
	for len(path) > 0 && path[len(path)-1] == '/' {
		path = path[0 : len(path)-1]
	}
	// Find the last element
	if i := bytealg.LastIndexByteString(path, '/'); i >= 0 {
		path = path[i+1:]
	}

apiVersion: gateway.networking.k8s.io/v1beta1
kind: HTTPRoute
metadata:
  name: invalid-path-alphanum-specialchars-mix
spec:
  rules:
  - matches:
    - path:
        type: PathPrefix

        path1    | path2    | test1   | test2   | expectedEntries
        '/pathA' | '/pathA' | 'false' | 'false' | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'false' | 'true'  | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'true'  | 'false' | [[path: '/pathA', test: 'false']]
        '/pathA' | '/pathA' | 'true'  | 'true'  | [[path: '/pathA', test: 'true' ]]

// Join(base, path) will always produce a path contained within base and
// Clean(path) will always produce an unrooted path with no ".." path elements.
//
// IsLocal is a purely lexical operation.
// In particular, it does not account for the effect of any symbolic links
// that may exist in the filesystem.
func IsLocal(path string) bool {
	return filepathlite.IsLocal(path)
}

            ]
        }
    )


def test_post_files_and_token(tmp_path, app: FastAPI):
    patha = tmp_path / "test.txt"
    pathb = tmp_path / "testb.txt"
    patha.write_text("<file content>")
    pathb.write_text("<file b content>")

    client = TestClient(app)
    with patha.open("rb") as filea, pathb.open("rb") as fileb:
        response = client.post(
            "/files/",
            data={"token": "foo"},

            ]
        }
    )


def test_post_files_and_token(tmp_path, app: FastAPI):
    patha = tmp_path / "test.txt"
    pathb = tmp_path / "testb.txt"
    patha.write_text("<file content>")
    pathb.write_text("<file b content>")

    client = TestClient(app)
    with patha.open("rb") as filea, pathb.open("rb") as fileb:
        response = client.post(
            "/files/",
            data={"token": "foo"},