SYMBOL INDEX (6954 symbols across 835 files)

FILE: build/fbcode_builder/CMake/fb_py_test_main.py
  class get_cpu_instr_counter (line 42) | class get_cpu_instr_counter:
    method read (line 43) | def read(self):
  class TestStatus (line 52) | class TestStatus:
  class PathMatcher (line 62) | class PathMatcher:
    method __init__ (line 63) | def __init__(self, include_patterns, omit_patterns):
    method omit (line 67) | def omit(self, path):
    method include (line 78) | def include(self, path):
  class DebugWipeFinder (line 82) | class DebugWipeFinder(PathFinder):
    method __init__ (line 88) | def __init__(self, matcher):
    method find_spec (line 91) | def find_spec(self, fullname, path=None, target=None):
  function optimize_for_coverage (line 128) | def optimize_for_coverage(cov, include_patterns, omit_patterns):
  class TeeStream (line 138) | class TeeStream:
    method __init__ (line 139) | def __init__(self, *streams):
    method write (line 142) | def write(self, data):
    method flush (line 146) | def flush(self):
    method isatty (line 150) | def isatty(self):
  class CallbackStream (line 154) | class CallbackStream:
    method __init__ (line 155) | def __init__(self, callback, bytes_callback=None, orig=None):
    method write (line 170) | def write(self, data):
    method flush (line 173) | def flush(self):
    method isatty (line 176) | def isatty(self):
    method fileno (line 179) | def fileno(self):
  class BuckTestResult (line 183) | class BuckTestResult(unittest.TextTestResult):
    method __init__ (line 191) | def __init__(
    method getResults (line 203) | def getResults(self):
    method startTest (line 206) | def startTest(self, test):
    method _find_next_test (line 227) | def _find_next_test(self, suite):
    method stopTest (line 245) | def stopTest(self, test):
    method stopTestRun (line 282) | def stopTestRun(self):
    method _withTest (line 288) | def _withTest(self, test):
    method _setStatus (line 293) | def _setStatus(self, test, status, message=None, stacktrace=None):
    method setStatus (line 302) | def setStatus(self, test, status, message=None, stacktrace=None):
    method setException (line 314) | def setException(self, test, status, excinfo):
    method addSuccess (line 323) | def addSuccess(self, test):
    method addError (line 327) | def addError(self, test, err):
    method addFailure (line 331) | def addFailure(self, test, err):
    method addSkip (line 335) | def addSkip(self, test, reason):
    method addExpectedFailure (line 339) | def addExpectedFailure(self, test, err):
    method addUnexpectedSuccess (line 343) | def addUnexpectedSuccess(self, test):
    method addStdout (line 347) | def addStdout(self, val):
    method addStdoutBytes (line 353) | def addStdoutBytes(self, val):
    method addStderr (line 357) | def addStderr(self, val):
    method addStderrBytes (line 363) | def addStderrBytes(self, val):
  class BuckTestRunner (line 368) | class BuckTestRunner(unittest.TextTestRunner):
    method __init__ (line 369) | def __init__(self, main_program, suite, show_output=True, **kwargs):
    method _makeResult (line 375) | def _makeResult(self):
  function _format_test_name (line 386) | def _format_test_name(test_class, attrname):
  class StderrLogHandler (line 390) | class StderrLogHandler(logging.StreamHandler):
    method __init__ (line 401) | def __init__(self):
    method stream (line 405) | def stream(self):
  class RegexTestLoader (line 409) | class RegexTestLoader(unittest.TestLoader):
    method __init__ (line 410) | def __init__(self, regex=None):
    method getTestCaseNames (line 414) | def getTestCaseNames(self, testCaseClass):
  class Loader (line 431) | class Loader:
    method __init__ (line 435) | def __init__(self, modules, regex=None):
    method load_all (line 439) | def load_all(self):
    method load_args (line 449) | def load_args(self, args):
  class MainProgram (line 486) | class MainProgram:
    method __init__ (line 495) | def __init__(self, argv):
    method init_option_parser (line 500) | def init_option_parser(self):
    method parse_options (line 580) | def parse_options(self, argv):
    method setup_logging (line 592) | def setup_logging(self):
    method create_loader (line 629) | def create_loader(self):
    method load_tests (line 634) | def load_tests(self):
    method get_tests (line 651) | def get_tests(self, test_suite):
    method run (line 662) | def run(self):
    method run_tests (line 680) | def run_tests(self, test_suite):
    method get_abbr_impl (line 704) | def get_abbr_impl(self):
    method start_coverage (line 718) | def start_coverage(self):
    method get_coverage (line 743) | def get_coverage(self):
    method convert_to_diff_cov_str (line 780) | def convert_to_diff_cov_str(self, analysis):
  function main (line 800) | def main(argv):

FILE: build/fbcode_builder/CMake/fb_py_win_main.c
  function locate_py_main (line 13) | int locate_py_main(int argc, wchar_t** argv) {
  function wmain (line 47) | int wmain() {

FILE: build/fbcode_builder/CMake/make_fbpy_archive.py
  class UsageError (line 19) | class UsageError(Exception):
    method __init__ (line 20) | def __init__(self, message):
    method __str__ (line 23) | def __str__(self):
  class BadManifestError (line 27) | class BadManifestError(UsageError):
    method __init__ (line 28) | def __init__(self, path, line_num, message):
  function parse_manifest (line 41) | def parse_manifest(manifest, path_map):
  function populate_install_tree (line 93) | def populate_install_tree(inst_dir, path_map):
  function build_pex (line 127) | def build_pex(args, path_map):
  function build_zipapp (line 157) | def build_zipapp(args, path_map):
  function create_main_module (line 177) | def create_main_module(args, inst_dir, path_map):
  function build_install_dir (line 198) | def build_install_dir(args, path_map):
  function ensure_directory (line 213) | def ensure_directory(path):
  function install_library (line 221) | def install_library(args, path_map):
  function parse_manifests (line 242) | def parse_manifests(args):
  function check_main_module (line 258) | def check_main_module(args, path_map):
  function main (line 303) | def main():

FILE: build/fbcode_builder/getdeps.py
  class UsageError (line 46) | class UsageError(Exception):
  class ValidateManifest (line 60) | class ValidateManifest(SubCmd):
    method run (line 61) | def run(self, args):
    method setup_parser (line 70) | def setup_parser(self, parser):
  class ShowHostType (line 75) | class ShowHostType(SubCmd):
    method run (line 76) | def run(self, args):
  class ProjectCmdBase (line 82) | class ProjectCmdBase(SubCmd):
    method run (line 83) | def run(self, args):
    method process_project_dir_arguments (line 120) | def process_project_dir_arguments(self, args, loader):
    method setup_parser (line 161) | def setup_parser(self, parser):
    method setup_project_cmd_parser (line 220) | def setup_project_cmd_parser(self, parser):
    method create_builder (line 223) | def create_builder(self, loader, manifest):
    method check_built (line 239) | def check_built(self, loader, manifest):
  class CachedProject (line 246) | class CachedProject:
    method __init__ (line 250) | def __init__(self, cache, loader, m):
    method is_cacheable (line 269) | def is_cacheable(self):
    method was_cached (line 273) | def was_cached(self):
    method download (line 277) | def download(self):
    method upload (line 302) | def upload(self):
  class FetchCmd (line 322) | class FetchCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 323) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 338) | def run_project_cmd(self, args, loader, manifest):
  class InstallSysDepsCmd (line 371) | class InstallSysDepsCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 372) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 409) | def run_project_cmd(self, args, loader, manifest):
  class ListDepsCmd (line 491) | class ListDepsCmd(ProjectCmdBase):
    method run_project_cmd (line 492) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 497) | def setup_project_cmd_parser(self, parser):
  function clean_dirs (line 507) | def clean_dirs(opts):
  class CleanCmd (line 516) | class CleanCmd(SubCmd):
    method run (line 517) | def run(self, args):
  class ShowScratchDirCmd (line 523) | class ShowScratchDirCmd(SubCmd):
    method run (line 524) | def run(self, args):
  class ShowBuildDirCmd (line 530) | class ShowBuildDirCmd(ProjectCmdBase):
    method run_project_cmd (line 531) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 541) | def setup_project_cmd_parser(self, parser):
  class ShowInstDirCmd (line 551) | class ShowInstDirCmd(ProjectCmdBase):
    method run_project_cmd (line 552) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 568) | def setup_project_cmd_parser(self, parser):
  class QueryPathsCmd (line 578) | class QueryPathsCmd(ProjectCmdBase):
    method run_project_cmd (line 579) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 600) | def setup_project_cmd_parser(self, parser):
  class ShowSourceDirCmd (line 610) | class ShowSourceDirCmd(ProjectCmdBase):
    method run_project_cmd (line 611) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 621) | def setup_project_cmd_parser(self, parser):
  class BuildCmd (line 631) | class BuildCmd(ProjectCmdBase):
    method run_project_cmd (line 632) | def run_project_cmd(self, args, loader, manifest):
    method compute_dep_change_status (line 757) | def compute_dep_change_status(self, m, built_marker, loader):
    method compute_source_change_status (line 793) | def compute_source_change_status(
    method setup_project_cmd_parser (line 834) | def setup_project_cmd_parser(self, parser):
  class FixupDeps (line 897) | class FixupDeps(ProjectCmdBase):
    method run_project_cmd (line 898) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 924) | def setup_project_cmd_parser(self, parser):
  class TestCmd (line 938) | class TestCmd(ProjectCmdBase):
    method run_project_cmd (line 939) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 953) | def setup_project_cmd_parser(self, parser):
  class DebugCmd (line 982) | class DebugCmd(ProjectCmdBase):
    method run_project_cmd (line 983) | def run_project_cmd(self, args, loader, manifest):
  class EnvCmd (line 991) | class EnvCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 992) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 1002) | def run_project_cmd(self, args, loader, manifest):
  class GenerateGitHubActionsCmd (line 1009) | class GenerateGitHubActionsCmd(ProjectCmdBase):
    method run_project_cmd (line 1021) | def run_project_cmd(self, args, loader, manifest):
    method get_run_on (line 1033) | def get_run_on(self, args):
    method write_job_for_platform (line 1066) | def write_job_for_platform(self, platform, args):  # noqa: C901
    method setup_project_cmd_parser (line 1415) | def setup_project_cmd_parser(self, parser):
  function get_arg_var_name (line 1486) | def get_arg_var_name(args):
  function parse_args (line 1494) | def parse_args():
  function main (line 1627) | def main():

FILE: build/fbcode_builder/getdeps/builder.py
  class BuilderBase (line 38) | class BuilderBase:
    method __init__ (line 39) | def __init__(
    method _get_cmd_prefix (line 79) | def _get_cmd_prefix(self) -> list[str]:
    method _check_cmd (line 101) | def _check_cmd(self, cmd: list[str], **kwargs: object) -> None:
    method _run_cmd (line 110) | def _run_cmd(
    method _reconfigure (line 143) | def _reconfigure(self, reconfigure: bool) -> bool:
    method _apply_patchfile (line 150) | def _apply_patchfile(self) -> None:
    method prepare (line 185) | def prepare(self, reconfigure: bool) -> None:
    method debug (line 191) | def debug(self, reconfigure: bool) -> None:
    method printenv (line 201) | def printenv(self, reconfigure: bool) -> None:
    method build (line 224) | def build(self, reconfigure: bool) -> None:
    method _job_weight_mib (line 254) | def _job_weight_mib(self) -> int:
    method num_jobs (line 273) | def num_jobs(self) -> int:
    method memory_limit_preexec_fn (line 277) | def memory_limit_preexec_fn(self) -> Callable[[], None] | None:
    method run_tests (line 285) | def run_tests(
    method _prepare (line 299) | def _prepare(self, reconfigure: bool) -> None:
    method _build (line 305) | def _build(self, reconfigure: bool) -> None:
    method _compute_env (line 312) | def _compute_env(self, env: Env | None = None) -> Env:
    method get_dev_run_script_path (line 325) | def get_dev_run_script_path(self) -> str:
    method get_dev_run_extra_path_dirs (line 329) | def get_dev_run_extra_path_dirs(
  class MakeBuilder (line 341) | class MakeBuilder(BuilderBase):
    method __init__ (line 342) | def __init__(
    method _make_binary (line 371) | def _make_binary(self) -> str | None:
    method _get_prefix (line 374) | def _get_prefix(self) -> list[str]:
    method _build (line 377) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 406) | def run_tests(
  class CMakeBootStrapBuilder (line 447) | class CMakeBootStrapBuilder(MakeBuilder):
    method _build (line 448) | def _build(self, reconfigure: bool) -> None:
  class AutoconfBuilder (line 459) | class AutoconfBuilder(BuilderBase):
    method __init__ (line 460) | def __init__(
    method _make_binary (line 493) | def _make_binary(self) -> str | None:
    method _build (line 496) | def _build(self, reconfigure: bool) -> None:
  class Iproute2Builder (line 540) | class Iproute2Builder(BuilderBase):
    method __init__ (line 545) | def __init__(
    method _build (line 567) | def _build(self, reconfigure: bool) -> None:
  class MesonBuilder (line 585) | class MesonBuilder(BuilderBase):
    method __init__ (line 588) | def __init__(
    method _build (line 610) | def _build(self, reconfigure: bool) -> None:
  class CMakeBuilder (line 644) | class CMakeBuilder(BuilderBase):
    method __init__ (line 757) | def __init__(
    method _invalidate_cache (line 801) | def _invalidate_cache(self) -> None:
    method _needs_reconfigure (line 813) | def _needs_reconfigure(self) -> bool:
    method _write_build_script (line 820) | def _write_build_script(self, **kwargs: object) -> None:
    method _compute_cmake_define_args (line 856) | def _compute_cmake_define_args(self, env: Env) -> list[str]:
    method _run_include_rewriter (line 924) | def _run_include_rewriter(self) -> None:
    method _build (line 941) | def _build(self, reconfigure: bool) -> None:
    method _build_targets (line 1005) | def _build_targets(self, targets: Sequence[str]) -> None:
    method _get_missing_test_executables (line 1044) | def _get_missing_test_executables(
    method run_tests (line 1082) | def run_tests(
  class NinjaBootstrap (line 1345) | class NinjaBootstrap(BuilderBase):
    method __init__ (line 1346) | def __init__(
    method _build (line 1368) | def _build(self, reconfigure: bool) -> None:
  class OpenSSLBuilder (line 1381) | class OpenSSLBuilder(BuilderBase):
    method __init__ (line 1382) | def __init__(
    method _build (line 1404) | def _build(self, reconfigure: bool) -> None:
  class Boost (line 1469) | class Boost(BuilderBase):
    method __init__ (line 1470) | def __init__(
    method _build (line 1499) | def _build(self, reconfigure: bool) -> None:
  class NopBuilder (line 1554) | class NopBuilder(BuilderBase):
    method __init__ (line 1555) | def __init__(
    method build (line 1569) | def build(self, reconfigure: bool) -> None:
  class SetupPyBuilder (line 1609) | class SetupPyBuilder(BuilderBase):
    method _build (line 1610) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 1640) | def run_tests(
  class SqliteBuilder (line 1667) | class SqliteBuilder(BuilderBase):
    method __init__ (line 1668) | def __init__(
    method _build (line 1690) | def _build(self, reconfigure: bool) -> None:

FILE: build/fbcode_builder/getdeps/buildopts.py
  function detect_project (line 34) | def detect_project(path: str) -> tuple[str | None, str | None]:
  class BuildOptions (line 53) | class BuildOptions:
    method __init__ (line 54) | def __init__(
    method manifests_dir (line 196) | def manifests_dir(self) -> str:
    method is_darwin (line 199) | def is_darwin(self) -> bool:
    method is_windows (line 202) | def is_windows(self) -> bool:
    method is_arm (line 205) | def is_arm(self) -> bool:
    method get_vcvars_path (line 208) | def get_vcvars_path(self) -> str | None:
    method is_linux (line 211) | def is_linux(self) -> bool:
    method is_freebsd (line 214) | def is_freebsd(self) -> bool:
    method get_num_jobs (line 217) | def get_num_jobs(self, job_weight: int) -> int:
    method get_context_generator (line 228) | def get_context_generator(
    method compute_env_for_install_dirs (line 251) | def compute_env_for_install_dirs(
    method add_homebrew_package_to_env (line 389) | def add_homebrew_package_to_env(self, package: str, env: Env) -> bool:
    method add_prefix_to_env (line 397) | def add_prefix_to_env(
  function list_win32_subst_letters (line 529) | def list_win32_subst_letters() -> dict[str, str]:
  function find_existing_win32_subst_for_path (line 545) | def find_existing_win32_subst_for_path(
  function find_unused_drive_letter (line 556) | def find_unused_drive_letter() -> str | None:
  function map_subst_path (line 580) | def map_subst_path(path: str) -> str:
  function _check_host_type (line 611) | def _check_host_type(args: argparse.Namespace, host_type: HostType | Non...
  function setup_build_options (line 623) | def setup_build_options(

FILE: build/fbcode_builder/getdeps/cache.py
  class ArtifactCache (line 11) | class ArtifactCache:
    method download_to_file (line 17) | def download_to_file(self, name: str, dest_file_name: str) -> bool:
    method upload_from_file (line 28) | def upload_from_file(self, name: str, source_file_name: str) -> None:
  function create_cache (line 38) | def create_cache() -> ArtifactCache | None:

FILE: build/fbcode_builder/getdeps/cargo.py
  class CargoBuilder (line 25) | class CargoBuilder(BuilderBase):
    method __init__ (line 26) | def __init__(
    method run_cargo (line 61) | def run_cargo(
    method build_source_dir (line 80) | def build_source_dir(self) -> str:
    method workspace_dir (line 83) | def workspace_dir(self) -> str:
    method manifest_dir (line 86) | def manifest_dir(self, manifest: str) -> str:
    method recreate_dir (line 89) | def recreate_dir(self, src: str, dst: str) -> None:
    method recreate_linked_dir (line 97) | def recreate_linked_dir(self, src: str, dst: str) -> None:
    method cargo_config_file (line 105) | def cargo_config_file(self) -> str:
    method _create_cargo_config (line 112) | def _create_cargo_config(self) -> dict[str, dict[str, str]]:
    method _prepare (line 178) | def _prepare(self, reconfigure: bool) -> None:
    method _build (line 187) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 223) | def run_tests(
    method _patchup_workspace (line 256) | def _patchup_workspace(self, dep_to_git: dict[str, dict[str, str]]) ->...
    method _resolve_config (line 325) | def _resolve_config(
    method _resolve_dep_to_git (line 360) | def _resolve_dep_to_git(self) -> dict[str, dict[str, str]]:
    method _resolve_dep_to_crates (line 448) | def _resolve_dep_to_crates(
    method _extract_crates_used (line 492) | def _extract_crates_used(
    method _resolve_crate_to_path (line 521) | def _resolve_crate_to_path(

FILE: build/fbcode_builder/getdeps/copytree.py
  function containing_repo_type (line 23) | def containing_repo_type(path: str) -> tuple[str | None, str | None]:
  function find_eden_root (line 36) | def find_eden_root(dirpath: str) -> str | None:
  function prefetch_dir_if_eden (line 55) | def prefetch_dir_if_eden(dirpath: str) -> None:
  function simple_copytree (line 73) | def simple_copytree(src_dir: str, dest_dir: str, symlinks: bool = False)...
  function _remove_readonly_and_try_again (line 106) | def _remove_readonly_and_try_again(
  function rmtree_more (line 134) | def rmtree_more(path: str) -> None:

FILE: build/fbcode_builder/getdeps/dyndeps.py
  function copyfile (line 29) | def copyfile(src: str, dest: str) -> None:
  class DepBase (line 34) | class DepBase:
    method __init__ (line 35) | def __init__(
    method list_dynamic_deps (line 53) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method interesting_dep (line 56) | def interesting_dep(self, d: str) -> bool:
    method process_deps (line 64) | def process_deps(
    method find_all_dependencies (line 97) | def find_all_dependencies(self, build_dir: str) -> list[str]:
    method munge_in_place (line 114) | def munge_in_place(self, objfile: str, final_lib_dir: str) -> None:
    method rewrite_dep (line 142) | def rewrite_dep(
    method resolve_loader_path (line 152) | def resolve_loader_path(self, dep: str) -> str | None:
    method list_objs_in_dir (line 163) | def list_objs_in_dir(
    method is_objfile (line 180) | def is_objfile(self, objfile: str) -> bool:
    method strip_debug_info (line 183) | def strip_debug_info(self, objfile: str) -> None:
    method check_call_verbose (line 188) | def check_call_verbose(self, args: list[str]) -> None:
  class WinDeps (line 193) | class WinDeps(DepBase):
    method __init__ (line 194) | def __init__(
    method find_dumpbin (line 204) | def find_dumpbin(self) -> str:
    method list_dynamic_deps (line 239) | def list_dynamic_deps(self, exe: str) -> list[str]:
    method rewrite_dep (line 254) | def rewrite_dep(
    method interesting_dep (line 282) | def interesting_dep(self, d: str) -> bool:
    method is_objfile (line 289) | def is_objfile(self, objfile: str) -> bool:
    method emit_dev_run_script (line 296) | def emit_dev_run_script(self, script_path: str, dep_dirs: list[str]) -...
    method compute_dependency_paths (line 312) | def compute_dependency_paths(self, build_dir: str) -> list[str]:
    method compute_dependency_paths_fast (line 328) | def compute_dependency_paths_fast(self, build_dir: str) -> list[str]:
    method read_custom_dep_dirs (line 344) | def read_custom_dep_dirs(self, build_dir: str) -> set[str]:
    method _get_dev_run_script_contents (line 364) | def _get_dev_run_script_contents(self, path_dirs: list[str]) -> str:
  class ElfDeps (line 382) | class ElfDeps(DepBase):
    method __init__ (line 383) | def __init__(
    method list_dynamic_deps (line 409) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method rewrite_dep (line 420) | def rewrite_dep(
    method is_objfile (line 436) | def is_objfile(self, objfile: str) -> bool:
    method strip_debug_info (line 444) | def strip_debug_info(self, objfile: str) -> None:
  class MachDeps (line 452) | class MachDeps(DepBase):
    method interesting_dep (line 453) | def interesting_dep(self, d: str) -> bool:
    method is_objfile (line 458) | def is_objfile(self, objfile: str) -> bool:
    method list_dynamic_deps (line 470) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method rewrite_dep (line 489) | def rewrite_dep(
  function create_dyn_dep_munger (line 514) | def create_dyn_dep_munger(

FILE: build/fbcode_builder/getdeps/envfuncs.py
  class Env (line 16) | class Env:
    method __init__ (line 17) | def __init__(self, src: Mapping[str, str] | None = None) -> None:
    method update (line 24) | def update(self, src: Mapping[str, str]) -> None:
    method copy (line 28) | def copy(self) -> Env:
    method _key (line 31) | def _key(self, key: str) -> str | None:
    method get (line 60) | def get(self, key: str, defval: str | None = None) -> str | None:
    method __getitem__ (line 66) | def __getitem__(self, key: str) -> str:
    method unset (line 72) | def unset(self, key: str) -> None:
    method __delitem__ (line 80) | def __delitem__(self, key: str) -> None:
    method __repr__ (line 83) | def __repr__(self) -> str:
    method set (line 86) | def set(self, key: str, value: str) -> None:
    method __setitem__ (line 107) | def __setitem__(self, key: str, value: str) -> None:
    method __iter__ (line 110) | def __iter__(self) -> Iterator[str]:
    method __len__ (line 113) | def __len__(self) -> int:
    method keys (line 116) | def keys(self) -> KeysView[str]:
    method values (line 119) | def values(self) -> ValuesView[str]:
    method items (line 122) | def items(self) -> ItemsView[str, str]:
  function add_path_entry (line 126) | def add_path_entry(
  function add_flag (line 145) | def add_flag(env: Env, name: str, flag: str, append: bool = True) -> None:
  function tpx_path (line 162) | def tpx_path() -> str:
  function path_search (line 166) | def path_search(
  function _perform_path_search (line 191) | def _perform_path_search(path: str, exename: str) -> str | None:

FILE: build/fbcode_builder/getdeps/errors.py
  class TransientFailure (line 9) | class TransientFailure(Exception):
  class ManifestNotFound (line 17) | class ManifestNotFound(Exception):
    method __init__ (line 18) | def __init__(self, manifest_name: str) -> None:

FILE: build/fbcode_builder/getdeps/expr.py
  function parse_expr (line 15) | def parse_expr(expr_text: str, valid_variables: set[str]) -> ExprNode:
  class ExprNode (line 44) | class ExprNode:
    method eval (line 45) | def eval(self, ctx: dict[str, str | None]) -> bool:
  class TrueExpr (line 49) | class TrueExpr(ExprNode):
    method eval (line 50) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 53) | def __str__(self) -> str:
  class NotExpr (line 57) | class NotExpr(ExprNode):
    method __init__ (line 58) | def __init__(self, node: ExprNode) -> None:
    method eval (line 61) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 64) | def __str__(self) -> str:
  class AllExpr (line 68) | class AllExpr(ExprNode):
    method __init__ (line 69) | def __init__(self, nodes: list[ExprNode]) -> None:
    method eval (line 72) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 78) | def __str__(self) -> str:
  class AnyExpr (line 85) | class AnyExpr(ExprNode):
    method __init__ (line 86) | def __init__(self, nodes: list[ExprNode]) -> None:
    method eval (line 89) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 95) | def __str__(self) -> str:
  class EqualExpr (line 102) | class EqualExpr(ExprNode):
    method __init__ (line 103) | def __init__(self, key: str, value: str) -> None:
    method eval (line 107) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 110) | def __str__(self) -> str:
  class Parser (line 114) | class Parser:
    method __init__ (line 115) | def __init__(self, text: str, valid_variables: set[str]) -> None:
    method parse (line 120) | def parse(self) -> ExprNode:
    method top (line 129) | def top(self) -> ExprNode:
    method ident (line 158) | def ident(self) -> str:
    method parse_not (line 164) | def parse_not(self) -> NotExpr:
    method parse_any (line 172) | def parse_any(self) -> AnyExpr:
    method parse_all (line 183) | def parse_all(self) -> AllExpr:

FILE: build/fbcode_builder/getdeps/fetcher.py
  function file_name_is_cmake_file (line 42) | def file_name_is_cmake_file(file_name: str) -> bool:
  class ChangeStatus (line 52) | class ChangeStatus:
    method __init__ (line 65) | def __init__(self, all_changed: bool = False) -> None:
    method record_change (line 76) | def record_change(self, file_name: str) -> None:
    method sources_changed (line 96) | def sources_changed(self) -> bool:
    method build_changed (line 103) | def build_changed(self) -> bool:
  class Fetcher (line 111) | class Fetcher(ABC):
    method update (line 117) | def update(self) -> ChangeStatus:
    method clean (line 126) | def clean(self) -> None:
    method hash (line 132) | def hash(self) -> str:
    method get_src_dir (line 146) | def get_src_dir(self) -> str:
  class LocalDirFetcher (line 152) | class LocalDirFetcher:
    method __init__ (line 159) | def __init__(self, path: str) -> None:
    method update (line 162) | def update(self) -> ChangeStatus:
    method hash (line 165) | def hash(self) -> str:
    method get_src_dir (line 168) | def get_src_dir(self) -> str:
    method clean (line 171) | def clean(self) -> None:
  class SystemPackageFetcher (line 175) | class SystemPackageFetcher:
    method __init__ (line 176) | def __init__(
    method packages_are_installed (line 188) | def packages_are_installed(self) -> bool:
    method update (line 224) | def update(self) -> ChangeStatus:
    method hash (line 228) | def hash(self) -> str:
    method get_src_dir (line 234) | def get_src_dir(self) -> None:
  class PreinstalledNopFetcher (line 238) | class PreinstalledNopFetcher(SystemPackageFetcher):
    method __init__ (line 239) | def __init__(self) -> None:
  class GitFetcher (line 243) | class GitFetcher(Fetcher):
    method __init__ (line 246) | def __init__(
    method _update (line 291) | def _update(self) -> ChangeStatus:
    method update (line 320) | def update(self) -> ChangeStatus:
    method _clone (line 326) | def _clone(self) -> None:
    method clean (line 347) | def clean(self) -> None:
    method hash (line 351) | def hash(self) -> str:
    method get_src_dir (line 354) | def get_src_dir(self) -> str:
  function does_file_need_update (line 358) | def does_file_need_update(
  function copy_if_different (line 392) | def copy_if_different(src_name: str, dest_name: str) -> bool:
  function filter_strip_marker (line 417) | def filter_strip_marker(dest_name: str, marker: str) -> None:
  function list_files_under_dir_newer_than_timestamp (line 442) | def list_files_under_dir_newer_than_timestamp(
  class ShipitPathMap (line 453) | class ShipitPathMap:
    method __init__ (line 454) | def __init__(self) -> None:
    method add_mapping (line 460) | def add_mapping(self, fbsource_dir: str, target_dir: str) -> None:
    method add_exclusion (line 468) | def add_exclusion(self, pattern: str) -> None:
    method _minimize_roots (line 472) | def _minimize_roots(self) -> None:
    method _sort_mapping (line 490) | def _sort_mapping(self) -> None:
    method _map_name (line 493) | def _map_name(self, norm_name: str, dest_root: str) -> str | None:
    method mirror (line 520) | def mirror(self, fbsource_root: str, dest_root: str) -> ChangeStatus:
  class FbsourceRepoData (line 594) | class FbsourceRepoData(NamedTuple):
  function get_fbsource_repo_data (line 602) | def get_fbsource_repo_data(build_options: BuildOptions) -> FbsourceRepoD...
  function is_public_commit (line 636) | def is_public_commit(build_options: BuildOptions) -> bool:  # noqa: C901
  class SimpleShipitTransformerFetcher (line 727) | class SimpleShipitTransformerFetcher(Fetcher):
    method __init__ (line 728) | def __init__(
    method clean (line 741) | def clean(self) -> None:
    method update (line 745) | def update(self) -> ChangeStatus:
    method hash (line 765) | def hash(self) -> str:
    method get_src_dir (line 771) | def get_src_dir(self) -> str:
  class SubFetcher (line 775) | class SubFetcher(Fetcher):
    method __init__ (line 778) | def __init__(self, base: Fetcher, subs: list[tuple[Fetcher, str]]) -> ...
    method update (line 782) | def update(self) -> ChangeStatus:
    method clean (line 794) | def clean(self) -> None:
    method hash (line 799) | def hash(self) -> str:
    method get_src_dir (line 805) | def get_src_dir(self) -> str:
  class ShipitTransformerFetcher (line 809) | class ShipitTransformerFetcher(Fetcher):
    method _shipit_paths (line 811) | def _shipit_paths(cls, build_options: BuildOptions) -> list[str]:
    method __init__ (line 824) | def __init__(
    method update (line 839) | def update(self) -> ChangeStatus:
    method clean (line 845) | def clean(self) -> None:
    method available (line 850) | def available(cls, build_options: BuildOptions) -> bool:
    method run_shipit (line 856) | def run_shipit(self) -> None:
    method hash (line 900) | def hash(self) -> str:
    method get_src_dir (line 904) | def get_src_dir(self) -> str:
  function download_url_to_file_with_progress (line 908) | def download_url_to_file_with_progress(url: str, file_name: str) -> None:
  class ArchiveFetcher (line 1011) | class ArchiveFetcher(Fetcher):
    method __init__ (line 1012) | def __init__(
    method _verify_hash (line 1034) | def _verify_hash(self) -> None:
    method _download_dir (line 1049) | def _download_dir(self) -> str:
    method _download (line 1056) | def _download(self) -> None:
    method clean (line 1074) | def clean(self) -> None:
    method update (line 1078) | def update(self) -> ChangeStatus:
    method hash (line 1148) | def hash(self) -> str:
    method get_src_dir (line 1151) | def get_src_dir(self) -> str:
  function homebrew_package_prefix (line 1155) | def homebrew_package_prefix(package: str) -> str | None:

FILE: build/fbcode_builder/getdeps/include_rewriter.py
  class IncludePathRewriter (line 27) | class IncludePathRewriter:
    method __init__ (line 43) | def __init__(self, mappings: list[tuple[str, str]], verbose: bool = Fa...
    method rewrite_file (line 65) | def rewrite_file(self, file_path: Path, dry_run: bool = False) -> bool:
    method process_directory (line 128) | def process_directory(self, source_dir: Path, dry_run: bool = False) -...
  function rewrite_includes_from_manifest (line 175) | def rewrite_includes_from_manifest(

FILE: build/fbcode_builder/getdeps/load.py
  class Loader (line 26) | class Loader:
    method _list_manifests (line 29) | def _list_manifests(self, build_opts: BuildOptions) -> Iterator[str]:
    method _load_manifest (line 39) | def _load_manifest(self, path: str) -> ManifestParser:
    method load_project (line 42) | def load_project(
    method load_all (line 55) | def load_all(self, build_opts: BuildOptions) -> dict[str, ManifestPars...
  class ResourceLoader (line 69) | class ResourceLoader(Loader):
    method __init__ (line 70) | def __init__(self, namespace: str, manifests_dir: str) -> None:
    method _list_manifests (line 74) | def _list_manifests(self, build_opts: BuildOptions) -> Iterator[str]:
    method _find_manifest (line 89) | def _find_manifest(self, project_name: str) -> str:
    method _load_manifest (line 97) | def _load_manifest(self, path: str) -> ManifestParser:
    method load_project (line 103) | def load_project(
  function patch_loader (line 114) | def patch_loader(namespace: str, manifests_dir: str = "manifests") -> None:
  function load_project (line 119) | def load_project(build_opts: BuildOptions, project_name: str) -> Manifes...
  function load_all_manifests (line 125) | def load_all_manifests(build_opts: BuildOptions) -> dict[str, ManifestPa...
  class ManifestLoader (line 129) | class ManifestLoader:
    method __init__ (line 137) | def __init__(
    method load_manifest (line 155) | def load_manifest(self, name: str) -> ManifestParser:
    method load_all_manifests (line 162) | def load_all_manifests(self) -> dict[str, ManifestParser]:
    method dependencies_of (line 177) | def dependencies_of(self, manifest: ManifestParser) -> list[ManifestPa...
    method manifests_in_dependency_order (line 185) | def manifests_in_dependency_order(
    method set_project_src_dir (line 263) | def set_project_src_dir(self, project_name: str, path: str) -> None:
    method set_project_build_dir (line 266) | def set_project_build_dir(self, project_name: str, path: str) -> None:
    method set_project_install_dir (line 269) | def set_project_install_dir(self, project_name: str, path: str) -> None:
    method set_project_install_prefix (line 272) | def set_project_install_prefix(self, project_name: str, path: str) -> ...
    method create_fetcher (line 275) | def create_fetcher(
    method get_project_hash (line 285) | def get_project_hash(self, manifest: ManifestParser) -> str:
    method _compute_project_hash (line 292) | def _compute_project_hash(self, manifest: ManifestParser) -> str:
    method _get_project_dir_name (line 368) | def _get_project_dir_name(self, manifest: ManifestParser) -> str:
    method get_project_install_dir (line 375) | def get_project_install_dir(self, manifest: ManifestParser) -> str:
    method get_project_build_dir (line 383) | def get_project_build_dir(self, manifest: ManifestParser) -> str:
    method get_project_install_prefix (line 391) | def get_project_install_prefix(self, manifest: ManifestParser) -> str ...
    method get_project_install_dir_respecting_install_prefix (line 394) | def get_project_install_dir_respecting_install_prefix(

FILE: build/fbcode_builder/getdeps/manifest.py
  function parse_conditional_section_name (line 166) | def parse_conditional_section_name(name: str, section_def: str) -> ExprN...
  function validate_allowed_fields (line 171) | def validate_allowed_fields(
  function validate_allow_values (line 192) | def validate_allow_values(
  function validate_section (line 208) | def validate_section(
  class ManifestParser (line 243) | class ManifestParser:
    method __init__ (line 244) | def __init__(self, file_name: str, fp: str | typing.IO[str] | None = N...
    method get (line 299) | def get(
    method get_dependencies (line 327) | def get_dependencies(self, ctx: ManifestContext) -> list[str]:
    method get_section_as_args (line 345) | def get_section_as_args(
    method get_section_as_ordered_pairs (line 377) | def get_section_as_ordered_pairs(
    method get_section_as_dict (line 403) | def get_section_as_dict(
    method update_hash (line 425) | def update_hash(self, hasher: hashlib._Hash, ctx: ManifestContext) -> ...
    method is_first_party_project (line 451) | def is_first_party_project(self) -> bool:
    method get_required_system_packages (line 455) | def get_required_system_packages(
    method _is_satisfied_by_preinstalled_environment (line 466) | def _is_satisfied_by_preinstalled_environment(self, ctx: ManifestConte...
    method get_repo_url (line 483) | def get_repo_url(self, ctx: ManifestContext) -> str | None:
    method _create_fetcher (line 486) | def _create_fetcher(
    method create_fetcher (line 574) | def create_fetcher(
    method get_builder_name (line 594) | def get_builder_name(self, ctx: ManifestContext) -> str:
    method create_builder (line 600) | def create_builder(  # noqa:C901
    method create_prepare_builders (line 817) | def create_prepare_builders(
    method create_cargo_builder (line 844) | def create_cargo_builder(
  class ManifestContext (line 876) | class ManifestContext:
    method __init__ (line 893) | def __init__(self, ctx_dict: dict[str, str | None]) -> None:
    method get (line 897) | def get(self, key: str) -> str | None:
    method set (line 900) | def set(self, key: str, value: str | None) -> None:
    method copy (line 904) | def copy(self) -> ManifestContext:
    method __str__ (line 907) | def __str__(self) -> str:
  class ContextGenerator (line 914) | class ContextGenerator:
    method __init__ (line 920) | def __init__(self, default_ctx: dict[str, str | None]) -> None:
    method set_value_for_project (line 924) | def set_value_for_project(
    method set_value_for_all_projects (line 933) | def set_value_for_all_projects(self, key: str, value: str | None) -> N...
    method get_context (line 938) | def get_context(self, project_name: str) -> ManifestContext:

FILE: build/fbcode_builder/getdeps/platform.py
  function is_windows (line 16) | def is_windows() -> bool:
  function get_linux_type (line 22) | def get_linux_type() -> tuple[str | None, str | None, str | None]:
  function _get_available_ram_linux (line 59) | def _get_available_ram_linux() -> int:
  function _get_available_ram_macos (line 90) | def _get_available_ram_macos() -> int:
  function _get_available_ram_windows (line 117) | def _get_available_ram_windows() -> int:
  function _get_available_ram_freebsd (line 148) | def _get_available_ram_freebsd() -> int:
  function get_available_ram (line 174) | def get_available_ram() -> int:
  function is_current_host_arm (line 192) | def is_current_host_arm() -> bool:
  class HostType (line 201) | class HostType:
    method __init__ (line 202) | def __init__(
    method is_windows (line 242) | def is_windows(self) -> bool:
    method is_arm (line 252) | def is_arm(self) -> bool:
    method is_darwin (line 255) | def is_darwin(self) -> bool:
    method is_linux (line 258) | def is_linux(self) -> bool:
    method is_freebsd (line 261) | def is_freebsd(self) -> bool:
    method as_tuple_string (line 264) | def as_tuple_string(self) -> str:
    method get_package_manager (line 271) | def get_package_manager(self) -> str | None:
    method from_tuple_string (line 287) | def from_tuple_string(s: str) -> HostType:
    method __eq__ (line 291) | def __eq__(self, b: object) -> bool:

FILE: build/fbcode_builder/getdeps/py_wheel_builder.py
  class PythonWheelBuilder (line 99) | class PythonWheelBuilder(BuilderBase):
    method _build (line 109) | def _build(self, reconfigure: bool) -> None:
    method _run_cmake_build (line 178) | def _run_cmake_build(self, reconfigure: bool) -> None:
    method _write_cmakelists (line 195) | def _write_cmakelists(
    method _write_cmake_config_template (line 222) | def _write_cmake_config_template(self) -> None:
    method _add_sources (line 229) | def _add_sources(
    method _parse_wheel_name (line 244) | def _parse_wheel_name(self) -> WheelNameInfo:
    method _read_wheel_metadata (line 281) | def _read_wheel_metadata(self, wheel_name: WheelNameInfo) -> email.mes...
  function _to_cmake_path (line 287) | def _to_cmake_path(path: str) -> str:

FILE: build/fbcode_builder/getdeps/runcmd.py
  class RunCommandError (line 21) | class RunCommandError(Exception):
  function make_memory_limit_preexec_fn (line 25) | def make_memory_limit_preexec_fn(
  function _print_env_diff (line 72) | def _print_env_diff(env: Env, log_fn: Callable[[str], None]) -> None:
  function check_cmd (line 94) | def check_cmd(
  function run_cmd (line 107) | def run_cmd(
  function _run_cmd (line 145) | def _run_cmd(
  function _pipe_output (line 218) | def _pipe_output(p: subprocess.Popen[bytes], log_fn: Callable[[str], Non...
  function _pipe_output (line 244) | def _pipe_output(p: subprocess.Popen[bytes], log_fn: Callable[[str], Non...

FILE: build/fbcode_builder/getdeps/subcmd.py
  class SubCmd (line 14) | class SubCmd:
    method run (line 18) | def run(self, args: argparse.Namespace) -> int:
    method setup_parser (line 22) | def setup_parser(self, parser: argparse.ArgumentParser) -> None:
  function add_subcommands (line 31) | def add_subcommands(
  function cmd (line 49) | def cmd(

FILE: build/fbcode_builder/getdeps/test/expr_test.py
  class ExprTest (line 14) | class ExprTest(unittest.TestCase):
    method test_equal (line 15) | def test_equal(self) -> None:
    method test_not_equal (line 22) | def test_not_equal(self) -> None:
    method test_bad_not (line 28) | def test_bad_not(self) -> None:
    method test_bad_variable (line 33) | def test_bad_variable(self) -> None:
    method test_all (line 38) | def test_all(self) -> None:
    method test_any (line 45) | def test_any(self) -> None:

FILE: build/fbcode_builder/getdeps/test/manifest_test.py
  class ManifestTest (line 16) | class ManifestTest(unittest.TestCase):
    method test_missing_section (line 17) | def test_missing_section(self) -> None:
    method test_missing_name (line 23) | def test_missing_name(self) -> None:
    method test_minimal (line 35) | def test_minimal(self) -> None:
    method test_minimal_with_fbsource_path (line 46) | def test_minimal_with_fbsource_path(self) -> None:
    method test_unknown_field (line 58) | def test_unknown_field(self) -> None:
    method test_invalid_section_name (line 75) | def test_invalid_section_name(self) -> None:
    method test_value_in_dependencies_section (line 90) | def test_value_in_dependencies_section(self) -> None:
    method test_invalid_conditional_section_name (line 110) | def test_invalid_conditional_section_name(self) -> None:
    method test_section_as_args (line 129) | def test_section_as_args(self) -> None:
    method test_section_as_dict (line 169) | def test_section_as_dict(self) -> None:
    method test_parse_common_manifests (line 207) | def test_parse_common_manifests(self) -> None:
    method test_mismatch_name (line 213) | def test_mismatch_name(self) -> None:
    method test_duplicate_manifest (line 226) | def test_duplicate_manifest(self) -> None:
    method assertRaisesRegex (line 235) | def assertRaisesRegex(self, *args, **kwargs):

FILE: build/fbcode_builder/getdeps/test/platform_test.py
  class PlatformTest (line 14) | class PlatformTest(unittest.TestCase):
    method test_create (line 15) | def test_create(self) -> None:
    method test_rendering_of_none (line 23) | def test_rendering_of_none(self) -> None:
    method test_is_methods (line 27) | def test_is_methods(self) -> None:

FILE: build/fbcode_builder/getdeps/test/retry_test.py
  class RetryTest (line 18) | class RetryTest(unittest.TestCase):
    method _get_build_opts (line 19) | def _get_build_opts(self) -> BuildOptions:
    method _get_manifest (line 24) | def _get_manifest(self) -> ManifestParser:
    method _get_archive_fetcher (line 29) | def _get_archive_fetcher(self) -> ArchiveFetcher:
    method test_no_retries (line 41) | def test_no_retries(
    method test_retries (line 77) | def test_retries(
    method test_all_retries (line 124) | def test_all_retries(

FILE: build/fbcode_builder/getdeps/test/scratch_test.py
  class Win32SubstTest (line 14) | class Win32SubstTest(unittest.TestCase):
    method test_no_existing_subst (line 15) | def test_no_existing_subst(self) -> None:
    method test_exact_match_returns_drive_path (line 29) | def test_exact_match_returns_drive_path(self) -> None:
    method test_multiple_exact_matches_returns_arbitrary_drive_path (line 45) | def test_multiple_exact_matches_returns_arbitrary_drive_path(self) -> ...
    method test_drive_letter_is_case_insensitive (line 58) | def test_drive_letter_is_case_insensitive(self) -> None:
    method test_path_components_are_case_insensitive (line 67) | def test_path_components_are_case_insensitive(self) -> None:

FILE: build/fbcode_builder/getdeps/test/strip_marker_test.py
  class ManifestStripMarkerTest (line 17) | class ManifestStripMarkerTest(unittest.TestCase):
    method test_default_strip_marker (line 18) | def test_default_strip_marker(self) -> None:
    method test_custom_strip_marker (line 28) | def test_custom_strip_marker(self) -> None:
  class FilterStripMarkerTest (line 40) | class FilterStripMarkerTest(unittest.TestCase):
    method _write_temp (line 41) | def _write_temp(self, content: str) -> str:
    method _read (line 48) | def _read(self, path: str) -> str:
    method test_single_line_removal (line 52) | def test_single_line_removal(self) -> None:
    method test_block_removal (line 60) | def test_block_removal(self) -> None:
    method test_no_marker_present_no_change (line 76) | def test_no_marker_present_no_change(self) -> None:
    method test_custom_marker_single_line (line 85) | def test_custom_marker_single_line(self) -> None:
    method test_custom_marker_block (line 94) | def test_custom_marker_block(self) -> None:
    method test_custom_marker_ignores_default (line 109) | def test_custom_marker_ignores_default(self) -> None:
    method test_mixed_single_and_block (line 119) | def test_mixed_single_and_block(self) -> None:
    method test_marker_with_regex_metacharacters (line 136) | def test_marker_with_regex_metacharacters(self) -> None:
    method test_binary_file_skipped (line 147) | def test_binary_file_skipped(self) -> None:

FILE: proxygen/external/http_parser/http_parser.h
  type __int8 (line 32) | typedef __int8 int8_t;
  type __int16 (line 34) | typedef __int16 int16_t;
  type __int32 (line 36) | typedef __int32 int32_t;
  type __int64 (line 38) | typedef __int64 int64_t;
  function namespace (line 45) | namespace proxygen {

FILE: proxygen/external/http_parser/http_parser_cpp.cpp
  type proxygen (line 33) | namespace proxygen {
  type state (line 281) | enum state
  type header_states (line 369) | enum header_states
  type http_host_state (line 388) | enum http_host_state
  function parse_url_char (line 478) | static enum state
  function http_parser_execute (line 630) | size_t http_parser_execute (http_parser *parser,
  function http_parser_execute_options (line 638) | size_t http_parser_execute_options (http_parser *parser,
  type http_method (line 2190) | enum http_method
  function http_parser_init (line 2196) | void
  type http_errno (line 2211) | enum http_errno
  type http_errno (line 2217) | enum http_errno
  function http_parse_host_char (line 2223) | static enum http_host_state
  function http_parse_host (line 2296) | static int
  function http_parser_parse_url (line 2370) | int
  function http_parser_parse_url_options (line 2377) | int
  function http_parser_pause (line 2495) | void

FILE: proxygen/external/http_parser/test.c
  type message (line 43) | struct message {
  type message (line 76) | struct message
  type message (line 81) | struct message
  type message (line 794) | struct message
  type message (line 1141) | struct message
  function request_url_cb (line 1206) | int
  function header_field_cb (line 1214) | int
  function header_value_cb (line 1230) | int
  function body_cb (line 1248) | int
  function count_body_cb (line 1258) | int
  function message_begin_cb (line 1267) | int
  function headers_complete_cb (line 1275) | int
  function message_complete_cb (line 1288) | int
  function response_reason_cb (line 1300) | int
  function chunk_header_cb (line 1308) | int
  function chunk_complete_cb (line 1326) | int
  function dontcall_message_begin_cb (line 1336) | int
  function dontcall_header_field_cb (line 1344) | int
  function dontcall_header_value_cb (line 1352) | int
  function dontcall_request_url_cb (line 1360) | int
  function dontcall_body_cb (line 1368) | int
  function dontcall_headers_complete_cb (line 1376) | int
  function dontcall_message_complete_cb (line 1385) | int
  function dontcall_response_reason_cb (line 1394) | int
  function dontcall_chunk_header_cb (line 1402) | int
  function dontcall_chunk_complete_cb (line 1410) | int
  function pause_message_begin_cb (line 1436) | int
  function pause_header_field_cb (line 1444) | int
  function pause_header_value_cb (line 1452) | int
  function pause_request_url_cb (line 1460) | int
  function pause_body_cb (line 1468) | int
  function pause_headers_complete_cb (line 1476) | int
  function pause_message_complete_cb (line 1484) | int
  function pause_response_reason_cb (line 1492) | int
  function pause_chunk_header_cb (line 1500) | int
  function pause_chunk_complete_cb (line 1508) | int
  function empty_cb (line 1516) | int empty_cb (http_parser *p) { return 0; }
  function empty_data_cb (line 1517) | int empty_data_cb (http_parser *p, const char *buf, size_t len) { return...
  function parser_init (line 1571) | void
  function parser_free (line 1588) | void
  function parse (line 1596) | size_t parse (const char *buf, size_t len)
  function parse_count_body (line 1605) | size_t parse_count_body (const char *buf, size_t len)
  function parse_pause (line 1614) | size_t parse_pause (const char *buf, size_t len)
  function check_str_eq (line 1626) | static inline int
  function check_num_eq (line 1646) | static inline int
  function message_eq (line 1667) | int
  function count_parsed_messages (line 1722) | size_t
  function upgrade_message_fix (line 1745) | void
  function print_error (line 1782) | static void
  type url_test (line 1826) | struct url_test {
  type url_test (line 1834) | struct url_test
  function dump_url (line 2316) | void
  function test_parse_url (line 2337) | void
  function test_message (line 2392) | void
  function test_message_count_body (line 2452) | void
  type http_errno (line 2489) | enum http_errno
  type http_errno (line 2495) | enum http_errno
  function test_lax_in_strict_mode (line 2523) | void
  function test_no_overflow_parse_url (line 2555) | void
  function test_header_overflow_error (line 2578) | void
  function test_no_overflow_long_body (line 2608) | void
  function test_multiple3 (line 2644) | void
  function test_scan (line 2701) | void
  function test_message_pause (line 2850) | void
  function test_on_message_begin_cb (line 2903) | void
  function main (line 2913) | int

FILE: proxygen/httpclient/samples/H3Datagram/H3DatagramClient.cpp
  class DatagramClient (line 55) | class DatagramClient
    method DatagramClient (line 63) | explicit DatagramClient(folly::EventBase* evb, H3DatagramAsyncSocket& ...
    method start (line 67) | void start() {
    method shutdown (line 81) | void shutdown() {
    method sendPing (line 88) | void sendPing() {
    method writePing (line 98) | virtual void writePing(std::unique_ptr<folly::IOBuf> buf) {
    method getReadBuffer (line 107) | void getReadBuffer(void** buf, size_t* len) noexcept override {
    method onDataAvailable (line 112) | void onDataAvailable(const folly::SocketAddress& client,
    method onReadError (line 139) | void onReadError(const folly::AsyncSocketException& ex) noexcept overr...
    method onReadClosed (line 143) | void onReadClosed() noexcept override {
    method timeoutExpired (line 147) | void timeoutExpired() noexcept override {
  function main (line 164) | int main(int argc, char* argv[]) {

FILE: proxygen/httpclient/samples/curl/CurlClient.cpp
  type CurlService (line 30) | namespace CurlService {
    type stat (line 67) | struct stat
    function HTTPHeaders (line 82) | HTTPHeaders CurlClient::parseHeaders(const std::string& headersString) {
    function string (line 313) | const string& CurlClient::getServerName() const {

FILE: proxygen/httpclient/samples/curl/CurlClient.h
  function detachTransaction (line 32) | void detachTransaction() noexcept override;
  function onUpgrade (line 47) | void onUpgrade(proxygen::UpgradeProtocol /*protocol*/) noexcept override {
  function onEgressResumed (line 50) | void onEgressResumed() noexcept override {
  function onEgressPaused (line 53) | void onEgressPaused() noexcept override {
  function detachTransaction (line 98) | void detachTransaction() noexcept override;
  function std (line 119) | const std::string& getServerName() const;
  function setHeadersLogging (line 131) | void setHeadersLogging(bool enabled) {
  function setEOMFunc (line 135) | void setEOMFunc(std::function<void()> eomFunc) {
  function setOnBodyFunc (line 139) | void setOnBodyFunc(
  function recvWindow_ (line 161) | int32_t recvWindow_{0}
  function h2c_ (line 164) | bool h2c_{false};

FILE: proxygen/httpclient/samples/curl/CurlClientMain.cpp
  function main (line 52) | int main(int argc, char* argv[]) {

FILE: proxygen/httpclient/samples/httperf2/Client.cpp
  function createTransportSettings (line 182) | static quic::TransportSettings createTransportSettings() {
  type linger (line 383) | struct linger

FILE: proxygen/httpclient/samples/httperf2/Client.h
  function setTransaction (line 103) | void setTransaction(proxygen::HTTPTransaction* txn) noexcept override {
  function detachTransaction (line 106) | void detachTransaction() noexcept override;
  function onChunkComplete (line 116) | void onChunkComplete() noexcept override {
  function onEOM (line 122) | void onEOM() noexcept override;
  function onEgressResumed (line 131) | void onEgressResumed() noexcept override {
  function class (line 143) | class InfoCollector : public ::proxygen::HTTPSession::InfoCallback {
  function outstandingTransactions_ (line 158) | uint32_t outstandingTransactions_{0}

FILE: proxygen/httpclient/samples/httperf2/HTTPerf2.cpp
  class ClientRunner (line 119) | class ClientRunner
  type proxygen (line 174) | namespace proxygen {
    function httperf2 (line 175) | int httperf2(folly::Optional<folly::SocketAddress> bindAddress,

FILE: proxygen/httpclient/samples/httperf2/HTTPerf2.h
  function namespace (line 20) | namespace proxygen {

FILE: proxygen/httpclient/samples/httperf2/HTTPerfStats.h
  function class (line 19) | class HTTPerfStats {
  function addConnection (line 65) | void addConnection(uint32_t connLat) {
  function addHandshake (line 70) | void addHandshake() {
  function addResume (line 74) | void addResume() {
  function addRequest (line 78) | void addRequest() {
  function addResponse (line 82) | void addResponse(uint32_t reqLat) {
  function addErrorLat (line 87) | void addErrorLat(uint32_t reqLat) {
  function addResponseCode (line 91) | void addResponseCode(uint32_t code) {
  function addBytesReceived (line 107) | void addBytesReceived(uint32_t count) {
  function addConnectError (line 111) | void addConnectError() {
  function addWriteError (line 115) | void addWriteError() {
  function addMessageError (line 119) | void addMessageError() {
  function addTimeoutError (line 123) | void addTimeoutError() {
  function addEOFResponse (line 127) | void addEOFResponse() {
  function addEOFError (line 131) | void addEOFError() {
  function merge (line 135) | void merge(const HTTPerfStats& stats) {

FILE: proxygen/httpclient/samples/httperf2/Main.cpp
  function main (line 13) | int main(int argc, char* argv[]) {

FILE: proxygen/httpclient/samples/websocket/WebSocketClient.cpp
  type websocketclient (line 19) | namespace websocketclient {

FILE: proxygen/httpclient/samples/websocket/WebSocketClient.h
  function namespace (line 16) | namespace websocketclient {

FILE: proxygen/httpclient/samples/websocket/main.cpp
  function main (line 28) | int main(int argc, char* argv[]) {

FILE: proxygen/httpserver/Filters.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/httpserver/HTTPServer.cpp
  type proxygen (line 25) | namespace proxygen {
    class AcceptorFactory (line 27) | class AcceptorFactory : public wangle::AcceptorFactory {
      method AcceptorFactory (line 29) | AcceptorFactory(std::shared_ptr<HTTPServerOptions> options,
      method newAcceptor (line 38) | std::shared_ptr<wangle::Acceptor> newAcceptor(
    class HandlerCallbacks (line 102) | class HandlerCallbacks : public IOThreadPoolExecutorBase::IOObserver {
      method HandlerCallbacks (line 104) | explicit HandlerCallbacks(std::shared_ptr<HTTPServerOptions> options)
      method registerEventBase (line 108) | void registerEventBase(folly::EventBase& evb) noexcept override {
      method unregisterEventBase (line 116) | void unregisterEventBase(folly::EventBase& evb) noexcept override {

FILE: proxygen/httpserver/HTTPServer.h
  function namespace (line 22) | namespace proxygen {

FILE: proxygen/httpserver/HTTPServerAcceptor.cpp
  type proxygen (line 19) | namespace proxygen {
    function HTTPTransactionHandler (line 91) | HTTPTransactionHandler* HTTPServerAcceptor::newHandler(

FILE: proxygen/httpserver/HTTPServerAcceptor.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/httpserver/HTTPServerOptions.h
  function zstdContentCompressionLevel (line 159) | int zstdContentCompressionLevel{8}
  function useExistingSocket (line 194) | void useExistingSocket(folly::AsyncServerSocket::UniquePtr socket) {
  function useExistingSocket (line 198) | void useExistingSocket(int socketFd) {

FILE: proxygen/httpserver/HTTPTransactionHandlerAdaptor.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/httpserver/Mocks.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/httpserver/PushHandler.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/httpserver/RequestHandler.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/httpserver/RequestHandlerAdaptor.cpp
  type proxygen (line 16) | namespace proxygen {

FILE: proxygen/httpserver/RequestHandlerAdaptor.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/httpserver/RequestHandlerFactory.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/httpserver/ResponseBuilder.h
  function sendWithEOM (line 135) | void sendWithEOM() {
  function send (line 140) | void send() {
  type class (line 192) | enum class
  function sendEOM_ (line 235) | bool sendEOM_{false};

FILE: proxygen/httpserver/ResponseHandler.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/httpserver/ScopedHTTPServer.h
  function namespace (line 18) | namespace proxygen {
  function std (line 192) | inline std::unique_ptr<ScopedHTTPServer> ScopedHTTPServer::start(

FILE: proxygen/httpserver/SignalHandler.cpp
  type proxygen (line 16) | namespace proxygen {

FILE: proxygen/httpserver/SignalHandler.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/httpserver/filters/CompressionFilter.h
  function sendHeaders (line 35) | void sendHeaders(HTTPMessage& msg) noexcept override {
  function sendChunkHeader (line 64) | void sendChunkHeader(size_t len) noexcept override {
  function sendBody (line 79) | void sendBody(std::unique_ptr<folly::IOBuf> body) noexcept override {
  function sendEOM (line 115) | void sendEOM() noexcept override {
  function chunked_ (line 145) | bool chunked_{false};

FILE: proxygen/httpserver/filters/DecompressionFilter.cpp
  type proxygen (line 13) | namespace proxygen {
    function RequestHandler (line 63) | RequestHandler* DecompressionFilterFactory::onRequest(

FILE: proxygen/httpserver/filters/DecompressionFilter.h
  function namespace (line 15) | namespace proxygen {
  function class (line 48) | class DecompressionFilterFactory : public RequestHandlerFactory {

FILE: proxygen/httpserver/filters/DirectResponseHandler.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/httpserver/filters/RejectConnectFilter.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/httpserver/filters/tests/CompressionFilterTest.cpp
  type ZlibTest (line 37) | struct ZlibTest {
    method makeDecompressor (line 38) | static std::unique_ptr<StreamDecompressor> makeDecompressor() {
    method getExpectedEncoding (line 41) | static std::string getExpectedEncoding() {
    method getCompressionLevel (line 44) | static int32_t getCompressionLevel() {
  type ZstdTest (line 49) | struct ZstdTest {
    method makeDecompressor (line 50) | static std::unique_ptr<StreamDecompressor> makeDecompressor() {
    method getExpectedEncoding (line 53) | static std::string getExpectedEncoding() {
    method getCompressionLevel (line 56) | static int32_t getCompressionLevel() {
  class CompressionFilterTest (line 62) | class CompressionFilterTest : public Test {
    method SetUp (line 66) | void SetUp() override {
    method TearDown (line 73) | void TearDown() override {
    method exercise_compression (line 87) | void exercise_compression(bool expectCompression,
    method createResponseChain (line 245) | std::unique_ptr<folly::IOBuf> createResponseChain(
  function TYPED_TEST (line 268) | TYPED_TEST(CompressionFilterTest, NonchunkedCompression) {
  function TYPED_TEST (line 281) | TYPED_TEST(CompressionFilterTest, ChunkedCompression) {
  function TYPED_TEST (line 295) | TYPED_TEST(CompressionFilterTest, ParameterizedContenttype) {
  function TYPED_TEST (line 308) | TYPED_TEST(CompressionFilterTest, MixedcaseContenttype) {
  function TYPED_TEST (line 322) | TYPED_TEST(CompressionFilterTest, MultipleAcceptedEncodings) {
  function TYPED_TEST (line 337) | TYPED_TEST(CompressionFilterTest, ResponseAlreadyCompressedTest) {
  function TYPED_TEST (line 356) | TYPED_TEST(CompressionFilterTest, MultipleAcceptedEncodingsQvalues) {
  function TYPED_TEST (line 370) | TYPED_TEST(CompressionFilterTest, NoCompressibleAcceptedEncodings) {
  function TYPED_TEST (line 382) | TYPED_TEST(CompressionFilterTest, MissingAcceptedEncodings) {
  function TYPED_TEST (line 395) | TYPED_TEST(CompressionFilterTest, UncompressibleContenttype) {
  function TYPED_TEST (line 408) | TYPED_TEST(CompressionFilterTest, UncompressibleContenttypeParam) {
  function TYPED_TEST (line 422) | TYPED_TEST(CompressionFilterTest, TooSmallToCompress) {
  function TYPED_TEST (line 437) | TYPED_TEST(CompressionFilterTest, SmallChunksCompress) {
  function TYPED_TEST (line 455) | TYPED_TEST(CompressionFilterTest, MinimumCompressSizeEqualToRequestSize) {
  function TYPED_TEST (line 471) | TYPED_TEST(CompressionFilterTest, CompressionDisabledForEncoding) {
  function TYPED_TEST (line 488) | TYPED_TEST(CompressionFilterTest, NoResponseBody) {

FILE: proxygen/httpserver/filters/tests/DecompressionFilterTest.cpp
  function compressWithZstd (line 22) | std::unique_ptr<folly::IOBuf> compressWithZstd(const std::string& data) {
  class DecompressionFilterTest (line 30) | class DecompressionFilterTest : public Test {
    method SetUp (line 32) | void SetUp() override {
    method TearDown (line 37) | void TearDown() override {
  function TEST_F (line 54) | TEST_F(DecompressionFilterTest, ZstdContentEncodingInitializesDecompress...
  function TEST_F (line 86) | TEST_F(DecompressionFilterTest, NoContentEncodingPassesThrough) {
  function TEST_F (line 109) | TEST_F(DecompressionFilterTest, ValidZstdBodyDecompression) {
  function TEST_F (line 154) | TEST_F(DecompressionFilterTest, MultipleChunksDecompression) {
  function TEST_F (line 200) | TEST_F(DecompressionFilterTest, InvalidCompressedDataSendsAbort) {
  function TEST_F (line 230) | TEST_F(DecompressionFilterTest, PassThroughWithoutDecompressor) {
  function TEST_F (line 271) | TEST_F(DecompressionFilterTest, ContentLengthRemovedWhenDecompressing) {
  function TEST_F (line 297) | TEST_F(DecompressionFilterTest, UnsupportedEncodingPassesThrough) {
  function TEST_F (line 328) | TEST_F(DecompressionFilterTest, EOMPassThroughWithoutDecompressor) {
  function TEST_F (line 348) | TEST_F(DecompressionFilterTest, EmptyBodyWithZstdEncoding) {
  function TEST_F (line 370) | TEST_F(DecompressionFilterTest, FactoryCreatesFilterForZstd) {
  function TEST_F (line 391) | TEST_F(DecompressionFilterTest, FactoryCreatesFilterForNonZstd) {
  function TEST_F (line 411) | TEST_F(DecompressionFilterTest, FactoryCreatesFilterForGzip) {
  function TEST_F (line 432) | TEST_F(DecompressionFilterTest, LargeDataDecompression) {

FILE: proxygen/httpserver/samples/echo/EchoHandler.cpp
  type EchoService (line 23) | namespace EchoService {

FILE: proxygen/httpserver/samples/echo/EchoHandler.h
  function namespace (line 14) | namespace proxygen {
  function namespace (line 18) | namespace EchoService {

FILE: proxygen/httpserver/samples/echo/EchoServer.cpp
  class EchoHandlerFactory (line 35) | class EchoHandlerFactory : public RequestHandlerFactory {
    method onServerStart (line 37) | void onServerStart(folly::EventBase* /*evb*/) noexcept override {
    method onServerStop (line 41) | void onServerStop() noexcept override {
    method RequestHandler (line 45) | RequestHandler* onRequest(RequestHandler*, HTTPMessage*) noexcept over...
  function main (line 53) | int main(int argc, char* argv[]) {

FILE: proxygen/httpserver/samples/echo/EchoStats.h
  function namespace (line 13) | namespace EchoService {

FILE: proxygen/httpserver/samples/echo/test/EchoHandlerTest.cpp
  class MockEchoStats (line 20) | class MockEchoStats : public EchoStats {
  class EchoHandlerFixture (line 26) | class EchoHandlerFixture : public testing::Test {
    method SetUp (line 28) | void SetUp() override {
    method TearDown (line 34) | void TearDown() override {
  function TEST_F (line 49) | TEST_F(EchoHandlerFixture, OnProperRequestSendsResponse) {
  function TEST_F (line 67) | TEST_F(EchoHandlerFixture, ReplaysBodyProperly) {

FILE: proxygen/httpserver/samples/hq/ConnIdLogger.h
  function namespace (line 22) | namespace proxygen {
  function std (line 117) | const std::chrono::seconds kMaxAge{60};

FILE: proxygen/httpserver/samples/hq/FizzContext.cpp
  function createFizzServerContextImpl (line 143) | quic::samples::FizzServerContextPtr createFizzServerContextImpl(
  type quic::samples (line 202) | namespace quic::samples {
    function FizzServerContextPtr (line 204) | FizzServerContextPtr createFizzServerContext(
    function FizzServerContextPtr (line 213) | FizzServerContextPtr createFizzServerContextWithInsecureDefault(
    function FizzClientContextPtr (line 222) | FizzClientContextPtr createFizzClientContext(
    function createSSLContext (line 254) | wangle::SSLContextConfig createSSLContext(

FILE: proxygen/httpserver/samples/hq/FizzContext.h
  function namespace (line 18) | namespace quic::samples {

FILE: proxygen/httpserver/samples/hq/H1QDownstreamSession.h
  function onNewBidirectionalStream (line 38) | void onNewBidirectionalStream(quic::StreamId id) noexcept override {
  function onNewUnidirectionalStream (line 73) | void onNewUnidirectionalStream(quic::StreamId id) noexcept override {
  function onStopSending (line 80) | void onStopSending(quic::StreamId,
  function onConnectionEnd (line 83) | void onConnectionEnd() noexcept override {
  function onConnectionError (line 87) | void onConnectionError(quic::QuicError) noexcept override {
  function onConnectionEnd (line 91) | void onConnectionEnd(quic::QuicError /* error */) noexcept override {

FILE: proxygen/httpserver/samples/hq/H1QUpstreamSession.h
  function namespace (line 18) | namespace quic::samples {
  function onDestroy (line 71) | void onDestroy(const proxygen::HTTPSessionBase& session) override {
  function drain (line 78) | void drain() {
  function onNewBidirectionalStream (line 85) | void onNewBidirectionalStream(quic::StreamId id) noexcept override {
  function onNewUnidirectionalStream (line 93) | void onNewUnidirectionalStream(quic::StreamId id) noexcept override {
  function onStopSending (line 100) | void onStopSending(quic::StreamId,
  function onConnectionEnd (line 103) | void onConnectionEnd() noexcept override {
  function onConnectionError (line 108) | void onConnectionError(quic::QuicError) noexcept override {
  function onConnectionEnd (line 112) | void onConnectionEnd(quic::QuicError /* error */) noexcept override {

FILE: proxygen/httpserver/samples/hq/H2Server.cpp
  type quic::samples (line 14) | namespace quic::samples {
    function RequestHandler (line 31) | RequestHandler* H2Server::SampleHandlerFactory::onRequest(

FILE: proxygen/httpserver/samples/hq/H2Server.h
  function namespace (line 15) | namespace quic::samples {

FILE: proxygen/httpserver/samples/hq/HQClient.cpp
  type quic::samples (line 31) | namespace quic::samples {
    function startClient (line 363) | int startClient(const HQToolClientParams& params) {

FILE: proxygen/httpserver/samples/hq/HQClient.h
  function setOnBodyFunc (line 38) | void setOnBodyFunc(
  function onTransportReady (line 47) | void onTransportReady() noexcept override;
  function H1QUpstreamSession (line 108) | H1QUpstreamSession* h1qSession_{nullptr};

FILE: proxygen/httpserver/samples/hq/HQCommandLine.cpp
  type quic::samples (line 163) | namespace quic::samples {
    function initializeCommonSettings (line 192) | void initializeCommonSettings(HQToolParams& hqParams) {
    function initializeTransportSettings (line 221) | void initializeTransportSettings(HQToolParams& hqUberParams) {
    function initializeHttpServerSettings (line 342) | void initializeHttpServerSettings(HQToolServerParams& hqParams) {
    function initializeHttpClientSettings (line 359) | void initializeHttpClientSettings(HQToolClientParams& hqParams) {
    function initializeQLogSettings (line 400) | void initializeQLogSettings(HQBaseParams& hqParams) {
    function initializeFizzSettings (line 405) | void initializeFizzSettings(HQToolParams& toolParams) {
    function HQInvalidParams (line 427) | HQInvalidParams validate(const HQToolParams& params) {
    function HQInvalidParams (line 537) | const HQInvalidParams& HQToolParamsBuilderFromCmdline::invalidParams()
    function HQToolParams (line 542) | HQToolParams HQToolParamsBuilderFromCmdline::build() noexcept {
    function initializeParamsFromCmdline (line 546) | const folly::Expected<HQToolParams, HQInvalidParams>

FILE: proxygen/httpserver/samples/hq/HQCommandLine.h
  type class (line 17) | enum class
  type HQToolClientParams (line 21) | struct HQToolClientParams
  function migrateClient (line 37) | bool migrateClient{false};
  type HQToolServerParams (line 44) | struct HQToolServerParams
  function useInsecureDefaultCertificate (line 58) | bool useInsecureDefaultCertificate{false};
  function HQBaseParams (line 72) | [[nodiscard]] const HQBaseParams& baseParams() const {
  function else (line 75) | else if (mode == HQMode::SERVER) {
  function HQMode (line 90) | HQMode mode{HQMode::INVALID};
  function valid (line 108) | [[nodiscard]] bool valid() const noexcept;

FILE: proxygen/httpserver/samples/hq/HQLoggerHelper.h
  function namespace (line 20) | namespace quic::samples {

FILE: proxygen/httpserver/samples/hq/HQParams.cpp
  type quic::samples (line 11) | namespace quic::samples {

FILE: proxygen/httpserver/samples/hq/HQParams.h
  type HTTPVersion (line 29) | struct HTTPVersion {
  function major (line 32) | uint16_t major{1}
  function minor (line 33) | uint16_t minor{1}
  type HQBaseParams (line 50) | struct HQBaseParams {
  function prettyJson (line 75) | bool prettyJson{false};
  function HQBaseParams (line 81) | struct HQServerParams : public HQBaseParams {
  function HQBaseParams (line 90) | struct HQClientParams : public HQBaseParams {
  type HQInvalidParam (line 99) | struct HQInvalidParam {

FILE: proxygen/httpserver/samples/hq/HQServer.cpp
  class HQSessionController (line 43) | class HQSessionController
    method onTransportReady (line 77) | void onTransportReady(const proxygen::HTTPSessionBase&) override {
  function HTTPTransactionHandler (line 107) | HTTPTransactionHandler* HQSessionController::getRequestHandler(
  type quic::samples (line 138) | namespace quic::samples {
    function TakeoverProtocolVersion (line 377) | TakeoverProtocolVersion HQServer::getTakeoverProtocolVersion() const {

FILE: proxygen/httpserver/samples/hq/HQServer.h
  function namespace (line 22) | namespace proxygen {
  function namespace (line 26) | namespace quic::samples {

FILE: proxygen/httpserver/samples/hq/HQServerModule.cpp
  function sendKnobFrame (line 19) | void sendKnobFrame(HQSession* session, const folly::StringPiece str) {
  type quic::samples (line 38) | namespace quic::samples {
    function startServer (line 40) | void startServer(

FILE: proxygen/httpserver/samples/hq/HQServerModule.h
  function namespace (line 13) | namespace quic::samples {

FILE: proxygen/httpserver/samples/hq/InsecureVerifierDangerousDoNotUseInProduction.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/httpserver/samples/hq/SampleHandlers.cpp
  type quic::samples (line 24) | namespace quic::samples {
    function HTTPTransactionHandler (line 28) | HTTPTransactionHandler* Dispatcher::getRequestHandler(HTTPMessage* msg) {
    class WaitReleaseHandler (line 85) | class WaitReleaseHandler
    class ServerPushHandler (line 156) | class ServerPushHandler

FILE: proxygen/httpserver/samples/hq/SampleHandlers.h
  type HandlerParams (line 45) | struct HandlerParams {
  function explicit (line 75) | explicit BaseSampleHandler(const HandlerParams& params) : params_(params) {
  function setTransaction (line 78) | void setTransaction(proxygen::HTTPTransaction* txn) noexcept override {
  function detachTransaction (line 82) | void detachTransaction() noexcept override {
  function onChunkHeader (line 86) | void onChunkHeader(size_t /*length*/) noexcept override {
  function onChunkComplete (line 89) | void onChunkComplete() noexcept override {
  function onTrailers (line 92) | void onTrailers(
  function onUpgrade (line 96) | void onUpgrade(proxygen::UpgradeProtocol /*protocol*/) noexcept override {
  function onEgressPaused (line 99) | void onEgressPaused() noexcept override {
  function onEgressResumed (line 102) | void onEgressResumed() noexcept override {
  function maybeAddAltSvcHeader (line 105) | void maybeAddAltSvcHeader(proxygen::HTTPMessage& msg) const {
  function std (line 115) | static const std::string& getH1QFooter() {
  function getQueryParamAsNumber (line 152) | static uint32_t getQueryParamAsNumber(
  function onHeadersComplete (line 196) | void onHeadersComplete(
  function onBody (line 213) | void onBody(std::unique_ptr<folly::IOBuf> chain) noexcept override {
  function onEOM (line 216) | void onEOM() noexcept override {
  function onError (line 221) | void onError(const proxygen::HTTPException& /*error*/) noexcept override {
  function sendChunkRandomData (line 237) | void sendChunkRandomData(uint32_t chunkSize) {
  function sleepFutureCallback (line 248) | void sleepFutureCallback() {
  function totalChunkCount_ (line 272) | uint32_t totalChunkCount_{60};
  function onBody (line 428) | void onBody(std::unique_ptr<folly::IOBuf> /*chain*/) noexcept override {
  function onEOM (line 433) | void onEOM() noexcept override {
  function onError (line 437) | void onError(const proxygen::HTTPException& /*error*/) noexcept override {
  function onEgressPaused (line 442) | void onEgressPaused() noexcept override {
  function onEgressResumed (line 446) | void onEgressResumed() noexcept override {
  function sendError (line 495) | void sendError(const std::string& errorMsg) {
  function kMaxAllowedLength (line 507) | const uint64_t kMaxAllowedLength{1ULL * 1024 * 1024 * 1024}; // 1 GB

FILE: proxygen/httpserver/samples/hq/devious/DeviousBaton.cpp
  function makeBatonMessage (line 17) | std::unique_ptr<folly::IOBuf> makeBatonMessage(uint64_t padLen, uint8_t ...
  type devious (line 35) | namespace devious {
    function HTTPMessage (line 94) | HTTPMessage DeviousBaton::makeRequest(uint64_t version,

FILE: proxygen/httpserver/samples/hq/devious/DeviousBaton.h
  type class (line 18) | enum class
  function BatonStreamError (line 26) | enum class BatonStreamError {

FILE: proxygen/httpserver/samples/hq/devious/test/DeviousBatonTests.cpp
  type Message (line 20) | struct Message {
  function expectSendMessage (line 24) | folly::SemiFuture<Message> expectSendMessage(MockWebTransport& wt) {
  class DeviousBatonTest (line 49) | class DeviousBatonTest : public testing::TestWithParam<uint8_t> {}
  function TEST_P (line 51) | TEST_P(DeviousBatonTest, Basic) {

FILE: proxygen/httpserver/samples/hq/main.cpp
  function main (line 22) | int main(int argc, char* argv[]) {

FILE: proxygen/httpserver/samples/masque/MasqueClient.cpp
  function resolveAddress (line 49) | folly::SocketAddress resolveAddress(const std::string& host,
  class MasqueInteropClient (line 76) | class MasqueInteropClient
    method MasqueInteropClient (line 84) | explicit MasqueInteropClient(folly::EventBase* evb,
    method start (line 93) | void start() {
    method exitCode (line 117) | [[nodiscard]] int exitCode() const {
    method sendPayload (line 122) | void sendPayload() {
    method timeoutExpired (line 139) | void timeoutExpired() noexcept override {
    method getReadBuffer (line 145) | void getReadBuffer(void** buf, size_t* len) noexcept override {
    method onDataAvailable (line 150) | void onDataAvailable(const folly::SocketAddress& /*client*/,
    method onReadError (line 177) | void onReadError(const folly::AsyncSocketException& ex) noexcept overr...
    method onReadClosed (line 186) | void onReadClosed() noexcept override {
  function main (line 208) | int main(int argc, char* argv[]) {

FILE: proxygen/httpserver/samples/proxy/ProxyHandler.cpp
  type ProxyService (line 36) | namespace ProxyService {

FILE: proxygen/httpserver/samples/proxy/ProxyHandler.h
  function namespace (line 18) | namespace proxygen {
  function namespace (line 22) | namespace ProxyService {

FILE: proxygen/httpserver/samples/proxy/ProxyServer.cpp
  class ProxyHandlerFactory (line 38) | class ProxyHandlerFactory : public RequestHandlerFactory {
    method onServerStart (line 40) | void onServerStart(folly::EventBase* evb) noexcept override {
    method onServerStop (line 49) | void onServerStop() noexcept override {
    method RequestHandler (line 54) | RequestHandler* onRequest(RequestHandler*, HTTPMessage*) noexcept over...
    type TimerWrapper (line 59) | struct TimerWrapper {
  function main (line 66) | int main(int argc, char* argv[]) {

FILE: proxygen/httpserver/samples/proxy/ProxyStats.h
  function namespace (line 13) | namespace ProxyService {

FILE: proxygen/httpserver/samples/proxy/SessionWrapper.h
  function namespace (line 13) | namespace ProxyService {

FILE: proxygen/httpserver/samples/push/PushRequestHandler.cpp
  type PushService (line 19) | namespace PushService {
    function createLargeBody (line 25) | std::string createLargeBody() {

FILE: proxygen/httpserver/samples/push/PushRequestHandler.h
  function namespace (line 14) | namespace proxygen {
  function onEOM (line 31) | void onEOM() noexcept override;

FILE: proxygen/httpserver/samples/push/PushServer.cpp
  class PushRequestHandlerFactory (line 35) | class PushRequestHandlerFactory : public RequestHandlerFactory {
    method onServerStart (line 37) | void onServerStart(folly::EventBase* /*evb*/) noexcept override {
    method onServerStop (line 41) | void onServerStop() noexcept override {
    method RequestHandler (line 45) | RequestHandler* onRequest(RequestHandler*, HTTPMessage*) noexcept over...
  function main (line 53) | int main(int argc, char* argv[]) {

FILE: proxygen/httpserver/samples/push/PushStats.h
  function namespace (line 13) | namespace PushService {

FILE: proxygen/httpserver/samples/static/StaticHandler.cpp
  type StaticService (line 19) | namespace StaticService {

FILE: proxygen/httpserver/samples/static/StaticHandler.h
  function namespace (line 16) | namespace proxygen {
  function namespace (line 20) | namespace StaticService {

FILE: proxygen/httpserver/samples/static/StaticServer.cpp
  class StaticHandlerFactory (line 39) | class StaticHandlerFactory : public RequestHandlerFactory {
    method onServerStart (line 41) | void onServerStart(folly::EventBase* /*evb*/) noexcept override {
    method onServerStop (line 44) | void onServerStop() noexcept override {
    method RequestHandler (line 47) | RequestHandler* onRequest(RequestHandler*, HTTPMessage*) noexcept over...
  function main (line 54) | int main(int argc, char* argv[]) {

FILE: proxygen/httpserver/samples/websocket/WebSocketHandler.cpp
  type websockethandler (line 15) | namespace websockethandler {

FILE: proxygen/httpserver/samples/websocket/WebSocketHandler.h
  function namespace (line 15) | namespace proxygen {
  function namespace (line 19) | namespace websockethandler {

FILE: proxygen/httpserver/samples/websocket/main.cpp
  class WebSocketHandlerFactory (line 35) | class WebSocketHandlerFactory : public RequestHandlerFactory {
    method onServerStart (line 37) | void onServerStart(folly::EventBase* /*evb*/) noexcept override {
    method onServerStop (line 40) | void onServerStop() noexcept override {
    method RequestHandler (line 43) | RequestHandler* onRequest(RequestHandler*, HTTPMessage*) noexcept over...
  function main (line 50) | int main(int argc, char* argv[]) {

FILE: proxygen/httpserver/tests/HTTPServerTest.cpp
  class ServerThread (line 45) | class ServerThread {
    method ServerThread (line 52) | explicit ServerThread(HTTPServer* server) : server_(server) {
    method start (line 61) | bool start() {
  class WaitableServerThread (line 89) | class WaitableServerThread {
    method WaitableServerThread (line 97) | explicit WaitableServerThread(HTTPServer* server) : server_(server) {
    method start (line 107) | bool start(
    method exitThread (line 127) | void exitThread() {
  function TEST (line 132) | TEST(MultiBind, HandlesListenFailures) {
  function TEST (line 167) | TEST(HttpServerStartStop, TestRepeatStopCalls) {
  function TEST (line 180) | TEST(HttpServerStartStop, TestUseExistingIoExecutor) {
  class MockRequestHandlerFactory (line 193) | class MockRequestHandlerFactory : public RequestHandlerFactory {
  function TEST (line 203) | TEST(HttpServerStartStop, TestZeroThreadsMeansNumCPUs) {
  class AcceptorFactoryForTest (line 228) | class AcceptorFactoryForTest : public wangle::AcceptorFactory {
    method newAcceptor (line 230) | std::shared_ptr<wangle::Acceptor> newAcceptor(
  function TEST (line 238) | TEST(HttpServerStartStop, TestUseExistingAcceptorFactory) {
  class Cb (line 253) | class Cb : public folly::AsyncSocket::ConnectCallback {
    method Cb (line 255) | explicit Cb(folly::AsyncSSLSocket* sock) : sock_(sock) {
    method connectSuccess (line 257) | void connectSuccess() noexcept override {
    method connectErr (line 265) | void connectErr(const folly::AsyncSocketException&) noexcept override {
    method X509 (line 269) | const X509* getPeerCert() {
  function getSslContextConfig (line 281) | wangle::SSLContextConfig getSslContextConfig(bool useMultiCA) {
  function TEST (line 298) | TEST(SSL, SSLTest) {
  function TEST (line 324) | TEST(SSL, SSLTestWithMultiCAs) {
  class DummyFilterFactory (line 353) | class DummyFilterFactory : public RequestHandlerFactory {
    class DummyFilter (line 355) | class DummyFilter : public Filter {
      method DummyFilter (line 357) | explicit DummyFilter(RequestHandler* upstream) : Filter(upstream) {
    method RequestHandler (line 361) | RequestHandler* onRequest(RequestHandler* h, HTTPMessage*) noexcept ov...
    method onServerStart (line 365) | void onServerStart(folly::EventBase*) noexcept override {
    method onServerStop (line 367) | void onServerStop() noexcept override {
  class TestHandlerFactory (line 371) | class TestHandlerFactory : public RequestHandlerFactory {
    class TestHandler (line 373) | class TestHandler : public RequestHandler {
      method onRequest (line 374) | void onRequest(std::unique_ptr<HTTPMessage>) noexcept override {
      method onBody (line 376) | void onBody(std::unique_ptr<folly::IOBuf>) noexcept override {
      method onUpgrade (line 378) | void onUpgrade(UpgradeProtocol) noexcept override {
      method onEOM (line 381) | void onEOM() noexcept override {
      method requestComplete (line 399) | void requestComplete() noexcept override {
      method onError (line 403) | void onError(ProxygenError) noexcept override {
    method RequestHandler (line 408) | RequestHandler* onRequest(RequestHandler*, HTTPMessage*) noexcept over...
    method onServerStart (line 412) | void onServerStart(folly::EventBase*) noexcept override {
    method onServerStop (line 414) | void onServerStop() noexcept override {
  function setupServer (line 418) | std::pair<std::unique_ptr<HTTPServer>, std::unique_ptr<ServerThread>>
  function TEST (line 450) | TEST(SSL, TestAllowInsecureOnSecureServer) {
  function TEST (line 476) | TEST(SSL, DisallowInsecureOnSecureServer) {
  type SSLSessionReadCallback (line 510) | struct SSLSessionReadCallback
    method SSLSessionReadCallback (line 513) | SSLSessionReadCallback() {
    method setSSLSession (line 516) | void setSSLSession(
    method getSSLSession (line 525) | [[nodiscard]] folly::ssl::SSLSessionUniquePtr getSSLSession(
    method removeSSLSession (line 529) | bool removeSSLSession(const std::string&) noexcept override {
    method readDataAvailable (line 532) | void readDataAvailable(size_t) noexcept override {
    method getReadBuffer (line 534) | void getReadBuffer(void** buf, size_t* lenReturn) override {
    method readEOF (line 538) | void readEOF() noexcept override {
    method readErr (line 540) | void readErr(const folly::AsyncSocketException&) noexcept override {
  function TEST (line 549) | TEST(SSL, TestResumptionWithTicketsTLS12) {
  function TEST (line 588) | TEST(SSL, TestResumptionWithTickets) {
  function TEST (line 626) | TEST(SSL, TestResumptionAfterUpdateFails) {
  function TEST (line 697) | TEST(SSL, TestUpdateTLSCredentials) {
  function TEST (line 781) | TEST(GetListenSocket, TestNoBootstrap) {
  function TEST (line 791) | TEST(GetListenSocket, TestBootstrapWithNoBinding) {
  function TEST (line 805) | TEST(GetListenSocket, TestBootstrapWithBinding) {
  function TEST (line 816) | TEST(UseExistingSocket, TestWithExistingAsyncServerSocket) {
  function TEST (line 841) | TEST(UseExistingSocket, TestWithSocketFd) {
  function TEST (line 865) | TEST(UseExistingSocket, TestWithMultipleSocketFds) {
  class ScopedServerTest (line 898) | class ScopedServerTest : public testing::Test {
    method SetUp (line 900) | void SetUp() override {
    method createScopedServer (line 909) | std::unique_ptr<ScopedHTTPServer> createScopedServer() {
    method connectSSL (line 917) | std::unique_ptr<CurlClient> connectSSL(const std::string& caFile = "",
    method connectPlainText (line 937) | std::unique_ptr<CurlClient> connectPlainText() {
    method HTTPServerOptions (line 950) | virtual HTTPServerOptions createDefaultOpts() {
  function TEST_F (line 965) | TEST_F(ScopedServerTest, Start) {
  function TEST_F (line 972) | TEST_F(ScopedServerTest, StartStrictSSL) {
  function TEST_F (line 980) | TEST_F(ScopedServerTest, StartNotStrictSSL) {
  function TEST_F (line 992) | TEST_F(ScopedServerTest, StartSSLWithInsecure) {
  class ConnectionFilterTest (line 1012) | class ConnectionFilterTest : public ScopedServerTest {
    method HTTPServerOptions (line 1014) | HTTPServerOptions createDefaultOpts() override {
  function TEST_F (line 1043) | TEST_F(ConnectionFilterTest, Test) {

FILE: proxygen/httpserver/tests/RequestHandlerAdaptorTest.cpp
  type StubRequestHandlerAdaptor (line 20) | struct StubRequestHandlerAdaptor : public RequestHandlerAdaptor {
    method sendHeaders (line 23) | void sendHeaders(HTTPMessage& /*msg*/) noexcept override {
    method sendEOM (line 27) | void sendEOM() noexcept override {
  function testExpectHandling (line 34) | void testExpectHandling(bool handlerResponds) {
  function TEST (line 47) | TEST(RequestHandlerAdaptorTest, Expect) {
  function TEST (line 52) | TEST(RequestHandlerAdaptorTest, ExpectInvalid) {
  function TEST (line 68) | TEST(RequestHandlerAdaptorTest, onTimeoutError) {
  function TEST (line 83) | TEST(RequestHandlerAdaptorTest, onStreamAbortError) {
  function TEST (line 100) | TEST(RequestHandlerAdaptorTest, onGoaway) {

FILE: proxygen/lib/dns/AsyncDNSStatsCollector.cpp
  type proxygen (line 35) | namespace proxygen {

FILE: proxygen/lib/dns/AsyncDNSStatsCollector.h
  function namespace (line 19) | namespace proxygen {

FILE: proxygen/lib/dns/CAresResolver.cpp
  type HostentDeleter (line 37) | struct HostentDeleter {
  type AresDataDeleter (line 44) | struct AresDataDeleter {
  class NullStatsCollector (line 53) | class NullStatsCollector : public DNSResolver::StatsCollector {
    method NullStatsCollector (line 55) | NullStatsCollector() = default;
    method recordSuccess (line 57) | void recordSuccess(const std::vector<DNSResolver::Answer>& /*answers*/,
    method recordError (line 60) | void recordError(const folly::exception_wrapper& /*ew*/,
    method recordQueryResult (line 63) | void recordQueryResult(uint8_t /*rcode*/) noexcept override {
  type proxygen (line 457) | namespace proxygen {
    class CAresResolver::MultiQuery (line 469) | class CAresResolver::MultiQuery
      method MultiQuery (line 473) | MultiQuery(CAresResolver* resolver, std::string name)
      method resolve (line 479) | void resolve(ResolutionCallback* callback,
      method cancelResolutionImpl (line 498) | void cancelResolutionImpl() override {
      method resolutionSuccess (line 517) | void resolutionSuccess(std::vector<Answer> a) noexcept override {
      method resolutionError (line 534) | void resolutionError(const folly::exception_wrapper& ew) noexcept ov...
      method finish (line 551) | void finish() {
    class CAresResolver::SocketHandler (line 581) | class CAresResolver::SocketHandler : public folly::EventHandler {
      method SocketHandler (line 583) | SocketHandler(CAresResolver* resolver,
      method handlerReady (line 594) | void handlerReady(uint16_t events) noexcept override {
    type detail (line 1041) | namespace detail {
      function parseTxtRecords (line 1042) | folly::Expected<std::vector<DNSResolver::Answer>, ParseError> parseT...
      function parseSrvRecords (line 1067) | folly::Expected<std::vector<DNSResolver::Answer>, ParseError> parseS...
      function parseMxRecords (line 1090) | folly::Expected<std::vector<DNSResolver::Answer>, ParseError> parseM...

FILE: proxygen/lib/dns/CAresResolver.h
  function namespace (line 26) | namespace proxygen {

FILE: proxygen/lib/dns/CachingDNSResolver.cpp
  type proxygen (line 19) | namespace proxygen {

FILE: proxygen/lib/dns/CachingDNSResolver.h
  function namespace (line 21) | namespace proxygen {
  function resolutionError (line 172) | void resolutionError(const folly::exception_wrapper& ew) noexcept overri...
  function cancelResolutionImpl (line 195) | void cancelResolutionImpl() override {

FILE: proxygen/lib/dns/DNSModule.cpp
  type proxygen (line 25) | namespace proxygen {

FILE: proxygen/lib/dns/DNSModule.h
  function virtual (line 29) | virtual DNSResolver::UniquePtr provideDNSResolver(
  function setDNSPort (line 49) | void setDNSPort(uint16_t port) {
  function setDNSServers (line 58) | void setDNSServers(const std::list<folly::SocketAddress>& servers) {
  function setCacheParameters (line 67) | void setCacheParameters(size_t maxSize, size_t clearSize) {
  function setStaleCacheTTL (line 76) | void setStaleCacheTTL(size_t min, size_t factor) {
  function setStaleCacheSizeMultiplier (line 81) | void setStaleCacheSizeMultiplier(size_t multiplier) {
  function cacheClearSize_ (line 89) | size_t cacheClearSize_{256};

FILE: proxygen/lib/dns/DNSResolver.cpp
  type proxygen (line 21) | namespace proxygen {
    function describe (line 143) | std::string describe(const DNSResolver::ResolutionStatus status, bool ...
    function familyToString (line 170) | folly::StringPiece familyToString(sa_family_t family) {

FILE: proxygen/lib/dns/DNSResolver.h
  function namespace (line 27) | namespace proxygen {

FILE: proxygen/lib/dns/FutureDNSResolver.cpp
  type proxygen (line 11) | namespace proxygen {
    class FutureDNSResolutionCallback (line 13) | class FutureDNSResolutionCallback : public DNSResolver::ResolutionCall...
      method FutureDNSResolutionCallback (line 15) | explicit FutureDNSResolutionCallback(
      method resolutionError (line 20) | void resolutionError(const folly::exception_wrapper& ew) noexcept ov...
      method resolutionSuccess (line 25) | void resolutionSuccess(

FILE: proxygen/lib/dns/FutureDNSResolver.h
  function namespace (line 21) | namespace proxygen {

FILE: proxygen/lib/dns/NaiveResolutionCallback.cpp
  type proxygen (line 11) | namespace proxygen {
    function isDNSAnswer (line 17) | static bool isDNSAnswer(const DNSAnswer& a) {

FILE: proxygen/lib/dns/NaiveResolutionCallback.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/dns/Rfc6724.cpp
  type SortElement (line 51) | struct SortElement {
  type proxygen (line 67) | namespace proxygen {
    function rfc6724_sort (line 69) | void rfc6724_sort(vector<SocketAddress>& addrs,
  function find_src_addr (line 139) | static bool find_src_addr(const SocketAddress* addr, SocketAddress& srcA...
  function get_scope (line 202) | static int get_scope(const SocketAddress* addr) {
  function get_label (line 247) | static int get_label(const SocketAddress* addr) {
  function get_precedence (line 287) | static int get_precedence(const SocketAddress* addr) {
  function get_common_prefix (line 319) | static int get_common_prefix(const in6_addr* src, const in6_addr* dst) {
  function rfc6724_compare (line 344) | static int rfc6724_compare(const void* ptr1, const void* ptr2) {

FILE: proxygen/lib/dns/Rfc6724.h
  function namespace (line 35) | namespace proxygen {

FILE: proxygen/lib/dns/SyncDNSResolver.cpp
  type proxygen (line 17) | namespace proxygen {

FILE: proxygen/lib/dns/SyncDNSResolver.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/dns/test/CAresResolverTest.cpp
  class MockCAresResolver (line 20) | class MockCAresResolver : public CAresResolver {
  class MockQuery (line 35) | class MockQuery : public CAresResolver::Query {
  class CAresResolverTest (line 42) | class CAresResolverTest : public testing::Test {
    method SetUp (line 44) | void SetUp() override {
  class MockQueryWithCob (line 53) | class MockQueryWithCob : public MockQuery {
    method MockQueryWithCob (line 55) | MockQueryWithCob(CAresResolver* resolver,
  class MockResolutionCallback (line 69) | class MockResolutionCallback : public CAresResolver::ResolutionCallback {
    method resolutionSuccess (line 72) | void resolutionSuccess(
    method resolutionError (line 75) | void resolutionError(
  function TEST_F (line 80) | TEST_F(CAresResolverTest, ScheduleFallbackOnTimeout) {
  function TEST_F (line 95) | TEST_F(CAresResolverTest, DontScheduleFallbackOnTimeoutNoCob) {
  function TEST_F (line 110) | TEST_F(CAresResolverTest, ScheduleFallbackOnFailureDnscr) {
  function TEST_F (line 125) | TEST_F(CAresResolverTest, ScheduleFallbackOnFailureDnscrNoCob) {
  function TEST_F (line 178) | TEST_F(CAresResolverTest, TestParseTxtRecords) {
  class CNameMockResolver (line 203) | class CNameMockResolver : public CAresResolver {
    method query (line 207) | void query(const std::string& /*name*/,
    method queryFinished (line 227) | void queryFinished() override {
    method queryFinishedCount (line 231) | [[nodiscard]] int queryFinishedCount() const {
  function TEST_F (line 338) | TEST_F(CAresResolverTest, CheckForCNameSynchronousCallbackNoUAF) {

FILE: proxygen/lib/dns/test/CachingDNSResolverTest.cpp
  type CachingDNSParams (line 19) | struct CachingDNSParams {
  class CachingDNSResolverFixture (line 27) | class CachingDNSResolverFixture : public testing::Test {
    method SetUp (line 29) | void SetUp() override {
    method initializeResolverWithParams (line 33) | void initializeResolverWithParams(const CachingDNSParams& params) {
    method initializeWithDefaultParams (line 50) | void initializeWithDefaultParams() {
  function TEST_F (line 61) | TEST_F(CachingDNSResolverFixture, NoCrashWhileDestructing) {
  function TEST_F (line 67) | TEST_F(CachingDNSResolverFixture, ResolutionError) {
  function TEST_F (line 73) | TEST_F(CachingDNSResolverFixture, CacheHit) {
  function TEST_F (line 85) | TEST_F(CachingDNSResolverFixture, CacheClearAfterMax) {
  function TEST_F (line 103) | TEST_F(CachingDNSResolverFixture, CacheClearExpiredRecords) {
  function TEST_F (line 120) | TEST_F(CachingDNSResolverFixture, StaleCacheHitAfterFailure) {

FILE: proxygen/lib/dns/test/DNSResolverTest.cpp
  function h (line 21) | size_t h(const DNSResolver::Answer& a) {
  function TEST (line 27) | TEST(DNSResolverAnswerHashTest, EqualAnswersHaveEqualHash_Address) {
  function TEST (line 36) | TEST(DNSResolverAnswerHashTest, EqualAnswersHaveEqualHash_Name) {
  function TEST (line 46) | TEST(DNSResolverAnswerHashTest, EqualAnswersHaveEqualHash_CName) {
  function TEST (line 57) | TEST(DNSResolverAnswerHashTest, EqualAnswersHaveEqualHash_MX) {
  function TEST (line 66) | TEST(DNSResolverAnswerHashTest, DistinctAnswersBehaveInUnorderedSet) {
  function TEST (line 107) | TEST(DNSResolverAnswerHashTest, IgnoresTTLAndCreationTime) {
  function TEST (line 122) | TEST(DNSResolverAnswerHashTest, DifferentTypeNotEqual) {
  function TEST (line 132) | TEST(DNSResolverAnswerHashTest, DifferentAddressNotEqual) {
  function TEST (line 140) | TEST(DNSResolverAnswerHashTest, DifferentNameNotEqual) {
  function TEST (line 150) | TEST(DNSResolverAnswerHashTest, DifferentCanonicalNameNotEqual) {
  function TEST (line 161) | TEST(DNSResolverAnswerHashTest, DifferentPortNotEqual) {
  function TEST (line 172) | TEST(DNSResolverAnswerHashTest, DifferentPriorityNotEqual) {
  function TEST (line 182) | TEST(DNSResolverAnswerHashTest, SameCanonicalNameAndPortEqual) {
  function TEST (line 195) | TEST(DNSResolverAnswerHashTest, CanonicalNameAndPortInUnorderedSet) {

FILE: proxygen/lib/dns/test/Dummies.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/dns/test/FutureDNSResolverTest.cpp
  type proxygen (line 21) | namespace proxygen {
    function invert (line 25) | std::map<V, K> invert(const std::map<K, V>& input) {
    class FakeResolverError (line 33) | class FakeResolverError : public std::runtime_error {
      method FakeResolverError (line 35) | explicit FakeResolverError(string message)
    class FakeDNSResolver (line 40) | class FakeDNSResolver : public DNSResolver {
      method FakeDNSResolver (line 42) | explicit FakeDNSResolver(
      method resolveAddress (line 56) | void resolveAddress(ResolutionCallback* cb,
      method resolveHostname (line 74) | void resolveHostname(
      method resolveMailExchange (line 95) | void resolveMailExchange(ResolutionCallback* cb,
      method setStatsCollector (line 124) | void setStatsCollector(DNSResolver::StatsCollector* collector) overr...
    class FutureDNSResolverTest (line 137) | class FutureDNSResolverTest : public ::testing::Test {
      method SetUp (line 142) | void SetUp() override {
    function TEST_F (line 175) | TEST_F(FutureDNSResolverTest, TestResolveAddressSuccess) {
    function TEST_F (line 189) | TEST_F(FutureDNSResolverTest, TestResolveAddressFail) {
    function TEST_F (line 195) | TEST_F(FutureDNSResolverTest, TestResolveHostnameSuccess) {
    function TEST_F (line 209) | TEST_F(FutureDNSResolverTest, TestResolveHostnameFail) {
    function TEST_F (line 215) | TEST_F(FutureDNSResolverTest, TestResolveMailExchangeSuccess) {
    function TEST_F (line 248) | TEST_F(FutureDNSResolverTest, TestResolveMailExchangeFail) {

FILE: proxygen/lib/dns/test/MockDNSModule.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/dns/test/MockDNSModule.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/dns/test/MockDNSResolver.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/dns/test/Mocks.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/dns/test/Rfc6724Test.cpp
  function TEST (line 20) | TEST(SyncDNSResolver, Basic102) {
  function TEST_F (line 58) | TEST_F(SyncDNSResolverTest, Sorted) {
  function TEST_F (line 84) | TEST_F(SyncDNSResolverTest, SortedLocal) {
  function TEST_F (line 110) | TEST_F(SyncDNSResolverTest, Unsorted) {

FILE: proxygen/lib/dns/test/SyncDNSResolverTest.cpp
  function TEST_F (line 17) | TEST_F(SyncDNSResolverTest, Success) {
  function TEST_F (line 40) | TEST_F(SyncDNSResolverTest, EmptyResponseIsTreatedAsError) {
  function TEST_F (line 57) | TEST_F(SyncDNSResolverTest, AsyncSuccess) {
  function TEST_F (line 76) | TEST_F(SyncDNSResolverTest, Failure) {

FILE: proxygen/lib/dns/test/SyncDNSResolverTest.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/healthcheck/PoolHealthChecker.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/healthcheck/ServerHealthCheckerCallback.cpp
  type proxygen (line 11) | namespace proxygen {
    function serverDownInfoStr (line 13) | const std::string serverDownInfoStr(ServerDownInfo info) {

FILE: proxygen/lib/healthcheck/ServerHealthCheckerCallback.h
  function namespace (line 19) | namespace proxygen {

FILE: proxygen/lib/http/HQConnector.cpp
  type proxygen (line 24) | namespace proxygen {

FILE: proxygen/lib/http/HQConnector.h
  function setSupportedQuicVersions (line 45) | void setSupportedQuicVersions(
  function setH3Settings (line 49) | void setH3Settings(SettingsList settings) {
  function HQUpstreamSession (line 86) | HQUpstreamSession* session_{nullptr};

FILE: proxygen/lib/http/HTTP3ErrorCode.cpp
  type proxygen (line 12) | namespace proxygen {
    function toString (line 14) | std::string toString(HTTP3::ErrorCode code) {
    function getAllHTTP3ErrorCodes (line 65) | std::vector<HTTP3::ErrorCode> getAllHTTP3ErrorCodes() {

FILE: proxygen/lib/http/HTTP3ErrorCode.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/HTTPConnector.cpp
  type proxygen (line 24) | namespace proxygen {

FILE: proxygen/lib/http/HTTPConnector.h
  function namespace (line 22) | namespace proxygen {

FILE: proxygen/lib/http/HTTPConnectorWithFizz.cpp
  type proxygen (line 16) | namespace proxygen {

FILE: proxygen/lib/http/HTTPConnectorWithFizz.h
  function namespace (line 20) | namespace proxygen {

FILE: proxygen/lib/http/HTTPConstants.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/HTTPConstants.h
  type class (line 51) | enum class
  function UpgradeProtocol (line 62) | enum class UpgradeProtocol : int {

FILE: proxygen/lib/http/HTTPException.cpp
  type proxygen (line 14) | namespace proxygen {
    function toHTTP3ErrorCode (line 16) | HTTP3::ErrorCode toHTTP3ErrorCode(proxygen::ErrorCode err) {

FILE: proxygen/lib/http/HTTPException.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/http/HTTPHeaderSize.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/HTTPHeaders.cpp
  type proxygen (line 63) | namespace proxygen {
    function HTTPHeaders (line 231) | HTTPHeaders& HTTPHeaders::operator=(const HTTPHeaders& hdrs) {
    function HTTPHeaders (line 239) | HTTPHeaders& HTTPHeaders::operator=(HTTPHeaders&& hdrs) {
    function HTTPHeaderCode (line 407) | HTTPHeaderCode* HTTPHeaders::codes() const noexcept {
    function HTTPHeaderCode (line 411) | HTTPHeaderCode* HTTPHeaders::codes(const uint8_t* memory,

FILE: proxygen/lib/http/HTTPHeaders.h
  function namespace (line 25) | namespace proxygen {

FILE: proxygen/lib/http/HTTPMessage.cpp
  type proxygen (line 22) | namespace proxygen {
    function httpPriorityToString (line 24) | std::string httpPriorityToString(const HTTPPriority& pri) {
    function HTTPMessage (line 151) | HTTPMessage& HTTPMessage::operator=(const HTTPMessage& message) {
    function HTTPMessage (line 197) | HTTPMessage& HTTPMessage::operator=(HTTPMessage&& message) {
    type FormattedDate (line 326) | struct FormattedDate {
      method string (line 330) | string formatDate() {
    function string (line 348) | string HTTPMessage::formatDateHeader() {
    function StringPiece (line 429) | const StringPiece HTTPMessage::getCookie(const string& name) const {
    function string (line 519) | const string* HTTPMessage::getQueryParamPtr(const string& name) const {
    function string (line 536) | const string& HTTPMessage::getQueryParam(const string& name) const {
    function HTTPQueryParamMap (line 566) | const HTTPQueryParamMap& HTTPMessage::getQueryParams() const {
    function StringPiece (line 699) | StringPiece HTTPMessage::trim(StringPiece sp) {
    function ParseURL (line 1003) | ParseURL HTTPMessage::setURLImplInternal(bool unparse, bool strict) {

FILE: proxygen/lib/http/HTTPMessage.h
  function namespace (line 28) | namespace proxygen {
  function std (line 219) | const std::string& getDstIP() const {
  function rawSetMethod (line 249) | void rawSetMethod(const std::string& method) {
  function rawSetURL (line 284) | void rawSetURL(const std::string& url) {
  function std (line 294) | const std::string& getPath() const {
  function std (line 313) | const std::string& getQueryString() const {
  function rawSetStatusMessage (line 349) | void rawSetStatusMessage(std::string msg) {
  function setVersionString (line 360) | void setVersionString(const std::string& ver) {
  function HTTPHeaders (line 389) | HTTPHeaders* getTrailers() {
  function HTTPHeaders (line 392) | const HTTPHeaders* getTrailers() const {
  function setTrailers (line 399) | void setTrailers(std::unique_ptr<HTTPHeaders>&& trailers) {
  function isHTTP1_0 (line 420) | bool isHTTP1_0() const;
  function setWantsKeepalive (line 474) | void setWantsKeepalive(bool wantsKeepaliveVal) {
  function setTrailersAllowed (line 491) | void setTrailersAllowed(bool trailersAllowedVal) {
  function getStatusCode (line 506) | uint16_t getStatusCode() const;
  function HTTPQueryParamMap (line 603) | const HTTPQueryParamMap& getQueryParams() const;
  function setMasque (line 688) | void setMasque() {
  function std (line 696) | const std::string& getScheme() const {
  function setSecureInfo (line 718) | void setSecureInfo(int ver, const char* cipher) {
  function setAdvancedProtocolString (line 724) | void setAdvancedProtocolString(const std::string& protocol) {
  function std (line 732) | const std::string* getAdvancedProtocolString() const {
  function std (line 742) | const std::string& getProtocolString() const {
  function normalizePriority (line 758) | static uint8_t normalizePriority(int8_t pri) {
  function setPriority (line 768) | void setPriority(int8_t pri) {
  function noexcept (line 780) | const noexcept {
  function setSeqNo (line 797) | void setSeqNo(int32_t seqNo) {
  function setIngressHeaderSize (line 807) | void setIngressHeaderSize(const HTTPHeaderSize& size) {
  function setStartTime (line 820) | void setStartTime(const TimePoint& startTime) {
  function computeKeepalive (line 855) | bool computeKeepalive() const;
  function parseQueryParams (line 926) | void parseQueryParams() const;
  function clear (line 1014) | void clear() {
  function copyFrom (line 1030) | void copyFrom(const Fields& other) {
  function moveFrom (line 1056) | void moveFrom(Fields&& other) {
  function mutable (line 1072) | mutable MessageType which_{MessageType::NONE};
  function Request (line 1097) | const Request& request() const {
  function Response (line 1116) | const Response& response() const {
  function string (line 1164) | string stripCntrlChars(const Str& str) {

FILE: proxygen/lib/http/HTTPMessageFilters.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/HTTPMessageFilters.h
  function namespace (line 20) | namespace proxygen {
  function virtual (line 31) | virtual void setPrevFilter(HTTPMessageFilter* prev) noexcept {
  function virtual (line 38) | virtual void setPrevSink(HTTPSink* prev) noexcept {
  function onHeadersComplete (line 53) | void onHeadersComplete(std::unique_ptr<HTTPMessage> msg) noexcept overri...
  function onBody (line 56) | void onBody(std::unique_ptr<folly::IOBuf> chain) noexcept override {
  function onChunkHeader (line 59) | void onChunkHeader(size_t length) noexcept override {
  function onChunkComplete (line 62) | void onChunkComplete() noexcept override {
  function onTrailers (line 65) | void onTrailers(std::unique_ptr<HTTPHeaders> trailers) noexcept override {
  function onEOM (line 68) | void onEOM() noexcept override {
  function onUpgrade (line 71) | void onUpgrade(UpgradeProtocol protocol) noexcept override {
  function onError (line 74) | void onError(const HTTPException& error) noexcept override {
  function onInvariantViolation (line 78) | void onInvariantViolation(const HTTPException& error) noexcept final {
  function setTransaction (line 83) | void setTransaction(HTTPTransaction* txn) noexcept final {
  function detachTransaction (line 86) | void detachTransaction() noexcept final {
  function onEgressPaused (line 96) | void onEgressPaused() noexcept final {
  function onEgressResumed (line 99) | void onEgressResumed() noexcept final {
  function onPushedTransaction (line 102) | void onPushedTransaction(HTTPTransaction* txn) noexcept final {
  function virtual (line 106) | [[nodiscard]] virtual std::string_view getFilterName() const noexcept {
  function virtual (line 134) | virtual void nextOnBody(std::unique_ptr<folly::IOBuf> chain) {
  function virtual (line 137) | virtual void nextOnChunkHeader(size_t length) {
  function virtual (line 140) | virtual void nextOnChunkComplete() {
  function virtual (line 143) | virtual void nextOnTrailers(std::unique_ptr<HTTPHeaders> trailers) {
  function virtual (line 146) | virtual void nextOnEOM() {
  function virtual (line 149) | virtual void nextOnError(const HTTPException& ex) {
  function nextElementIsPaused_ (line 157) | bool nextElementIsPaused_{false};

FILE: proxygen/lib/http/HTTPMethod.cpp
  function StringVector (line 25) | const StringVector& getMethodStrings() {
  type proxygen (line 45) | namespace proxygen {
    function stringToMethod (line 47) | folly::Optional<HTTPMethod> stringToMethod(folly::StringPiece method) {

FILE: proxygen/lib/http/HTTPMethod.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/HTTPPriorityFunctions.cpp
  type proxygen (line 13) | namespace proxygen {
    function T (line 17) | T getWithDefault(StructuredHeaders::Dictionary& dict,
    function httpPriorityFromHTTPMessage (line 37) | folly::Optional<HTTPPriority> httpPriorityFromHTTPMessage(
    function httpPriorityFromString (line 43) | folly::Optional<HTTPPriority> httpPriorityFromString(

FILE: proxygen/lib/http/HTTPPriorityFunctions.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/HeaderConstants.cpp
  type proxygen::headers (line 11) | namespace proxygen::headers {

FILE: proxygen/lib/http/HeaderConstants.h
  function std (line 30) | constexpr std::string_view kWTProtocol{"wt-protocol"};

FILE: proxygen/lib/http/ProxyStatus.cpp
  type proxygen (line 25) | namespace proxygen {
    function StatusType (line 31) | StatusType ProxyStatus::getStatusType() const {
    function ProxyStatus (line 40) | ProxyStatus& ProxyStatus::setProxyStatusParameter(folly::StringPiece n...
    function ProxyStatus (line 51) | ProxyStatus& ProxyStatus::setProxy(const std::string& proxy) {
    function ProxyStatus (line 55) | ProxyStatus& ProxyStatus::setUpstreamIP(const std::string& upstreamIP) {
    function ProxyStatus (line 59) | ProxyStatus& ProxyStatus::setProxyError(const bool isProxyError) {
    function ProxyStatus (line 67) | ProxyStatus& ProxyStatus::setServerError(const bool isServerError) {
    function ProxyStatus (line 75) | ProxyStatus& ProxyStatus::setClientError(const bool isClientError) {
    function ProxyStatus (line 83) | ProxyStatus& ProxyStatus::setClientAddress(const std::string& clientAd...
    function ProxyStatus (line 87) | ProxyStatus& ProxyStatus::setDetails(const std::string& details) {

FILE: proxygen/lib/http/ProxyStatus.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/ProxygenErrorEnum.cpp
  type proxygen (line 17) | namespace proxygen {

FILE: proxygen/lib/http/ProxygenErrorEnum.h
  function namespace (line 11) | namespace proxygen {

FILE: proxygen/lib/http/RFC2616.cpp
  function strtoulWrapper (line 20) | bool strtoulWrapper(const char*& curs, const char* end, unsigned long& v...
  function equalsIgnoreCase (line 38) | bool equalsIgnoreCase(folly::StringPiece s1, folly::StringPiece s2) {
  type proxygen::RFC2616 (line 47) | namespace proxygen::RFC2616 {
    function BodyAllowed (line 49) | BodyAllowed isRequestBodyAllowed(folly::Optional<HTTPMethod> method) {
    function responseBodyMustBeEmpty (line 60) | bool responseBodyMustBeEmpty(unsigned status) {
    function bodyImplied (line 64) | bool bodyImplied(const HTTPHeaders& headers) {
    function parseQvalue (line 69) | double parseQvalue(const EncodingParams& params) {
    function parseQvalues (line 79) | bool parseQvalues(folly::StringPiece value, TokenPairVec& output) {
    function parseByteRangeSpec (line 100) | bool parseByteRangeSpec(folly::StringPiece value,
    function parseEncoding (line 167) | folly::Try<EncodingList> parseEncoding(const folly::StringPiece header) {
    function acceptsEncoding (line 216) | bool acceptsEncoding(const folly::StringPiece header,
    function acceptsEncoding (line 225) | bool acceptsEncoding(const EncodingList& encodings,

FILE: proxygen/lib/http/RFC2616.h
  function namespace (line 23) | namespace proxygen {

FILE: proxygen/lib/http/StatusTypeEnum.cpp
  type proxygen (line 17) | namespace proxygen {

FILE: proxygen/lib/http/StatusTypeEnum.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/SynchronizedLruQuicPskCache.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/SynchronizedLruQuicPskCache.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/Types.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/Window.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/http/Window.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/CapsuleCodec.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/CapsuleCodec.h
  type class (line 19) | enum class
  function class (line 24) | class Callback {
  function setCallback (line 43) | void setCallback(Callback* callback) {
  function noexcept (line 48) | canParseCapsule(uint64_t /*capsuleType*/) noexcept {
  function curCapsuleLength_ (line 60) | uint64_t curCapsuleLength_{0}
  function ParseState (line 64) | enum class ParseState : uint8_t {

FILE: proxygen/lib/http/codec/CodecProtocol.cpp
  type proxygen (line 17) | namespace proxygen {
    function CodecProtocol (line 33) | extern CodecProtocol getCodecProtocolFromStr(folly::StringPiece protoc...
    function isValidCodecProtocolStr (line 71) | extern bool isValidCodecProtocolStr(folly::StringPiece protocolStr) {
    function isHTTP1_1CodecProtocol (line 78) | extern bool isHTTP1_1CodecProtocol(CodecProtocol protocol) {
    function isHTTP2CodecProtocol (line 82) | extern bool isHTTP2CodecProtocol(CodecProtocol protocol) {
    function isHQCodecProtocol (line 86) | extern bool isHQCodecProtocol(CodecProtocol protocol) {
    function isHTTPBinaryCodecProtocol (line 90) | extern bool isHTTPBinaryCodecProtocol(CodecProtocol protocol) {
    function isParallelCodecProtocol (line 94) | extern bool isParallelCodecProtocol(CodecProtocol protocol) {
    function serverAcceptedUpgrade (line 98) | extern bool serverAcceptedUpgrade(const std::string& clientUpgrade,

FILE: proxygen/lib/http/codec/CodecProtocol.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/http/codec/CodecUtil.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/CodecUtil.h
  function namespace (line 21) | namespace proxygen {

FILE: proxygen/lib/http/codec/ControlMessageRateLimitFilter.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/DebugFilter.h
  function namespace (line 15) | namespace proxygen {
  function shouldDumpStream (line 69) | bool shouldDumpStream(HTTPCodec::StreamID streamID) {
  function shouldTrackStream (line 74) | bool shouldTrackStream(const HTTPMessage& msg) {
  function onAbort (line 78) | void onAbort(StreamID streamID, ErrorCode code) override {
  function onError (line 87) | void onError(HTTPCodec::StreamID streamID,
  function onGoaway (line 99) | void onGoaway(uint64_t lastStream,
  function dump (line 111) | void dump() {
  function maxBufSize_ (line 125) | size_t maxBufSize_{10000};

FILE: proxygen/lib/http/codec/DefaultHTTPCodecFactory.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/DefaultHTTPCodecFactory.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/DirectErrorsRateLimitFilter.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/ErrorCode.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/ErrorCode.h
  function namespace (line 20) | namespace proxygen {

FILE: proxygen/lib/http/codec/FlowControlFilter.cpp
  type proxygen (line 11) | namespace proxygen {
    function HTTPException (line 14) | HTTPException getException(const std::string& msg) {

FILE: proxygen/lib/http/codec/FlowControlFilter.h
  function namespace (line 14) | namespace folly {
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/http/codec/HQControlCodec.cpp
  function drainingId (line 19) | uint64_t drainingId(proxygen::TransportDirection dir) {
  type proxygen::hq (line 29) | namespace proxygen::hq {
    function ParseResult (line 33) | ParseResult HQControlCodec::checkFrameAllowed(FrameType type) {
    function ParseResult (line 73) | ParseResult HQControlCodec::parseCancelPush(Cursor& cursor,
    function ParseResult (line 80) | ParseResult HQControlCodec::parseSettings(Cursor& cursor,
    function ParseResult (line 127) | ParseResult HQControlCodec::parseGoaway(Cursor& cursor,
    function ParseResult (line 137) | ParseResult HQControlCodec::parseMaxPushId(Cursor& cursor,
    function ParseResult (line 144) | ParseResult HQControlCodec::parsePriorityUpdate(Cursor& cursor,
    function ParseResult (line 157) | ParseResult HQControlCodec::parsePushPriorityUpdate(Cursor& cursor,

FILE: proxygen/lib/http/codec/HQControlCodec.h
  function onUnidirectionalIngressEOF (line 57) | void onUnidirectionalIngressEOF() override {
  function isWaitingToDrain (line 68) | bool isWaitingToDrain() const override;
  function onIngress (line 74) | size_t onIngress(const folly::IOBuf& /*buf*/) override {
  function onIngressEOF (line 79) | void onIngressEOF() override {
  function HTTPSettings (line 99) | const HTTPSettings* getIngressSettings() const override {
  function HTTPSettings (line 104) | HTTPSettings* getEgressSettings() override {
  function HTTPSettings (line 109) | const HTTPSettings* getEgressSettings() const {
  function enableDoubleGoawayDrain (line 114) | void enableDoubleGoawayDrain() override {
  function disableDoubleGoawayDrain (line 118) | void disableDoubleGoawayDrain() override {
  function minUnseenPushID_ (line 165) | uint64_t minUnseenPushID_{kMaxPushId + 1};

FILE: proxygen/lib/http/codec/HQFramedCodec.cpp
  type proxygen::hq (line 20) | namespace proxygen::hq {
    function ParseResult (line 25) | ParseResult HQFramedCodec::parseFrame(Cursor& cursor) {

FILE: proxygen/lib/http/codec/HQFramedCodec.h
  function CodecProtocol (line 40) | CodecProtocol getProtocol() const override {
  function setParserPaused (line 69) | void setParserPaused(bool paused) override {
  function setResumeHook (line 80) | void setResumeHook(folly::Function<void()> resumeHook) {
  function onIngressUpgradeMessage (line 101) | bool onIngressUpgradeMessage(const HTTPMessage& /*msg*/) override {
  function generateConnectionPreface (line 106) | size_t generateConnectionPreface(folly::IOBufQueue& /*writeBuf*/) overri...
  function generateHeader (line 112) | void generateHeader(folly::IOBufQueue& /*writeBuf*/,
  function generatePushPromise (line 123) | void generatePushPromise(folly::IOBufQueue& /*writeBuf*/,
  function generateBody (line 134) | size_t generateBody(folly::IOBufQueue& /* writeBuf*/,
  function generateChunkHeader (line 144) | size_t generateChunkHeader(folly::IOBufQueue& /*writeBuf*/,
  function generateChunkTerminator (line 152) | size_t generateChunkTerminator(folly::IOBufQueue& /*writeBuf*/,
  function generateTrailers (line 158) | size_t generateTrailers(folly::IOBufQueue& /*writeBuf*/,
  function generatePadding (line 165) | size_t generatePadding(folly::IOBufQueue& /*writeBuf*/,
  function generateEOM (line 173) | size_t generateEOM(folly::IOBufQueue& /*writeBuf*/,
  function generateRstStream (line 180) | size_t generateRstStream(folly::IOBufQueue& /*writeBuf*/,
  function generateGoaway (line 188) | size_t generateGoaway(
  function generatePingRequest (line 198) | size_t generatePingRequest(
  function generatePingReply (line 206) | size_t generatePingReply(folly::IOBufQueue& /*writeBuf*/,
  function generateSettings (line 213) | size_t generateSettings(folly::IOBufQueue& /*writeBuf*/) override {
  function generateSettingsAck (line 219) | size_t generateSettingsAck(folly::IOBufQueue& /*writeBuf*/) override {
  function generateWindowUpdate (line 225) | size_t generateWindowUpdate(folly::IOBufQueue& /*writeBuf*/,
  function HTTPSettings (line 233) | const HTTPSettings* getIngressSettings() const override {
  function HTTPSettings (line 239) | HTTPSettings* getEgressSettings() override {
  function setHeaderCodecStats (line 262) | void setHeaderCodecStats(HeaderCodec::Stats* /*hcStats*/) override {
  function isRequest (line 267) | bool isRequest(StreamID /*id*/) const {
  function CompressionInfo (line 274) | CompressionInfo getCompressionInfo() const override {
  function pendingDataFrameBytes_ (line 354) | size_t pendingDataFrameBytes_{0}
  function receivedFrameCount_ (line 357) | uint64_t receivedFrameCount_{0}
  function FrameState (line 360) | enum class FrameState : uint8_t {

FILE: proxygen/lib/http/codec/HQFramer.cpp
  type proxygen::hq (line 21) | namespace proxygen::hq {
    function isGreaseId (line 23) | bool isGreaseId(uint64_t id) {
    function getGreaseId (line 30) | folly::Optional<uint64_t> getGreaseId(uint64_t n) {
    function ParseResult (line 37) | ParseResult parseData(folly::io::Cursor& cursor,
    function ParseResult (line 45) | ParseResult parseHeaders(folly::io::Cursor& cursor,
    function ParseResult (line 54) | static ParseResult parseIdOnlyFrame(folly::io::Cursor& cursor,
    function ParseResult (line 73) | ParseResult parseCancelPush(folly::io::Cursor& cursor,
    function decodeSettingValue (line 79) | folly::Expected<folly::Optional<SettingValue>, HTTP3::ErrorCode>
    function ParseResult (line 110) | ParseResult parseSettings(folly::io::Cursor& cursor,
    function ParseResult (line 139) | ParseResult parsePushPromise(folly::io::Cursor& cursor,
    function ParseResult (line 158) | ParseResult parseGoaway(folly::io::Cursor& cursor,
    function ParseResult (line 164) | ParseResult parseMaxPushId(folly::io::Cursor& cursor,
    function ParseResult (line 170) | ParseResult parsePriorityUpdate(folly::io::Cursor& cursor,
    function WriteResult (line 197) | WriteResult writeFrameHeader(IOBufQueue& queue,
    function WriteResult (line 216) | WriteResult writeSimpleFrame(IOBufQueue& queue,
    function WriteResult (line 229) | WriteResult writeData(IOBufQueue& queue,
    function WriteResult (line 234) | WriteResult writePadding(IOBufQueue& queue,
    function WriteResult (line 239) | WriteResult writeHeaders(IOBufQueue& queue,
    function WriteResult (line 244) | WriteResult writeCancelPush(folly::IOBufQueue& writeBuf,
    function WriteResult (line 262) | WriteResult writeSettings(IOBufQueue& queue,
    function WriteResult (line 302) | WriteResult writePushPromise(IOBufQueue& queue,
    function WriteResult (line 327) | WriteResult writeGoaway(folly::IOBufQueue& writeBuf,
    function WriteResult (line 345) | WriteResult writeMaxPushId(folly::IOBufQueue& writeBuf,
    function WriteResult (line 363) | WriteResult writePriorityUpdate(folly::IOBufQueue& writeBuf,
    function WriteResult (line 384) | WriteResult writePushPriorityUpdate(
    function WriteResult (line 406) | WriteResult writeStreamPreface(folly::IOBufQueue& writeBuf,
    function WriteResult (line 460) | WriteResult writeGreaseFrame(folly::IOBufQueue& writeBuf) noexcept {
    function WriteResult (line 474) | WriteResult writeWTStreamPreface(folly::IOBufQueue& writeBuf,

FILE: proxygen/lib/http/codec/HQFramer.h
  type class (line 41) | enum class
  type class (line 50) | enum class
  type class (line 55) | enum class
  type FrameHeader (line 90) | struct FrameHeader {
  type class (line 95) | enum class
  function WebTransportStreamType (line 373) | enum class WebTransportStreamType : uint8_t { UNI = 0, BIDI = 1 };

FILE: proxygen/lib/http/codec/HQMultiCodec.h
  function namespace (line 15) | namespace proxygen::hq {
  function std (line 140) | const std::string& getUserAgent() const override {
  function onIngressEOF (line 152) | void onIngressEOF() override {
  function isParserPaused (line 161) | bool isParserPaused() const override {
  function generateConnectionPreface (line 171) | size_t generateConnectionPreface(folly::IOBufQueue& /*writeBuf*/) overri...
  function generateSettingsAck (line 175) | size_t generateSettingsAck(folly::IOBufQueue& /*writeBuf*/) override {
  function generateBody (line 202) | size_t generateBody(folly::IOBufQueue& writeBuf,
  function generateTrailers (line 211) | size_t generateTrailers(folly::IOBufQueue& writeBuf,
  function generatePadding (line 217) | size_t generatePadding(folly::IOBufQueue& writeBuf,
  function generateEOM (line 223) | size_t generateEOM(folly::IOBufQueue& writeBuf, StreamID stream) override {
  function setHeaderCodecStats (line 227) | void setHeaderCodecStats(HeaderCodec::Stats* hcStats) override {
  function getDefaultWindowSize (line 236) | uint32_t getDefaultWindowSize() const override {
  function nextPushID (line 244) | uint64_t nextPushID() {
  function onIngressPushId (line 249) | void onIngressPushId(uint64_t pushId) {
  function HTTPCodec (line 263) | const HTTPCodec& getCurrentCodec() const {
  function HQStreamCodec (line 273) | const HQStreamCodec& getCodec(StreamID stream) const {
  function nextPushID_ (line 294) | uint64_t nextPushID_{0}
  function strictValidation_ (line 295) | bool strictValidation_{true};

FILE: proxygen/lib/http/codec/HQStreamCodec.cpp
  type proxygen::hq (line 19) | namespace proxygen::hq {
    function ParseResult (line 43) | ParseResult HQStreamCodec::checkFrameAllowed(FrameType type) {
    function ParseResult (line 69) | ParseResult HQStreamCodec::parseData(Cursor& cursor,
    function ParseResult (line 91) | ParseResult HQStreamCodec::parseHeaders(Cursor& cursor,
    function ParseResult (line 137) | ParseResult HQStreamCodec::parsePushPromise(Cursor& cursor,
    function CompressionInfo (line 432) | CompressionInfo HQStreamCodec::getCompressionInfo() const {

FILE: proxygen/lib/http/codec/HQStreamCodec.h
  function namespace (line 19) | namespace proxygen {

FILE: proxygen/lib/http/codec/HQUnidirectionalCodec.cpp
  type proxygen::hq (line 11) | namespace proxygen::hq {

FILE: proxygen/lib/http/codec/HQUnidirectionalCodec.h
  function namespace (line 17) | namespace proxygen::hq {

FILE: proxygen/lib/http/codec/HQUtils.cpp
  type proxygen::hq (line 13) | namespace proxygen::hq {
    function hqToHttpErrorCode (line 29) | proxygen::ErrorCode hqToHttpErrorCode(HTTP3::ErrorCode err) {
    function ProxygenError (line 60) | ProxygenError toProxygenError(quic::QuicErrorCode error, bool fromPeer) {
    function httpToHqSettingsId (line 82) | folly::Optional<hq::SettingId> httpToHqSettingsId(proxygen::SettingsId...
    function hqToHttpSettingsId (line 109) | folly::Optional<proxygen::SettingsId> hqToHttpSettingsId(hq::SettingId...

FILE: proxygen/lib/http/codec/HQUtils.h
  function namespace (line 20) | namespace proxygen::hq {

FILE: proxygen/lib/http/codec/HTTP1xCodec.cpp
  function u64toa (line 40) | unsigned u64toa(uint64_t value, char* dst) {
  function appendUint (line 61) | void appendUint(IOBufQueue& queue, size_t& len, uint64_t value) {
  function appendString (line 72) | void appendString(IOBufQueue& queue, size_t& len, StringPiece str) {
  function validateContentLen (line 80) | bool validateContentLen(const HTTPHeaders& hdrs) noexcept {
  function validateTransferEncoding (line 95) | bool validateTransferEncoding(const HTTPHeaders& hdrs) noexcept {
  type proxygen (line 107) | namespace proxygen {
    function http_parser_settings (line 183) | const http_parser_settings* HTTP1xCodec::getParserSettings() {
    function HTTP1xCodec (line 1394) | HTTP1xCodec HTTP1xCodec::makeResponseCodec(bool mayChunkEgress) {

FILE: proxygen/lib/http/codec/HTTP1xCodec.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTP2Codec.cpp
  type proxygen (line 33) | namespace proxygen {
    function ErrorCode (line 155) | ErrorCode HTTP2Codec::parseFrame(folly::io::Cursor& cursor) {
    function ErrorCode (line 264) | ErrorCode HTTP2Codec::handleEndStream() {
    function ErrorCode (line 296) | ErrorCode HTTP2Codec::parseAllData(Cursor& cursor) {
    function ErrorCode (line 317) | ErrorCode HTTP2Codec::parseDataFrameData(Cursor& cursor,
    function ErrorCode (line 399) | ErrorCode HTTP2Codec::parseHeaders(Cursor& cursor) {
    function ErrorCode (line 414) | ErrorCode HTTP2Codec::parseContinuation(Cursor& cursor) {
    function ErrorCode (line 424) | ErrorCode HTTP2Codec::parseHeadersImpl(
    function ErrorCode (line 714) | ErrorCode HTTP2Codec::parseRFC9218Priority(Cursor& cursor) {
    function ErrorCode (line 730) | ErrorCode HTTP2Codec::parseRstStream(Cursor& cursor) {
    function ErrorCode (line 748) | ErrorCode HTTP2Codec::parseSettings(Cursor& cursor) {
    function ErrorCode (line 771) | ErrorCode HTTP2Codec::handleSettings(const std::deque<SettingPair>& se...
    function ErrorCode (line 861) | ErrorCode HTTP2Codec::parsePushPromise(Cursor& cursor) {
    function ErrorCode (line 898) | ErrorCode HTTP2Codec::parsePing(Cursor& cursor) {
    function ErrorCode (line 913) | ErrorCode HTTP2Codec::parseGoaway(Cursor& cursor) {
    function ErrorCode (line 941) | ErrorCode HTTP2Codec::parseWindowUpdate(Cursor& cursor) {
    function ErrorCode (line 974) | ErrorCode HTTP2Codec::parseCertificateRequest(Cursor& cursor) {
    function ErrorCode (line 988) | ErrorCode HTTP2Codec::parseCertificate(Cursor& cursor) {
    function ErrorCode (line 1016) | ErrorCode HTTP2Codec::checkNewStream(uint32_t streamId, bool trailersA...

FILE: proxygen/lib/http/codec/HTTP2Codec.h
  function CodecProtocol (line 38) | CodecProtocol getProtocol() const override {
  function HTTPSettings (line 111) | const HTTPSettings* getIngressSettings() const override {
  function HTTPSettings (line 114) | HTTPSettings* getEgressSettings() override {
  function getDefaultWindowSize (line 117) | uint32_t getDefaultWindowSize() const override {
  function setHeaderCodecStats (line 132) | void setHeaderCodecStats(HeaderCodec::Stats* hcStats) override {
  function isRequest (line 136) | bool isRequest(StreamID id) const {
  function setReuseIOBufHeadroomForData (line 159) | void setReuseIOBufHeadroomForData(bool enabled) {
  function setHeaderIndexingStrategy (line 163) | void setHeaderIndexingStrategy(const HeaderIndexingStrategy* indexingStr...
  function HeaderIndexingStrategy (line 166) | const HeaderIndexingStrategy* getHeaderIndexingStrategy() const {
  function setAddDateHeaderToResponse (line 170) | void setAddDateHeaderToResponse(bool addDateHeader) {
  function setValidateHeaders (line 174) | void setValidateHeaders(bool validate) {
  function setStrictValidation (line 178) | void setStrictValidation(bool strict) {
  function setDebugLevel (line 182) | void setDebugLevel(uint64_t debugLevel) {
  type DeferredParseError (line 229) | struct DeferredParseError {
  function curCertId_ (line 304) | uint16_t curCertId_{0}
  function receivedFrameCount_ (line 321) | uint64_t receivedFrameCount_{0}
  type class (line 323) | enum class
  function pendingDataFrameBytes_ (line 333) | size_t pendingDataFrameBytes_{0}
  function pendingDataFramePaddingBytes_ (line 334) | size_t pendingDataFramePaddingBytes_{0}
  function strictValidation_ (line 350) | bool strictValidation_{false};

FILE: proxygen/lib/http/codec/HTTP2Constants.cpp
  type proxygen::http2 (line 11) | namespace proxygen::http2 {

FILE: proxygen/lib/http/codec/HTTP2Constants.h
  function namespace (line 15) | namespace proxygen::http2 {

FILE: proxygen/lib/http/codec/HTTP2Framer.cpp
  type proxygen::http2 (line 17) | namespace proxygen::http2 {
    function writePadding (line 35) | void writePadding(IOBufQueue& queue, folly::Optional<uint8_t> size) {
    function computeLengthAndType (line 49) | size_t computeLengthAndType(uint32_t length,
    function writeFrameHeader (line 78) | size_t writeFrameHeader(IOBufQueue& queue,
    function writeFrameHeader (line 119) | size_t writeFrameHeader(uint8_t* buf,
    function parseUint31 (line 151) | uint32_t parseUint31(Cursor& cursor) {
    function ErrorCode (line 156) | ErrorCode parseErrorCode(Cursor& cursor, ErrorCode& outCode) {
    function skipPriority (line 165) | void skipPriority(Cursor& cursor) {
    function ErrorCode (line 181) | ErrorCode parsePadding(Cursor& cursor,
    function ErrorCode (line 206) | ErrorCode skipPadding(Cursor& cursor, uint8_t length, bool verify) {
    function isValidFrameType (line 225) | bool isValidFrameType(FrameType type) {
    function frameAffectsCompression (line 257) | bool frameAffectsCompression(FrameType t) {
    function frameHasPadding (line 262) | bool frameHasPadding(const FrameHeader& header) {
    function ErrorCode (line 268) | ErrorCode parseFrameHeader(Cursor& cursor, FrameHeader& header) noexce...
    function ErrorCode (line 282) | ErrorCode parseData(Cursor& cursor,
    function ErrorCode (line 302) | ErrorCode parseDataBegin(Cursor& cursor,
    function ErrorCode (line 316) | ErrorCode parseDataEnd(Cursor& cursor,
    function ErrorCode (line 324) | ErrorCode parseHeaders(Cursor& cursor,
    function ErrorCode (line 346) | ErrorCode parseRFC9218Priority(Cursor& cursor,
    function ErrorCode (line 364) | ErrorCode parseRstStream(Cursor& cursor,
    function ErrorCode (line 377) | ErrorCode parseSettings(Cursor& cursor,
    function ErrorCode (line 402) | ErrorCode parsePushPromise(Cursor& cursor,
    function ErrorCode (line 431) | ErrorCode parsePing(Cursor& cursor,
    function ErrorCode (line 447) | ErrorCode parseGoaway(Cursor& cursor,
    function ErrorCode (line 470) | ErrorCode parseWindowUpdate(Cursor& cursor,
    function ErrorCode (line 481) | ErrorCode parseContinuation(Cursor& cursor,
    function ErrorCode (line 493) | ErrorCode parseAltSvc(Cursor& cursor,
    function ErrorCode (line 525) | ErrorCode parseCertificateRequest(
    function ErrorCode (line 546) | ErrorCode parseCertificate(
    function writeData (line 569) | size_t writeData(IOBufQueue& queue,
    function writePadding (line 595) | size_t writePadding(IOBufQueue& queue,
    function calculatePreHeaderBlockSize (line 615) | uint8_t calculatePreHeaderBlockSize(bool hasAssocStream,
    function writeHeaders (line 629) | size_t writeHeaders(uint8_t* header,
    function writeRFC9218Priority (line 657) | size_t writeRFC9218Priority(IOBufQueue& queue,
    function writeRstStream (line 676) | size_t writeRstStream(IOBufQueue& queue,
    function writeSettings (line 692) | size_t writeSettings(IOBufQueue& queue,
    function writeSettingsAck (line 707) | size_t writeSettingsAck(IOBufQueue& queue) {
    function writePushPromise (line 712) | size_t writePushPromise(uint8_t* header,
    function writePing (line 743) | size_t writePing(IOBufQueue& queue, uint64_t opaqueData, bool ack) noe...
    function writeGoaway (line 755) | size_t writeGoaway(IOBufQueue& queue,
    function writeWindowUpdate (line 775) | size_t writeWindowUpdate(IOBufQueue& queue,
    function writeContinuation (line 792) | size_t writeContinuation(IOBufQueue& queue,
    function writeAltSvc (line 808) | size_t writeAltSvc(IOBufQueue& queue,
    function writeCertificateRequest (line 833) | size_t writeCertificateRequest(folly::IOBufQueue& writeBuf,
    function writeCertificate (line 853) | size_t writeCertificate(folly::IOBufQueue& writeBuf,

FILE: proxygen/lib/http/codec/HTTP2Framer.h
  function namespace (line 24) | namespace proxygen::http2 {

FILE: proxygen/lib/http/codec/HTTPBinaryCodec.cpp
  type proxygen (line 25) | namespace proxygen {
    function encodeInteger (line 28) | folly::Expected<size_t, quic::TransportErrorCode> encodeInteger(
    function encodeString (line 39) | void encodeString(folly::StringPiece str, folly::io::QueueAppender& ap...
    function ParseResult (line 59) | ParseResult HTTPBinaryCodec::parseFramingIndicator(folly::io::Cursor& ...
    function ParseResult (line 87) | ParseResult HTTPBinaryCodec::parseKnownLengthString(
    function ParseResult (line 121) | ParseResult HTTPBinaryCodec::parseRequestControlData(folly::io::Cursor...
    function ParseResult (line 187) | ParseResult HTTPBinaryCodec::parseResponseControlData(folly::io::Curso...
    function ParseResult (line 204) | ParseResult HTTPBinaryCodec::parseSingleHeaderHelper(
    function ParseResult (line 242) | ParseResult HTTPBinaryCodec::parseKnownLengthHeadersHelper(
    function ParseResult (line 278) | ParseResult HTTPBinaryCodec::parseIndeterminateLengthHeadersHelper(
    function ParseResult (line 310) | ParseResult HTTPBinaryCodec::parseHeaders(folly::io::Cursor& cursor,
    function ParseResult (line 320) | ParseResult HTTPBinaryCodec::parseContent(folly::io::Cursor& cursor,
    function ParseResult (line 327) | ParseResult HTTPBinaryCodec::parseSingleContentHelper(folly::io::Curso...
    function ParseResult (line 357) | ParseResult HTTPBinaryCodec::parseKnownLengthContentHelper(
    function ParseResult (line 367) | ParseResult HTTPBinaryCodec::parseIndeterminateLengthContentHelper(
    function ParseResult (line 404) | ParseResult HTTPBinaryCodec::parseTrailers(folly::io::Cursor& cursor,

FILE: proxygen/lib/http/codec/HTTPBinaryCodec.h
  type class (line 19) | enum class
  function class (line 26) | class ParseResult {
  function CodecProtocol (line 63) | CodecProtocol getProtocol() const override {
  function StreamID (line 74) | StreamID createStream() override {
  function setCallback (line 77) | void setCallback(Callback* callback) override {
  function setParserPaused (line 83) | void setParserPaused(bool paused) override {
  function onIngressEOF (line 90) | void onIngressEOF() override;
  type class (line 213) | enum class
  function FramingIndicator (line 227) | enum class FramingIndicator : uint8_t {

FILE: proxygen/lib/http/codec/HTTPChecks.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTPChecks.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTPCodec.h
  function namespace (line 23) | namespace proxygen {
  function virtual (line 636) | virtual size_t generatePingRequest(
  function virtual (line 646) | virtual size_t generatePingReply(folly::IOBufQueue& /* writeBuf */,
  function virtual (line 655) | virtual size_t generateSettings(folly::IOBufQueue& /* writeBuf */) {
  function virtual (line 663) | virtual size_t generateSettingsAck(folly::IOBufQueue& /* writeBuf */) {
  function virtual (line 673) | virtual size_t generateWindowUpdate(folly::IOBufQueue& /* writeBuf */,
  function virtual (line 683) | virtual size_t generatePriority(folly::IOBufQueue& /* writeBuf */,
  function virtual (line 693) | virtual size_t generatePushPriority(folly::IOBufQueue& /* writeBuf */,
  function virtual (line 703) | virtual size_t generateCertificateRequest(
  function virtual (line 714) | virtual size_t generateCertificate(
  function virtual (line 725) | virtual HTTPSettings* getEgressSettings() {
  function virtual (line 729) | [[nodiscard]] virtual const HTTPSettings* getIngressSettings() const {
  function virtual (line 737) | virtual void enableDoubleGoawayDrain() {
  function virtual (line 740) | virtual void disableDoubleGoawayDrain() {
  function virtual (line 746) | virtual void setHeaderCodecStats(HeaderCodec::Stats* /* stats */) {
  function virtual (line 766) | [[nodiscard]] virtual int8_t mapDependencyToPriority(

FILE: proxygen/lib/http/codec/HTTPCodecFactory.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTPCodecFactory.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTPCodecFilter.cpp
  type proxygen (line 11) | namespace proxygen {
    function CompressionInfo (line 136) | CompressionInfo PassThroughHTTPCodecFilter::getCompressionInfo() const {
    function CodecProtocol (line 140) | CodecProtocol PassThroughHTTPCodecFilter::getProtocol() const {
    function TransportDirection (line 148) | TransportDirection PassThroughHTTPCodecFilter::getTransportDirection()...
    function HTTPSettings (line 344) | HTTPSettings* PassThroughHTTPCodecFilter::getEgressSettings() {
    function HTTPSettings (line 348) | const HTTPSettings* PassThroughHTTPCodecFilter::getIngressSettings() c...

FILE: proxygen/lib/http/codec/HTTPCodecFilter.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTPCodecPrinter.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTPCodecPrinter.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTPParallelCodec.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/HTTPParallelCodec.h
  function namespace (line 19) | namespace folly::io {
  function TransportDirection (line 33) | [[nodiscard]] TransportDirection getTransportDirection() const override {
  function setCallback (line 53) | void setCallback(Callback* callback) override {
  function setParserPaused (line 56) | void setParserPaused(bool /* paused */) override {
  function onIngressEOF (line 61) | void onIngressEOF() override {
  function isReusable (line 63) | [[nodiscard]] bool isReusable() const override;
  function enableDoubleGoawayDrain (line 68) | void enableDoubleGoawayDrain() override;
  function isInitiatedStream (line 81) | [[nodiscard]] bool isInitiatedStream(StreamID stream) const {
  function isInitiatedStream (line 85) | static bool isInitiatedStream(TransportDirection direction, StreamID str...
  function isStreamIngressEgressAllowed (line 91) | [[nodiscard]] bool isStreamIngressEgressAllowed(StreamID stream) const {
  function StreamID (line 100) | StreamID lastStreamID_{0}
  function StreamID (line 102) | StreamID ingressGoawayAck_{std::numeric_limits<uint32_t>::max()};

FILE: proxygen/lib/http/codec/HTTPRequestVerifier.h
  function reset (line 21) | void reset(HTTPMessage* msg) {
  function setMethod (line 32) | bool setMethod(folly::StringPiece method) {
  function setPath (line 48) | bool setPath(folly::StringPiece path,
  function setScheme (line 75) | bool setScheme(folly::StringPiece scheme) {
  function setAuthority (line 98) | bool setAuthority(folly::StringPiece authority,
  function setUpgradeProtocol (line 120) | bool setUpgradeProtocol(folly::StringPiece protocol, bool strictValidati...
  function validate (line 136) | bool validate() {
  function setMessage (line 162) | void setMessage(HTTPMessage* msg) {
  function setHasMethod (line 166) | void setHasMethod(bool hasMethod) {
  function setHasPath (line 170) | void setHasPath(bool hasPath) {
  function setHasScheme (line 174) | void setHasScheme(bool hasScheme) {
  function setHasAuthority (line 178) | void setHasAuthority(bool hasAuthority) {
  function setHasUpgradeProtocol (line 186) | void setHasUpgradeProtocol(bool val) {
  function hasUpgradeProtocol (line 190) | bool hasUpgradeProtocol() {
  function hasValidationError (line 194) | bool hasValidationError() {
  function hasUpgradeProtocol_ (line 206) | bool hasUpgradeProtocol_{false};

FILE: proxygen/lib/http/codec/HTTPSettings.cpp
  type proxygen (line 13) | namespace proxygen {
    function HTTPSetting (line 32) | const HTTPSetting* HTTPSettings::getSetting(SettingsId id) const {
    function SettingsValue (line 41) | SettingsValue HTTPSettings::getSetting(SettingsId id,

FILE: proxygen/lib/http/codec/HTTPSettings.h
  function namespace (line 22) | namespace proxygen {

FILE: proxygen/lib/http/codec/HeaderDecodeInfo.cpp
  type proxygen (line 17) | namespace proxygen {

FILE: proxygen/lib/http/codec/HeaderDecodeInfo.h
  function strictValidation_ (line 68) | bool strictValidation_{false};

FILE: proxygen/lib/http/codec/HeadersRateLimitFilter.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/QPACKDecoderCodec.h
  function namespace (line 15) | namespace proxygen::hq {

FILE: proxygen/lib/http/codec/QPACKEncoderCodec.h
  function namespace (line 16) | namespace proxygen::hq {

FILE: proxygen/lib/http/codec/RateLimitFilter.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/RateLimitFilter.h
  function namespace (line 16) | namespace proxygen {
  function class (line 84) | class RateLimitFilter : public PassThroughHTTPCodecFilter {

FILE: proxygen/lib/http/codec/ResetsRateLimitFilter.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/SettingsId.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/TransportDirection.cpp
  type proxygen (line 13) | namespace proxygen {
    function getTransportDirectionString (line 15) | std::string_view getTransportDirectionString(TransportDirection dir) {
    function TransportDirection (line 26) | TransportDirection operator!(TransportDirection dir) {

FILE: proxygen/lib/http/codec/TransportDirection.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/CompressionInfo.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKCodec.cpp
  type proxygen (line 26) | namespace proxygen {
    type compress (line 28) | namespace compress {
      function prepareHeaders (line 29) | uint32_t prepareHeaders(const vector<Header>& headers,

FILE: proxygen/lib/http/codec/compress/HPACKCodec.h
  function namespace (line 20) | namespace folly::io {
  function namespace (line 24) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKConstants.h
  function namespace (line 14) | namespace proxygen::HPACK {

FILE: proxygen/lib/http/codec/compress/HPACKContext.cpp
  type proxygen (line 11) | namespace proxygen {
    function HPACKHeader (line 101) | const HPACKHeader& HPACKContext::getHeader(uint32_t index) {

FILE: proxygen/lib/http/codec/compress/HPACKContext.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKDecodeBuffer.cpp
  type proxygen (line 19) | namespace proxygen {
    function DecodeError (line 51) | DecodeError HPACKDecodeBuffer::decodeLiteral(folly::fbstring& literal) {
    function DecodeError (line 55) | DecodeError HPACKDecodeBuffer::decodeLiteral(uint8_t nbit,
    function DecodeError (line 104) | DecodeError HPACKDecodeBuffer::decodeInteger(uint64_t& integer) {
    function DecodeError (line 108) | DecodeError HPACKDecodeBuffer::decodeInteger(uint8_t nbit, uint64_t& i...
    type HPACK (line 147) | namespace HPACK {

FILE: proxygen/lib/http/codec/compress/HPACKDecodeBuffer.h
  function reset (line 35) | void reset(folly::io::Cursor& cursorVal) {
  function reset (line 39) | void reset(folly::io::Cursor& cursorVal, uint32_t totalBytes) {
  function maxLiteralSize_ (line 95) | uint32_t maxLiteralSize_{std::numeric_limits<uint32_t>::max()};

FILE: proxygen/lib/http/codec/compress/HPACKDecoder.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKDecoder.h
  function namespace (line 19) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKDecoderBase.cpp
  type proxygen (line 12) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKDecoderBase.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKEncodeBuffer.cpp
  type proxygen (line 20) | namespace proxygen {
    function string (line 137) | string HPACKEncodeBuffer::toBin() {

FILE: proxygen/lib/http/codec/compress/HPACKEncodeBuffer.h
  function setHuffmanLimits (line 28) | void setHuffmanLimits(std::pair<uint32_t, uint32_t> limits) {
  function setWriteBuf (line 105) | void setWriteBuf(folly::IOBufQueue* writeBuf) {
  function huffMin_ (line 124) | uint32_t huffMin_{0}
  function huffMax_ (line 125) | uint32_t huffMax_{std::numeric_limits<uint32_t>::max()};

FILE: proxygen/lib/http/codec/compress/HPACKEncoder.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKEncoder.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKEncoderBase.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKEncoderBase.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKHeader.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKHeader.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HPACKHeaderName.h
  function namespace (line 20) | namespace proxygen {
  function HTTPHeaderCode (line 111) | [[nodiscard]] HTTPHeaderCode getHeaderCode() const {
  function copyAddress (line 155) | void copyAddress(const HPACKHeaderName& headerName) {
  function moveAddress (line 166) | void moveAddress(HPACKHeaderName&& goner) {
  function resetAddress (line 173) | void resetAddress() {
  function namespace (line 206) | namespace std {

FILE: proxygen/lib/http/codec/compress/HPACKStreamingCallback.h
  function namespace (line 15) | namespace proxygen::HPACK {

FILE: proxygen/lib/http/codec/compress/Header.h
  function namespace (line 14) | namespace proxygen::compress {

FILE: proxygen/lib/http/codec/compress/HeaderCodec.h
  function namespace (line 17) | namespace folly {
  function namespace (line 22) | namespace folly::io {
  type HeaderDecodeResult (line 28) | struct HeaderDecodeResult {
  type class (line 37) | enum class
  function class (line 39) | class Stats {
  function setEncodeHeadroom (line 63) | void setEncodeHeadroom(uint32_t headroom) {
  function virtual (line 67) | virtual void setMaxUncompressed(uint64_t maxUncompressed) {
  function setStats (line 78) | void setStats(Stats* stats) {
  function encodeHeadroom_ (line 84) | uint32_t encodeHeadroom_{0}
  function maxUncompressed_ (line 85) | uint64_t maxUncompressed_{kMaxUncompressed};

FILE: proxygen/lib/http/codec/compress/HeaderIndexingStrategy.cpp
  type proxygen (line 11) | namespace proxygen {
    function HeaderIndexingStrategy (line 13) | const HeaderIndexingStrategy* HeaderIndexingStrategy::getDefaultInstan...

FILE: proxygen/lib/http/codec/compress/HeaderIndexingStrategy.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/HeaderPiece.h
  function namespace (line 17) | namespace proxygen::compress {

FILE: proxygen/lib/http/codec/compress/HeaderTable.cpp
  type proxygen (line 13) | namespace proxygen {
    function HPACKHeader (line 105) | const HPACKHeader& HeaderTable::getHeader(uint32_t index) const {

FILE: proxygen/lib/http/codec/compress/HeaderTable.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/Huffman.cpp
  type proxygen::huffman (line 18) | namespace proxygen::huffman {
    function HuffTree (line 271) | const HuffTree& huffTree() {

FILE: proxygen/lib/http/codec/compress/Huffman.h
  function namespace (line 17) | namespace proxygen::huffman {

FILE: proxygen/lib/http/codec/compress/Logging.cpp
  type proxygen (line 18) | namespace proxygen {
    function ostream (line 20) | ostream& operator<<(ostream& os, const std::list<uint32_t>* refset) {
    function string (line 37) | string printDelta(const vector<HPACKHeader>& v1,

FILE: proxygen/lib/http/codec/compress/Logging.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/NoPathIndexingStrategy.cpp
  type proxygen (line 11) | namespace proxygen {
    function NoPathIndexingStrategy (line 13) | const NoPathIndexingStrategy* NoPathIndexingStrategy::getInstance() {

FILE: proxygen/lib/http/codec/compress/NoPathIndexingStrategy.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/QPACKCodec.cpp
  type proxygen (line 22) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/QPACKCodec.h
  function namespace (line 20) | namespace folly::io {
  function namespace (line 24) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/QPACKContext.cpp
  type proxygen (line 13) | namespace proxygen {
    function HPACKHeader (line 19) | const HPACKHeader& QPACKContext::getHeader(bool isStatic,

FILE: proxygen/lib/http/codec/compress/QPACKContext.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/QPACKDecoder.cpp
  type proxygen (line 19) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/QPACKDecoder.h
  function namespace (line 20) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/QPACKEncoder.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/QPACKEncoder.h
  type EncodeResult (line 39) | struct EncodeResult {
  function setMaxVulnerable (line 86) | void setMaxVulnerable(uint32_t maxVulnerable) {
  function setMinFreeForTesting (line 92) | void setMinFreeForTesting(uint32_t minFree) {
  function dynamicReferenceAllowed (line 118) | bool dynamicReferenceAllowed() const;
  type OutstandingBlock (line 175) | struct OutstandingBlock {
  function maxInUseIndex (line 177) | uint32_t maxInUseIndex{0}
  function vulnerable (line 178) | bool vulnerable{false};
  function maxDepends_ (line 185) | uint32_t maxDepends_{0}
  function numVulnerable_ (line 187) | uint32_t numVulnerable_{0}
  function maxTableSize_ (line 188) | uint32_t maxTableSize_{0}
  function maxEncoderStreamBytes_ (line 189) | int64_t maxEncoderStreamBytes_{0}
  function numOutstandingBlocks_ (line 191) | uint32_t numOutstandingBlocks_{0}
  function maxNumOutstandingBlocks_ (line 192) | uint32_t maxNumOutstandingBlocks_{kDefaultMaxOutstandingListSize};

FILE: proxygen/lib/http/codec/compress/QPACKHeaderTable.cpp
  function getMinFree (line 25) | uint32_t getMinFree(uint32_t tableSize) {
  type proxygen (line 32) | namespace proxygen {
    function HPACKHeader (line 127) | const HPACKHeader& QPACKHeaderTable::getHeader(uint32_t index,

FILE: proxygen/lib/http/codec/compress/QPACKHeaderTable.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/QPACKStaticHeaderTable.cpp
  type proxygen (line 128) | namespace proxygen {
    function StaticHeaderTable (line 146) | const StaticHeaderTable& QPACKStaticHeaderTable::get() {

FILE: proxygen/lib/http/codec/compress/QPACKStaticHeaderTable.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/StaticHeaderTable.cpp
  type proxygen (line 88) | namespace proxygen {
    function StaticHeaderTable (line 122) | const StaticHeaderTable& StaticHeaderTable::get() {

FILE: proxygen/lib/http/codec/compress/StaticHeaderTable.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/experimental/interop/QPACKInterop.cpp
  function writeFrame (line 36) | void writeFrame(folly::io::QueueAppender& appender,
  function encodeBlocks (line 45) | void encodeBlocks(QPACKCodec& decoder,
  function encodeHar (line 99) | void encodeHar(QPACKCodec& decoder, const proxygen::HTTPArchive& har) {
  class Reader (line 109) | class Reader {
    method Reader (line 113) | explicit Reader(const std::string& fname) : filename(fname) {
    method read (line 117) | virtual ssize_t read() {
  class CompressedReader (line 142) | class CompressedReader : public Reader {
    method CompressedReader (line 150) | explicit CompressedReader(
    method onIngress (line 155) | void onIngress(folly::IOBufQueue& inbuf) override {
  function decodeAndVerify (line 179) | int decodeAndVerify(QPACKCodec& decoder, const proxygen::HTTPArchive& ha...
  class QIFCallback (line 216) | class QIFCallback : public HPACK::StreamingCallback {
    method QIFCallback (line 218) | QIFCallback(uint64_t id_, std::ofstream& of_) : id(id_), of(of_) {
    method onHeader (line 221) | void onHeader(const HPACKHeaderName& name,
    method onHeadersComplete (line 229) | void onHeadersComplete(HTTPHeaderSize /*decodedSize*/,
    method onDecodeError (line 234) | void onDecodeError(HPACK::DecodeError decodeError) override {
  function decodeToQIF (line 244) | int decodeToQIF(QPACKCodec& decoder) {
  function interopHAR (line 275) | int interopHAR(QPACKCodec& decoder) {
  type QIFReader (line 294) | struct QIFReader : public Reader {
    method QIFReader (line 301) | QIFReader() : Reader(FLAGS_input) {
    method read (line 305) | ssize_t read() override {
    method iseol (line 315) | static bool iseol(uint8_t ch) {
    method onIngress (line 319) | void onIngress(folly::IOBufQueue& input) override {
  function interopQIF (line 385) | int interopQIF(QPACKCodec& decoder) {
  function main (line 405) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/CompressionScheme.h
  function namespace (line 15) | namespace proxygen::compress {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/CompressionSimulator.cpp
  type proxygen::compress (line 33) | namespace proxygen::compress {
    function CompressionScheme (line 251) | CompressionScheme* CompressionSimulator::getScheme(StringPiece domain) {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/CompressionSimulator.h
  function namespace (line 20) | namespace proxygen::compress {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/CompressionTypes.h
  function namespace (line 13) | namespace proxygen::compress {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.cpp
  function combineCookieCrumbsSorted (line 21) | std::string combineCookieCrumbsSorted(std::vector<std::string> crumbs) {
  function containsAllHeaders (line 28) | bool containsAllHeaders(const HTTPHeaders& h1, const HTTPHeaders& h2) {
  type proxygen (line 79) | namespace proxygen {
    type compress (line 81) | namespace compress {
      function prepareMessageForCompression (line 83) | std::vector<compress::Header> prepareMessageForCompression(

FILE: proxygen/lib/http/codec/compress/experimental/simulator/CompressionUtils.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/HPACKQueue.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/HPACKQueueTests.cpp
  function bufLen (line 21) | uint64_t bufLen(const std::unique_ptr<IOBuf>& buf) {
  class HPACKQueueTests (line 30) | class HPACKQueueTests : public testing::TestWithParam<int> {
    method HPACKQueueTests (line 32) | HPACKQueueTests() : queue(std::make_unique<HPACKQueue>(server)) {
  function TEST_F (line 41) | TEST_F(HPACKQueueTests, QueueInline) {
  function TEST_F (line 56) | TEST_F(HPACKQueueTests, QueueReorder) {
  function TEST_F (line 80) | TEST_F(HPACKQueueTests, QueueReorderOoo) {
  function TEST_F (line 105) | TEST_F(HPACKQueueTests, QueueError) {
  function TEST_P (line 128) | TEST_P(HPACKQueueTests, QueueDeleted) {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/HPACKScheme.h
  function recvAck (line 41) | void recvAck(std::unique_ptr<Ack> /*ack*/) override {
  function FrameFlags (line 55) | FrameFlags flags{allowOOO_};
  function decode (line 59) | void decode(FrameFlags flags,
  function HPACKQueue (line 84) | HPACKQueue serverQueue_{server_};

FILE: proxygen/lib/http/codec/compress/experimental/simulator/Main.cpp
  function main (line 36) | int main(int argc, char* argv[]) {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/QMINScheme.h
  type qmin_index_type (line 25) | enum qmin_index_type {
  type qmin_encode_status (line 34) | enum qmin_encode_status {
  type qmin_ctl_out (line 39) | struct qmin_ctl_out {
  type qmin_enc (line 43) | struct qmin_enc
  type qmin_enc (line 44) | struct qmin_enc
  type qmin_ctl_out (line 46) | struct qmin_ctl_out
  function qmin_enc_cmds_in (line 50) | static ssize_t qmin_enc_cmds_in(struct qmin_enc * /*enc*/,
  function qmin_enc_encode (line 55) | static enum qmin_encode_status qmin_enc_encode(struct qmin_enc * /*enc*/,
  function qmin_enc_end_stream_headers (line 67) | static int qmin_enc_end_stream_headers(struct qmin_enc * /*enc*/) {
  type qmin_enc (line 70) | struct qmin_enc
  function qmin_enc_destroy (line 73) | static void qmin_enc_destroy(struct qmin_enc * /*enc*/) {
  type qmin_dec (line 75) | struct qmin_dec
  type qmin_dec (line 76) | struct qmin_dec
  type qmin_ctl_out (line 78) | struct qmin_ctl_out
  function qmin_dec_cmds_in (line 82) | static ssize_t qmin_dec_cmds_in(struct qmin_dec * /*dec*/,
  function qmin_dec_decode (line 87) | static ssize_t qmin_dec_decode(struct qmin_dec * /*dec*/,
  function qmin_dec_stream_done (line 96) | static int qmin_dec_stream_done(struct qmin_dec * /*dec*/,
  function qmin_dec_destroy (line 100) | static void qmin_dec_destroy(struct qmin_dec * /*dec*/) {
  type stream_chunk (line 109) | struct stream_chunk {
  type stream (line 116) | struct stream {
  function namespace (line 121) | namespace proxygen::compress {
  type stream_chunk (line 365) | struct stream_chunk
  function runLoopCallback (line 422) | void runLoopCallback() noexcept override {
  function write_ctl_msg (line 426) | void write_ctl_msg(const void *buf, size_t sz, unsigned idx) {
  function write_enc2dec (line 439) | static void write_enc2dec(void *ctx, const void *buf, size_t sz) {
  function write_dec2enc (line 444) | static void write_dec2enc(void *ctx, const void *buf, size_t sz) {
  type qmin_enc (line 451) | struct qmin_enc
  type qmin_dec (line 452) | struct qmin_dec
  type stream (line 460) | struct stream
  type qmin_ctl_out (line 463) | struct qmin_ctl_out

FILE: proxygen/lib/http/codec/compress/experimental/simulator/QPACKScheme.h
  function namespace (line 15) | namespace proxygen::compress {

FILE: proxygen/lib/http/codec/compress/experimental/simulator/SimStreamingCallback.h
  function namespace (line 17) | namespace proxygen::compress {
  function maybeMarkHolDelay (line 87) | void maybeMarkHolDelay() {
  function requestIndex (line 94) | uint16_t requestIndex{0}
  function seqn (line 96) | uint16_t seqn{0}
  function isPublic (line 102) | bool isPublic{false};

FILE: proxygen/lib/http/codec/compress/test/EncoderBenchmark.cpp
  function HTTPHeaders (line 18) | const HTTPHeaders& getHeaders() {
  function encoderBenchmark (line 40) | void encoderBenchmark(uint32_t iters, bool huffman, uint32_t tableSize) {
  function BENCHMARK (line 76) | BENCHMARK(EncoderHuffman4096, iters) {
  function BENCHMARK (line 80) | BENCHMARK(EncoderNoHuffman4096, iters) {
  function BENCHMARK (line 84) | BENCHMARK(EncoderHuffman0, iters) {
  function BENCHMARK (line 88) | BENCHMARK(EncoderNoHuffman0, iters) {
  function main (line 92) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/codec/compress/test/HPACKBenchmark.cpp
  function encode (line 21) | unique_ptr<IOBuf> encode(vector<HPACKHeader>& headers, HPACKEncoder& enc...
  function encodeDecode (line 25) | void encodeDecode(vector<HPACKHeader>& headers,
  function getHeaders (line 36) | vector<HPACKHeader> getHeaders() {
  function encodeBench (line 59) | void encodeBench(int reencodes, int iters) {
  function encodeDecodeBench (line 69) | void encodeDecodeBench(int reencodes, int iters) {
  function BENCHMARK (line 80) | BENCHMARK(Encode, iters) {
  function BENCHMARK (line 84) | BENCHMARK(Encode1, iters) {
  function BENCHMARK (line 88) | BENCHMARK(Encode2, iters) {
  function BENCHMARK (line 92) | BENCHMARK(EncodeDecode, iters) {
  function BENCHMARK (line 96) | BENCHMARK(EncodeDecode1, iters) {
  function BENCHMARK (line 100) | BENCHMARK(EncodeDecode2, iters) {
  function main (line 104) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/codec/compress/test/HPACKBufferTests.cpp
  class HPACKBufferTests (line 26) | class HPACKBufferTests : public testing::Test {
    method HPACKBufferTests (line 32) | HPACKBufferTests() : encoder_(512), decoder_(cursor_, 0, kMaxLiteralSi...
    method releaseData (line 37) | void releaseData() {
    method releaseData (line 41) | void releaseData(HPACKEncodeBuffer& encoder) {
    method resetDecoder (line 48) | void resetDecoder() {
    method resetDecoder (line 52) | void resetDecoder(IOBuf* buf) {
  function TEST_F (line 64) | TEST_F(HPACKBufferTests, EncodeInteger) {
  function TEST_F (line 94) | TEST_F(HPACKBufferTests, EncodePlainLiteral) {
  function TEST_F (line 105) | TEST_F(HPACKBufferTests, EncodePlainLiteralN) {
  function TEST_F (line 117) | TEST_F(HPACKBufferTests, EncodeHuffmanLiteral) {
  function TEST_F (line 128) | TEST_F(HPACKBufferTests, EncodeHuffmanLiteralN) {
  function TEST_F (line 139) | TEST_F(HPACKBufferTests, DecodeSingleByte) {
  function TEST_F (line 167) | TEST_F(HPACKBufferTests, DecodeMultiByte) {
  function TEST_F (line 205) | TEST_F(HPACKBufferTests, DecodeIntegerError) {
  function TEST_F (line 221) | TEST_F(HPACKBufferTests, DecodeLiteralError) {
  function TEST_F (line 241) | TEST_F(HPACKBufferTests, DecodeLiteralMultiBuffer) {
  function TEST_F (line 271) | TEST_F(HPACKBufferTests, DecodeHuffmanLiteralMultiBuffer) {
  function TEST_F (line 308) | TEST_F(HPACKBufferTests, DecodeHuffmanLiteralN) {
  function TEST_F (line 327) | TEST_F(HPACKBufferTests, DecodePlainLiteral) {
  function TEST_F (line 342) | TEST_F(HPACKBufferTests, DecodePlainLiteralN) {
  function TEST_F (line 357) | TEST_F(HPACKBufferTests, IntegerEncodeDecode) {
  function TEST_F (line 383) | TEST_F(HPACKBufferTests, IntegerOverflow) {
  function TEST_F (line 425) | TEST_F(HPACKBufferTests, IntegerMax) {
  function TEST_F (line 444) | TEST_F(HPACKBufferTests, EmptyIobufLiteral) {
  function TEST_F (line 467) | TEST_F(HPACKBufferTests, LargeLiteralError) {

FILE: proxygen/lib/http/codec/compress/test/HPACKCodecTests.cpp
  function isLowercase (line 28) | bool isLowercase(StringPiece str) {
  type DecodeResult (line 39) | struct DecodeResult {
  function decode (line 44) | folly::Expected<DecodeResult, HPACK::DecodeError> decode(
  function encodeDecode (line 56) | folly::Expected<DecodeResult, HPACK::DecodeError> encodeDecode(
  class HPACKCodecTests (line 65) | class HPACKCodecTests : public testing::Test {
  function TEST_F (line 71) | TEST_F(HPACKCodecTests, Request) {
  function TEST_F (line 79) | TEST_F(HPACKCodecTests, Response) {
  function TEST_F (line 92) | TEST_F(HPACKCodecTests, Headroom) {
  function TEST_F (line 108) | TEST_F(HPACKCodecTests, LowercasingHeaderNames) {
  function TEST_F (line 125) | TEST_F(HPACKCodecTests, MultivalueHeaders) {
  function TEST_F (line 146) | TEST_F(HPACKCodecTests, DecodeError) {
  function TEST_F (line 167) | TEST_F(HPACKCodecTests, HeaderCodecStats) {
  function TEST_F (line 209) | TEST_F(HPACKCodecTests, UncompressedSizeLimit) {
  function TEST_F (line 226) | TEST_F(HPACKCodecTests, SizeLimitStats) {
  function TEST_F (line 248) | TEST_F(HPACKCodecTests, DefaultHeaderIndexingStrategy) {
  class TestIndexingStrat (line 276) | class TestIndexingStrat : public HeaderIndexingStrategy {
    method indexHeader (line 278) | [[nodiscard]] bool indexHeader(const HPACKHeaderName&,
    method getHuffmanLimits (line 284) | [[nodiscard]] std::pair<uint32_t, uint32_t> getHuffmanLimits()
  function TEST_F (line 292) | TEST_F(HPACKCodecTests, CustomHeaderIndexingStrategy) {

FILE: proxygen/lib/http/codec/compress/test/HPACKContextTests.cpp
  class HPACKContextTests (line 25) | class HPACKContextTests : public testing::TestWithParam<bool> {}
  class TestContext (line 27) | class TestContext : public HPACKContext {
    method TestContext (line 30) | explicit TestContext(uint32_t tableSize) : HPACKContext(tableSize) {
    method add (line 33) | void add(const HPACKHeader& header) {
  function TEST_F (line 38) | TEST_F(HPACKContextTests, GetIndex) {
  function TEST_F (line 46) | TEST_F(HPACKContextTests, IsStatic) {
  function TEST_F (line 63) | TEST_F(HPACKContextTests, StaticTable) {
  function TEST_F (line 76) | TEST_F(HPACKContextTests, StaticTableHeaderNamesAreCommon) {
  function TEST_F (line 94) | TEST_F(HPACKContextTests,
  function TEST_F (line 105) | TEST_F(HPACKContextTests, StaticIndex) {
  function TEST_F (line 117) | TEST_F(HPACKContextTests, EncoderMultipleValues) {
  function TEST_F (line 133) | TEST_F(HPACKContextTests, DecoderLargeHeader) {
  function TEST_F (line 149) | TEST_F(HPACKContextTests, DecoderLargeHeaderClear) {
  function TEST_F (line 171) | TEST_F(HPACKContextTests, DecoderInvalidPeek) {
  function TEST_F (line 192) | TEST_F(HPACKContextTests, DecoderInvalidLiteralPeek) {
  function checkError (line 212) | void checkError(const IOBuf* buf, const HPACK::DecodeError err) {
  function TEST_F (line 219) | TEST_F(HPACKContextTests, DecodeErrors) {
  function TEST_F (line 280) | TEST_F(HPACKContextTests, ExcludeHeadersLargerThanTable) {
  function TEST_F (line 299) | TEST_F(HPACKContextTests, EncodeToWriteBuf) {
  function TEST_P (line 309) | TEST_P(HPACKContextTests, ContextUpdate) {

FILE: proxygen/lib/http/codec/compress/test/HPACKHeaderTests.cpp
  class HPACKHeaderTests (line 20) | class HPACKHeaderTests : public testing::Test {}
  function TEST_F (line 22) | TEST_F(HPACKHeaderTests, Size) {
  function TEST_F (line 27) | TEST_F(HPACKHeaderTests, Operators) {
  function TEST_F (line 49) | TEST_F(HPACKHeaderTests, HasValue) {
  function TEST_F (line 56) | TEST_F(HPACKHeaderTests, HeaderIndexingStrategyBasic) {
  class HPACKHeaderNameTest (line 68) | class HPACKHeaderNameTest : public testing::Test {}
  function HPACKHeaderName (line 70) | HPACKHeaderName destroyedHPACKHeaderName(std::string name) {
  function TEST_F (line 76) | TEST_F(HPACKHeaderNameTest, TestConstructor) {
  function TEST_F (line 88) | TEST_F(HPACKHeaderNameTest, TestCopyConstructor) {
  function TEST_F (line 103) | TEST_F(HPACKHeaderNameTest, TestMoveConstructor) {
  function TEST_F (line 114) | TEST_F(HPACKHeaderNameTest, TestAssignmentOperators) {
  function TEST_F (line 151) | TEST_F(HPACKHeaderNameTest, TestGetSize) {
  function TEST_F (line 159) | TEST_F(HPACKHeaderNameTest, TestOperators) {
  function TEST_F (line 175) | TEST_F(HPACKHeaderNameTest, TestIsCommonHeader) {

FILE: proxygen/lib/http/codec/compress/test/HTTPArchive.cpp
  function parseHTTPArchiveTime (line 28) | folly::Optional<std::chrono::steady_clock::time_point> parseHTTPArchiveT...
  function extractMessage (line 62) | proxygen::HTTPMessage extractMessage(folly::dynamic& obj,
  function extractMessageFromPublic (line 102) | proxygen::HTTPMessage extractMessageFromPublic(folly::dynamic& obj) {
  type proxygen (line 118) | namespace proxygen {
    function readFileToIOBuf (line 120) | std::unique_ptr<IOBuf> readFileToIOBuf(const std::string& filename) {

FILE: proxygen/lib/http/codec/compress/test/HTTPArchive.h
  function namespace (line 19) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/test/HeaderPieceTests.cpp
  class HeaderPieceTests (line 15) | class HeaderPieceTests : public testing::Test {}
  function TEST_F (line 17) | TEST_F(HeaderPieceTests, Basic) {

FILE: proxygen/lib/http/codec/compress/test/HeaderTableTests.cpp
  type proxygen (line 18) | namespace proxygen {
    class HeaderTableTests (line 20) | class HeaderTableTests : public testing::Test {
      method xcheck (line 22) | void xcheck(uint32_t internal, uint32_t external) {
      method resizeTable (line 27) | void resizeTable(HeaderTable& table, uint32_t newCapacity, uint32_t ...
      method resizeAndFillTable (line 34) | void resizeAndFillTable(HeaderTable& table,
    function TEST_F (line 53) | TEST_F(HeaderTableTests, IndexTranslation) {
    function TEST_F (line 68) | TEST_F(HeaderTableTests, Add) {
    function TEST_F (line 81) | TEST_F(HeaderTableTests, Evict) {
    function TEST_F (line 120) | TEST_F(HeaderTableTests, ReduceCapacity) {
    function TEST_F (line 137) | TEST_F(HeaderTableTests, Comparison) {
    function TEST_F (line 157) | TEST_F(HeaderTableTests, Print) {
    function TEST_F (line 165) | TEST_F(HeaderTableTests, IncreaseCapacity) {
    function TEST_F (line 189) | TEST_F(HeaderTableTests, VaryCapacity) {
    function TEST_F (line 214) | TEST_F(HeaderTableTests, VaryCapacityMalignHeadIndex) {
    function TEST_F (line 264) | TEST_F(HeaderTableTests, AddLargerThanTable) {
    function TEST_F (line 294) | TEST_F(HeaderTableTests, IncreaseLengthOfFullTable) {
    function TEST_F (line 323) | TEST_F(HeaderTableTests, SmallTable) {
    function TEST_F (line 332) | TEST_F(HeaderTableTests, TinyTable) {

FILE: proxygen/lib/http/codec/compress/test/HuffmanTests.cpp
  class HuffmanTests (line 23) | class HuffmanTests : public testing::Test {
  function TEST_F (line 28) | TEST_F(HuffmanTests, Codes) {
  function TEST_F (line 44) | TEST_F(HuffmanTests, Size) {
  function TEST_F (line 55) | TEST_F(HuffmanTests, Encode) {
  function TEST_F (line 79) | TEST_F(HuffmanTests, Decode) {
  function TEST_F (line 107) | TEST_F(HuffmanTests, NonPrintableDecode) {
  function TEST_F (line 126) | TEST_F(HuffmanTests, ExampleCom) {
  function TEST_F (line 143) | TEST_F(HuffmanTests, UserAgent) {
  function TEST_F (line 168) | TEST_F(HuffmanTests, FitInBuffer) {
  function treeDfs (line 197) | uint32_t treeDfs(const SuperHuffNode* allSnodes,
  class TestingHuffTree (line 260) | class TestingHuffTree : public HuffTree {
    method TestingHuffTree (line 262) | explicit TestingHuffTree(const HuffTree& tree) : HuffTree(tree) {
    method SuperHuffNode (line 265) | const SuperHuffNode* getInternalTable() {
    method TestingHuffTree (line 269) | static TestingHuffTree getHuffTree() {
  function TEST_F (line 275) | TEST_F(HuffmanTests, SanityChecks) {

FILE: proxygen/lib/http/codec/compress/test/LoggingTests.cpp
  class LoggingTests (line 20) | class LoggingTests : public testing::Test {}
  function TEST_F (line 22) | TEST_F(LoggingTests, Refset) {
  function TEST_F (line 31) | TEST_F(LoggingTests, DumpHeaderVector) {
  function TEST_F (line 40) | TEST_F(LoggingTests, PrintDelta) {
  function TEST_F (line 66) | TEST_F(LoggingTests, DumpBin) {

FILE: proxygen/lib/http/codec/compress/test/QPACKCodecTests.cpp
  function headersEq (line 28) | void headersEq(vector<Header>& headerVec, compress::HeaderPieceList& hea...
  class QPACKTests (line 41) | class QPACKTests : public testing::Test {
    method SetUp (line 43) | void SetUp() override {
    method controlAck (line 50) | void controlAck() {
    method headerAck (line 56) | void headerAck(uint64_t streamId) {
  function TEST_F (line 66) | TEST_F(QPACKTests, TestEncoderTableSize) {
  function TEST_F (line 75) | TEST_F(QPACKTests, TestSimple) {
  function TEST_F (line 93) | TEST_F(QPACKTests, TestAbsoluteIndex) {
  function TEST_F (line 124) | TEST_F(QPACKTests, TestWithQueue) {
  function TEST_F (line 192) | TEST_F(QPACKTests, HeaderCodecStats) {

FILE: proxygen/lib/http/codec/compress/test/QPACKContextTests.cpp
  function verifyDecode (line 24) | std::shared_ptr<bool> verifyDecode(
  function stringInOutput (line 57) | bool stringInOutput(IOBuf* stream, const std::string& expected) {
  function headerAck (line 63) | HPACK::DecodeError headerAck(QPACKDecoder& decoder,
  function cancelStream (line 69) | HPACK::DecodeError cancelStream(QPACKDecoder& decoder,
  function toFixedLengthString (line 75) | std::string toFixedLengthString(uint32_t i) {
  function TEST (line 81) | TEST(QPACKContextTests, StaticOnly) {
  function TEST (line 101) | TEST(QPACKContextTests, StaticNameIndex) {
  function TEST (line 131) | TEST(QPACKContextTests, Indexed) {
  function TEST (line 144) | TEST(QPACKContextTests, NameIndexed) {
  function TEST (line 159) | TEST(QPACKContextTests, NameIndexedInsert) {
  function TEST (line 175) | TEST(QPACKContextTests, PostBaseNameIndexedLiteral) {
  function TEST (line 195) | TEST(QPACKContextTests, TestOutstandingListTooLong) {
  function TEST (line 248) | TEST(QPACKContextTests, TestOutstandingListAckingAll) {
  function TEST (line 291) | TEST(QPACKContextTests, Unacknowledged) {
  function TEST (line 310) | TEST(QPACKContextTests, TestDraining) {
  function TEST (line 326) | TEST(QPACKContextTests, TestDuplicate) {
  function TEST (line 347) | TEST(QPACKContextTests, TestTableSizeUpdate) {
  function TEST (line 371) | TEST(QPACKContextTests, TestTableSizeUpdateMax) {
  function TEST (line 387) | TEST(QPACKContextTests, TestEncoderFlowControl) {
  function TEST (line 434) | TEST(QPACKContextTests, TestAcks) {
  function TEST (line 487) | TEST(QPACKContextTests, TestEncodeBlocksSelfEviction) {
  function TEST (line 508) | TEST(QPACKContextTests, TestImplicitAcks) {
  function TEST (line 538) | TEST(QPACKContextTests, TestDecodeQueue) {
  function TEST (line 553) | TEST(QPACKContextTests, TestDecodeQueueDelete) {
  function TEST (line 592) | TEST(QPACKContextTests, TestDecodeQueueResetSelf) {
  function TEST (line 612) | TEST(QPACKContextTests, TestEncoderStreamEndBlocked) {
  function TEST (line 630) | TEST(QPACKContextTests, TestEncoderStreamEndUnderflow) {
  function TEST (line 649) | TEST(QPACKContextTests, TestDecodeMaxUncompressed) {
  function TEST (line 661) | TEST(QPACKContextTests, TestDecoderStreamChunked) {
  function TEST (line 685) | TEST(QPACKContextTests, TestEncoderStreamReorder) {
  function TEST (line 714) | TEST(QPACKContextTests, TestEncoderTableLimit) {
  function TEST (line 722) | TEST(QPACKContextTests, TestDecodePartialControl) {
  function TEST (line 741) | TEST(QPACKContextTests, WrapRICBehind) {
  function TEST (line 788) | TEST(QPACKContextTests, WrapRICAhead) {
  function checkQError (line 851) | void checkQError(QPACKDecoder& decoder,
  function TEST (line 861) | TEST(QPACKContextTests, DecodeErrors) {
  function TEST (line 1013) | TEST(QPACKContextTests, TestEvictedNameReference) {
  function TEST (line 1037) | TEST(QPACKContextTests, TestFragmentTableSizeUpdate) {

FILE: proxygen/lib/http/codec/compress/test/QPACKHeaderTableTests.cpp
  type proxygen (line 15) | namespace proxygen {
    class QPACKHeaderTableTests (line 17) | class QPACKHeaderTableTests : public testing::Test {
    function TEST_F (line 23) | TEST_F(QPACKHeaderTableTests, Indexing) {
    function TEST_F (line 43) | TEST_F(QPACKHeaderTableTests, Eviction) {
    function TEST_F (line 62) | TEST_F(QPACKHeaderTableTests, BadEviction) {
    function TEST_F (line 87) | TEST_F(QPACKHeaderTableTests, Wrapcount) {
    function TEST_F (line 108) | TEST_F(QPACKHeaderTableTests, NameIndex) {
    function TEST_F (line 115) | TEST_F(QPACKHeaderTableTests, GetIndex) {
    function TEST_F (line 124) | TEST_F(QPACKHeaderTableTests, Duplication) {
    function TEST_F (line 173) | TEST_F(QPACKHeaderTableTests, CanEvictWithRoom) {
    function TEST_F (line 187) | TEST_F(QPACKHeaderTableTests, EvictNonDrained) {
    function TEST_F (line 215) | TEST_F(QPACKHeaderTableTests, BadSync) {
    function TEST_F (line 220) | TEST_F(QPACKHeaderTableTests, TinyTable) {

FILE: proxygen/lib/http/codec/compress/test/RFCExamplesTests.cpp
  class RFCRequestTest (line 26) | class RFCRequestTest : public testing::TestWithParam<RfcParam> {
    method RFCRequestTest (line 28) | RFCRequestTest() {
  class RFCResponseTest (line 53) | class RFCResponseTest : public testing::TestWithParam<RfcParam> {
    method RFCResponseTest (line 55) | RFCResponseTest() {
  function unhexlify (line 116) | std::string unhexlify(const std::string& input) {
  function TEST_P (line 123) | TEST_P(RFCRequestTest, RfcExampleRequest) {
  function TEST_P (line 147) | TEST_P(RFCResponseTest, RfcExampleResponse) {

FILE: proxygen/lib/http/codec/compress/test/TestStreamingCallback.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/http/codec/compress/test/TestUtil.cpp
  type proxygen::hpack (line 25) | namespace proxygen::hpack {
    function dumpToFile (line 27) | void dumpToFile(const string& filename, const IOBuf* buf) {
    function verifyHeaders (line 39) | void verifyHeaders(vector<HPACKHeader>& headers,
    function encodeDecode (line 55) | unique_ptr<IOBuf> encodeDecode(vector<HPACKHeader>& headers,
    function encodeDecode (line 71) | void encodeDecode(vector<HPACKHeader>& headers,
    function decode (line 93) | unique_ptr<HPACKDecoder::headers_t> decode(HPACKDecoder& decoder,
    function headersFromArray (line 106) | vector<compress::Header> headersFromArray(vector<vector<string>>& a) {
    function basicHeaders (line 114) | vector<compress::Header> basicHeaders() {

FILE: proxygen/lib/http/codec/compress/test/TestUtil.h
  function namespace (line 20) | namespace proxygen::hpack {

FILE: proxygen/lib/http/codec/test/CapsuleCodecTest.cpp
  class TestCapsuleCodecCallback (line 20) | class TestCapsuleCodecCallback : public CapsuleCodec::Callback {
  class TestCapsuleCodec (line 30) | class TestCapsuleCodec : public CapsuleCodec {
    method TestCapsuleCodec (line 32) | explicit TestCapsuleCodec(TestCapsuleCodecCallback* callback = nullptr)
    method canParseCapsule (line 36) | bool canParseCapsule(uint64_t capsuleType) noexcept override {
    method parseCapsule (line 40) | folly::Expected<folly::Unit, ErrorCode> parseCapsule(
  class CapsuleCodecTest (line 53) | class CapsuleCodecTest : public Test {
    method SetUp (line 55) | void SetUp() override {
  function generateStringCapsule (line 63) | quic::BufQueue generateStringCapsule(uint64_t type,
  function TEST_F (line 80) | TEST_F(CapsuleCodecTest, ValidCapsuleParsing) {
  function TEST_F (line 88) | TEST_F(CapsuleCodecTest, InvalidCapsuleType) {
  function TEST_F (line 98) | TEST_F(CapsuleCodecTest, TooLargePayloadAndEom) {
  function TEST_F (line 106) | TEST_F(CapsuleCodecTest, ParseUnderflowInvalidPayload) {
  function TEST_F (line 114) | TEST_F(CapsuleCodecTest, ParseUnderflowLength) {
  function TEST_F (line 128) | TEST_F(CapsuleCodecTest, SkipCapsule) {
  function TEST_F (line 135) | TEST_F(CapsuleCodecTest, SkipCapsuleMultiple) {
  function TEST_F (line 148) | TEST_F(CapsuleCodecTest, ParseUnderflowAndNotEom) {
  function TEST_F (line 177) | TEST_F(CapsuleCodecTest, MultipleCapsules) {

FILE: proxygen/lib/http/codec/test/CodecUtilTests.cpp
  type proxygen::test (line 15) | namespace proxygen::test {
    function input (line 17) | folly::ByteRange input(const char *str) {
    function TEST (line 21) | TEST(CodecUtil, validateURL) {
    function TEST (line 28) | TEST(CodecUtil, validateMethod) {
    function TEST (line 38) | TEST(CodecUtil, validateScheme) {
    function TEST (line 44) | TEST(CodecUtil, validateHeaderName) {
    function TEST (line 96) | TEST(CodecUtil, validateHeaderValue) {
    function TEST (line 162) | TEST(CodecUtil, hasGzipAndDeflate) {

FILE: proxygen/lib/http/codec/test/CrossCodecTest.cpp
  function parseBufWithH1Codec (line 18) | void parseBufWithH1Codec(FakeHTTPCodecCallback& callback,
  function TEST (line 32) | TEST(CrossCodecTest, ConnectRequestConversion) {

FILE: proxygen/lib/http/codec/test/DefaultHTTPCodecFactoryTest.cpp
  function TEST (line 19) | TEST(DefaultHTTPCodecFactoryTest, GetCodec) {
  class DefaultHTTPCodecFactoryValidationTest (line 39) | class DefaultHTTPCodecFactoryValidationTest
  function TEST_P (line 42) | TEST_P(DefaultHTTPCodecFactoryValidationTest, StrictValidation) {

FILE: proxygen/lib/http/codec/test/FilterTests.cpp
  function makeIOBuf (line 26) | std::unique_ptr<folly::IOBuf> makeIOBuf(const std::string& str) {
  class MockFlowControlCallback (line 31) | class MockFlowControlCallback : public FlowControlFilter::Callback {
  class FilterTest (line 37) | class FilterTest : public testing::Test {
    method FilterTest (line 39) | FilterTest()
  class HTTPChecksTest (line 54) | class HTTPChecksTest : public FilterTest {
    method SetUp (line 56) | void SetUp() override {
  class DebugFilterTest (line 61) | class DebugFilterTest : public FilterTest {
    method SetUp (line 63) | void SetUp() override {
  class FlowControlFilterTest (line 76) | class FlowControlFilterTest : public FilterTest {
    method SetUp (line 78) | void SetUp() override {
  function TEST_F (line 123) | TEST_F(DefaultFlowControl, FlowControlConstruct) {
  function TEST_F (line 152) | TEST_F(DefaultFlowControl, SendUpdate) {
  function TEST_F (line 166) | TEST_F(BigWindow, RecvTooMuch) {
  function TEST_F (line 191) | TEST_F(BigWindow, RemoteIncrease) {
  function TEST_F (line 229) | TEST_F(HTTPChecksTest, SendTraceBodyDeath) {
  function TEST_F (line 238) | TEST_F(HTTPChecksTest, SendGetBody) {
  function TEST_F (line 250) | TEST_F(HTTPChecksTest, RecvTraceBody) {
  function TEST_F (line 268) | TEST_F(DebugFilterTest, NoError) {
  function TEST_F (line 277) | TEST_F(DebugFilterTest, NoErrorGoaway) {
  function TEST_F (line 283) | TEST_F(DebugFilterTest, IngressGoaway) {
  function TEST_F (line 289) | TEST_F(DebugFilterTest, EgressGoaway) {
  function TEST_F (line 296) | TEST_F(DebugFilterTest, IngressRstTrackedStream) {
  function TEST_F (line 306) | TEST_F(DebugFilterTest, EgressRstTrackedStream) {
  function TEST_F (line 316) | TEST_F(DebugFilterTest, OnSessionError) {
  function TEST_F (line 323) | TEST_F(DebugFilterTest, OnStreamErrorTracked) {
  function TEST_F (line 334) | TEST_F(DebugFilterTest, OnStreamErrorPartialMsg) {

FILE: proxygen/lib/http/codec/test/HQCodecTest.cpp
  class FakeHQHTTPCodecCallback (line 28) | class FakeHQHTTPCodecCallback
    method onError (line 34) | void onError(HTTPCodec::StreamID streamId,
  type CodecType (line 41) | enum class CodecType {
  class HQCodecTestFixture (line 53) | class HQCodecTestFixture : public T {
    method SetUp (line 55) | void SetUp() override {
    method SetUpCodecs (line 60) | void SetUpCodecs() {
    method parse (line 68) | void parse() {
    method parseUpstream (line 73) | void parseUpstream() {
    method parseControl (line 78) | void parseControl(CodecType type) {
    method addAndCheckSimpleHeaders (line 99) | size_t addAndCheckSimpleHeaders() {
    method makeCodecs (line 113) | void makeCodecs() {
  class HQCodecTest (line 163) | class HQCodecTest : public HQCodecTestFixture<Test> {}
  function TEST_F (line 165) | TEST_F(HQCodecTest, DataFrame) {
  function TEST_F (line 176) | TEST_F(HQCodecTest, PriorityUpdate) {
  function TEST_F (line 187) | TEST_F(HQCodecTest, DataFrameStreaming) {
  function TEST_F (line 211) | TEST_F(HQCodecTest, PushPromiseFrame) {
  function TEST_F (line 230) | TEST_F(HQCodecTest, HeadersOverSize) {
  function TEST_F (line 268) | TEST_F(HQCodecTest, Trailers) {
  function TEST_F (line 310) | TEST_F(HQCodecTest, GenerateExtraHeaders) {
  function TEST_F (line 382) | TEST_F(HQCodecTest, qpack) {
  function TEST_F (line 386) | TEST_F(HQCodecTest, qpackBlocked) {
  function TEST_F (line 390) | TEST_F(HQCodecTest, qpackError) {
  function TEST_F (line 417) | TEST_F(HQCodecTest, qpackErrorShort) {
  function TEST_F (line 426) | TEST_F(HQCodecTest, extraHeaders) {
  function TEST_F (line 454) | TEST_F(HQCodecTest, MultipleHeaders) {
  function TEST_F (line 481) | TEST_F(HQCodecTest, InvalidHeaders) {
  function TEST_F (line 498) | TEST_F(HQCodecTest, ParserStopsAfterPushPromiseError) {
  function TEST_F (line 518) | TEST_F(HQCodecTest, ZeroLengthData) {
  function TEST_F (line 544) | TEST_F(HQCodecTest, ZeroLengthSettings) {
  function TEST_F (line 555) | TEST_F(HQCodecTest, InvalidSettings) {
  function TEST_F (line 567) | TEST_F(HQCodecTest, ZeroLengthTrailers) {
  function TEST_F (line 583) | TEST_F(HQCodecTest, TruncatedStream) {
  function TEST_F (line 603) | TEST_F(HQCodecTest, BasicConnect) {
  function TEST_F (line 618) | TEST_F(HQCodecTest, TemplateDrivenConnect) {
  function TEST_F (line 641) | TEST_F(HQCodecTest, TrimLwsInHeaderValue) {
  function TEST_F (line 668) | TEST_F(HQCodecTest, OnlyDataAfterConnect) {
  function TEST_F (line 688) | TEST_F(HQCodecTest, MultipleSettingsUpstream) {
  function TEST_F (line 699) | TEST_F(HQCodecTest, MultipleSettingsDownstream) {
  function TEST_F (line 710) | TEST_F(HQCodecTest, RfcPriorityCallback) {
  function TEST_F (line 719) | TEST_F(HQCodecTest, RfcPushPriorityCallback) {
  function TEST_F (line 728) | TEST_F(HQCodecTest, PriorityCallback) {
  function TEST_F (line 737) | TEST_F(HQCodecTest, PushPriorityCallback) {
  function TEST_F (line 772) | TEST_F(HQCodecTest, ServerGoaway) {
  function TEST_F (line 776) | TEST_F(HQCodecTest, ClientGoaway) {
  function TEST_F (line 780) | TEST_F(HQCodecTest, HighAscii) {
  function TEST_F (line 841) | TEST_F(HQCodecTest, WebTransportProtocol) {
  function TEST_F (line 858) | TEST_F(HQCodecTest, PaddingIgnored) {
  type FrameAllowedParams (line 884) | struct FrameAllowedParams {
  function frameParamsToTestName (line 890) | std::string frameParamsToTestName(
  class HQCodecTestFrameAllowed (line 954) | class HQCodecTestFrameAllowed
  function TEST_P (line 957) | TEST_P(HQCodecTestFrameAllowed, FrameAllowedOnCodec) {
  class HQCodecTestFrameBeforeSettings (line 1128) | class HQCodecTestFrameBeforeSettings
  function TEST_P (line 1131) | TEST_P(HQCodecTestFrameBeforeSettings, FrameAllowedOnControlCodec) {

FILE: proxygen/lib/http/codec/test/HQFramerTest.cpp
  function comparePushId (line 27) | bool comparePushId(PushId lhs, PushId rhs) {
  function isValidPushId (line 32) | bool isValidPushId(folly::Optional<PushId> maxAllowedPushId, PushId push...
  class HQFramerTestFixture (line 47) | class HQFramerTestFixture : public T {
    method HQFramerTestFixture (line 49) | HQFramerTestFixture() = default;
    method parse (line 52) | void parse(ParseResult parseError,
    method parse (line 64) | void parse(ParseResult parseError,
  class HQFramerTest (line 89) | class HQFramerTest : public HQFramerTestFixture<testing::Test> {}
  function TEST_F (line 91) | TEST_F(HQFramerTest, TestValidPushId) {
  function TEST_F (line 109) | TEST_F(HQFramerTest, TestWriteFrameHeaderManual) {
  function TEST_F (line 115) | TEST_F(HQFramerTest, TestWriteUnframedBytes) {
  function TEST_F (line 125) | TEST_F(HQFramerTest, DataFrameZeroLength) {
  function TEST_F (line 134) | TEST_F(HQFramerTest, TestWriteGreaseFrame) {
  function TEST_F (line 148) | TEST_F(HQFramerTest, TestWriteWebTransportStreamPreface) {
  type FrameHeaderLengthParams (line 165) | struct FrameHeaderLengthParams {
  type DataOnlyFrameParams (line 170) | struct DataOnlyFrameParams {
  class HQFramerTestDataOnlyFrames (line 179) | class HQFramerTestDataOnlyFrames
  function TEST_P (line 182) | TEST_P(HQFramerTestDataOnlyFrames, TestDataOnlyFrame) {
  function TEST_F (line 205) | TEST_F(HQFramerTest, ParsePushPromiseFrameOK) {
  type IdOnlyFrameParams (line 219) | struct IdOnlyFrameParams {
  class HQFramerTestIdOnlyFrames (line 226) | class HQFramerTestIdOnlyFrames
  function TEST_P (line 229) | TEST_P(HQFramerTestIdOnlyFrames, TestIdOnlyFrame) {
  function TEST_F (line 314) | TEST_F(HQFramerTest, SettingsFrameOK) {
  function TEST_F (line 333) | TEST_F(HQFramerTest, MaxPushIdFrameOK) {
  function TEST_F (line 347) | TEST_F(HQFramerTest, MaxPushIdFrameLargePushId) {
  function TEST_F (line 362) | TEST_F(HQFramerTest, MaxPushIdTooLarge) {
  type SettingsValuesParams (line 370) | struct SettingsValuesParams {
  class HQFramerTestSettingsValues (line 376) | class HQFramerTestSettingsValues
  function TEST_P (line 379) | TEST_P(HQFramerTestSettingsValues, ValueAllowed) {
  function TEST_F (line 417) | TEST_F(HQFramerTest, SettingsFrameEmpty) {
  function TEST_F (line 429) | TEST_F(HQFramerTest, SettingsFrameTrailingJunk) {
  function TEST_F (line 452) | TEST_F(HQFramerTest, SettingsFrameWriteError) {
  function TEST_F (line 460) | TEST_F(HQFramerTest, SettingsFrameUnknownId) {
  function TEST_F (line 473) | TEST_F(HQFramerTest, PriorityUpdate) {
  function TEST_F (line 486) | TEST_F(HQFramerTest, PriorityUpdateWithoutIncremental) {
  function TEST_F (line 499) | TEST_F(HQFramerTest, BadPriorityUpdate) {

FILE: proxygen/lib/http/codec/test/HQFramerTest.h
  function writeFrameHeaderManual (line 18) | size_t writeFrameHeaderManual(folly::IOBufQueue& queue,
  function appenderOp (line 57) | auto appenderOp = [&](auto val) { appender.writeBE<decltype(val)>(val); }
  function appenderOp (line 87) | auto appenderOp = [&](auto val) { appender.writeBE<decltype(val)>(val); }

FILE: proxygen/lib/http/codec/test/HQMultiCodecTest.cpp
  class HQMultiCodecTest (line 18) | class HQMultiCodecTest : public Test {
    method SetUp (line 20) | void SetUp() override {
  function TEST_F (line 29) | TEST_F(HQMultiCodecTest, Egress) {
  function TEST_F (line 57) | TEST_F(HQMultiCodecTest, Ingress) {
  function TEST_F (line 103) | TEST_F(HQMultiCodecTest, Generic) {

FILE: proxygen/lib/http/codec/test/HTTP1xCodecTest.cpp
  class HTTP1xCodecCallback (line 24) | class HTTP1xCodecCallback : public HTTPCodec::Callback {
    method HTTP1xCodecCallback (line 26) | HTTP1xCodecCallback() = default;
    method onMessageBegin (line 28) | void onMessageBegin(HTTPCodec::StreamID /*stream*/,
    method onPushMessageBegin (line 31) | void onPushMessageBegin(HTTPCodec::StreamID /*stream*/,
    method onHeadersComplete (line 35) | void onHeadersComplete(HTTPCodec::StreamID /*stream*/,
    method onBody (line 41) | void onBody(HTTPCodec::StreamID /*stream*/,
    method onChunkHeader (line 46) | void onChunkHeader(HTTPCodec::StreamID /*stream*/,
    method onChunkComplete (line 49) | void onChunkComplete(HTTPCodec::StreamID /*stream*/) override {
    method onTrailersComplete (line 51) | void onTrailersComplete(HTTPCodec::StreamID /*stream*/,
    method onMessageComplete (line 56) | void onMessageComplete(HTTPCodec::StreamID /*stream*/,
    method onError (line 60) | void onError(HTTPCodec::StreamID /*stream*/,
  function getSimpleRequestData (line 77) | unique_ptr<folly::IOBuf> getSimpleRequestData() {
  function getSimpleRequestDataQueue (line 82) | unique_ptr<folly::IOBuf> getSimpleRequestDataQueue() {
  function TEST (line 91) | TEST(HTTP1xCodecTest, TestSimpleHeaders) {
  function TEST (line 104) | TEST(HTTP1xCodecTest, TestSimpleHeadersQueue) {
  function TEST (line 114) | TEST(HTTP1xCodecTest, TestSimpleHeadersQueueWithPause) {
  function TEST (line 130) | TEST(HTTP1xCodecTest, Test09Req) {
  function TEST (line 147) | TEST(HTTP1xCodecTest, Test09ReqVers) {
  function TEST (line 159) | TEST(HTTP1xCodecTest, Test09Resp) {
  function TEST (line 180) | TEST(HTTP1xCodecTest, TestResponseSplit) {
  function TEST (line 204) | TEST(HTTP1xCodecTest, TestO9NoVersion) {
  function TEST (line 217) | TEST(HTTP1xCodecTest, TestKeepalive09_10) {
  function TEST (line 299) | TEST(HTTP1xCodecTest, TestBadHeaders) {
  function TEST (line 316) | TEST(HTTP1xCodecTest, TestHighAsciiUA) {
  function TEST (line 334) | TEST(HTTP1xCodecTest, TestBadURL) {
  function TEST (line 351) | TEST(HTTP1xCodecTest, TestUnderscoreAllowedInHost) {
  function TEST (line 369) | TEST(HTTP1xCodecTest, TestHeadRequestChunkedResponse) {
  function TEST (line 393) | TEST(HTTP1xCodecTest, TestGetRequestChunkedResponse) {
  function getChunkedRequest1st (line 435) | unique_ptr<folly::IOBuf> getChunkedRequest1st() {
  function getChunkedRequest2nd (line 440) | unique_ptr<folly::IOBuf> getChunkedRequest2nd() {
  function TEST (line 445) | TEST(HTTP1xCodecTest, TestChunkedHeaders) {
  function TEST (line 466) | TEST(HTTP1xCodecTest, TestChunkedUpstream) {
  function TEST (line 502) | TEST(HTTP1xCodecTest, TestBadPost100) {
  function TEST (line 546) | TEST(HTTP1xCodecTest, TestMultipleIdenticalContentLengthHeaders) {
  function TEST (line 564) | TEST(HTTP1xCodecTest, TestMultipleDistinctContentLengthHeaders) {
  function TEST (line 583) | TEST(HTTP1xCodecTest, TestCorrectTransferEncodingHeader) {
  function TEST (line 601) | TEST(HTTP1xCodecTest, TestFoldedTransferEncodingHeader) {
  function TEST (line 620) | TEST(HTTP1xCodecTest, TestBadTransferEncodingHeader) {
  function TEST (line 641) | TEST(HTTP1xCodecTest, TestMalformedChunkDelimiter) {
  function TEST (line 676) | TEST(HTTP1xCodecTest, Test1xxConnectionHeader) {
  function TEST (line 705) | TEST(HTTP1xCodecTest, TestChainedBody) {
  function TEST (line 727) | TEST(HTTP1xCodecTest, TestIgnoreUpstreamUpgrade) {
  function TEST (line 747) | TEST(HTTP1xCodecTest, WebsocketUpgrade) {
  function TEST (line 784) | TEST(HTTP1xCodecTest, WebsocketUpgradeKeyError) {
  function TEST (line 807) | TEST(HTTP1xCodecTest, WebsocketUpgradeHeaderSet) {
  function TEST (line 827) | TEST(HTTP1xCodecTest, WebsocketConnectionHeader) {
  function TEST (line 859) | TEST(HTTP1xCodecTest, WebsocketUpgradeSecondTxn) {
  function TEST (line 933) | TEST(HTTP1xCodecTest, TrailersAndEomAreNotGeneratedWhenNonChunked) {
  function TEST (line 958) | TEST(HTTP1xCodecTest, TestChunkResponseSerialization) {
  function TEST (line 1018) | TEST(HTTP1xCodecTest, TestGenerateEmptyBodyWithEOM) {
  function TEST (line 1033) | TEST(HTTP1xCodecTest, TestHeaderValueWhiteSpaces) {
  function TEST (line 1047) | TEST(HTTP1xCodecTest, DownstreamGoaway) {
  function TEST (line 1066) | TEST(HTTP1xCodecTest, DownstreamImmediateGoaway) {
  function TEST (line 1074) | TEST(HTTP1xCodecTest, DownstreamErrorGoaway) {
  function TEST (line 1083) | TEST(HTTP1xCodecTest, GenerateRst) {
  function TEST (line 1091) | TEST(HTTP1xCodecTest, UpstreamGoaway) {
  function TEST (line 1100) | TEST(HTTP1xCodecTest, CloseOnEgressCompleteUpstreamConnect) {
  function TEST (line 1120) | TEST(HTTP1xCodecTest, CloseOnEgressCompleteDownstreamResponse) {
  function TEST (line 1145) | TEST(HTTP1xCodecTest, GenerateExtraHeaders) {
  function TEST (line 1177) | TEST(HTTP1xCodecTest, WebsocketUpgradeDuplicate) {
  function TEST (line 1190) | TEST(HTTP1xCodecTest, UpgradeAccepted) {
  function TEST (line 1197) | TEST(HTTP1xCodecTest, HugeURL) {
  function TEST (line 1220) | TEST(HTTP1xCodecTest, UTF8Chars) {
  function TEST (line 1248) | TEST(HTTP1xCodecTest, ExtraCRLF) {
  function TEST (line 1268) | TEST(HTTP1xCodecTest, ContentLengthLast) {
  function TEST (line 1288) | TEST(HTTP1xCodecTest, HugeChunkLength) {
  function TEST (line 1307) | TEST(HTTP1xCodecTest, HugeContentLength) {
  function TEST (line 1324) | TEST(HTTP1xCodecTest, Dechunk) {
  function TEST (line 1374) | TEST(HTTP1xCodecTest, Chunkify) {
  function TEST (line 1422) | TEST(HTTP1xCodecTest, ChunkifyConnClose) {
  function TEST (line 1474) | TEST(HTTP1xCodecTest, Chunkify100) {
  function TEST (line 1532) | TEST(HTTP1xCodecTest, TrailersNonChunked) {
  function TEST (line 1562) | TEST(HTTP1xCodecTest, HeaderCtls) {
  function TEST (line 1590) | TEST(HTTP1xCodecTest, HeaderCtlsMiddle) {
  function TEST (line 1610) | TEST(HTTP1xCodecTest, TrailerCtls) {
  function TEST (line 1633) | TEST(HTTP1xCodecTest, AbsoluteURLNoPath) {
  class ConnectionHeaderTest (line 1644) | class ConnectionHeaderTest
  function TEST_P (line 1650) | TEST_P(ConnectionHeaderTest, TestConnectionHeaders) {

FILE: proxygen/lib/http/codec/test/HTTP2CodecTest.cpp
  function TEST (line 28) | TEST(HTTP2CodecConstantsTest, HTTPContantsAreCommonHeaders) {
  class HTTP2CodecTest (line 45) | class HTTP2CodecTest : public HTTPParallelCodecTest {
    method HTTP2CodecTest (line 47) | HTTP2CodecTest() : HTTPParallelCodecTest(upstreamCodec_, downstreamCod...
    method SetUp (line 52) | void SetUp() override {
    method writeHeaders (line 62) | void writeHeaders(folly::IOBufQueue& writeBuf,
  function TEST_F (line 89) | TEST_F(HTTP2CodecTest, IgnoreUnknownSettings) {
  class HTTP2CodecTestOmitParsePreface (line 106) | class HTTP2CodecTestOmitParsePreface : public HTTP2CodecTest {
    method SetUp (line 107) | void SetUp() override {
  function TEST_F (line 112) | TEST_F(HTTP2CodecTest, NoExHeaders) {
  function TEST_F (line 127) | TEST_F(HTTP2CodecTest, BasicHeader) {
  function TEST_F (line 146) | TEST_F(HTTP2CodecTest, GenerateExtraHeaders) {
  function TEST_F (line 167) | TEST_F(HTTP2CodecTestOmitParsePreface, OmitSettingsAfterConnPrefaceError) {
  function TEST_F (line 182) | TEST_F(HTTP2CodecTest, BadHeaders) {
  function TEST_F (line 232) | TEST_F(HTTP2CodecTest, BadPseudoHeaders) {
  function TEST_F (line 265) | TEST_F(HTTP2CodecTest, BadHeaderValues) {
  function TEST_F (line 301) | TEST_F(HTTP2CodecTest, HostAuthority) {
  function TEST_F (line 341) | TEST_F(HTTP2CodecTest, HighAscii) {
  function TEST_F (line 390) | TEST_F(HTTP2CodecTest, EmptyPath) {
  function TEST_F (line 416) | TEST_F(HTTP2CodecTest, EmptyHeaderName) {
  function TEST_F (line 427) | TEST_F(HTTP2CodecTest, BasicConnect) {
  function TEST_F (line 442) | TEST_F(HTTP2CodecTest, BadConnect) {
  function TEST_F (line 480) | TEST_F(HTTP2CodecTest, TemplateDrivenConnect) {
  function TEST_F (line 564) | TEST_F(HTTP2CodecTest, NormalSizeHeader) {
  function TEST_F (line 568) | TEST_F(HTTP2CodecTest, OversizedHeader) {
  function TEST_F (line 572) | TEST_F(HTTP2CodecTest, NormalSizeFrame) {
  function TEST_F (line 576) | TEST_F(HTTP2CodecTest, OversizedFrame) {
  function TEST_F (line 580) | TEST_F(HTTP2CodecTest, BigHeaderCompressed) {
  function TEST_F (line 601) | TEST_F(HTTP2CodecTest, BasicHeaderReply) {
  function TEST_F (line 620) | TEST_F(HTTP2CodecTest, DontDoubleDate) {
  function TEST_F (line 641) | TEST_F(HTTP2CodecTest, BadHeadersReply) {
  function TEST_F (line 685) | TEST_F(HTTP2CodecTest, StripLwsHeaderValue) {
  function TEST_F (line 750) | TEST_F(HTTP2CodecTest, Cookies) {
  function TEST_F (line 768) | TEST_F(HTTP2CodecTest, BasicContinuation) {
  function TEST_F (line 787) | TEST_F(HTTP2CodecTest, ContinuationChain) {
  function TEST_F (line 809) | TEST_F(HTTP2CodecTest, BasicContinuationEndStream) {
  function TEST_F (line 829) | TEST_F(HTTP2CodecTest, BadContinuation) {
  function TEST_F (line 842) | TEST_F(HTTP2CodecTest, MissingContinuation) {
  function TEST_F (line 866) | TEST_F(HTTP2CodecTest, MissingContinuationBadFrame) {
  function TEST_F (line 891) | TEST_F(HTTP2CodecTest, BadContinuationStream) {
  function TEST_F (line 913) | TEST_F(HTTP2CodecTest, ContinuationLimit) {
  function TEST_F (line 933) | TEST_F(HTTP2CodecTest, ContinuationUnderLimit) {
  function TEST_F (line 946) | TEST_F(HTTP2CodecTest, FrameTooLarge) {
  function TEST_F (line 960) | TEST_F(HTTP2CodecTest, DataFrameZeroLengthWithEOM) {
  function TEST_F (line 982) | TEST_F(HTTP2CodecTest, UnknownFrameType) {
  function TEST_F (line 996) | TEST_F(HTTP2CodecTest, JunkAfterConnError) {
  function TEST_F (line 1014) | TEST_F(HTTP2CodecTest, BasicData) {
  function TEST_F (line 1031) | TEST_F(HTTP2CodecTest, LongData) {
  function TEST_F (line 1050) | TEST_F(HTTP2CodecTest, PushPromiseContinuation) {
  function TEST_F (line 1075) | TEST_F(HTTP2CodecTest, MalformedPaddingLength) {
  function TEST_F (line 1148) | TEST_F(HTTP2CodecTest, MalformedPadding) {
  function TEST_F (line 1157) | TEST_F(HTTP2CodecTestOmitParsePreface, NoAppByte) {
  function TEST_F (line 1179) | TEST_F(HTTP2CodecTest, DataFramePartialDataOnFrameHeaderCall) {
  function TEST_F (line 1200) | TEST_F(HTTP2CodecTest, DataFramePartialDataWithNoAppByte) {
  function TEST_F (line 1234) | TEST_F(HTTP2CodecTest, BasicRst) {
  function TEST_F (line 1246) | TEST_F(HTTP2CodecTest, BasicRstInvalidCode) {
  function TEST_F (line 1258) | TEST_F(HTTP2CodecTest, BasicPing) {
  function TEST_F (line 1279) | TEST_F(HTTP2CodecTest, BasicWindow) {
  function TEST_F (line 1296) | TEST_F(HTTP2CodecTest, ZeroWindow) {
  function TEST_F (line 1313) | TEST_F(HTTP2CodecTest, BasicGoaway) {
  function TEST_F (line 1326) | TEST_F(HTTP2CodecTest, BadGoaway) {
  function TEST_F (line 1337) | TEST_F(HTTP2CodecTest, RstStreamNoError) {
  function TEST_F (line 1355) | TEST_F(HTTP2CodecTest, DoubleGoaway) {
  function TEST_F (line 1403) | TEST_F(HTTP2CodecTest, DoubleGoawayWithError) {
  function TEST_F (line 1423) | TEST_F(HTTP2CodecTest, GoawayHandling) {
  function TEST_F (line 1486) | TEST_F(HTTP2CodecTest, GoawayReply) {
  function TEST_F (line 1506) | TEST_F(HTTP2CodecTest, BasicSetting) {
  function TEST_F (line 1520) | TEST_F(HTTP2CodecTest, SettingsAck) {
  function TEST_F (line 1530) | TEST_F(HTTP2CodecTest, BadSettings) {
  function TEST_F (line 1541) | TEST_F(HTTP2CodecTestOmitParsePreface, BadPushSettings) {
  function TEST_F (line 1559) | TEST_F(HTTP2CodecTest, SettingsTableSize) {
  function TEST_F (line 1588) | TEST_F(HTTP2CodecTestOmitParsePreface, BadSettingsTableSize) {
  function TEST_F (line 1621) | TEST_F(HTTP2CodecTest, SettingsTableSizeEarlyShrink) {
  function TEST_F (line 1661) | TEST_F(HTTP2CodecTest, ConcurrentStreams) {
  function TEST_F (line 1697) | TEST_F(HTTP2CodecTest, BasicRFC9218Priority) {
  function TEST_F (line 1706) | TEST_F(HTTP2CodecTest, BadRFC9218Priority) {
  class DummyQueue (line 1721) | class DummyQueue : public HTTPCodec::PriorityQueue {
    method DummyQueue (line 1723) | DummyQueue() = default;
    method addPriorityNode (line 1725) | void addPriorityNode(HTTPCodec::StreamID id, HTTPCodec::StreamID) over...
  function TEST_F (line 1732) | TEST_F(HTTP2CodecTest, BasicPushPromise) {
  function TEST_F (line 1785) | TEST_F(HTTP2CodecTest, DuplicatePushPromise) {
  function TEST_F (line 1808) | TEST_F(HTTP2CodecTest, BadPushPromise) {
  function TEST_F (line 1824) | TEST_F(HTTP2CodecTest, BadPushPromiseResets) {
  function TEST_F (line 1843) | TEST_F(HTTP2CodecTest, BasicCertificateRequest) {
  function TEST_F (line 1858) | TEST_F(HTTP2CodecTest, BasicCertificate) {
  function TEST_F (line 1872) | TEST_F(HTTP2CodecTest, BadServerPreface) {
  function TEST_F (line 1884) | TEST_F(HTTP2CodecTest, Normal1024Continuation) {
  function TEST_F (line 1907) | TEST_F(HTTP2CodecTest, StreamIdOverflow) {
  function TEST_F (line 1918) | TEST_F(HTTP2CodecTest, TestMultipleDifferentContentLengthHeaders) {
  function TEST_F (line 1935) | TEST_F(HTTP2CodecTest, TestMultipleIdenticalContentLengthHeaders) {
  function TEST_F (line 1954) | TEST_F(HTTP2CodecTest, HTTP2SettingsFailure) {
  function TEST_F (line 1982) | TEST_F(HTTP2CodecTest, HTTP2EnableConnect) {
  function TEST_F (line 2000) | TEST_F(HTTP2CodecTest, WebsocketUpgrade) {
  function TEST_F (line 2014) | TEST_F(HTTP2CodecTest, WebsocketBadHeader) {
  function TEST_F (line 2049) | TEST_F(HTTP2CodecTest, WebsocketDupProtocol) {
  function TEST_F (line 2072) | TEST_F(HTTP2CodecTest, WebsocketIncorrectResponse) {
  function TEST_F (line 2082) | TEST_F(HTTP2CodecTest, WebTransportProtocol) {
  function TEST_F (line 2099) | TEST_F(HTTP2CodecTest, TestAllEgressFrameTypeCallbacks) {
  function TEST_F (line 2170) | TEST_F(HTTP2CodecTest, Trailers) {
  function TEST_F (line 2204) | TEST_F(HTTP2CodecTest, TrailersWithPseudoHeaders) {
  function TEST_F (line 2235) | TEST_F(HTTP2CodecTest, TrailersNoBody) {
  function TEST_F (line 2264) | TEST_F(HTTP2CodecTest, TrailersContinuation) {
  function TEST_F (line 2295) | TEST_F(HTTP2CodecTest, TrailersReply) {
  function TEST_F (line 2333) | TEST_F(HTTP2CodecTest, TrailersReplyEmpty) {
  function TEST_F (line 2367) | TEST_F(HTTP2CodecTest, TrailersReplyWithNoData) {
  function TEST_F (line 2397) | TEST_F(HTTP2CodecTest, TrailersReplyWithPseudoHeaders) {
  function TEST_F (line 2430) | TEST_F(HTTP2CodecTest, TrailersReplyContinuation) {
  function TEST_F (line 2463) | TEST_F(HTTP2CodecTest, TrailersReplyMissingContinuation) {
  function TEST_F (line 2493) | TEST_F(HTTP2CodecTest, TrailersNotLatest) {
  function TEST_F (line 2520) | TEST_F(HTTP2CodecTest, ResponseWithoutRequest) {
  function TEST_F (line 2533) | TEST_F(HTTP2CodecTest, PaddingFrame) {
  function TEST_F (line 2558) | TEST_F(HTTP2CodecTest, MaxPadding) {
  class HTTP2CodecDoubleGoawayTest (line 2586) | class HTTP2CodecDoubleGoawayTest : public HTTPParallelCodecTest {
    method HTTP2CodecDoubleGoawayTest (line 2588) | HTTP2CodecDoubleGoawayTest()
    method SetUp (line 2592) | void SetUp() override {
  function TEST_F (line 2601) | TEST_F(HTTP2CodecDoubleGoawayTest, EnableDoubleGoawayAfterClose) {
  function TEST_F (line 2612) | TEST_F(HTTP2CodecTest, SendEmptyTrailers) {
  function TEST_F (line 2635) | TEST_F(HTTP2CodecTest, GenerateHeadersWithEmptyRequest) {
  function TEST_F (line 2649) | TEST_F(HTTP2CodecTest, SetIfNotPresent) {

FILE: proxygen/lib/http/codec/test/HTTP2FramerTest.cpp
  function writeFrameHeaderManual (line 24) | void writeFrameHeaderManual(IOBufQueue& queue,
  class HTTP2FramerTest (line 36) | class HTTP2FramerTest : public testing::Test {
    method HTTP2FramerTest (line 38) | HTTP2FramerTest() = default;
    method parse (line 41) | void parse(ParseFunc&& parseFn, FrameHeader& outHeader, Args&&... outA...
    method parse (line 46) | void parse(const IOBuf* data,
    method dataFrameTest (line 57) | void dataFrameTest(uint32_t dataLen, folly::Optional<uint8_t> padLen) {
    method dataFrameTest (line 62) | void dataFrameTest(std::unique_ptr<IOBuf> body,
  function TEST_F (line 89) | TEST_F(HTTP2FramerTest, WriteAndParseSmallDataNoPad) {
  function TEST_F (line 93) | TEST_F(HTTP2FramerTest, WriteAndParseSmallDataZeroPad) {
  function TEST_F (line 97) | TEST_F(HTTP2FramerTest, WriteAndParseSmallDataSmallPad) {
  function TEST_F (line 101) | TEST_F(HTTP2FramerTest, ManyDataFrameSizes) {
  function TEST_F (line 113) | TEST_F(HTTP2FramerTest, BadStreamData) {
  function TEST_F (line 125) | TEST_F(HTTP2FramerTest, BadStreamSettings) {
  function TEST_F (line 136) | TEST_F(HTTP2FramerTest, BadPad) {
  function TEST_F (line 151) | TEST_F(HTTP2FramerTest, NoHeadroomOptimization) {
  function TEST_F (line 174) | TEST_F(HTTP2FramerTest, UseHeadroomOptimization) {
  function TEST_F (line 194) | TEST_F(HTTP2FramerTest, BadStreamId) {
  function TEST_F (line 202) | TEST_F(HTTP2FramerTest, RstStream) {
  function TEST_F (line 216) | TEST_F(HTTP2FramerTest, Goaway) {
  function TEST_F (line 234) | TEST_F(HTTP2FramerTest, GoawayDebugData) {
  function TEST_F (line 258) | TEST_F(HTTP2FramerTest, GoawayDoubleRead) {
  function TEST_F (line 281) | TEST_F(HTTP2FramerTest, BasicRFC9218Priority) {
  function TEST_F (line 296) | TEST_F(HTTP2FramerTest, BadRFC9218Priority) {
  function TEST_F (line 314) | TEST_F(HTTP2FramerTest, HeadersWithPaddingAndPriority) {
  function TEST_F (line 346) | TEST_F(HTTP2FramerTest, Ping) {
  function TEST_F (line 360) | TEST_F(HTTP2FramerTest, WindowUpdate) {
  function TEST_F (line 373) | TEST_F(HTTP2FramerTest, CertificateRequest) {
  function TEST_F (line 394) | TEST_F(HTTP2FramerTest, EmptyCertificateRequest) {
  function TEST_F (line 411) | TEST_F(HTTP2FramerTest, ShortCertificateRequest) {
  function TEST_F (line 428) | TEST_F(HTTP2FramerTest, CertificateRequestOnNonzeroStream) {
  function TEST_F (line 445) | TEST_F(HTTP2FramerTest, EndingCertificate) {
  function TEST_F (line 467) | TEST_F(HTTP2FramerTest, Certificate) {
  function TEST_F (line 490) | TEST_F(HTTP2FramerTest, EmptyCertificate) {
  function TEST_F (line 507) | TEST_F(HTTP2FramerTest, ShortCertificate) {
  function TEST_F (line 523) | TEST_F(HTTP2FramerTest, CertificateOnNonzeroStream) {
  function TEST_F (line 540) | TEST_F(HTTP2FramerTest, ShortWindowUpdate) {
  function TEST_F (line 553) | TEST_F(HTTP2FramerTest, Uint32MaxWindowUpdate) {
  function TEST_F (line 574) | TEST_F(HTTP2FramerTest, AltSvc) {
  function TEST_F (line 604) | TEST_F(HTTP2FramerTest, Settings) {
  function TEST_F (line 620) | TEST_F(HTTP2FramerTest, SettingsAck) {
  function TEST_F (line 636) | TEST_F(HTTP2FramerTest, BadSettingsAck) {
  function TEST_F (line 656) | TEST_F(HTTP2FramerTest, UnknownSetting) {
  function TEST_F (line 672) | TEST_F(HTTP2FramerTest, PushPromise) {
  function TEST_F (line 700) | TEST_F(HTTP2FramerTest, Continuation) {

FILE: proxygen/lib/http/codec/test/HTTPBinaryCodecTest.cpp
  type proxygen::test (line 16) | namespace proxygen::test {
    class HTTPBinaryCodecForTest (line 18) | class HTTPBinaryCodecForTest : public HTTPBinaryCodec {
      method HTTPBinaryCodecForTest (line 20) | explicit HTTPBinaryCodecForTest(TransportDirection direction)
      method HTTPBinaryCodecForTest (line 23) | explicit HTTPBinaryCodecForTest(TransportDirection direction,
      method ParseResult (line 27) | ParseResult parseFramingIndicator(folly::io::Cursor& cursor,
      method ParseResult (line 33) | ParseResult parseRequestControlData(folly::io::Cursor& cursor,
      method ParseResult (line 39) | ParseResult parseResponseControlData(folly::io::Cursor& cursor,
      method ParseResult (line 45) | ParseResult parseHeaders(folly::io::Cursor& cursor,
      method ParseResult (line 53) | ParseResult parseContent(folly::io::Cursor& cursor, size_t remaining) {
    class HTTPBinaryCodecTest (line 63) | class HTTPBinaryCodecTest : public ::testing::Test {
      method SetUp (line 65) | void SetUp() override {
      method TearDown (line 71) | void TearDown() override {
    class HttpBinaryUpstreamCodecTest (line 78) | class HttpBinaryUpstreamCodecTest
    class HttpBinaryDownstreamCodecTest (line 81) | class HttpBinaryDownstreamCodecTest
    function TEST_F (line 84) | TEST_F(HttpBinaryUpstreamCodecTest, testParseFramingIndicatorSuccess) {
    function TEST_F (line 116) | TEST_F(HttpBinaryUpstreamCodecTest, testParseFramingIndicatorFailure) {
    function TEST_F (line 132) | TEST_F(HttpBinaryUpstreamCodecTest, testParseRequestControlDataSuccess) {
    function TEST_F (line 155) | TEST_F(HttpBinaryUpstreamCodecTest, testParseRequestControlDataWaiting) {
    function TEST_F (line 176) | TEST_F(HttpBinaryUpstreamCodecTest, testParseRequestControlDataFailure) {
    function TEST_F (line 212) | TEST_F(HttpBinaryUpstreamCodecTest, testParseResponseControlDataSucces...
    function TEST_F (line 229) | TEST_F(HttpBinaryUpstreamCodecTest, testParseResponseControlDataFailur...
    function TEST_F (line 259) | TEST_F(HttpBinaryUpstreamCodecTest, testParseKnownLengthHeadersSuccess) {
    function TEST_F (line 302) | TEST_F(HttpBinaryUpstreamCodecTest, testParseKnownLengthHeadersEmpty) {
    function TEST_F (line 319) | TEST_F(HttpBinaryUpstreamCodecTest, testParseKnownLengthHeadersWaiting) {
    function TEST_F (line 383) | TEST_F(HttpBinaryUpstreamCodecTest,
    function TEST_F (line 426) | TEST_F(HttpBinaryUpstreamCodecTest, testParseIndeterminateLengthHeader...
    function TEST_F (line 446) | TEST_F(HttpBinaryUpstreamCodecTest,
    function TEST_F (line 495) | TEST_F(HttpBinaryUpstreamCodecTest, testParseContentKnownLengthSuccess) {
    function TEST_F (line 511) | TEST_F(HttpBinaryUpstreamCodecTest, testParseContentKnownLengthFailure) {
    function TEST_F (line 525) | TEST_F(HttpBinaryUpstreamCodecTest,
    function TEST_F (line 543) | TEST_F(HttpBinaryUpstreamCodecTest,
    function TEST_F (line 559) | TEST_F(HttpBinaryDownstreamCodecTest, testOnIngressSuccess) {
    function TEST_F (line 603) | TEST_F(HttpBinaryDownstreamCodecTest, testOnIngressSuccessForControlDa...
    function TEST_F (line 627) | TEST_F(HttpBinaryDownstreamCodecTest,
    function TEST_F (line 679) | TEST_F(HttpBinaryDownstreamCodecTest, testOnIngressSuccessOneByteChunk...
    function TEST_F (line 726) | TEST_F(HttpBinaryDownstreamCodecTest, testOnIngressFailureMalformedMes...
    function TEST_F (line 759) | TEST_F(HttpBinaryDownstreamCodecTest, testOnIngressFailureIncompleteMe...
    function TEST_F (line 777) | TEST_F(HttpBinaryUpstreamCodecTest, testGenerateKnownLengthHeaders) {
    function TEST_F (line 811) | TEST_F(HttpBinaryUpstreamCodecTest, testGenerateIndeterminateLengthHea...
    function TEST_F (line 845) | TEST_F(HttpBinaryUpstreamCodecTest, testGenerateKnownLengthBody) {
    function TEST_F (line 862) | TEST_F(HttpBinaryUpstreamCodecTest, testGenerateIndeterminateLengthBod...
    function TEST_F (line 883) | TEST_F(HttpBinaryUpstreamCodecTest, testEncodeAndDecodeKnownLengthRequ...
    function TEST_F (line 940) | TEST_F(HttpBinaryUpstreamCodecTest, testEncodeAndDecodeRequestEmptyBod...
    function TEST_F (line 993) | TEST_F(HttpBinaryUpstreamCodecTest,
    function TEST_F (line 1052) | TEST_F(HttpBinaryUpstreamCodecTest,
    function TEST_F (line 1107) | TEST_F(HttpBinaryUpstreamCodecTest, IndeterminateLenReqKnownLengthResp) {

FILE: proxygen/lib/http/codec/test/HTTPParallelCodecTest.h
  function class (line 15) | class HTTPParallelCodecTest : public testing::Test {
  function dump_ (line 84) | bool dump_{false};

FILE: proxygen/lib/http/codec/test/MockHTTPCodec.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/codec/test/TestUtils.cpp
  type proxygen (line 21) | namespace proxygen {
    function makeBuf (line 26) | std::unique_ptr<folly::IOBuf> makeBuf(uint32_t size) {
    function makeMockParallelCodec (line 40) | std::unique_ptr<testing::NiceMock<MockHTTPCodec>> makeMockParallelCodec(
    function makeDownstreamParallelCodec (line 55) | std::unique_ptr<testing::NiceMock<MockHTTPCodec>>
    function makeUpstreamParallelCodec (line 60) | std::unique_ptr<testing::NiceMock<MockHTTPCodec>> makeUpstreamParallel...
    function HTTPMessage (line 64) | HTTPMessage getGetRequest(const std::string& url) {
    function HTTPMessage (line 73) | HTTPMessage getBigGetRequest(const std::string& url) {
    function makeGetRequest (line 85) | std::unique_ptr<HTTPMessage> makeGetRequest() {
    function HTTPMessage (line 89) | HTTPMessage getPostRequest(uint32_t contentLength) {
    function HTTPMessage (line 100) | HTTPMessage getChunkedPostRequest() {
    function makePostRequest (line 111) | std::unique_ptr<HTTPMessage> makePostRequest(uint32_t contentLength) {
    function HTTPMessage (line 115) | HTTPMessage getPubRequest(const std::string& url) {
    function HTTPMessage (line 124) | HTTPMessage getResponse(uint32_t code, uint32_t bodyLen) {
    function makeResponse (line 134) | std::unique_ptr<HTTPMessage> makeResponse(uint16_t statusCode) {
    function makeResponse (line 141) | std::tuple<std::unique_ptr<HTTPMessage>, std::unique_ptr<folly::IOBuf>>
    function HTTPMessage (line 148) | HTTPMessage getUpgradeRequest(const std::string& upgradeHeader,
    function HTTPMessage (line 161) | HTTPMessage getResponseWithInvalidBodyLength() {
    function isH3GreaseId (line 169) | bool isH3GreaseId(uint64_t id) {
    function fakeMockCodec (line 176) | void fakeMockCodec(MockHTTPCodec& codec) {

FILE: proxygen/lib/http/codec/test/TestUtils.h
  function onMessageBegin (line 120) | void onMessageBegin(HTTPCodec::StreamID /*stream*/, HTTPMessage*) overri...
  function onPushMessageBegin (line 123) | void onPushMessageBegin(HTTPCodec::StreamID pushPromiseId,
  function onHeadersComplete (line 130) | void onHeadersComplete(HTTPCodec::StreamID stream,
  function onBody (line 136) | void onBody(HTTPCodec::StreamID /*stream*/,
  function onChunkHeader (line 144) | void onChunkHeader(HTTPCodec::StreamID /*stream*/,
  function onChunkComplete (line 148) | void onChunkComplete(HTTPCodec::StreamID /*stream*/) override {
  function onTrailersComplete (line 151) | void onTrailersComplete(HTTPCodec::StreamID /*stream*/,
  function onMessageComplete (line 158) | void onMessageComplete(HTTPCodec::StreamID /*stream*/,
  function onError (line 162) | void onError(HTTPCodec::StreamID stream,
  function onAbort (line 173) | void onAbort(HTTPCodec::StreamID /*stream*/, ErrorCode code) override {
  function onFrameHeader (line 178) | void onFrameHeader(HTTPCodec::StreamID /*streamId*/,
  function onGoaway (line 186) | void onGoaway(uint64_t lastStreamId,
  function onUnknownFrame (line 194) | void onUnknownFrame(uint64_t /*streamId*/, uint64_t frameType) override {
  function onPingRequest (line 201) | void onPingRequest(uint64_t data) override {
  function onPingReply (line 205) | void onPingReply(uint64_t data) override {
  function onPriority (line 209) | void onPriority(HTTPCodec::StreamID, const HTTPPriority& pri) override {
  function onWindowUpdate (line 214) | void onWindowUpdate(HTTPCodec::StreamID stream, uint32_t amount) override {
  function onSettings (line 219) | void onSettings(const SettingsList& inSettings) override {

FILE: proxygen/lib/http/codec/webtransport/WebTransportCapsuleCodec.cpp
  type proxygen (line 18) | namespace proxygen {

FILE: proxygen/lib/http/codec/webtransport/WebTransportCapsuleCodec.h
  type class (line 16) | enum class
  function class (line 18) | class WebTransportCapsuleCodec : public CapsuleCodec {

FILE: proxygen/lib/http/codec/webtransport/WebTransportFramer.cpp
  type proxygen (line 21) | namespace proxygen {
    function parsePadding (line 23) | folly::Expected<PaddingCapsule, CapsuleCodec::ErrorCode> parsePadding(
    function parseWTResetStream (line 29) | folly::Expected<WTResetStreamCapsule, CapsuleCodec::ErrorCode>
    function parseWTStopSending (line 58) | folly::Expected<WTStopSendingCapsule, CapsuleCodec::ErrorCode>
    function parseWTStream (line 81) | folly::Expected<WTStreamCapsule, CapsuleCodec::ErrorCode> parseWTStream(
    function parseWTMaxData (line 98) | folly::Expected<WTMaxDataCapsule, CapsuleCodec::ErrorCode> parseWTMaxD...
    function parseWTMaxStreamData (line 113) | folly::Expected<WTMaxStreamDataCapsule, CapsuleCodec::ErrorCode>
    function parseWTMaxStreams (line 135) | folly::Expected<WTMaxStreamsCapsule, CapsuleCodec::ErrorCode> parseWTM...
    function parseWTDataBlocked (line 150) | folly::Expected<WTDataBlockedCapsule, CapsuleCodec::ErrorCode>
    function parseWTStreamDataBlocked (line 165) | folly::Expected<WTStreamDataBlockedCapsule, CapsuleCodec::ErrorCode>
    function parseWTStreamsBlocked (line 187) | folly::Expected<WTStreamsBlockedCapsule, CapsuleCodec::ErrorCode>
    function parseDatagram (line 202) | folly::Expected<DatagramCapsule, CapsuleCodec::ErrorCode> parseDatagram(
    function parseCloseWebTransportSession (line 212) | folly::Expected<CloseWebTransportSessionCapsule, CapsuleCodec::ErrorCode>
    function parseDrainWebTransportSession (line 234) | folly::Expected<DrainWebTransportSessionCapsule, CapsuleCodec::ErrorCode>
    function writeVarint (line 245) | void writeVarint(folly::IOBufQueue& buf,
    function writeCapsuleHeader (line 265) | void writeCapsuleHeader(folly::IOBufQueue& queue,
    function getCapsuleSize (line 277) | folly::Expected<uint64_t, quic::QuicError> getCapsuleSize(
    function WriteResult (line 294) | WriteResult writePadding(folly::IOBufQueue& queue,
    function WriteResult (line 306) | WriteResult writeWTResetStream(folly::IOBufQueue& queue,
    function WriteResult (line 324) | WriteResult writeWTStopSending(folly::IOBufQueue& queue,
    function WriteResult (line 340) | WriteResult writeWTStream(folly::IOBufQueue& queue,
    function WriteResult (line 362) | WriteResult writeWTMaxData(folly::IOBufQueue& queue,
    function WriteResult (line 376) | WriteResult writeWTMaxStreamData(folly::IOBufQueue& queue,
    function WriteResult (line 392) | WriteResult writeWTMaxStreams(folly::IOBufQueue& queue,
    function WriteResult (line 408) | WriteResult writeWTDataBlocked(folly::IOBufQueue& queue,
    function WriteResult (line 422) | WriteResult writeWTStreamDataBlocked(
    function WriteResult (line 441) | WriteResult writeWTStreamsBlocked(folly::IOBufQueue& queue,
    function WriteResult (line 458) | WriteResult writeDatagram(folly::IOBufQueue& queue,
    function WriteResult (line 474) | WriteResult writeCloseWebTransportSession(
    function WriteResult (line 496) | WriteResult writeDrainWebTransportSession(folly::IOBufQueue& queue) {

FILE: proxygen/lib/http/codec/webtransport/WebTransportFramer.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/codec/webtransport/test/WebTransportCapsuleCodecTest.cpp
  class WebTransportCapsuleCodecTest (line 17) | class WebTransportCapsuleCodecTest : public Test {
    method SetUp (line 19) | void SetUp() override {
    class TestWebTransportCapsuleCodecCallback (line 26) | class TestWebTransportCapsuleCodecCallback
    method testParseUnderflow (line 95) | void testParseUnderflow(CapsuleCodec::ErrorCode err, CodecVersion vers...
  function TEST_F (line 111) | TEST_F(WebTransportCapsuleCodecTest, OnPaddingCapsule) {
  function TEST_F (line 124) | TEST_F(WebTransportCapsuleCodecTest, OnWTResetStreamCapsule) {
  function TEST_F (line 140) | TEST_F(WebTransportCapsuleCodecTest, OnWTResetStreamCapsuleError) {
  function TEST_F (line 150) | TEST_F(WebTransportCapsuleCodecTest, OnWTStopSendingCapsule) {
  function TEST_F (line 164) | TEST_F(WebTransportCapsuleCodecTest, OnWTStopSendingCapsuleError) {
  function TEST_F (line 173) | TEST_F(WebTransportCapsuleCodecTest, OnWTStreamCapsule) {
  function TEST_F (line 191) | TEST_F(WebTransportCapsuleCodecTest, OnWTStreamCapsuleError) {
  function TEST_F (line 200) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTMaxDataCapsule) {
  function TEST_F (line 213) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTMaxDataCapsule) {
  function TEST_F (line 226) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTMaxDataCapsuleError) {
  function TEST_F (line 233) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTMaxDataCapsuleError) {
  function TEST_F (line 240) | TEST_F(WebTransportCapsuleCodecTest, OnWTMaxStreamDataCapsule) {
  function TEST_F (line 254) | TEST_F(WebTransportCapsuleCodecTest, OnWTMaxStreamDataCapsuleError) {
  function TEST_F (line 262) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTMaxStreamsCapsule) {
  function TEST_F (line 275) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTMaxStreamsCapsule) {
  function TEST_F (line 288) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTMaxStreamsCapsuleError) {
  function TEST_F (line 295) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTMaxStreamsCapsuleError) {
  function TEST_F (line 302) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTMaxStreamsUniCapsule) {
  function TEST_F (line 315) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTMaxStreamsUniCapsule) {
  function TEST_F (line 328) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTMaxStreamsUniCapsuleError) {
  function TEST_F (line 335) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTMaxStreamsUniCapsuleError) {
  function TEST_F (line 342) | TEST_F(WebTransportCapsuleCodecTest, H2OnDataBlockedCapsule) {
  function TEST_F (line 355) | TEST_F(WebTransportCapsuleCodecTest, H3OnDataBlockedCapsule) {
  function TEST_F (line 368) | TEST_F(WebTransportCapsuleCodecTest, H2OnDataBlockedCapsuleError) {
  function TEST_F (line 375) | TEST_F(WebTransportCapsuleCodecTest, H3OnDataBlockedCapsuleError) {
  function TEST_F (line 382) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTStreamsBlockedCapsule) {
  function TEST_F (line 395) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTStreamsBlockedCapsule) {
  function TEST_F (line 408) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTStreamsBlockedCapsuleError) {
  function TEST_F (line 415) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTStreamsBlockedCapsuleError) {
  function TEST_F (line 422) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTStreamsBlockedUniCapsule) {
  function TEST_F (line 435) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTStreamsBlockedUniCapsule) {
  function TEST_F (line 448) | TEST_F(WebTransportCapsuleCodecTest, H2OnWTStreamsBlockedUniCapsuleError) {
  function TEST_F (line 455) | TEST_F(WebTransportCapsuleCodecTest, H3OnWTStreamsBlockedUniCapsuleError) {
  function TEST_F (line 462) | TEST_F(WebTransportCapsuleCodecTest, OnWTStreamDataBlockedCapsule) {
  function TEST_F (line 476) | TEST_F(WebTransportCapsuleCodecTest, OnWTStreamDataBlockedCapsuleError) {
  function TEST_F (line 484) | TEST_F(WebTransportCapsuleCodecTest, OnDatagramCapsule) {
  function TEST_F (line 498) | TEST_F(WebTransportCapsuleCodecTest, H2OnCloseWebTransportSessionCapsule) {
  function TEST_F (line 513) | TEST_F(WebTransportCapsuleCodecTest, H3OnCloseWebTransportSessionCapsule) {
  function TEST_F (line 528) | TEST_F(WebTransportCapsuleCodecTest, H2OnCloseWebTransportSessionCapsule...
  function TEST_F (line 536) | TEST_F(WebTransportCapsuleCodecTest, H3OnCloseWebTransportSessionCapsule...
  function TEST_F (line 544) | TEST_F(WebTransportCapsuleCodecTest, H2OnDrainWebTransportSessionCapsule) {
  function TEST_F (line 552) | TEST_F(WebTransportCapsuleCodecTest, H3OnDrainWebTransportSessionCapsule) {

FILE: proxygen/lib/http/codec/webtransport/test/WebTransportFramerTest.cpp
  class WebTransportFramerTest (line 18) | class WebTransportFramerTest : public Test {}
  function parseCapsuleHeader (line 20) | uint64_t parseCapsuleHeader(folly::io::Cursor& cursor, uint64_t type) {
  function TEST (line 30) | TEST(WebTransportFramerTest, Padding) {
  function TEST (line 51) | TEST(WebTransportFramerTest, WTResetStream) {
  function TEST (line 70) | TEST(WebTransportFramerTest, WTResetStreamStreamIdError) {
  function TEST (line 90) | TEST(WebTransportFramerTest, WTResetStreamAppProtocolErrorCodeError) {
  function TEST (line 110) | TEST(WebTransportFramerTest, WTResetStreamReliableSizeError) {
  function TEST (line 129) | TEST(WebTransportFramerTest, WTResetStreamCapsuleSizeError) {
  function TEST (line 138) | TEST(WebTransportFramerTest, WTStopSending) {
  function TEST (line 155) | TEST(WebTransportFramerTest, WTStopSendingStreamIdError) {
  function TEST (line 174) | TEST(WebTransportFramerTest, WTStopSendingAppProtocolErrorCodeError) {
  function TEST (line 192) | TEST(WebTransportFramerTest, WTStopSendingCapsuleSizeError) {
  function TEST (line 200) | TEST(WebTransportFramerTest, WTStream) {
  function TEST (line 242) | TEST(WebTransportFramerTest, WTStreamStreamIdError) {
  function TEST (line 262) | TEST(WebTransportFramerTest, WTStreamDataError) {
  function TEST (line 282) | TEST(WebTransportFramerTest, WTStreamCapsuleSizeError) {
  function TEST (line 292) | TEST(WebTransportFramerTest, WTMaxData) {
  function TEST (line 307) | TEST(WebTransportFramerTest, WTMaxDataError) {
  function TEST (line 324) | TEST(WebTransportFramerTest, WTMaxDataCapsuleSizeError) {
  function TEST (line 331) | TEST(WebTransportFramerTest, WTMaxStreamData) {
  function TEST (line 347) | TEST(WebTransportFramerTest, WTMaxStreamDataStreamIdError) {
  function TEST (line 365) | TEST(WebTransportFramerTest, WTMaxStreamDataError) {
  function TEST (line 382) | TEST(WebTransportFramerTest, WTMaxStreamDataCapsuleSizeError) {
  function TEST (line 391) | TEST(WebTransportFramerTest, WTMaxStreams) {
  function TEST (line 406) | TEST(WebTransportFramerTest, WTMaxStreamsError) {
  function TEST (line 423) | TEST(WebTransportFramerTest, WTMaxStreamsCapsuleSizeError) {
  function TEST (line 430) | TEST(WebTransportFramerTest, WTMaxStreamsUni) {
  function TEST (line 445) | TEST(WebTransportFramerTest, WTMaxStreamsUniError) {
  function TEST (line 462) | TEST(WebTransportFramerTest, WTMaxStreamsUniCapsuleSizeError) {
  function TEST (line 469) | TEST(WebTransportFramerTest, WTDataBlocked) {
  function TEST (line 484) | TEST(WebTransportFramerTest, WTDataBlockedError) {
  function TEST (line 501) | TEST(WebTransportFramerTest, WTDataBlockedCapsuleSizeError) {
  function TEST (line 508) | TEST(WebTransportFramerTest, WTStreamDataBlocked) {
  function TEST (line 524) | TEST(WebTransportFramerTest, WTStreamDataBlockedStreamIdError) {
  function TEST (line 542) | TEST(WebTransportFramerTest, WTStreamDataBlockedMaxStreamDataError) {
  function TEST (line 559) | TEST(WebTransportFramerTest, WTStreamDataBlockedCapsuleSizeError) {
  function TEST (line 568) | TEST(WebTransportFramerTest, WTStreamsBlocked) {
  function TEST (line 583) | TEST(WebTransportFramerTest, WTStreamsBlockedError) {
  function TEST (line 600) | TEST(WebTransportFramerTest, WTStreamsBlockedCapsuleSizeError) {
  function TEST (line 607) | TEST(WebTransportFramerTest, WTStreamsBlockedUni) {
  function TEST (line 622) | TEST(WebTransportFramerTest, WTStreamsBlockedUniError) {
  function TEST (line 639) | TEST(WebTransportFramerTest, WTStreamsBlockedUniCapsuleSizeError) {
  function TEST (line 646) | TEST(WebTransportFramerTest, Datagram) {
  function TEST (line 662) | TEST(WebTransportFramerTest, DatagramError) {
  function TEST (line 679) | TEST(WebTransportFramerTest, CloseWebTransportSession) {
  function TEST (line 697) | TEST(WebTransportFramerTest, CloseWebTransportSessionErrorCodeError) {
  function TEST (line 716) | TEST(WebTransportFramerTest, CloseWebTransportSessionErrorMsgError) {
  function TEST (line 734) | TEST(WebTransportFramerTest, DrainWebTransportSession) {

FILE: proxygen/lib/http/connpool/Endpoint.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/connpool/ServerIdleSessionController.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/connpool/ServerIdleSessionController.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/connpool/SessionHolder.cpp
  type proxygen (line 22) | namespace proxygen {
    function HTTPSessionBase (line 57) | const HTTPSessionBase& SessionHolder::getSession() const {
    function HTTPTransaction (line 61) | HTTPTransaction* SessionHolder::newTransaction(

FILE: proxygen/lib/http/connpool/SessionHolder.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/connpool/SessionPool.cpp
  type proxygen (line 16) | namespace proxygen {
    function HTTPTransaction (line 101) | HTTPTransaction* SessionPool::getTransaction(
    function HTTPTransaction (line 162) | HTTPTransaction* SessionPool::attemptOpenTransaction(

FILE: proxygen/lib/http/connpool/SessionPool.h
  function getMaxIdleSessions (line 79) | [[nodiscard]] uint32_t getMaxIdleSessions() const;
  function ServerIdleSessionController (line 230) | ServerIdleSessionController* serverIdleSessionController_{nullptr};

FILE: proxygen/lib/http/connpool/ThreadIdleSessionController.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/connpool/ThreadIdleSessionController.h
  function namespace (line 29) | namespace proxygen {

FILE: proxygen/lib/http/connpool/test/SessionPoolTest.cpp
  function TEST_F (line 27) | TEST_F(SessionPoolFixture, ParallelPoolChangedMaxSessions) {
  function TEST_F (line 46) | TEST_F(SessionPoolFixture, SerialPoolBasic) {
  function TEST_F (line 66) | TEST_F(SessionPoolFixture, ParallelPoolBasic) {
  function TEST_F (line 93) | TEST_F(SessionPoolFixture, SerialPoolPurge) {
  function TEST_F (line 139) | TEST_F(SessionPoolFixture, ParallelPoolLists) {
  function TEST_F (line 237) | TEST_F(SessionPoolFixture, OutstandingWrites) {
  function TEST_F (line 272) | TEST_F(SessionPoolFixture, OutstandingTransaction) {
  function TEST_F (line 301) | TEST_F(SessionPoolFixture, DroppedRequestNotPooled) {
  function TEST_F (line 349) | TEST_F(SessionPoolFixture, InsertIntoZeroSizePool) {
  function TEST_F (line 357) | TEST_F(SessionPoolFixture, DrainSessionLater) {
  function TEST_F (line 374) | TEST_F(SessionPoolFixture, InsertDrainedSession) {
  function TEST_F (line 393) | TEST_F(SessionPoolFixture, CloseNotReusable) {
  function TEST_F (line 418) | TEST_F(SessionPoolFixture, InsertOldSession) {
  function TEST_F (line 431) | TEST_F(SessionPoolFixture, IdleTmeout) {
  function TEST_F (line 447) | TEST_F(SessionPoolFixture, AgeOut) {
  function TEST_F (line 464) | TEST_F(SessionPoolFixture, DrainOnShutdown) {
  class TestIdleController (line 498) | class TestIdleController : public ServerIdleSessionController {
    method SessionPool (line 501) | SessionPool* popBestIdlePool() {
  function TEST_F (line 506) | TEST_F(SessionPoolFixture, MoveIdleSessionBetweenThreadsTest) {
  function TEST_F (line 564) | TEST_F(SessionPoolFixture, PurgeAddedSessionTest) {
  function TEST_F (line 578) | TEST_F(SessionPoolFixture, ServerIdleSessionControllerTest) {
  function TEST_F (line 608) | TEST_F(SessionPoolFixture, WritePausedSessionNotMarkedAsIdle) {
  function TEST_F (line 657) | TEST_F(SessionPoolFixture, ThreadIdleSessionControllerLimitsTotalIdle) {
  function TEST_F (line 694) | TEST_F(SessionPoolFixture, ThreadIdleSessionControllerTrackSessionPoolCh...
  function TEST_F (line 726) | TEST_F(SessionPoolFixture, DescribeWithNullTransport) {
  function main (line 738) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/connpool/test/SessionPoolTestFixture.h
  function namespace (line 21) | namespace proxygen {
  function HTTPUpstreamSession (line 83) | HTTPUpstreamSession* makeSerialSession() {
  function HTTPUpstreamSession (line 87) | HTTPUpstreamSession* makeParallelSession() {
  function onCreate (line 104) | void onCreate(const HTTPSessionBase&) override {
  function onDestroy (line 108) | void onDestroy(const HTTPSessionBase&) override {
  function onConnectionCreated (line 115) | void onConnectionCreated() override {
  function onConnectionClosed (line 118) | void onConnectionClosed() override {
  function onConnectionActivated (line 121) | void onConnectionActivated() override {
  function onConnectionDeactivated (line 124) | void onConnectionDeactivated() override {
  function onRead (line 127) | void onRead(size_t /*bytesRead*/) override {
  function onWrite (line 129) | void onWrite(size_t /*bytesWritten*/) override {
  function setTransaction (line 133) | void setTransaction(HTTPTransaction* /*txn*/) noexcept override {
  function detachTransaction (line 136) | void detachTransaction() noexcept override {
  function onHeadersComplete (line 139) | void onHeadersComplete(
  function onBody (line 142) | void onBody(std::unique_ptr<folly::IOBuf> /*chain*/) noexcept override {
  function onChunkHeader (line 144) | void onChunkHeader(size_t /*length*/) noexcept override {}
  function onChunkComplete (line 145) | void onChunkComplete() noexcept override {}
  function onTrailers (line 146) | void onTrailers(std::unique_ptr<HTTPHeaders> /*trailers*/) noexcept over...
  function onEOM (line 148) | void onEOM() noexcept override {
  function onUpgrade (line 150) | void onUpgrade(UpgradeProtocol /*protocol*/) noexcept override {
  function onError (line 152) | void onError(const HTTPException& /*error*/) noexcept override {
  function onEgressPaused (line 154) | void onEgressPaused() noexcept override {
  function onEgressResumed (line 156) | void onEgressResumed() noexcept override {
  function closed_ (line 166) | uint32_t closed_{0}
  function activated_ (line 167) | uint32_t activated_{0}
  function deactivated_ (line 168) | uint32_t deactivated_{0}
  function numSessions_ (line 169) | uint32_t numSessions_{0}
  function attached_ (line 170) | bool attached_{false};

FILE: proxygen/lib/http/coro/HTTPBodyEventQueue.cpp
  type proxygen::coro (line 17) | namespace proxygen::coro {
    function HTTPBodyEvent (line 97) | HTTPBodyEvent HTTPBodyEventQueue::dequeueBodyEvent(uint32_t max) {

FILE: proxygen/lib/http/coro/HTTPBodyEventQueue.h
  function namespace (line 18) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPByteEventHelpers.cpp
  type proxygen::coro (line 15) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPByteEventHelpers.h
  function namespace (line 20) | namespace proxygen::coro {
  function timeoutExpired (line 40) | void timeoutExpired() noexcept override {
  function callbackCanceled (line 53) | void callbackCanceled() noexcept override {
  function Refcount (line 69) | Refcount* refcount{nullptr};
  type QuicWriteLoopByteEvent (line 74) | struct QuicWriteLoopByteEvent {
  function class (line 91) | class QuicByteEventCallback : public quic::ByteEventCallback {
  type RegAndEvent (line 149) | struct RegAndEvent {
  type TxAckEvent (line 153) | struct TxAckEvent {
  function LegacyLifecycleObserver (line 170) | LegacyLifecycleObserver(getConfigWithByteEventsEnabled()) {
  function setByteEventTimeout (line 173) | void setByteEventTimeout(std::chrono::milliseconds timeout) {
  function maxTransportWriteOffset_ (line 284) | size_t maxTransportWriteOffset_{0}
  function maxTransportTxOffset_ (line 285) | size_t maxTransportTxOffset_{0}
  function maxTransportAckOffset_ (line 286) | size_t maxTransportAckOffset_{0}
  function numPendingTxAckEvents_ (line 294) | uint8_t numPendingTxAckEvents_{0}
  function txAckByteEventsEnabled_ (line 295) | bool txAckByteEventsEnabled_{false};

FILE: proxygen/lib/http/coro/HTTPByteEvents.h
  function namespace (line 16) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPCoroSession.cpp
  function HTTPErrorCode (line 44) | HTTPErrorCode sourceCompleteErr2ErrorCode(HTTPErrorCode ec) {
  function setSecureMsg (line 70) | void setSecureMsg(HTTPMessage& msg,
  class CoroWtSessionImpl (line 80) | class CoroWtSessionImpl : public CoroWtSession {
  type proxygen::coro (line 98) | namespace proxygen::coro {
    function HTTPSource (line 100) | HTTPSource* getErrorResponse(uint16_t statusCode, const std::string& b...
    type HTTPCoroSession::WtHelper (line 107) | struct HTTPCoroSession::WtHelper {
      method createEgressSource (line 109) | auto createEgressSource() const noexcept {
      method createHttpSourceTransport (line 116) | auto createHttpSourceTransport(detail::EgressSourcePtr&& egress,
      method createWtSession (line 121) | auto createWtSession(std::unique_ptr<folly::coro::TransportIf> trans...
    type HTTPCoroSession::StreamState (line 138) | struct HTTPCoroSession::StreamState {
      type Upgrade (line 152) | enum class Upgrade : uint8_t {
      method StreamState (line 182) | StreamState(folly::EventBase* evb,
      method getID (line 200) | HTTPCodec::StreamID getID() const {
      method setWriteBuf (line 204) | void setWriteBuf(folly::IOBufQueue* writeBuf) {
      method abortIngress (line 216) | void abortIngress(HTTPErrorCode err, std::string_view details = "") {
      method setReadTimeout (line 221) | void setReadTimeout(std::chrono::milliseconds readTimeout) {
      method HTTPPriority (line 228) | HTTPPriority getPriority() const {
      method setPriority (line 232) | void setPriority(HTTPPriority priority) {
      method getStreamOffset (line 236) | uint64_t getStreamOffset() const {
      method addToStreamOffset (line 240) | void addToStreamOffset(uint64_t bytes) {
      method initIngressPush (line 244) | void initIngressPush(HTTPCodec::StreamID assocStreamID) {
      method streamSourceActive (line 249) | void streamSourceActive() {
      method startEgressCoro (line 254) | void startEgressCoro() {
      method checkForUpgrade (line 261) | bool checkForUpgrade(const HTTPMessage& msg, bool isIngress) {
      method isUpgraded (line 275) | bool isUpgraded() const {
      method markIngressAsHeadResponse (line 279) | void markIngressAsHeadResponse() {
      method markStreamSourceComplete (line 283) | void markStreamSourceComplete() {
      method markEgressComplete (line 288) | void markEgressComplete() {
      method markEgressCoroComplete (line 292) | void markEgressCoroComplete() {
      method canSendHeaders (line 297) | bool canSendHeaders() const {
      method isEgressComplete (line 301) | bool isEgressComplete() const {
      method isDetachable (line 305) | bool isDetachable() const {
      method observedBodyLength (line 313) | uint64_t observedBodyLength() const {
      method setPendingEgressEOM (line 317) | void setPendingEgressEOM() {
      method pendingEgressEOM (line 321) | bool pendingEgressEOM() const {
      method isBodyQueueEmpty (line 325) | bool isBodyQueueEmpty() const {
      method setEgressSource (line 329) | void setEgressSource(HTTPSource* source) {
      method setErrorStatusCode (line 333) | void setErrorStatusCode(uint16_t statusCode) {
      method nextHeaderEvent (line 341) | folly::coro::Task<HTTPHeaderEvent> nextHeaderEvent() {
      method nextBodyEvent (line 348) | folly::coro::Task<HTTPBodyEventQueue::ReadBodyResult> nextBodyEvent() {
      method stopReading (line 352) | void stopReading(HTTPErrorCode error) {
      method nextEgressEvent (line 356) | std::pair<HTTPBodyEvent, bool> nextEgressEvent(uint32_t maxToSend) {
      method onWindowUpdate (line 378) | folly::Expected<bool, folly::Unit> onWindowUpdate(uint32_t amount) {
      method setSendWindow (line 387) | void setSendWindow(uint32_t capacity) {
      method isFlowControlBlocked (line 391) | bool isFlowControlBlocked() const {
      method resetStream (line 395) | void resetStream(const HTTPError& err) {
      method isStateReset (line 408) | bool isStateReset() const {
      method setExpectedEgressContentLength (line 412) | void setExpectedEgressContentLength(const std::string& contentLen, b...
      method skipEgressContentLengthValidation (line 416) | void skipEgressContentLengthValidation() {
      method setDeferredStopSending (line 420) | void setDeferredStopSending(bool deferredStopSending) {
      method getDeferredStopSending (line 424) | bool getDeferredStopSending() const {
    function HTTPCoroSession (line 485) | HTTPCoroSession* HTTPCoroSession::makeUpstreamCoroSession(
    function HTTPCoroSession (line 494) | HTTPCoroSession* HTTPCoroSession::makeDownstreamCoroSession(
    function HTTPCoroSession (line 506) | HTTPCoroSession* HTTPCoroSession::makeUpstreamCoroSession(
    function HTTPCoroSession (line 515) | HTTPCoroSession* HTTPCoroSession::makeDownstreamCoroSession(
  class ControlRCB (line 2762) | class ControlRCB : public QuicReadCallback {
    method ControlRCB (line 2764) | ControlRCB(HTTPQuicCoroSession& session,
    method readAvailable (line 2771) | void readAvailable(quic::StreamId id) noexcept override {
    method noError (line 2808) | bool noError(quic::QuicErrorCode error) {
    method readError (line 2822) | void readError(quic::StreamId id, quic::QuicError error) noexcept over...
  function HTTPHeaderSize (line 3590) | HTTPHeaderSize HTTPCoroSession::addPushPromiseToWriteBuf(
  function makeInternalEx (line 3757) | folly::coro::Task<WtReqResult> makeInternalEx(std::string_view err) {

FILE: proxygen/lib/http/coro/HTTPCoroSession.h
  function namespace (line 43) | namespace proxygen {
  function class (line 54) | class HTTPSessionContext
  type WtHelper (line 510) | struct WtHelper
  function sessionBytesScheduled_ (line 536) | uint64_t sessionBytesScheduled_{0}
  function numPushStreams_ (line 546) | uint32_t numPushStreams_{0}
  function pendingSendStreams_ (line 547) | uint32_t pendingSendStreams_{0}
  function nextStreamSequenceNumber_ (line 548) | uint32_t nextStreamSequenceNumber_{0}
  function ResponseState (line 568) | enum class ResponseState { HEADERS, BODY, DONE };
  function notifyPendingShutdown (line 693) | void notifyPendingShutdown() override {
  function dumpConnectionState (line 704) | void dumpConnectionState(uint8_t /*loglevel*/) override {
  function scheduleGoawayTimeout (line 718) | void scheduleGoawayTimeout() {
  function virtual (line 745) | virtual HTTPCodec::StreamID getSessionStreamID() const = 0;
  function virtual (line 777) | virtual bool sendFlowControlUpdate(HTTPCodec::StreamID /*id*/,
  function virtual (line 781) | virtual bool isConnectionFlowControlBlocked() {
  function virtual (line 785) | virtual void interruptReadLoop() {
  function resetAfterDrainingWrites_ (line 851) | bool resetAfterDrainingWrites_{false};
  function dispatchUniWTStream (line 1024) | void dispatchUniWTStream(quic::StreamId streamId,
  function onError (line 1043) | void onError(HTTPCodec::StreamID streamID,
  function onConnectionEnd (line 1054) | void onConnectionEnd() noexcept override;
  function pingTimeout (line 1062) | void pingTimeout() noexcept override {
  function onPing (line 1064) | void onPing() noexcept override {
  function onDatagramsAvailable (line 1069) | void onDatagramsAvailable() noexcept override;
  function getDatagramSizeLimit (line 1082) | uint16_t getDatagramSizeLimit() const override;
  function streamHeadersComplete (line 1123) | void streamHeadersComplete(StreamState& /*stream*/) override;
  function isConnectionFlowControlBlocked (line 1147) | bool isConnectionFlowControlBlocked() override {
  function detachEvb (line 1172) | void detachEvb() override;
  function onPushPriority (line 1211) | void onPushPriority(quic::StreamId, const HTTPPriority&) override {
  function isStreamIngressLimitExceeded (line 1218) | bool isStreamIngressLimitExceeded(HTTPCodec::StreamID streamID) {
  function onStreamWriteReady (line 1223) | void onStreamWriteReady(quic::StreamId id,
  function readEOF_ (line 1247) | bool readEOF_{false};
  function isReadPaused_ (line 1262) | bool isReadPaused_{false};
  function Refcount (line 1273) | Refcount(kDeliveryCallbackRefcount) {
  function onByteEventRegistered (line 1276) | void onByteEventRegistered(quic::ByteEvent) override {
  function onByteEvent (line 1280) | void onByteEvent(quic::ByteEvent byteEvent) override {
  function onByteEventCanceled (line 1285) | void onByteEventCanceled(quic::ByteEvent byteEvent) override {
  function Refcount (line 1302) | Refcount byteEventRefcount_{0}

FILE: proxygen/lib/http/coro/HTTPError.cpp
  function checkInvalidAppErrorCode (line 19) | bool checkInvalidAppErrorCode(HTTPErrorCode ec) {
  function getErrorStringMap (line 68) | folly::F14FastMap<HTTPErrorCode, std::string> getErrorStringMap() {
  type proxygen::coro (line 77) | namespace proxygen::coro {
    function ErrorCode (line 90) | ErrorCode HTTPErrorCode2ErrorCode(HTTPErrorCode ec, bool fromSource) {
    function HTTPErrorCode2HTTP3ErrorCode (line 146) | HTTP3::ErrorCode HTTPErrorCode2HTTP3ErrorCode(HTTPErrorCode ec,
    function HTTPErrorCode (line 210) | HTTPErrorCode ErrorCode2HTTPErrorCode(ErrorCode ec) {
    function HTTPErrorCode (line 219) | HTTPErrorCode HTTP3ErrorCode2HTTPErrorCode(HTTP3::ErrorCode ec) {
    function HTTPErrorCode (line 231) | HTTPErrorCode HTTPException2HTTPErrorCode(const proxygen::HTTPExceptio...
    function ProxygenError (line 256) | ProxygenError HTTPErrorCode2ProxygenError(HTTPErrorCode code) {
    function HTTPException (line 296) | HTTPException HTTPErrorToHTTPException(const HTTPError& err) {

FILE: proxygen/lib/http/coro/HTTPError.h
  function namespace (line 18) | namespace proxygen {
  function namespace (line 22) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPEvents.cpp
  type proxygen::coro (line 12) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPEvents.h
  function namespace (line 20) | namespace proxygen::coro {
  type HTTPBodyEvent (line 108) | struct HTTPBodyEvent {
  function eom (line 254) | eventType(EventType::DATAGRAM), eom(false) {
  function Padding (line 258) | enum class Padding {}
  function eom (line 260) | eventType(EventType::PADDING), eom(false) {
  function explicit (line 271) | explicit HTTPBodyEvent(std::unique_ptr<HTTPHeaders> trailers)
  function explicit (line 276) | explicit HTTPBodyEvent(folly::coro::Task<TimedBaton::Status> resume)

FILE: proxygen/lib/http/coro/HTTPFilterFactoryHandler.cpp
  type proxygen::coro (line 14) | namespace proxygen::coro {
    function HTTPFilterFactoryHandler (line 61) | HTTPFilterFactoryHandler&& HTTPFilterFactoryHandler::addFilterFactory(

FILE: proxygen/lib/http/coro/HTTPFilterFactoryHandler.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPFixedSource.h
  function namespace (line 15) | namespace proxygen::coro {
  function class (line 148) | class HTTPErrorSource : public HTTPSource {

FILE: proxygen/lib/http/coro/HTTPHandlerChain.cpp
  type proxygen::coro (line 11) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPHandlerChain.h
  function setNextHandler (line 24) | void setNextHandler(std::shared_ptr<HTTPHandler> nextHandler) {

FILE: proxygen/lib/http/coro/HTTPHybridSource.h
  function namespace (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPSource.h
  function namespace (line 18) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPSourceFilter.cpp
  type proxygen::coro (line 11) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPSourceFilter.h
  function namespace (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPSourceFilterChain.h
  function namespace (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPSourceHolder.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPSourceReader.cpp
  type proxygen::coro (line 12) | namespace proxygen::coro {
    function HTTPSourceReader (line 14) | HTTPSourceReader& HTTPSourceReader::preRead(PreReadFn preReadFn) {
    function HTTPSourceReader (line 23) | HTTPSourceReader& HTTPSourceReader::preReadAsync(AsyncPreReadFn preRea...
    function HTTPSourceReader (line 32) | HTTPSourceReader& HTTPSourceReader::onHeaders(HeaderFn headerFn) {
    function HTTPSourceReader (line 40) | HTTPSourceReader& HTTPSourceReader::onHeadersAsync(AsyncHeaderFn heade...
    function HTTPSourceReader (line 49) | HTTPSourceReader& HTTPSourceReader::onBody(BodyFn bodyFn) {
    function HTTPSourceReader (line 57) | HTTPSourceReader& HTTPSourceReader::onBodyAsync(AsyncBodyFn bodyFn) {
    function HTTPSourceReader (line 66) | HTTPSourceReader& HTTPSourceReader::onDatagram(DatagramFn datagramFn) {
    function HTTPSourceReader (line 74) | HTTPSourceReader& HTTPSourceReader::onDatagramAsync(
    function HTTPSourceReader (line 84) | HTTPSourceReader& HTTPSourceReader::onPushPromise(PushPromiseFn promis...
    function HTTPSourceReader (line 92) | HTTPSourceReader& HTTPSourceReader::onPushPromiseAsync(
    function HTTPSourceReader (line 102) | HTTPSourceReader& HTTPSourceReader::onTrailers(TrailerFn trailerFn) {
    function HTTPSourceReader (line 110) | HTTPSourceReader& HTTPSourceReader::onTrailersAsync(AsyncTrailerFn tra...
    function HTTPSourceReader (line 119) | HTTPSourceReader& HTTPSourceReader::onError(ErrorFn errorFn) {
    function HTTPSourceReader (line 127) | HTTPSourceReader& HTTPSourceReader::onErrorAsync(AsyncErrorFn errorFn) {

FILE: proxygen/lib/http/coro/HTTPSourceReader.h
  function namespace (line 18) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPStreamSource.cpp
  type proxygen::coro (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPStreamSource.h
  function namespace (line 20) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPStreamSourceHolder.h
  function namespace (line 13) | namespace proxygen::coro {
  function start (line 29) | void start() {
  function sourceComplete (line 33) | void sourceComplete(HTTPCodec::StreamID /*id*/,
  function windowOpen (line 48) | void windowOpen(HTTPCodec::StreamID) override {
  function HTTPStreamSource (line 62) | HTTPStreamSource* get() {

FILE: proxygen/lib/http/coro/HTTPStreamSourceSink.cpp
  class NoopTxnHandler (line 19) | class NoopTxnHandler : public HTTPTransactionHandler {
    method NoopTxnHandler (line 21) | explicit NoopTxnHandler() = default;
    method setTransaction (line 23) | void setTransaction(HTTPTransaction*) noexcept override {
    method detachTransaction (line 25) | void detachTransaction() noexcept override {
    method onHeadersComplete (line 27) | void onHeadersComplete(std::unique_ptr<HTTPMessage>) noexcept override {
    method onBody (line 29) | void onBody(std::unique_ptr<folly::IOBuf>) noexcept override {
    method onChunkHeader (line 31) | void onChunkHeader(size_t) noexcept override {
    method onChunkComplete (line 33) | void onChunkComplete() noexcept override {
    method onTrailers (line 35) | void onTrailers(std::unique_ptr<HTTPHeaders>) noexcept override {
    method onEOM (line 37) | void onEOM() noexcept override {
    method onUpgrade (line 39) | void onUpgrade(UpgradeProtocol) noexcept override {
    method onError (line 41) | void onError(const HTTPException&) noexcept override {
    method onInvariantViolation (line 43) | void onInvariantViolation(const HTTPException&) noexcept override {
    method onEgressPaused (line 45) | void onEgressPaused() noexcept override {
    method onEgressResumed (line 47) | void onEgressResumed() noexcept override {
    method onPushedTransaction (line 49) | void onPushedTransaction(HTTPTransaction*) noexcept override {
    method onGoaway (line 51) | void onGoaway(ErrorCode) noexcept override {
    method onDatagram (line 53) | void onDatagram(std::unique_ptr<folly::IOBuf>) noexcept override {
    method onWebTransportBidiStream (line 55) | void onWebTransportBidiStream(
    method onWebTransportUniStream (line 58) | void onWebTransportUniStream(
    method onWebTransportSessionClose (line 61) | void onWebTransportSessionClose(folly::Optional<uint32_t>) noexcept ov...
  class EomHttpSource (line 68) | class EomHttpSource : public HTTPSource {
    method readHeaderEvent (line 69) | folly::coro::Task<HTTPHeaderEvent> readHeaderEvent() override {
    method readBodyEvent (line 72) | folly::coro::Task<HTTPBodyEvent> readBodyEvent(
    method stopReading (line 76) | void stopReading(folly::Optional<const HTTPErrorCode>) override {
  function handleIngressException (line 80) | inline void handleIngressException(
  class InlineExecutor (line 102) | class InlineExecutor : public folly::Executor {
    method add (line 103) | void add(folly::Func f) override {
  type InlineAwaitable (line 108) | struct InlineAwaitable {
    method co_viaIfAsync (line 112) | folly::coro::ViaIfAsyncAwaitable<WaitForIngressUnpaused> co_viaIfAsync(
    method InlineAwaitable (line 117) | static InlineAwaitable make(folly::coro::Task<TimedBaton::Status>&& task,
    method InlineAwaitable (line 123) | explicit InlineAwaitable(WaitForIngressUnpaused&& taskIn) noexcept
  type proxygen::coro (line 132) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPStreamSourceSink.h
  function namespace (line 21) | namespace proxygen::coro {
  function getCurrentFlowControlInfo (line 78) | void getCurrentFlowControlInfo(FlowControlInfo*) const override {
  function CompressionInfo (line 80) | [[nodiscard]] CompressionInfo getHeaderCompressionInfo() const override {
  function sendChunkHeader (line 95) | void sendChunkHeader(size_t /*length*/) override {
  function sendChunkTerminator (line 97) | void sendChunkTerminator() override {
  function sendTrailers (line 99) | void sendTrailers(const HTTPHeaders& trailers) override {
  function sendPadding (line 102) | void sendPadding(uint16_t bytes) override {
  function sendEOM (line 105) | void sendEOM() override {
  function isEgressEOMSeen (line 108) | bool isEgressEOMSeen() override {
  function sendAbort (line 111) | void sendAbort() override;
  function trackEgressBodyOffset (line 115) | bool trackEgressBodyOffset(uint64_t, ByteEventFlags) override {
  function getCurrentTransportInfo (line 125) | void getCurrentTransportInfo(wangle::TransportInfo* tinfo) const override {
  function pauseIngress (line 130) | void pauseIngress() override {
  function resumeIngress (line 134) | void resumeIngress() override {
  function setEgressRateLimit (line 149) | void setEgressRateLimit(uint64_t /*bitsPerSecond*/) override {
  function setIdleTimeout (line 155) | void setIdleTimeout(std::chrono::milliseconds timeout) override {
  function timeoutExpired (line 158) | void timeoutExpired() override {
  function describe (line 169) | void describe(std::ostream& os) override {
  function windowOpen (line 187) | void windowOpen(HTTPCodec::StreamID) override {
  function sourceComplete (line 192) | void sourceComplete(HTTPCodec::StreamID /*id*/,
  type EgressHeaders (line 198) | struct EgressHeaders {
  function class (line 203) | class EgressSource : public HTTPStreamSource {
  function HTTPTransactionHandler (line 209) | HTTPTransactionHandler* handler_{nullptr};

FILE: proxygen/lib/http/coro/HTTPStreamSourceSinkFactory.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/HTTPTransactionAdaptorSource.cpp
  type proxygen::coro (line 18) | namespace proxygen::coro {
    function HTTPTransactionAdaptorSource (line 31) | HTTPTransactionAdaptorSource* HTTPTransactionAdaptorSource::create(
    function HTTPSource (line 45) | HTTPSource* HTTPTransactionAdaptorSource::getIngressSource() {

FILE: proxygen/lib/http/coro/HTTPTransactionAdaptorSource.h
  function namespace (line 17) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/benchmark/HTTPCoroBenchmark.cpp
  function getServerCertPath (line 37) | std::string getServerCertPath() {
  function getServerKeyPath (line 45) | std::string getServerKeyPath() {
  class InsecureVerifierDangerousDoNotUseInProduction (line 56) | class InsecureVerifierDangerousDoNotUseInProduction
    method verify (line 61) | [[nodiscard]] std::shared_ptr<const folly::AsyncTransportCertificate> ...
    method getCertificateRequestExtensions (line 67) | [[nodiscard]] std::vector<fizz::Extension> getCertificateRequestExtens...
  type TransportType (line 73) | enum class TransportType { TCP, TLS, TLS_FIZZ, QUIC }
  function transportImpl (line 75) | HTTPClient::SecureTransportImpl transportImpl(TransportType transportTyp...
  class SizeHandler (line 89) | class SizeHandler
    method SizeHandler (line 96) | explicit SizeHandler(size_t size) : respBody_(makeBuf(size)) {
    method SizeHandler (line 99) | explicit SizeHandler(std::unique_ptr<folly::IOBuf> respBody)
    method SizeHandler (line 103) | SizeHandler(const SizeHandler& other) : respBody_(other.respBody_->clo...
    method SizeHandler (line 106) | SizeHandler& operator=(const SizeHandler& other) {
    method handleRequest (line 114) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    method HTTPTransactionHandler (line 131) | static HTTPTransactionHandler* makeHandler(
    method setTransaction (line 137) | void setTransaction(HTTPTransaction* txn) noexcept override {
    method detachTransaction (line 140) | void detachTransaction() noexcept override {
    method onHeadersComplete (line 144) | void onHeadersComplete(std::unique_ptr<HTTPMessage>) noexcept override {
    method onBody (line 146) | void onBody(std::unique_ptr<folly::IOBuf>) noexcept override {
    method onTrailers (line 148) | void onTrailers(std::unique_ptr<HTTPHeaders>) noexcept override {
    method onEOM (line 150) | void onEOM() noexcept override {
    method onUpgrade (line 157) | void onUpgrade(UpgradeProtocol) noexcept override {
    method onError (line 159) | void onError(const HTTPException& error) noexcept override {
    method onEgressPaused (line 165) | void onEgressPaused() noexcept override {
    method onEgressResumed (line 167) | void onEgressResumed() noexcept override {
  class ScopedEventBaseThread (line 174) | class ScopedEventBaseThread {
    method ScopedEventBaseThread (line 176) | explicit ScopedEventBaseThread()
    method runInThread (line 185) | void runInThread(std::function<void(folly::EventBase*)> func) {
  class BenchmarkFixture (line 200) | class BenchmarkFixture {
    method BenchmarkFixture (line 202) | explicit BenchmarkFixture(TransportType type,
  function init (line 223) | void init() {
  function initCoro (line 236) | void initCoro() {
  function initLegacy (line 273) | void initLegacy() {
  function tearDown (line 317) | void tearDown() {
  function run (line 322) | void run(size_t iters) {
  function get (line 350) | folly::coro::Task<void> get(HTTPCoroSessionPool& pool) {
  function makePool (line 377) | std::unique_ptr<HTTPCoroSessionPool> makePool(folly::EventBase* evb) {
  function runImpl (line 413) | folly::coro::Task<void> runImpl(folly::EventBase* evb,
  function BENCHMARK (line 431) | BENCHMARK(legacy_plaintext_threads_2_concurrency_1_size_0, iters) {
  function BENCHMARK (line 436) | BENCHMARK(plaintext_threads_2_concurrency_1_size_0, iters) {
  function BENCHMARK (line 441) | BENCHMARK(legacy_fizz_threads_2_concurrency_1_size_0, iters) {
  function BENCHMARK (line 446) | BENCHMARK(fizz_threads_2_concurrency_1_size_0, iters) {
  function BENCHMARK (line 451) | BENCHMARK(legacy_openssl_threads_2_concurrency_1_size_0, iters) {
  function BENCHMARK (line 456) | BENCHMARK(openssl_threads_2_concurrency_1_size_0, iters) {
  function BENCHMARK (line 461) | BENCHMARK(legacy_quic_threads_2_concurrency_1_size_0, iters) {
  function BENCHMARK (line 466) | BENCHMARK(quic_threads_2_concurrency_1_size_0, iters) {
  function BENCHMARK (line 472) | BENCHMARK(legacy_fizz_threads_2_concurrency_20_size_0, iters) {
  function BENCHMARK (line 477) | BENCHMARK(fizz_threads_2_concurrency_20_size_0, iters) {
  function BENCHMARK (line 482) | BENCHMARK(legacy_openssl_threads_2_concurrency_20_size_0, iters) {
  function BENCHMARK (line 487) | BENCHMARK(openssl_threads_2_concurrency_20_size_0, iters) {
  function BENCHMARK (line 492) | BENCHMARK(legacy_quic_threads_2_concurrency_20_size_0, iters) {
  function BENCHMARK (line 497) | BENCHMARK(quic_threads_2_concurrency_20_size_0, iters) {
  function BENCHMARK (line 503) | BENCHMARK(legacy_plaintext_threads_2_concurrency_1_size_4096, iters) {
  function BENCHMARK (line 508) | BENCHMARK(plaintext_threads_2_concurrency_1_size_4096, iters) {
  function BENCHMARK (line 513) | BENCHMARK(legacy_fizz_threads_2_concurrency_1_size_4096, iters) {
  function BENCHMARK (line 518) | BENCHMARK(fizz_threads_2_concurrency_1_size_4096, iters) {
  function BENCHMARK (line 523) | BENCHMARK(legacy_openssl_threads_2_concurrency_1_size_4096, iters) {
  function BENCHMARK (line 528) | BENCHMARK(openssl_threads_2_concurrency_1_size_4096, iters) {
  function BENCHMARK (line 533) | BENCHMARK(legacy_quic_threads_2_concurrency_1_size_4096, iters) {
  function BENCHMARK (line 538) | BENCHMARK(quic_threads_2_concurrency_1_size_4096, iters) {
  function BENCHMARK (line 544) | BENCHMARK(legacy_fizz_threads_2_concurrency_20_size_4096, iters) {
  function BENCHMARK (line 550) | BENCHMARK(fizz_threads_2_concurrency_20_size_4096, iters) {
  function BENCHMARK (line 555) | BENCHMARK(legacy_openssl_threads_2_concurrency_20_size_4096, iters) {
  function BENCHMARK (line 560) | BENCHMARK(openssl_threads_2_concurrency_20_size_4096, iters) {
  function BENCHMARK (line 565) | BENCHMARK(legacy_quic_threads_2_concurrency_20_size_4096, iters) {
  function BENCHMARK (line 570) | BENCHMARK(quic_threads_2_concurrency_20_size_4096, iters) {
  function BENCHMARK (line 576) | BENCHMARK(legacy_plaintext_threads_2_concurrency_1_size_65535, iters) {
  function BENCHMARK (line 581) | BENCHMARK(plaintext_threads_2_concurrency_1_size_65535, iters) {
  function BENCHMARK (line 586) | BENCHMARK(legacy_fizz_threads_2_concurrency_1_size_65535, iters) {
  function BENCHMARK (line 592) | BENCHMARK(fizz_threads_2_concurrency_1_size_65535, iters) {
  function BENCHMARK (line 597) | BENCHMARK(legacy_openssl_threads_2_concurrency_1_size_65535, iters) {
  function BENCHMARK (line 602) | BENCHMARK(openssl_threads_2_concurrency_1_size_65535, iters) {
  function BENCHMARK (line 607) | BENCHMARK(legacy_quic_threads_2_concurrency_1_size_65535, iters) {
  function BENCHMARK (line 612) | BENCHMARK(quic_threads_2_concurrency_1_size_65535, iters) {
  function BENCHMARK (line 617) | BENCHMARK(legacy_plaintext_threads_2_concurrency_1_size_1M, iters) {
  function BENCHMARK (line 622) | BENCHMARK(plaintext_threads_2_concurrency_1_size_1M, iters) {
  function BENCHMARK (line 627) | BENCHMARK(legacy_fizz_threads_2_concurrency_1_size_1M, iters) {
  function BENCHMARK (line 633) | BENCHMARK(fizz_threads_2_concurrency_1_size_1M, iters) {
  function BENCHMARK (line 638) | BENCHMARK(legacy_quic_threads_2_concurrency_1_size_1M, iters) {
  function BENCHMARK (line 643) | BENCHMARK(quic_threads_2_concurrency_1_size_1M, iters) {
  function BENCHMARK (line 649) | BENCHMARK(legacy_fizz_threads_2_concurrency_20_size_65535, iters) {
  function BENCHMARK (line 655) | BENCHMARK(fizz_threads_2_concurrency_20_size_65535, iters) {
  function BENCHMARK (line 660) | BENCHMARK(legacy_openssl_threads_2_concurrency_20_size_65535, iters) {
  function BENCHMARK (line 665) | BENCHMARK(openssl_threads_2_concurrency_20_size_65535, iters) {
  function BENCHMARK (line 670) | BENCHMARK(legacy_quic_threads_2_concurrency_20_size_65535, iters) {
  function BENCHMARK (line 675) | BENCHMARK(quic_threads_2_concurrency_20_size_65535, iters) {
  function main (line 680) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/coro/client/CertReloadSessionPool.cpp
  type proxygen::coro (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/client/CertReloadSessionPool.h
  function namespace (line 17) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/client/CoroDNSResolver.cpp
  function hasDNSResolverInstance (line 28) | bool hasDNSResolverInstance(folly::EventBase* evb) {
  function hasStatsCollector (line 32) | bool hasStatsCollector(folly::EventBase* evb) {
  function StatsCollector (line 36) | StatsCollector* getStatsCollector(folly::EventBase* evb) {
  class CoroResolutionCallback (line 58) | class CoroResolutionCallback : public DNSResolver::ResolutionCallback {
    method CoroResolutionCallback (line 60) | explicit CoroResolutionCallback(folly::coro::Baton& baton) : baton_(ba...
    method resolutionSuccess (line 63) | void resolutionSuccess(
    method resolutionError (line 79) | void resolutionError(const folly::exception_wrapper& exp) noexcept ove...
  type proxygen::coro (line 93) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/client/CoroDNSResolver.h
  function namespace (line 18) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/client/HTTPClient.cpp
  function makeTLSParams (line 30) | HTTPCoroConnector::TLSParams makeTLSParams(
  function getConnParamsImpl (line 42) | void getConnParamsImpl(HTTPCoroConnector::ConnectionParams* connParams,
  function stringToIOBuf (line 90) | std::unique_ptr<folly::IOBuf> stringToIOBuf(std::optional<std::string> s...
  function HTTPSource (line 103) | HTTPSource* makeHTTPRequestSource(
  function HTTPSource (line 124) | HTTPSource* makeHTTPRequestSource(
  function makeRequestReadResponse (line 134) | folly::coro::Task<void> makeRequestReadResponse(
  type proxygen::coro (line 165) | namespace proxygen::coro {
    function HTTPSourceReader (line 566) | HTTPSourceReader HTTPClient::makeDefaultReader(HTTPClient::Response& r...

FILE: proxygen/lib/http/coro/client/HTTPClient.h
  function namespace (line 21) | namespace fizz {
  function namespace (line 25) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/client/HTTPClientConnectionCache.cpp
  function makePoolKey (line 26) | std::string makePoolKey(folly::StringPiece address,
  type proxygen::coro (line 48) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/client/HTTPClientConnectionCache.h
  function namespace (line 16) | namespace proxygen::coro {
  function usingProxy (line 154) | [[nodiscard]] bool usingProxy() const {

FILE: proxygen/lib/http/coro/client/HTTPCoroConnector.cpp
  function getValidSni (line 50) | folly::Optional<std::string> getValidSni(std::string_view sni) {
  class ConnectCB (line 61) | class ConnectCB
    method ConnectCB (line 65) | explicit ConnectCB(
    method connectSuccess (line 71) | void connectSuccess() noexcept override {
    method connectErr (line 74) | void connectErr(const folly::AsyncSocketException& ex) noexcept overri...
    method fizzHandshakeSuccess (line 79) | void fizzHandshakeSuccess(AsyncFizzClient* /*transport*/) noexcept ove...
    method fizzHandshakeError (line 83) | void fizzHandshakeError(AsyncFizzClient* /*transport*/,
  function connectTCP (line 100) | folly::coro::Task<std::unique_ptr<CoroTransportIf>> connectTCP(
  function initTransportInfoFromSSLSocket (line 124) | void initTransportInfoFromSSLSocket(wangle::TransportInfo& tinfo,
  function initTransportInfoFromCoroSSLTransport (line 137) | void initTransportInfoFromCoroSSLTransport(wangle::TransportInfo& tinfo,
  function initTransportInfoFromFizz (line 155) | void initTransportInfoFromFizz(wangle::TransportInfo& tinfo,
  function initTransportInfoFromQuic (line 175) | void initTransportInfoFromQuic(wangle::TransportInfo& tinfo,
  function setupCodec (line 183) | void setupCodec(HTTPCodec& codec,
  function setupSession (line 203) | void setupSession(HTTPCoroSession* session,
  function connectFizz (line 231) | folly::coro::Task<std::unique_ptr<CoroTransportIf>> connectFizz(
  function getSslSession (line 281) | inline std::shared_ptr<folly::ssl::SSLSession> getSslSession(
  function connectTLS (line 288) | folly::coro::Task<std::unique_ptr<CoroTransportIf>> connectTLS(
  class QuicConnectCB (line 346) | class QuicConnectCB
    method QuicConnectCB (line 350) | QuicConnectCB(folly::EventBase* evb,
    method quicConnectErr (line 365) | void quicConnectErr(folly::exception_wrapper ex) noexcept {
    method onConnectionSetupError (line 369) | void onConnectionSetupError(quic::QuicError error) noexcept override {
    method onReplaySafe (line 385) | void onReplaySafe() noexcept override {
    method onTransportReady (line 388) | void onTransportReady() noexcept override {
  function connectQuic (line 419) | folly::coro::Task<HTTPCoroSession*> connectQuic(
  function connectImpl (line 493) | folly::coro::Task<HTTPCoroSession*> connectImpl(
  type proxygen::coro (line 562) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/client/HTTPCoroConnector.h
  function namespace (line 31) | namespace wangle {
  function namespace (line 35) | namespace quic {
  function class (line 52) | class HTTPCoroConnector {
  function TLSParams (line 75) | static const TLSParams& defaultTLSParams() {
  type FizzContextAndVerifier (line 80) | struct FizzContextAndVerifier {
  function TLSParams (line 85) | static const TLSParams& defaultQuicTLSParams() {
  type BaseConnectionParams (line 101) | struct BaseConnectionParams {
  type ConnectionParams (line 114) | struct ConnectionParams
  function SslSessionManagerIf (line 119) | SslSessionManagerIf* sslSessionManager{nullptr};
  function ConnectionParams (line 125) | static const ConnectionParams& defaultConnectionParams() {
  function BaseConnectionParams (line 130) | struct QuicConnectionParams : public BaseConnectionParams {
  type SessionParams (line 144) | struct SessionParams {
  function HTTPSessionStats (line 152) | HTTPSessionStats* sessionStats{nullptr};

FILE: proxygen/lib/http/coro/client/HTTPCoroSessionPool.cpp
  function Ex (line 23) | inline Ex maxWaitersEx() {
  type proxygen::coro (line 29) | namespace proxygen::coro {
    function HTTPSessionContextPtr (line 530) | HTTPSessionContextPtr HTTPCoroSessionPool::detachIdleSession() noexcept {

FILE: proxygen/lib/http/coro/client/HTTPCoroSessionPool.h
  function state_ (line 41) | enum State : uint8_t { Idle = 0, Available, Full } state_{Available};
  type PoolParams (line 50) | struct PoolParams {
  function class (line 59) | class Observer {
  function PoolParams (line 72) | static PoolParams defaultPoolParams() {
  function virtual (line 124) | virtual ~HTTPCoroSessionPool() {
  function setMaxConnectionAttempts (line 141) | void setMaxConnectionAttempts(uint8_t maxConnectionAttempts) {
  function setPoolingEnabled (line 146) | void setPoolingEnabled(bool poolingEnabled) {
  function setMaxConnections (line 150) | void setMaxConnections(uint32_t maxConnections) {
  function setSessionParams (line 156) | void setSessionParams(HTTPCoroConnector::SessionParams sessionParams) {
  function setMaxAge (line 160) | void setMaxAge(std::chrono::seconds maxAge) {
  function class (line 188) | class Exception : public std::runtime_error {
  function setConnParams (line 218) | void setConnParams(const HTTPCoroConnector::ConnectionParams& connParams) {
  function setQuicConnectionParams (line 223) | void setQuicConnectionParams(
  function class (line 237) | class IdleSessionObserverIf {
  function HTTPSessionContextPtr (line 247) | HTTPSessionContextPtr detachIdleSession() noexcept;
  function notifyIdleSessionObserver (line 260) | void notifyIdleSessionObserver() const noexcept;
  function connectsInProgress_ (line 285) | uint64_t connectsInProgress_{0}
  type Waiter (line 286) | struct Waiter {
  function onNewSslSession (line 296) | void onNewSslSession(SslSessionPtr session) noexcept override {
  function SslSessionPtr (line 299) | SslSessionPtr getSslSession() noexcept override {
  function poolingEnabled_ (line 306) | bool poolingEnabled_{true};

FILE: proxygen/lib/http/coro/client/HTTPSessionFactory.h
  function namespace (line 15) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/client/main.cpp
  function fetchUrl (line 17) | folly::coro::Task<void> fetchUrl(folly::EventBase* evb, std::string url) {
  function main (line 28) | int main(int argc, char* argv[]) {

FILE: proxygen/lib/http/coro/client/samples/cocurl/CoCurl.cpp
  class InsecureVerifierDangerousDoNotUseInProduction (line 64) | class InsecureVerifierDangerousDoNotUseInProduction
    method verify (line 69) | [[nodiscard]] std::shared_ptr<const folly::AsyncTransportCertificate> ...
    method getCertificateRequestExtensions (line 75) | [[nodiscard]] std::vector<fizz::Extension> getCertificateRequestExtens...
  function main (line 95) | int main(int argc, char** argv) {
  function getWithCoro (line 181) | folly::coro::Task<void> getWithCoro(folly::EventBase* evb,
  function postWithCoro (line 207) | folly::coro::Task<void> postWithCoro(folly::EventBase* evb,
  function getViaProxy (line 247) | folly::coro::Task<void> getViaProxy(folly::EventBase* evb,

FILE: proxygen/lib/http/coro/client/test/CoroDNSResolverTests.cpp
  type proxygen::coro::test (line 24) | namespace proxygen::coro::test {
    class CoroDNSResolverTest (line 26) | class CoroDNSResolverTest : public Test {
      method expectResolveHostname (line 32) | void expectResolveHostname(
    function TEST_F (line 49) | TEST_F(CoroDNSResolverTest, testSuccess) {
    function TEST_F (line 77) | TEST_F(CoroDNSResolverTest, testNoNames) {
    function TEST_F (line 98) | TEST_F(CoroDNSResolverTest, testMultipleReturnedDomains) {
    function TEST_F (line 122) | TEST_F(CoroDNSResolverTest, testAllReturnedDomains) {
    function TEST_F (line 145) | TEST_F(CoroDNSResolverTest, UserSuppliedDnsResolver) {
    function TEST (line 170) | TEST(SingletonTest, DnsSingletonShutdown) {

FILE: proxygen/lib/http/coro/client/test/HTTPClientTests.cpp
  function transportImpl (line 39) | HTTPClient::SecureTransportImpl transportImpl(TransportType transportTyp...
  function ConnParams (line 55) | ConnParams getConnParams(TransportType transportType) {
  function getQuicConnParams (line 63) | std::shared_ptr<const HTTPCoroConnector::QuicConnectionParams>
  function HTTPCoroConnector_connect (line 69) | folly::coro::Task<HTTPCoroSession*> HTTPCoroConnector_connect(
  function transportTypeToAlpn (line 93) | std::string transportTypeToAlpn(TransportType ttype) {
  class EventBaseBackend (line 110) | class EventBaseBackend : public folly::EventBaseBackendBase {
    method EventBaseBackend (line 112) | EventBaseBackend() {
    method event_base (line 119) | event_base* getEventBase() override {
    method eb_event_base_loop (line 123) | int eb_event_base_loop(int flags) override {
    method eb_event_base_loopbreak (line 126) | int eb_event_base_loopbreak() override {
    method eb_event_add (line 130) | int eb_event_add(Event& event, const struct timeval* timeout) override {
    method eb_event_del (line 137) | int eb_event_del(EventBaseBackendBase::Event& event) override {
    method eb_event_active (line 141) | bool eb_event_active(Event& event, int res) override {
  type proxygen::coro::test (line 152) | namespace proxygen::coro::test {
    function CO_TEST_P_X (line 154) | CO_TEST_P_X(HTTPClientTests, ConnectorConnect) {
    function CO_TEST_P_X (line 177) | CO_TEST_P_X(HTTPClientTests, ConnectWithCustomTimeout) {
    function TEST_P (line 194) | TEST_P(HTTPClientTests, ConnectCancel) {
    function TEST_P (line 211) | TEST_P(HTTPClientTests, CancelledConnection) {
    function CO_TEST_P_X (line 242) | CO_TEST_P_X(HTTPClientTests, MigrateSessionEvb) {
    function CO_TEST_P_X (line 311) | CO_TEST_P_X(HTTPClientTLSOnlyTests, sslSessionCallbacks) {
    function CO_TEST_P_X (line 340) | CO_TEST_P_X(HTTPClientTests, ConnectorConnectError) {
    function CO_TEST_P_X (line 358) | CO_TEST_P_X(HTTPClientTests, ConnectorConnectTimeout) {
    function CO_TEST_P_X (line 414) | CO_TEST_P_X(HTTPClientTLSTests, ConnectorConnectTLSError) {
    function CO_TEST_P_X (line 423) | CO_TEST_P_X(HTTPClientTests, ConnectorConnectHappyEyeballs) {
    function CO_TEST_P_X (line 438) | CO_TEST_P_X(HTTPClientTests, ConnectorConnectHappyEyeballsDoubleSucces...
    function CO_TEST_P_X (line 459) | CO_TEST_P_X(HTTPClientTests, ConnectorConnectHappyEyeballsFail) {
    function CO_TEST_P_X (line 480) | CO_TEST_P_X(HTTPClientTests, ConnectorConnectHappyEyeballsCancelFallba...
    function CO_TEST_P_X (line 507) | CO_TEST_P_X(HTTPClientTests, ConnectorConnectHappyEyeballsFastFail) {
    function CO_TEST_P_X (line 523) | CO_TEST_P_X(HTTPClientTests, Get) {
    function CO_TEST_P_X (line 535) | CO_TEST_P_X(HTTPClientTests, SetHostHeader) {
    function CO_TEST_P_X (line 546) | CO_TEST_P_X(HTTPClientTests, GetWithSessionAndReservation) {
    function CO_TEST_P_X (line 581) | CO_TEST_P_X(HTTPClientTests, SessionPoolCancellationTest) {
    function CO_TEST_P_X (line 609) | CO_TEST_P_X(HTTPClientTests, GetTrailers) {
    function CO_TEST_P_X (line 619) | CO_TEST_P_X(HTTPClientTests, Post) {
    function CO_TEST_P_X (line 626) | CO_TEST_P_X(HTTPClientTests, PostEarlyReturn) {
    function CO_TEST_P_X (line 636) | CO_TEST_P_X(HTTPClientTests, PostCancel) {
    function CO_TEST_P_X (line 659) | CO_TEST_P_X(HTTPClientTests, Connect) {
    function CO_TEST_P_X (line 686) | CO_TEST_P_X(HTTPClientTests, PostSession) {
    function CO_TEST_P_X (line 719) | CO_TEST_P_X(HTTPClientTests, PostCustomReader) {
    function CO_TEST_P_X (line 739) | CO_TEST_P_X(HTTPClientTests, Request) {
    function CO_TEST_P_X (line 770) | CO_TEST_P_X(HTTPClientTests, getHTTPSessionAddressOverride) {
    function CO_TEST_P_X (line 799) | CO_TEST_P_X(HTTPClientTests, RequestBuildHTTPSource) {
    function CO_TEST_P_X (line 837) | CO_TEST_P_X(HTTPClientTests, GetBadURL) {
    function CO_TEST_P_X (line 842) | CO_TEST_P_X(HTTPClientTests, SourceReaderErrorHandling) {
    function CO_TEST_P_X (line 858) | CO_TEST_P_X(HTTPClientTests, GetError) {
    function CO_TEST_P_X (line 864) | CO_TEST_P_X(HTTPClientTests, GetNon200) {
    function CO_TEST_P_X (line 871) | CO_TEST_P_X(HTTPClientTests, GetErrorHeaders) {
    function CO_TEST_P_X (line 878) | CO_TEST_P_X(HTTPClientTests, PostErrorBody) {
    function CO_TEST_P_X (line 887) | CO_TEST_P_X(HTTPClientTests, QuicConnParamsTestMocks) {
    function CO_TEST_P_X (line 931) | CO_TEST_P_X(HTTPClientTests, ClientBodyError) {
    function CO_TEST_P_X (line 966) | CO_TEST_P_X(HTTPClientTests, ServerBodyError) {
    class HTTPCoroSessionPoolTests (line 980) | class HTTPCoroSessionPoolTests : public HTTPClientTests {
      class CoroSessionPool (line 982) | class CoroSessionPool : public HTTPCoroSessionPool {
      method SetUp (line 995) | void SetUp() override {
      method makePool (line 1003) | std::unique_ptr<CoroSessionPool> makePool(
    function get (line 1031) | folly::coro::Task<uint16_t> get(HTTPCoroSessionPool& pool,
    function CO_TEST_P_X (line 1052) | CO_TEST_P_X(HTTPCoroSessionPoolTests, Pool) {
    function CO_TEST_P_X (line 1061) | CO_TEST_P_X(HTTPCoroSessionPoolTLSTests, PoolSessionReuse) {
    function CO_TEST_P_X (line 1072) | CO_TEST_P_X(HTTPCoroSessionPoolSSLTests, PoolSessionReuseCustomStore) {
    function CO_TEST_P_X (line 1099) | CO_TEST_P_X(HTTPCoroSessionPoolTests, PoolLateBind) {
    function CO_TEST_P_X (line 1112) | CO_TEST_P_X(HTTPCoroSessionPoolTests, PoolLateBindTimeout) {
    function CO_TEST_P_X (line 1135) | CO_TEST_P_X(HTTPCoroSessionPoolTests, PoolHeadersTimeout) {
    function CO_TEST_P_X (line 1167) | CO_TEST_P_X(HTTPCoroSessionPoolTests, PoolLateBindConnectOnClose) {
    function CO_TEST_P_X (line 1197) | CO_TEST_P_X(HTTPCoroSessionPoolTests, LateBindConnFailCancelWaiters) {
    function CO_TEST_P_X (line 1219) | CO_TEST_P_X(HTTPCoroSessionPoolTests, DrainCancelWaiters) {
    function CO_TEST_P_X (line 1240) | CO_TEST_P_X(HTTPCoroSessionPoolTests, TwoWaitersOneConns) {
    function CO_TEST_P_X (line 1295) | CO_TEST_P_X(HTTPCoroSessionPoolTests, TwoWaitersTwoConns) {
    function CO_TEST_P_X (line 1348) | CO_TEST_P_X(HTTPCoroSessionPoolTests, PoolMaxAge) {
    function CO_TEST_P_X (line 1358) | CO_TEST_P_X(HTTPCoroSessionPoolTests, PoolConnect) {
    function CO_TEST_P_X (line 1385) | CO_TEST_P_X(HTTPCoroSessionPoolTests, PoolingDisabled) {
    function TEST_P (line 1421) | TEST_P(HTTPCoroSessionPoolTests, DrainViaDestructor) {
    function TEST_P (line 1432) | TEST_P(HTTPCoroSessionPoolTests, LastOutstandingConnectFailed) {
    function CO_TEST_P_X (line 1528) | CO_TEST_P_X(HTTPCoroSessionPoolTests, IdleSessionsTest) {
    function CO_TEST_P_X (line 1621) | CO_TEST_P_X(HTTPCoroSessionPoolTests, FlushPool) {
    class CertReloadSessionPoolTests (line 1654) | class CertReloadSessionPoolTests : public HTTPClientTests {
      method SetUp (line 1659) | void SetUp() override {
      method makePool (line 1667) | std::unique_ptr<CertReloadSessionPool> makePool(
    function CO_TEST_P_X (line 1701) | CO_TEST_P_X(CertReloadSessionPoolTests, TimerCallback) {
    class HTTPClientConnectionCacheTests (line 1761) | class HTTPClientConnectionCacheTests : public HTTPClientTests {
      method SetUp (line 1763) | void SetUp() override {
      method poolExists (line 1776) | bool poolExists(const folly::SocketAddress& socket) {
      class HTTPClientConnectionCacheWrapper (line 1785) | class HTTPClientConnectionCacheWrapper : public HTTPClientConnection...
    function TEST_P (line 1795) | TEST_P(HTTPClientConnectionCacheTests, GetPool) {
    function TEST_P (line 1812) | TEST_P(HTTPClientConnectionCacheTests, GetPoolWithConnParams) {
    function TEST_P (line 1858) | TEST_P(HTTPClientConnectionCacheTests, PoolMaxSize) {
    function CO_TEST_P_X (line 1865) | CO_TEST_P_X(HTTPClientConnectionCacheTests, GetSession) {
    function TEST_P (line 1898) | TEST_P(HTTPClientConnectionCacheTests, EmptyPoolIsReaped) {
    function CO_TEST_P_X (line 1906) | CO_TEST_P_X(HTTPClientConnectionCacheTests, OnlyEmptyPoolsAreReaped) {
    function CO_TEST_P_X (line 1932) | CO_TEST_P_X(HTTPClientConnectionCacheTests, TraverseAtMostMaxPoolsDuri...
    function CO_TEST_P_X (line 1955) | CO_TEST_P_X(HTTPClientConnectionCacheTests, GetSessionDuringDrain) {
    function CO_TEST_P_X (line 1966) | CO_TEST_P_X(HTTPClientConnectionCacheTests, GetSessionReqCancel) {
    function CO_TEST_P_X (line 1981) | CO_TEST_P_X(HTTPClientConnectionCacheTests, PendingGetSessionDrain) {
    function CO_TEST_P_X (line 2019) | CO_TEST_P_X(HTTPClientConnectionCacheTests, PendingGetSessionReqCancel) {
    function CO_TEST_P_X (line 2056) | CO_TEST_P_X(HTTPClientConnectionCacheTLSTests, NonDefaultParams) {
    function CO_TEST_P_X (line 2085) | CO_TEST_P_X(HTTPClientConnectionCacheTests, ProxyConnect) {
    function CO_TEST_P_X (line 2106) | CO_TEST_P_X(HTTPClientConnectionCacheTests, ProxyGet) {

FILE: proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.cpp
  function getSniOrEmpty (line 17) | std::string getSniOrEmpty(const HTTPSessionContextPtr& ctx) {
  type proxygen::coro::test (line 25) | namespace proxygen::coro::test {

FILE: proxygen/lib/http/coro/client/test/HTTPClientTestsCommon.h
  type class (line 34) | enum class
  function std (line 36) | inline std::string transportTypeToTestName(
  function class (line 50) | class TestHandler : public HTTPHandler {
  function class (line 60) | class HTTPClientTests : public TestWithParam<TransportType> {

FILE: proxygen/lib/http/coro/client/test/HTTPConnectIntegrationTest.cpp
  function parseQueryParamAsInt (line 27) | auto parseQueryParamAsInt(const proxygen::HTTPMessage& message,
  type proxygen::coro::test (line 35) | namespace proxygen::coro::test {
    class ConnectHandler (line 37) | class ConnectHandler : public HTTPHandler {
      method ConnectHandler (line 39) | ConnectHandler(folly::SocketAddress serverAddress)
      method handleRequest (line 43) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    class Handler (line 64) | class Handler : public TestHandler {
      method handleRequest (line 66) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    class HTTPConnectIntegrationTest (line 125) | class HTTPConnectIntegrationTest : public ::testing::Test {
      method SetUp (line 127) | void SetUp() override {
      method getConnParams (line 142) | HTTPCoroConnector::ConnectionParams getConnParams() {
      method getProxySess (line 147) | folly::coro::Task<HTTPCoroSession*> getProxySess() {
      method proxyConnect (line 155) | folly::coro::Task<HTTPCoroSession*> proxyConnect(
    function CO_TEST_F_X (line 176) | CO_TEST_F_X(HTTPConnectIntegrationTest, Simple) {
    function CO_TEST_F_X (line 203) | CO_TEST_F_X(HTTPConnectIntegrationTest, TimeoutConnectTransportRead) {
    function CO_TEST_F_X (line 237) | CO_TEST_F_X(HTTPConnectIntegrationTest, CancelAfterTunnelTlsConnect) {

FILE: proxygen/lib/http/coro/client/test/MockHTTPClient.h
  function namespace (line 15) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/CompressionFilter.cpp
  type proxygen::coro (line 18) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/CompressionFilter.h
  function skipCompression_ (line 35) | bool skipCompression_{false};

FILE: proxygen/lib/http/coro/filters/CompressionFilterFactory.h
  function namespace (line 20) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/DecompressionFilter.cpp
  type SupportedCompression (line 18) | struct SupportedCompression {
  function AcceptedEncodings (line 33) | AcceptedEncodings getAcceptedEncodings() {
  function decompressionEgressHeaderEventHook (line 43) | void decompressionEgressHeaderEventHook(HTTPHeaderEvent& headerEvent) {
  type proxygen::coro (line 54) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/DecompressionFilter.h
  function namespace (line 15) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/DecompressionFilterFactory.cpp
  type proxygen::coro (line 12) | namespace proxygen::coro {
    function Filter (line 16) | Filter* makeDecompressionFilter() {

FILE: proxygen/lib/http/coro/filters/DecompressionFilterFactory.h
  function namespace (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/FilterFactory.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/HTTPRedirectHandler.cpp
  function isRedirectable (line 14) | bool isRedirectable(uint16_t code,
  type proxygen::coro (line 40) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/HTTPRedirectHandler.h
  function namespace (line 18) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/Logger.cpp
  type proxygen::coro (line 12) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/Logger.h
  function namespace (line 18) | namespace proxygen::coro {
  type class (line 161) | enum class
  function explicit (line 162) | explicit Filter(Direction dir) : direction_(dir) {
  function bodyBytes (line 183) | size_t bodyBytes{0}
  function ingress (line 186) | bool ingress{false};
  function Filter (line 193) | Filter respFilter{Filter::Direction::RESPONSE};

FILE: proxygen/lib/http/coro/filters/MutateFilter.cpp
  type proxygen::coro (line 11) | namespace proxygen::coro {
    function HTTPHeaderEventTask (line 22) | HTTPHeaderEventTask MutateFilter::readHeaderEvent() {
    function HTTPBodyEventTask (line 36) | HTTPBodyEventTask MutateFilter::readBodyEvent(uint32_t max) {

FILE: proxygen/lib/http/coro/filters/MutateFilter.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/RateLimitFilter.cpp
  type proxygen::coro (line 16) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/RateLimitFilter.h
  function namespace (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/RequestContextFilterFactory.cpp
  type proxygen::coro (line 12) | namespace proxygen::coro {
    class RequestContextFilter (line 15) | class RequestContextFilter : public HTTPSourceFilter {
      method RequestContextFilter (line 17) | explicit RequestContextFilter(
      method readHeaderEvent (line 22) | folly::coro::Task<HTTPHeaderEvent> readHeaderEvent() override {
      method readBodyEvent (line 28) | folly::coro::Task<HTTPBodyEvent> readBodyEvent(uint32_t max) override {

FILE: proxygen/lib/http/coro/filters/RequestContextFilterFactory.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/ServerFilterFactory.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/StatsFilterUtil.cpp
  type StatsState (line 19) | struct StatsState {
  function maybeSetError (line 37) | bool maybeSetError(StatsState& state, const folly::Try<T>& event) {
  type proxygen::coro (line 46) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/StatsFilterUtil.h
  function namespace (line 13) | namespace proxygen {
  function namespace (line 17) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/Status1xxFilter.cpp
  type proxygen::coro (line 12) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/Status1xxFilter.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/TransformFilter.cpp
  type proxygen::coro (line 11) | namespace proxygen::coro {
    function HTTPHeaderEventTask (line 22) | HTTPHeaderEventTask TransformFilter::readHeaderEvent() {
    function HTTPBodyEventTask (line 33) | HTTPBodyEventTask TransformFilter::readBodyEvent(uint32_t max) {

FILE: proxygen/lib/http/coro/filters/TransformFilter.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/VisitorFilter.cpp
  type proxygen::coro (line 11) | namespace proxygen::coro {
    function HTTPHeaderEventTask (line 22) | HTTPHeaderEventTask VisitorFilter::readHeaderEvent() {
    function HTTPBodyEventTask (line 36) | HTTPBodyEventTask VisitorFilter::readBodyEvent(uint32_t max) {

FILE: proxygen/lib/http/coro/filters/VisitorFilter.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/filters/test/CompressionFilterTests.cpp
  type proxygen::coro::test (line 23) | namespace proxygen::coro::test {
    type ZlibTest (line 28) | struct ZlibTest {
      method makeDecompressor (line 29) | static std::unique_ptr<StreamDecompressor> makeDecompressor() {
      method getExpectedEncoding (line 32) | static std::string getExpectedEncoding() {
      method getCompressionLevel (line 35) | static int32_t getCompressionLevel() {
    type ZstdTest (line 40) | struct ZstdTest {
      method makeDecompressor (line 41) | static std::unique_ptr<StreamDecompressor> makeDecompressor() {
      method getExpectedEncoding (line 44) | static std::string getExpectedEncoding() {
      method getCompressionLevel (line 47) | static int32_t getCompressionLevel() {
    class CompressionFilterTest (line 53) | class CompressionFilterTest : public Test {
      method SetUp (line 57) | void SetUp() override {
      method TearDown (line 63) | void TearDown() override {
      method exercise_compression (line 71) | void exercise_compression(
      method createResponseChain (line 160) | std::unique_ptr<folly::IOBuf> createResponseChain(
      method createCompressionOpts (line 175) | CompressionFilterUtils::FactoryOptions createCompressionOpts(
      method createResponse (line 197) | std::unique_ptr<HTTPMessage> createResponse(
    function TYPED_TEST (line 215) | TYPED_TEST(CompressionFilterTest, NonchunkedCompression) {
    function TYPED_TEST (line 230) | TYPED_TEST(CompressionFilterTest, ChunkedCompression) {
    function TYPED_TEST (line 245) | TYPED_TEST(CompressionFilterTest, ParameterizedContenttype) {
    function TYPED_TEST (line 260) | TYPED_TEST(CompressionFilterTest, MixedcaseContenttype) {
    function TYPED_TEST (line 276) | TYPED_TEST(CompressionFilterTest, MultipleAcceptedEncodings) {
    function TYPED_TEST (line 293) | TYPED_TEST(CompressionFilterTest, ResponseAlreadyCompressedTest) {
    function TYPED_TEST (line 313) | TYPED_TEST(CompressionFilterTest, MultipleAcceptedEncodingsQvalues) {
    function TYPED_TEST (line 328) | TYPED_TEST(CompressionFilterTest, NoCompressibleAcceptedEncodings) {
    function TYPED_TEST (line 342) | TYPED_TEST(CompressionFilterTest, MissingAcceptedEncodings) {
    function TYPED_TEST (line 357) | TYPED_TEST(CompressionFilterTest, UncompressibleContenttype) {
    function TYPED_TEST (line 372) | TYPED_TEST(CompressionFilterTest, UncompressibleContenttypeParam) {
    function TYPED_TEST (line 388) | TYPED_TEST(CompressionFilterTest, TooSmallToCompress) {
    function TYPED_TEST (line 405) | TYPED_TEST(CompressionFilterTest, SmallChunksCompress) {
    function TYPED_TEST (line 424) | TYPED_TEST(CompressionFilterTest, MinimumCompressSizeEqualToRequestSiz...
    function TYPED_TEST (line 441) | TYPED_TEST(CompressionFilterTest, CompressionDisabledForEncoding) {

FILE: proxygen/lib/http/coro/filters/test/DecompressionFilterTest.cpp
  function HTTPSource (line 24) | HTTPSource* getEgressDecompressionFilter(HTTPSource* source) {
  function HTTPSource (line 32) | HTTPSource* getIngressDecompressionFilter(HTTPSource* source) {
  type proxygen::coro::test (line 42) | namespace proxygen::coro::test {
    class DecompressionEgressFilterTest (line 44) | class DecompressionEgressFilterTest : public testing::Test {
    function CO_TEST_F_X (line 54) | CO_TEST_F_X(DecompressionEgressFilterTest, TestExceptionPassthru) {
    function CO_TEST_F_X (line 84) | CO_TEST_F_X(DecompressionEgressFilterTest, SkipExistingAcceptEncoding) {
    function CO_TEST_F_X (line 102) | CO_TEST_F_X(DecompressionEgressFilterTest, AddAcceptEncodingIfMissing) {
    class DecompressionIngressFilterTest (line 117) | class DecompressionIngressFilterTest : public testing::Test {
    function CO_TEST_F_X (line 127) | CO_TEST_F_X(DecompressionIngressFilterTest, TestExceptionPassthru) {
    type DecompressionIngressFilterCompressionParam (line 158) | struct DecompressionIngressFilterCompressionParam {
      method DecompressionIngressFilterCompressionParam (line 159) | DecompressionIngressFilterCompressionParam(std::string_view encoding,
    class DecompressionIngressFilterCompressionTest (line 168) | class DecompressionIngressFilterCompressionTest
    function CO_TEST_P_X (line 173) | CO_TEST_P_X(DecompressionIngressFilterCompressionTest,
    function CO_TEST_P_X (line 201) | CO_TEST_P_X(DecompressionIngressFilterCompressionTest,
    function CO_TEST_F_X (line 255) | CO_TEST_F_X(DecompressionIngressFilterTest, TestUnsupportedCompression) {
    function CO_TEST_F_X (line 281) | CO_TEST_F_X(DecompressionIngressFilterTest, TestMalformedCompression) {
    class MockStatsCallback (line 307) | class MockStatsCallback : public DecompressionIngressFilter::StatsCall...
    function CO_TEST_P_X (line 313) | CO_TEST_P_X(DecompressionIngressFilterCompressionTest,
    function CO_TEST_F_X (line 332) | CO_TEST_F_X(DecompressionIngressFilterTest, TestStatsCallback_Unsuppor...
    function CO_TEST_F_X (line 349) | CO_TEST_F_X(DecompressionIngressFilterTest, TestStatsCallback_Failure) {

FILE: proxygen/lib/http/coro/filters/test/FakeServerStats.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/coro/filters/test/FakeServerStats.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/http/coro/filters/test/HTTPRedirectHandlerTest.cpp
  type proxygen::coro::test (line 23) | namespace proxygen::coro::test {
    function HTTPFixedSource (line 25) | HTTPFixedSource* getRedirectResponse(
    class MockSessionFactory (line 37) | class MockSessionFactory : public HTTPSessionFactory {
    class HTTPRedirectHandlerTest (line 50) | class HTTPRedirectHandlerTest : public testing::Test {
      method SetUp (line 52) | void SetUp() override {
      method run (line 57) | folly::coro::Task<void> run(
      method expectRedirect (line 80) | void expectRedirect(
    function CO_TEST_F (line 107) | CO_TEST_F(HTTPRedirectHandlerTest, NoRedirect) {
    function CO_TEST_F (line 113) | CO_TEST_F(HTTPRedirectHandlerTest, BasicRedirects) {
    function CO_TEST_F (line 130) | CO_TEST_F(HTTPRedirectHandlerTest, AbsoluteRedirect) {
    function CO_TEST_F (line 149) | CO_TEST_F(HTTPRedirectHandlerTest, PostRedirect301) {
    function CO_TEST_F (line 158) | CO_TEST_F(HTTPRedirectHandlerTest, NoBodyOn303PostRedirect) {
    function CO_TEST_F (line 180) | CO_TEST_F(HTTPRedirectHandlerTest, OptionsRedirect) {
    function CO_TEST_F (line 188) | CO_TEST_F(HTTPRedirectHandlerTest, UnknownScheme) {
    function CO_TEST_F (line 198) | CO_TEST_F(HTTPRedirectHandlerTest, NoLocation) {
    function CO_TEST_F (line 208) | CO_TEST_F(HTTPRedirectHandlerTest, MaxRedirects) {
    function CO_TEST_F (line 226) | CO_TEST_F(HTTPRedirectHandlerTest, InvalidLocation) {
    function CO_TEST_F (line 235) | CO_TEST_F(HTTPRedirectHandlerTest, AbortIncompleteSourceOnError) {
    function CO_TEST_F (line 265) | CO_TEST_F(HTTPRedirectHandlerTest, RelativeRedirectAbsoluteOriginal) {
    function CO_TEST_F (line 288) | CO_TEST_F(HTTPRedirectHandlerTest, RelativeRedirectAbsoluteOriginalPro...
    function CO_TEST_F (line 310) | CO_TEST_F(HTTPRedirectHandlerTest, RelativeRedirectHostHeader) {
    function CO_TEST_F (line 330) | CO_TEST_F(HTTPRedirectHandlerTest, RelativeRedirectHostHeaderNonDefaul...
    function CO_TEST_F (line 352) | CO_TEST_F(HTTPRedirectHandlerTest, RelativeRedirectNoHostHeader) {
    function CO_TEST_F (line 361) | CO_TEST_F(HTTPRedirectHandlerTest, RelativeRedirectBadHostHeader) {
    function CO_TEST_F (line 374) | CO_TEST_F(HTTPRedirectHandlerTest, RedirectWithBody) {
    function CO_TEST_F (line 393) | CO_TEST_F(HTTPRedirectHandlerTest, StopReading) {
    function CO_TEST_F (line 424) | CO_TEST_F(HTTPRedirectHandlerTest, StopReadingWhileConnecting) {
    function CO_TEST_F (line 452) | CO_TEST_F(HTTPRedirectHandlerTest, StopReadingWhileSending) {
    function CO_TEST_F (line 479) | CO_TEST_F(HTTPRedirectHandlerTest, TestCallback) {

FILE: proxygen/lib/http/coro/filters/test/LoggerTest.cpp
  class TestLogger (line 25) | class TestLogger : public Logger::SampledLogger {
    method TestLogger (line 27) | TestLogger(TestLoggerCb&& logImpl, double rate)
    method getLoggingWeight (line 31) | uint32_t getLoggingWeight(bool error) override {
    method log (line 36) | void log(const Logger& logger, uint32_t weight) override {
  function makeTestLogger (line 46) | std::shared_ptr<Logger::SampledLogger> makeTestLogger(TestLoggerCb&& log...
  type proxygen::coro::test (line 53) | namespace proxygen::coro::test {
    class LoggerTest (line 55) | class LoggerTest : public testing::Test {
      method SetUp (line 57) | void SetUp() override {
      method run (line 76) | folly::coro::Task<void> run(HTTPSource* reqSource,
    function CO_TEST_F (line 98) | CO_TEST_F(LoggerTest, Basic) {
    function CO_TEST_F (line 150) | CO_TEST_F(LoggerTest, StreamIDAndIngressHeaderSize) {
    function CO_TEST_F (line 173) | CO_TEST_F(LoggerTest, StopReading) {
    function CO_TEST_F (line 192) | CO_TEST_F(LoggerTest, HeadersError) {
    function CO_TEST_F (line 208) | CO_TEST_F(LoggerTest, BodyError) {
    function CO_TEST_F (line 234) | CO_TEST_F(LoggerTest, DefaultLogger) {
    function CO_TEST_F (line 246) | CO_TEST_F(LoggerTest, Weight) {

FILE: proxygen/lib/http/coro/filters/test/MutateFilterTest.cpp
  type proxygen::coro::test (line 18) | namespace proxygen::coro::test {
    class MutateFilterTest (line 20) | class MutateFilterTest : public testing::Test {
    function CO_TEST_F_X (line 30) | CO_TEST_F_X(MutateFilterTest, SimpleTest) {
    function CO_TEST_F_X (line 82) | CO_TEST_F_X(MutateFilterTest, PassThruOnError) {

FILE: proxygen/lib/http/coro/filters/test/RateLimitFilterTest.cpp
  type proxygen::coro::test (line 26) | namespace proxygen::coro::test {
    class RateLimitFilterTest (line 27) | class RateLimitFilterTest : public testing::Test {
      method SetUp (line 29) | void SetUp() override {
      method verifyReadSize (line 35) | void verifyReadSize(uint64_t readSizeExpected, bool eom = false) {
      method timedRead (line 46) | std::chrono::seconds timedRead(uint64_t readAmount,
      method timedRead (line 59) | std::chrono::seconds timedRead(uint64_t readAmount) {
      method errorOutFilter (line 63) | folly::coro::Task<void> errorOutFilter() {
    function CO_TEST_F (line 83) | CO_TEST_F(RateLimitFilterTest, NoLimit) {
    function TEST_F (line 88) | TEST_F(RateLimitFilterTest, FirstReadAlwaysOK) {
    function TEST_F (line 94) | TEST_F(RateLimitFilterTest, SecondReadBelowLimit) {
    function TEST_F (line 101) | TEST_F(RateLimitFilterTest, SecondReadBeyondLimit) {
    function TEST_F (line 114) | TEST_F(RateLimitFilterTest, WontSleepTooLong) {
    function TEST_F (line 131) | TEST_F(RateLimitFilterTest, SetLimitClearCounter) {
    function CO_TEST_F (line 146) | CO_TEST_F(RateLimitFilterTest, CancelRead) {
    function TEST_F (line 169) | TEST_F(RateLimitFilterTest, MinReadAmount) {
    function TEST_F (line 192) | TEST_F(RateLimitFilterTest, ReadEOM) {
    function TEST_F (line 207) | TEST_F(RateLimitFilterTest, SourceHasLessData) {

FILE: proxygen/lib/http/coro/filters/test/RequestContextFilterFactoryTest.cpp
  type proxygen::coro::test (line 14) | namespace proxygen::coro::test {
    function CO_TEST (line 16) | CO_TEST(RequestContextFilterFactoryTest, RequestContextInjection) {

FILE: proxygen/lib/http/coro/filters/test/Status1xxFilterTest.cpp
  type proxygen::coro::test (line 19) | namespace proxygen::coro::test {
    function CO_TEST (line 21) | CO_TEST(Status1xxFilterTest, Ignore1xxResponses) {

FILE: proxygen/lib/http/coro/filters/test/TransformFilterTest.cpp
  type proxygen::coro::test (line 18) | namespace proxygen::coro::test {
    class TransformFilterTest (line 20) | class TransformFilterTest : public testing::Test {
    function CO_TEST_F_X (line 30) | CO_TEST_F_X(TransformFilterTest, BasicTest) {
    function CO_TEST_F_X (line 92) | CO_TEST_F_X(TransformFilterTest, PassthruFilter) {
    function CO_TEST_F_X (line 124) | CO_TEST_F_X(TransformFilterTest, InvokeOnError) {
    function CO_TEST_F_X (line 150) | CO_TEST_F_X(TransformFilterTest, TransformBodyToError) {

FILE: proxygen/lib/http/coro/filters/test/VisitorFilterTest.cpp
  type proxygen::coro::test (line 18) | namespace proxygen::coro::test {
    class VisitorFilterTest (line 20) | class VisitorFilterTest : public testing::Test {
    function CO_TEST_F_X (line 30) | CO_TEST_F_X(VisitorFilterTest, SimpleTest) {
    function CO_TEST_F_X (line 84) | CO_TEST_F_X(VisitorFilterTest, VisitorInvokedOnError) {
    function CO_TEST_F_X (line 115) | CO_TEST_F_X(VisitorFilterTest, PassThruObserver) {

FILE: proxygen/lib/http/coro/server/HTTPCoroAcceptor.cpp
  type proxygen::coro (line 17) | namespace proxygen::coro {
    function HTTPCoroSession (line 86) | HTTPCoroSession* HTTPCoroDownstreamSessionFactory::makeUniplexSession(
    function HTTPCoroSession (line 119) | HTTPCoroSession* HTTPCoroDownstreamSessionFactory::makeQuicSession(

FILE: proxygen/lib/http/coro/server/HTTPCoroAcceptor.h
  function namespace (line 16) | namespace proxygen {
  function namespace (line 22) | namespace quic {
  function namespace (line 26) | namespace wangle {
  function namespace (line 30) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/server/HTTPServer.cpp
  type proxygen::coro (line 22) | namespace proxygen::coro {
    class QuicAcceptorTransportFactory (line 26) | class QuicAcceptorTransportFactory : public quic::QuicServerTransportF...
      method QuicAcceptorTransportFactory (line 28) | explicit QuicAcceptorTransportFactory(HTTPServer& server) : server_(...
      method make (line 31) | quic::QuicServerTransport::Ptr make(
    function getHTTPSettingValueOrDefault (line 54) | uint64_t getHTTPSettingValueOrDefault(const SettingsList& settings,
    class HTTPServerHandler (line 73) | class HTTPServerHandler : public proxygen::coro::HTTPFilterFactoryHand...
      method HTTPServerHandler (line 75) | HTTPServerHandler(std::shared_ptr<HTTPHandler> userHandler,
    function HTTPCoroAcceptor (line 173) | HTTPCoroAcceptor* HTTPServer::createAcceptor(

FILE: proxygen/lib/http/coro/server/HTTPServer.h
  type QuicConfig (line 31) | struct QuicConfig {
  type SessionConfig (line 45) | struct SessionConfig {
  type Config (line 64) | struct Config {
  function zeroCopyEnableThreshold (line 85) | size_t zeroCopyEnableThreshold{0}
  function wangle (line 88) | static wangle::SSLContextConfig getDefaultTLSConfig() {
  type SocketAcceptorConfig (line 98) | struct SocketAcceptorConfig {
  function enableSoReusePort (line 200) | void enableSoReusePort() {
  function updateTlsCredentials (line 204) | void updateTlsCredentials() noexcept;
  function addObserver (line 222) | void addObserver(Observer* observer) {
  function removeObserver (line 227) | void removeObserver(Observer* observer) {
  function onConnectionSetupError (line 252) | void onConnectionSetupError(std::shared_ptr<quic::QuicSocket>,
  function State (line 270) | enum class State : uint8_t {
  function class (line 293) | class InternalThreadObserver

FILE: proxygen/lib/http/coro/server/ScopedHTTPServer.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/server/handlers/ExpectContinueWrapperHandler.cpp
  type proxygen::coro (line 16) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/server/handlers/ExpectContinueWrapperHandler.h
  function namespace (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/server/handlers/test/ExpectContinueWrapperHandlerTest.cpp
  type proxygen::coro::test (line 20) | namespace proxygen::coro::test {
    class ExpectContinueWrapperHandlerTest (line 22) | class ExpectContinueWrapperHandlerTest : public Test {
      method ExpectContinueWrapperHandlerTest (line 24) | ExpectContinueWrapperHandlerTest()
    function CO_TEST_F (line 37) | CO_TEST_F(ExpectContinueWrapperHandlerTest, SendContinueResponse) {
    function CO_TEST_F (line 94) | CO_TEST_F(ExpectContinueWrapperHandlerTest, NoExpectation) {
    function CO_TEST_F (line 126) | CO_TEST_F(ExpectContinueWrapperHandlerTest, InvalidExpectation) {
    function CO_TEST_F (line 157) | CO_TEST_F(ExpectContinueWrapperHandlerTest,
    function CO_TEST_F (line 186) | CO_TEST_F(ExpectContinueWrapperHandlerTest,
    function CO_TEST_F (line 217) | CO_TEST_F(ExpectContinueWrapperHandlerTest, StopReadingAfterInvoke) {

FILE: proxygen/lib/http/coro/server/samples/echo/EchoServer.cpp
  class EchoResponse (line 37) | class EchoResponse : public HTTPSource {
    method EchoResponse (line 39) | explicit EchoResponse(HTTPSourceHolder request)
    method readHeaderEvent (line 44) | folly::coro::Task<HTTPHeaderEvent> readHeaderEvent() override {
    method readBodyEvent (line 67) | folly::coro::Task<HTTPBodyEvent> readBodyEvent(uint32_t max) override {
    method stopReading (line 88) | void stopReading(
  class EchoHandler (line 99) | class EchoHandler
    method handleRequest (line 103) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    method onThreadStart (line 109) | void onThreadStart(folly::EventBase* /*evb*/) override {
    method onThreadStop (line 112) | void onThreadStop(folly::EventBase* /*evb*/) override {
  function main (line 119) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/coro/server/samples/fwdproxy/ConnectSource.h
  function guard (line 30) | auto guard =
  function inRead_ (line 116) | bool inRead_{false};

FILE: proxygen/lib/http/coro/server/samples/fwdproxy/FwdProxyServer.cpp
  class FwdProxyHandler (line 34) | class FwdProxyHandler : public proxygen::coro::HTTPHandler {
    method handleRequest (line 36) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    method handleConnect (line 89) | folly::coro::Task<HTTPSourceHolder> handleConnect(
  function main (line 127) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/coro/server/samples/proxy/ProxyServer.cpp
  function HTTPCoroSessionPool (line 35) | static HTTPCoroSessionPool& getPool(folly::EventBase* evb) {
  class ProxyHandler (line 54) | class ProxyHandler : public proxygen::coro::HTTPHandler {
    method handleRequest (line 56) | folly::coro::Task<HTTPSourceHolder> handleRequest(
  function main (line 89) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/coro/server/test/HTTPServerTest.cpp
  function getTestDir (line 42) | std::string_view getTestDir() {
  type StatsFactory (line 48) | struct StatsFactory : public ServerFilterFactory {
    method makeFilters (line 49) | std::pair<HTTPSourceFilter*, HTTPSourceFilter*> makeFilters() override {
    method onServerStart (line 52) | void onServerStart(folly::EventBase*) noexcept override {
    method onServerStop (line 54) | void onServerStop() noexcept override {
  class MockFizzLoggingCallback (line 59) | class MockFizzLoggingCallback : public wangle::FizzLoggingCallback {
  type proxygen::coro::test (line 90) | namespace proxygen::coro::test {
    type TransportType (line 95) | enum class TransportType { QUIC, TLS }
    function transportTypeToString (line 96) | std::string transportTypeToString(testing::TestParamInfo<TransportType...
    class TestHandler (line 107) | class TestHandler : public HTTPHandler {
      method handleRequest (line 109) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    class MockServerObserver (line 119) | class MockServerObserver : public HTTPServer::Observer {
    class HTTPServerTests (line 125) | class HTTPServerTests : public TestWithParam<TransportType> {
      method startServer (line 127) | void startServer(MockServerObserver* mockObserver = nullptr,
      method stopServer (line 182) | void stopServer() {
      method getTLSConfig (line 186) | wangle::SSLContextConfig getTLSConfig() {
      method initClient (line 203) | void initClient() {
    function TEST_P (line 221) | TEST_P(HTTPServerTests, TestBasic) {
    function TEST_P (line 238) | TEST_P(HTTPServerTests, TestExistingSocket) {
    function TEST_P (line 269) | TEST_P(HTTPServerTests, TestStopMultipleTimes) {
    function TEST_P (line 284) | TEST_P(HTTPServerTests, TestZeroThreadsMeansNumCPUs) {
    function TEST_P (line 296) | TEST_P(HTTPServerTests, TestSampling) {
    function TEST_P (line 313) | TEST_P(HTTPServerTests, TestFilterPass) {
    function TEST_P (line 334) | TEST_P(HTTPServerTests, TestFilterFail) {
    function TEST_P (line 355) | TEST_P(HTTPServerTests, TestFilterFailException) {
    function TEST_P (line 378) | TEST_P(HTTPServerTests, TestFizzLoggingCallbackInvoked) {
    function TEST_P (line 404) | TEST_P(HTTPServerTests, TestUpdateTLSCredentials) {
    class HTTPStatsFilterTests (line 511) | class HTTPStatsFilterTests : public HTTPServerTests {
      method SetUp (line 512) | void SetUp() override {
      class SourceFactoryTestHandler (line 526) | class SourceFactoryTestHandler : public TestHandler {
        method SourceFactoryTestHandler (line 528) | SourceFactoryTestHandler() = default;
        method handleRequest (line 530) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    function TEST_P (line 548) | TEST_P(HTTPStatsFilterTests, TestSimplePostStatsFilter) {
    function TEST_P (line 582) | TEST_P(HTTPStatsFilterTests, TestServerErrorHandler) {
    class MultiAcceptorHttpServerTest (line 634) | class MultiAcceptorHttpServerTest : public HTTPServerTests {
      method startServer (line 636) | void startServer(std::vector<folly::SocketAddress>&& addresses,
    function TEST_F (line 663) | TEST_F(MultiAcceptorHttpServerTest, TestMultiplePorts) {
    function TEST_F (line 699) | TEST_F(MultiAcceptorHttpServerTest, TestShutdown) {
    function TEST (line 725) | TEST(StatsFilterFactory, LatencyOnDestruction) {
    class ZeroCopyHTTPServerTest (line 733) | class ZeroCopyHTTPServerTest : public HTTPServerTests {}
    function TEST_P (line 739) | TEST_P(ZeroCopyHTTPServerTest, TestZeroCopyConfigBasicRequest) {
    function TEST_P (line 760) | TEST_P(ZeroCopyHTTPServerTest, TestZeroCopySocketOnlyBasicRequest) {
    function createTcpSocketPair (line 787) | std::pair<folly::NetworkSocket, folly::NetworkSocket> createTcpSocketP...
    class TestableHTTPCoroAcceptor (line 817) | class TestableHTTPCoroAcceptor : public HTTPCoroAcceptor {
    function TEST (line 827) | TEST(ZeroCopyAcceptor, ZeroCopyAppliedToAcceptedTransport) {
    function TEST (line 870) | TEST(ZeroCopyAcceptor, ZeroCopyNotAppliedWithoutThreshold) {

FILE: proxygen/lib/http/coro/test/HTTPCoroSessionTests.cpp
  function initSelfCodec (line 18) | void initSelfCodec(HTTPCodec &) {
  type proxygen::coro::test (line 22) | namespace proxygen::coro::test {
    function paramsToTestName (line 24) | std::string paramsToTestName(const testing::TestParamInfo<TestParams> ...

FILE: proxygen/lib/http/coro/test/HTTPCoroSessionTests.h
  function namespace (line 26) | namespace proxygen::coro::test {
  function addReadEvent (line 143) | void addReadEvent(HTTPCodec::StreamID id,
  function addReadEvent (line 149) | void addReadEvent(std::unique_ptr<folly::IOBuf> ev, bool eof) override {
  function pauseWrites (line 158) | void pauseWrites(HTTPCodec::StreamID id) override {
  function class (line 171) | class MockLifecycleObserver : public LifecycleObserver {
  function run (line 226) | void run() {
  function loopN (line 230) | void loopN(size_t n) {

FILE: proxygen/lib/http/coro/test/HTTPDownstreamCoroSessionTests.cpp
  type proxygen::coro::test (line 31) | namespace proxygen::coro::test {
    class HTTPDownstreamSessionTest (line 33) | class HTTPDownstreamSessionTest : public HTTPCoroSessionTest {
      method HTTPDownstreamSessionTest (line 35) | HTTPDownstreamSessionTest()
      method SetUp (line 41) | void SetUp() override {
      method addSimpleStrictHandler (line 54) | std::shared_ptr<HandlerFn> addSimpleStrictHandler(HandlerFn handlerF...
      method parseOutput (line 72) | void parseOutput() {
      method parseOneStream (line 76) | void parseOneStream(quic::MockQuicSocketDriver::StreamStatePair &str...
      method parseOutputHQ (line 146) | void parseOutputHQ() {
      method expectRequest (line 160) | folly::coro::Task<HTTPCodec::StreamID> expectRequest(
      method expectHeaderError (line 184) | static folly::coro::Task<HTTPError> expectHeaderError(
      method expectBodyError (line 196) | static folly::coro::Task<HTTPErrorCode> expectBodyError(
      method expectResponseHeaders (line 209) | void expectResponseHeaders(HTTPCodec::StreamID id, uint16_t statusCo...
      method expectResponseHeaders (line 217) | void expectResponseHeaders(
      method expectResponseBody (line 230) | void expectResponseBody(HTTPCodec::StreamID id) {
      method expectResponseEOM (line 234) | void expectResponseEOM(HTTPCodec::StreamID id) {
      method expectResponse (line 238) | void expectResponse(HTTPCodec::StreamID id,
      method sendRequest (line 261) | HTTPCodec::StreamID sendRequest(folly::StringPiece path,
      method sendRequest (line 279) | HTTPCodec::StreamID sendRequest(HTTPMessage &req,
      method createStreamID (line 304) | HTTPCodec::StreamID createStreamID() {
      method sendRequestHeader (line 316) | HTTPCodec::StreamID sendRequestHeader(HTTPMessage req,
      method sendRequestHeader (line 324) | void sendRequestHeader(HTTPCodec::StreamID id,
      method sendBody (line 334) | void sendBody(HTTPCodec::StreamID id,
      method sendPadding (line 345) | void sendPadding(HTTPCodec::StreamID id,
      method HTTPSource (line 354) | HTTPSource *makeResponseWithPush(
      method expectPush (line 364) | void expectPush(HTTPCodec::StreamID id,
      method addHandlerWithByteEvents (line 398) | std::shared_ptr<HandlerFn> addHandlerWithByteEvents(
    function TEST_P (line 455) | TEST_P(HTTPDownstreamSessionTest, TestEOF) {
    function TEST_P (line 460) | TEST_P(HTTPDownstreamSessionTest, Simple) {
    function TEST_P (line 481) | TEST_P(HTTPDownstreamSessionTest, PaddedRequest) {
    function TEST_P (line 516) | TEST_P(HTTPDownstreamSessionTest, HeadResponse) {
    function TEST_P (line 543) | TEST_P(HTTPDownstreamSessionTest, SimpleByteEvents) {
    function TEST_P (line 595) | TEST_P(HTTPDownstreamSessionTest, TrailerByteEvents) {
    function TEST_P (line 634) | TEST_P(HTTPDownstreamSessionTest, ByteEventErrors) {
    function TEST_P (line 655) | TEST_P(HTTPDownstreamSessionTest, ByteEventsCancelOnWriteError) {
    function TEST_P (line 692) | TEST_P(H1DownstreamSessionTest, ZeroByteEOMAckEventImmediate) {
    function TEST_P (line 775) | TEST_P(H1DownstreamSessionTest, ZeroByteEOMAckEventDelayed) {
    function TEST_P (line 855) | TEST_P(H1DownstreamSessionTest, ReadDataAfterCancel) {
    function TEST_P (line 883) | TEST_P(H2DownstreamSessionTest, ByteEventsCancelOnProtocolError) {
    function TEST_P (line 912) | TEST_P(H12DownstreamSessionTest, ByteEventTimeout) {
    function TEST_P (line 929) | TEST_P(H12DownstreamSessionTest, TooManyByteEvents) {
    function TEST_P (line 947) | TEST_P(H12DownstreamSessionTest, CancelPendingByteEvents) {
    function TEST_P (line 968) | TEST_P(H12DownstreamSessionTest, TxAckBeforeScheduleByteEvents) {
    function TEST_P (line 984) | TEST_P(HQDownstreamSessionTest, IngressBackpressureUnderLimit) {
    function TEST_P (line 1036) | TEST_P(H1DownstreamSessionTest, IngressBackpressureLimitExceeded) {
    function TEST_P (line 1095) | TEST_P(H1DownstreamSessionTest, IngressBackpressureSetReadBufferLimit) {
    function TEST_P (line 1155) | TEST_P(H1DownstreamSessionTest, IngressBackpressureLimitExceededTimeou...
    function TEST_P (line 1210) | TEST_P(HQDownstreamSessionTest, IngressBackpressureOverLimit) {
    function TEST_P (line 1332) | TEST_P(HQDownstreamSessionTest, IngressBackpressureOverLimitDelayedQPA...
    function TEST_P (line 1403) | TEST_P(HQDownstreamSessionTest, HQEgressStreamLimitExceeded) {
    function TEST_P (line 1442) | TEST_P(HQDownstreamSessionTest, HQEgressIndependentStreamLimitExceeded) {
    function TEST_P (line 1488) | TEST_P(H12DownstreamSessionTest, BodyError) {
    function TEST_P (line 1506) | TEST_P(HQStaticQPACKDownstreamSessionTest, StaticOnlyQPACK) {
    function TEST_P (line 1534) | TEST_P(HTTPDownstreamSessionTest, TwoRequests) {
    function CO_TEST_P (line 1582) | CO_TEST_P(H2DownstreamSessionTest, ResetRateLimit) {
    function TEST_P (line 1628) | TEST_P(HTTPDownstreamSessionTest, StreamIdSeqNo) {
    function TEST_P (line 1671) | TEST_P(HTTPDownstreamSessionTest, InvalidPeerCertificate) {
    function TEST_P (line 1704) | TEST_P(HTTPDownstreamSessionTest, LifecycleObserver) {
    function TEST_P (line 1761) | TEST_P(HTTPDownstreamSessionTest, LifecycleObserverRemoveCallback) {
    function TEST_P (line 1855) | TEST_P(HTTPDownstreamSessionTest, MultiLifecycleObserver) {
    function TEST_P (line 1938) | TEST_P(H1DownstreamSessionTest, NonKeepAliveResponse) {
    function TEST_P (line 1957) | TEST_P(H1DownstreamSessionTest, AntiPipeline) {
    function TEST_P (line 1996) | TEST_P(H1DownstreamSessionTest, AntiPipelineCancel) {
    function TEST_P (line 2033) | TEST_P(H2QDownstreamSessionTest, ResetStream) {
    function TEST_P (line 2058) | TEST_P(H2QDownstreamSessionTest, ResetEgressIngressOpen) {
    function TEST_P (line 2085) | TEST_P(H2QDownstreamSessionTest, ResetStreamAwaitingHeaders) {
    function TEST_P (line 2125) | TEST_P(HTTPDownstreamSessionTest, HoldContext) {
    function TEST_P (line 2158) | TEST_P(H2DownstreamSessionTest, ResetStreamNoError) {
    function TEST_P (line 2190) | TEST_P(H2QDownstreamSessionTest, StopReadingDefault500Source) {
    function TEST_P (line 2215) | TEST_P(HTTPDownstreamSessionTest, ContentLengthMismatch) {
    function TEST_P (line 2261) | TEST_P(HTTPDownstreamSessionTest, HandlerThrowsResetStream) {
    function TEST_P (line 2285) | TEST_P(H2QDownstreamSessionTest, StateMachineError) {
    function TEST_P (line 2328) | TEST_P(HTTPDownstreamSessionTest, SimplePost) {
    function TEST_P (line 2351) | TEST_P(HTTPDownstreamSessionTest,
    function TEST_P (line 2386) | TEST_P(HTTPDownstreamSessionTest, HandlerGracefullyTerminateIngressYie...
    function TEST_P (line 2412) | TEST_P(H2QDownstreamSessionTest, Push) {
    function TEST_P (line 2438) | TEST_P(H2QDownstreamSessionTest, PushEgressRstStream) {
    function TEST_P (line 2463) | TEST_P(H2QDownstreamSessionTest, PushIngressRstStream) {
    function TEST_P (line 2499) | TEST_P(H2QDownstreamSessionTest, EgressPushStreamLimitExceeded) {
    function TEST_P (line 2533) | TEST_P(H2DownstreamSessionTest, EgressPushNotSupported) {
    function TEST_P (line 2563) | TEST_P(H2DownstreamSessionTest, Ping) {
    function TEST_P (line 2581) | TEST_P(H2DownstreamSessionTest, StreamsFull) {
    function TEST_P (line 2598) | TEST_P(H2DownstreamSessionTest, EgressStreamFlowControl) {
    function TEST_P (line 2645) | TEST_P(H2DownstreamSessionTest, IngressStreamFlowControlError) {
    function TEST_P (line 2673) | TEST_P(H2DownstreamSessionTest, IngressStreamLimitExceeded) {
    function TEST_P (line 2684) | TEST_P(H1DownstreamSessionTest, EgressErrorRst) {
    function TEST_P (line 2708) | TEST_P(H1DownstreamSessionTest, EgressErrorRstPipeline) {
    function TEST_P (line 2733) | TEST_P(H1DownstreamSessionTest, ReceiveGoaway) {
    function TEST_P (line 2771) | TEST_P(H1DownstreamSessionTest, SendConnectionClose) {
    function TEST_P (line 2793) | TEST_P(H2QDownstreamSessionTest, ReceiveGoaway) {
    function TEST_P (line 2799) | TEST_P(HTTPDownstreamSessionTest, SendGoaway) {
    function TEST_P (line 2806) | TEST_P(HTTPDownstreamSessionTest, CloseWhenIdleNoStreams) {
    function TEST_P (line 2816) | TEST_P(HTTPDownstreamSessionTest, CloseWhenIdleWithStream) {
    function TEST_P (line 2834) | TEST_P(HTTPDownstreamSessionTest, EOFWithStream) {
    function TEST_P (line 2868) | TEST_P(H2QDownstreamSessionTest, ReceiveGoawayWithOpenStream) {
    function TEST_P (line 2893) | TEST_P(H2DownstreamSessionTest, ReceiveGoawayErrorWithOpenStream) {
    function TEST_P (line 2904) | TEST_P(HTTPDownstreamSessionTest, IdleTimeoutNoStreams) {
    function TEST_P (line 2916) | TEST_P(HQDownstreamSessionTest, QuicIdleTimeoutWithStream) {
    function TEST_P (line 2940) | TEST_P(HQDownstreamSessionTest, IdleTimeoutResetWithPing) {
    function TEST_P (line 2957) | TEST_P(H12DownstreamSessionTest, WebSocketUpgrade) {
    function TEST_P (line 3004) | TEST_P(H12DownstreamSessionTest, WriteTimeout) {
    class HTTPContinueSource (line 3023) | class HTTPContinueSource : public HTTPSource {
      method HTTPContinueSource (line 3025) | HTTPContinueSource() {
      method readHeaderEvent (line 3029) | folly::coro::Task<HTTPHeaderEvent> readHeaderEvent() override {
      method readBodyEvent (line 3043) | folly::coro::Task<HTTPBodyEvent> readBodyEvent(uint32_t) override {
      method stopReading (line 3047) | void stopReading(
    function TEST_P (line 3056) | TEST_P(HTTPDownstreamSessionTest, ReadTimeout) {
    function TEST_P (line 3101) | TEST_P(H1DownstreamSessionTest, HeadersReadTimeout) {
    function TEST_P (line 3126) | TEST_P(H2DownstreamSessionTest, HeadersReadTimeout) {
    function TEST_P (line 3143) | TEST_P(H1DownstreamSessionTest, BodyReadTimeout) {
    function TEST_P (line 3166) | TEST_P(HQDownstreamSessionTest, HeadersReadTimeout) {
    function TEST_P (line 3190) | TEST_P(H2QDownstreamSessionTest, StreamFlowControlTimeout) {
    function TEST_P (line 3213) | TEST_P(H2DownstreamSessionTest, ConnFlowControlTimeout) {
    function TEST_P (line 3238) | TEST_P(HQDownstreamSessionTest, ConnFlowControlTimeout) {
    function TEST_P (line 3262) | TEST_P(H2DownstreamSessionTest, TransactionBufferTimeout) {
    function TEST_P (line 3304) | TEST_P(H2DownstreamSessionTest, CodecError) {
    function TEST_P (line 3319) | TEST_P(H1DownstreamSessionTest, CodecHTTPError) {
    function TEST_P (line 3327) | TEST_P(H2DownstreamSessionTest, CodecHTTPError) {
    function TEST_P (line 3340) | TEST_P(HQDownstreamSessionTest, CodecHTTPError) {
    function TEST_P (line 3363) | TEST_P(H1DownstreamSessionTest, CodecHTTPErrorStreamEgressComplete) {
    function TEST_P (line 3396) | TEST_P(H1DownstreamSessionTest, CodecHTTPErrorStreamReadInProgress) {
    function TEST_P (line 3411) | TEST_P(HTTPDownstreamSessionTest, HandlerNoResponse) {
    function TEST_P (line 3427) | TEST_P(HTTPDownstreamSessionTest, ResponseHeadersError) {
    function CO_TEST_P_X (line 3447) | CO_TEST_P_X(HTTPDownstreamSessionTest, IngressErrorCustomResponse) {
    function CO_TEST_P_X (line 3493) | CO_TEST_P_X(HTTPDownstreamSessionTest, IngressErrorCustomResponseMisma...
    function TEST_P (line 3532) | TEST_P(HQDownstreamSessionTest, CreateControlStreamFail) {
    function TEST_P (line 3555) | TEST_P(HQDownstreamSessionTest, StopSending) {
    function TEST_P (line 3577) | TEST_P(HQDownstreamSessionTest, UniDispatchEdgeCases) {
    function TEST_P (line 3641) | TEST_P(H2QDownstreamSessionTest, StreamAfterGoaway) {
    function TEST_P (line 3668) | TEST_P(H2DownstreamSessionTest, BasicRFC9218PriorityUrgency) {
    function TEST_P (line 3718) | TEST_P(HQDownstreamSessionTest, onPriorityHeaderUrgency) {
    function TEST_P (line 3742) | TEST_P(HQDownstreamSessionTest, onPriorityHeaderUrgencyIncremental) {
    function TEST_P (line 3766) | TEST_P(HQDownstreamSessionTest, onPriorityUpdateFrame) {
    function TEST_P (line 3807) | TEST_P(HQDownstreamSessionTest, onServerPriorityHeader) {
    function TEST_P (line 3832) | TEST_P(HQDownstreamSessionTest, DelayedQPACK) {
    function TEST_P (line 3855) | TEST_P(HQDownstreamSessionTest, cancelQPACK) {
    function TEST_P (line 3884) | TEST_P(HQDownstreamSessionTest, DelayedQPACKCanceled) {
    function TEST_P (line 3914) | TEST_P(HQDownstreamSessionTest, DelayedQPACKTimeout) {
    function TEST_P (line 3942) | TEST_P(HQDownstreamSessionTest, DelayedQPACKTimeoutLoopOnceUAF) {
    function TEST_P (line 3971) | TEST_P(HQDownstreamSessionTest, DelayedQPACKICI) {
    function TEST_P (line 3987) | TEST_P(HQDownstreamSessionTest, QPACKEncoderLimited) {
    function TEST_P (line 4024) | TEST_P(HQDownstreamSessionTest, DelayedQPACKStopSendingReset) {
    function TEST_P (line 4056) | TEST_P(HQDownstreamSessionTest, DatagramNotSupportedTransport) {
    function TEST_P (line 4091) | TEST_P(HQDownstreamSessionDatagramTest, RxDatagramInvalidStreamId) {
    function TEST_P (line 4125) | TEST_P(HQDownstreamSessionDatagramTest, RxDatagramStreamIdLimitExceede...
    function TEST_P (line 4160) | TEST_P(HQDownstreamSessionDatagramTest, RxDatagramsPriorToStream) {
    function TEST_P (line 4214) | TEST_P(HQDownstreamSessionDatagramTest, RxStreamPriorToDatagrams) {

FILE: proxygen/lib/http/coro/test/HTTPFilterFactoryHandlerTests.cpp
  type proxygen::coro::test (line 23) | namespace proxygen::coro::test {
    class HTTPFilterFactoryHandlerTests (line 25) | class HTTPFilterFactoryHandlerTests : public ::testing::Test {
      method SetUp (line 27) | void SetUp() override {
      method TearDown (line 34) | void TearDown() override {
      type Direction (line 45) | enum class Direction { Request, Response, RequestResponse }
      class AppendFilterNameFilterFactory (line 46) | class AppendFilterNameFilterFactory : public FilterFactory {
        method AppendFilterNameFilterFactory (line 48) | AppendFilterNameFilterFactory(std::string filterName, Direction di...
        method makeFilters (line 52) | std::pair<HTTPSourceFilter*, HTTPSourceFilter*> makeFilters() over...
      class ReqFilterNameHandler (line 97) | class ReqFilterNameHandler : public HTTPHandler {
        method ReqFilterNameHandler (line 99) | ReqFilterNameHandler(std::string expectedReqFilterValue = "")
        method handleRequest (line 103) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    function CO_TEST_F (line 131) | CO_TEST_F(HTTPFilterFactoryHandlerTests, TestEmptyFilters) {
    function CO_TEST_F (line 150) | CO_TEST_F(HTTPFilterFactoryHandlerTests, TestFilterFactoriesSimple) {
    function CO_TEST_F (line 185) | CO_TEST_F(HTTPFilterFactoryHandlerTests, TestHandlerNullptrSource) {

FILE: proxygen/lib/http/coro/test/HTTPHandlerChainTests.cpp
  type proxygen::coro::test (line 12) | namespace proxygen::coro::test {
    class TestHTTPChainHandler (line 14) | class TestHTTPChainHandler : public HTTPChainHandler {
      method TestHTTPChainHandler (line 16) | TestHTTPChainHandler() = default;
      method handleRequest (line 19) | folly::coro::Task<HTTPSourceHolder> handleRequest(
    function TEST (line 27) | TEST(HTTPHandlerChainTests, getNextHandlerEmpty) {
    function TEST (line 32) | TEST(HTTPHandlerChainTests, setNextHandler) {
    function TEST (line 43) | TEST(HTTPHandlerChainTests, getFrontEmpty) {
    function TEST (line 48) | TEST(HTTPHandlerChainTests, getBackEmpty) {
    function TEST (line 53) | TEST(HTTPHandlerChainTests, getFrontNonEmpty) {
    function TEST (line 63) | TEST(HTTPHandlerChainTests, getBackNonEmpty) {
    function TEST (line 73) | TEST(HTTPHandlerChainTests, insertFrontMultiple) {
    function TEST (line 94) | TEST(HTTPHandlerChainTests, insertBackMultiple) {
    function TEST (line 115) | TEST(HTTPHandlerChainTests, insertMultiple) {
    function TEST (line 139) | TEST(HTTPHandlerChainTests, insertFrontNull) {
    function TEST (line 151) | TEST(HTTPHandlerChainTests, insertBackNull) {

FILE: proxygen/lib/http/coro/test/HTTPSourceTests.cpp
  type proxygen::coro::test (line 34) | namespace proxygen::coro::test {
    class MockStreamSourceCallback (line 36) | class MockStreamSourceCallback : public HTTPStreamSource::Callback {
      method MockStreamSourceCallback (line 38) | MockStreamSourceCallback() = default;
    class MockHTTPBodyEventQueueCallback (line 47) | class MockHTTPBodyEventQueueCallback : public HTTPBodyEventQueue::Call...
      method MockHTTPBodyEventQueueCallback (line 49) | MockHTTPBodyEventQueueCallback() = default;
    class HTTPStreamSourceTest (line 54) | class HTTPStreamSourceTest : public testing::Test {
      method SetUp (line 56) | void SetUp() override {
      method drainSource (line 68) | folly::coro::Task<void> drainSource(
      method run (line 111) | void run() {
      method reset (line 115) | void reset() {
    function CO_TEST (line 131) | CO_TEST(FixedSourceTest, BasicCopyTest) {
    function CO_TEST (line 151) | CO_TEST(FixedSourceTest, BasicMoveTest) {
    function TEST_F (line 171) | TEST_F(HTTPStreamSourceTest, Basic) {
    function TEST_F (line 187) | TEST_F(HTTPStreamSourceTest, Body) {
    function TEST_F (line 226) | TEST_F(HTTPStreamSourceTest, ContentLength0) {
    function TEST_F (line 239) | TEST_F(HTTPStreamSourceTest, ContentLengthShorterBody) {
    function TEST_F (line 254) | TEST_F(HTTPStreamSourceTest, ContentLengthLongerBody) {
    function TEST_F (line 269) | TEST_F(HTTPStreamSourceTest, ContentLengthMalformed) {
    function TEST_F (line 293) | TEST_F(HTTPStreamSourceTest, ContentLengthNotOkForEmptyGetResponse) {
    function TEST_F (line 305) | TEST_F(HTTPStreamSourceTest, ContentLengthOkForEmptyHeadResponse) {
    function TEST_F (line 320) | TEST_F(HTTPStreamSourceTest, ContentLengthIsNotIgnoredInChunkedBody) {
    function TEST_F (line 346) | TEST_F(HTTPStreamSourceTest, ContentLengthOkFor304ResponsesWithEmptyBo...
    function TEST_F (line 361) | TEST_F(HTTPStreamSourceTest, FinalHeaders) {
    function TEST_F (line 376) | TEST_F(HTTPStreamSourceTest, BodyBeforeFinalHeaders) {
    function TEST_F (line 389) | TEST_F(HTTPStreamSourceTest, DatagramPriorToHeader) {
    function TEST_F (line 403) | TEST_F(HTTPStreamSourceTest, BodyQueueDatagramEOM) {
    function TEST (line 423) | TEST(HTTPBodyStreamSourceTest, BodyOnlyStreamSource) {
    class HTTPStreamSourceTestPerCode (line 442) | class HTTPStreamSourceTestPerCode
    function TEST_P (line 446) | TEST_P(HTTPStreamSourceTestPerCode, ContentLengthIgnoredFor1xx) {
    function TEST_F (line 467) | TEST_F(HTTPStreamSourceTest, BodyBackpressure) {
    function TEST_F (line 497) | TEST_F(HTTPStreamSourceTest, KMinThreshold) {
    function TEST_F (line 522) | TEST_F(HTTPStreamSourceTest, Trailers) {
    function TEST_F (line 542) | TEST_F(HTTPStreamSourceTest, StateMachineError) {
    function TEST_F (line 588) | TEST_F(HTTPStreamSourceTest, APIErrorConsumerLateHeaders) {
    function TEST_F (line 614) | TEST_F(HTTPStreamSourceTest, APIErrorConsumerEarlyBody) {
    function TEST_F (line 633) | TEST_F(HTTPStreamSourceTest, StateMachineErrorHeaderWait) {
    function TEST_F (line 649) | TEST_F(HTTPStreamSourceTest, StopReadingWhileWaiting) {
    function TEST_F (line 672) | TEST_F(HTTPStreamSourceTest, BodyError) {
    function TEST_F (line 694) | TEST_F(HTTPStreamSourceTest, stopReading) {
    function TEST_F (line 708) | TEST_F(HTTPStreamSourceTest, cancel) {
    class BodyEventQueueTest (line 727) | class BodyEventQueueTest : public testing::Test {
      method BodyEventQueueTest (line 729) | BodyEventQueueTest() : queue_(&evb_, 1, queueCb, 100) {
      method SetUp (line 732) | void SetUp() override {
      method testCancelCoro (line 740) | void testCancelCoro(std::function<folly::coro::Task<void>()> coro) {
    function TEST_F (line 757) | TEST_F(BodyEventQueueTest, TestCancelReadHeaders) {
    function CO_TEST_F_X (line 772) | CO_TEST_F_X(BodyEventQueueTest, TestMatchingContentLength) {
    function CO_TEST_F_X (line 792) | CO_TEST_F_X(BodyEventQueueTest, TestMismatchedContentLengthOverExpecte...
    function CO_TEST_F_X (line 808) | CO_TEST_F_X(BodyEventQueueTest, TestMismatchedContentLengthUnderExpect...
    function CO_TEST_F_X (line 824) | CO_TEST_F_X(BodyEventQueueTest, TestSkipValidationOn304EmptyBody) {
    function CO_TEST_F_X (line 835) | CO_TEST_F_X(BodyEventQueueTest, TestInvalidBodyLength) {
    function TEST_F (line 852) | TEST_F(BodyEventQueueTest, TestCancelReadHeadersWithError) {
    function TEST_F (line 866) | TEST_F(BodyEventQueueTest, TestCancelReadBody) {
    function TEST_F (line 884) | TEST_F(BodyEventQueueTest, TestCancelReadBodyWithError) {
    function TEST_F (line 897) | TEST_F(BodyEventQueueTest, TestCancelReadBodyAwaitingBuffer) {
    function TEST (line 913) | TEST(HTTPSourceFilterTest, test) {
    function TEST (line 917) | TEST(HTTPSourceReader, test) {
    function TEST (line 974) | TEST(HTTPSourceReader, TestMissingTrailersFn) {
    function TEST (line 1024) | TEST(HTTPSourceReader, stop) {
    function TEST (line 1049) | TEST(HTTPSourceReader, cancelHeaders) {
    function TEST (line 1084) | TEST(HTTPSourceReader, cancelPreRead) {
    function TEST (line 1118) | TEST(HTTPSourceReader, cancelYieldException) {
    function TEST (line 1148) | TEST(HTTPSourceReader, datagrams) {
    function TEST (line 1186) | TEST(HTTPSourceReader, error) {
    function TEST (line 1207) | TEST(HTTPSourceReader, MaxReadSize) {
    function TEST (line 1230) | TEST(HTTPSourceReader, filter) {
    function TEST (line 1272) | TEST(HTTPErrorTests, ErrorStrings) {
    function TEST (line 1284) | TEST(HTTPEventTest, DefaultTrailers) {
    function CO_TEST (line 1290) | CO_TEST(HybridSourceTest, BasicTest) {
    function CO_TEST (line 1311) | CO_TEST(HybridSourceTest, StopReading) {
    class NameFilter (line 1330) | class NameFilter : public HTTPSourceFilter {
      method NameFilter (line 1332) | NameFilter(std::string inName, std::vector<std::string>& inNames)
      method readHeaderEvent (line 1337) | folly::coro::Task<HTTPHeaderEvent> readHeaderEvent() override {
    function CO_TEST (line 1347) | CO_TEST(FilterChainTest, SetBeforeInsert) {
    function CO_TEST (line 1366) | CO_TEST(FilterChainTest, ReleaseFilterChain) {
    function CO_TEST (line 1391) | CO_TEST(FilterChainTest, InsertBeforeSet) {
    function CO_TEST (line 1414) | CO_TEST(FilterChainTest, StopReading) {
    function CO_TEST (line 1439) | CO_TEST(ConsumerProducer, TestConcurrentAccess) {
    function CO_TEST (line 1512) | CO_TEST(ConsumerProducer, TestConcurrentAccessWithAbort) {
    function CO_TEST (line 1558) | CO_TEST(ConsumerProducer, TestHTTPStreamSourceHolderDestructor) {
    function TEST (line 1642) | TEST(HTTPStreamSourceHolder, Simple) {
    function TEST (line 1663) | TEST(HTTPStreamSourceHolder, DestructorTest) {
    function TEST (line 1670) | TEST(HTTPStreamSourceHolder, EgressBackpressure) {

FILE: proxygen/lib/http/coro/test/HTTPStreamSourceSinkTests.cpp
  type proxygen::coro::test (line 22) | namespace proxygen::coro::test {
    function CO_TEST_P_X (line 24) | CO_TEST_P_X(HTTPClientTests, BasicUpstream) {
    function CO_TEST_P_X (line 42) | CO_TEST_P_X(HTTPClientTests, UpstreamPauseBeforeEOM) {
    function CO_TEST_P_X (line 68) | CO_TEST_P_X(HTTPClientTests, FailSendUpstreamReq) {
    function CO_TEST_P_X (line 96) | CO_TEST_P_X(HTTPClientTests, PostWithPause) {
    function CO_TEST_P_X (line 133) | CO_TEST_P_X(HTTPClientTests, SendAbortDuringPause) {
    function CO_TEST_P_X (line 161) | CO_TEST_P_X(HTTPClientTests, DetachAndAbortIfIncomplete) {

FILE: proxygen/lib/http/coro/test/HTTPTestSources.h
  function namespace (line 19) | namespace proxygen::coro::test {
  function class (line 76) | class OnEOMSource : public HTTPSourceFilter {
  function class (line 108) | class TimeoutSource : public HTTPSource {

FILE: proxygen/lib/http/coro/test/HTTPTransactionAdaptorSourceTest.cpp
  type proxygen::coro::test (line 22) | namespace proxygen::coro::test {
    class HTTPTransactionAdaptorSourceTests (line 32) | class HTTPTransactionAdaptorSourceTests : public HTTPClientTests {
      method SetUp (line 34) | void SetUp() override {
      method createMockHTTPTransaction (line 45) | std::unique_ptr<::testing::StrictMock<MockHTTPTransaction>>
      method HTTPTransactionHandler (line 79) | HTTPTransactionHandler* getHandler() {
      type SourceExpectations (line 83) | struct SourceExpectations {
      method consumeAndValidateSource (line 90) | folly::coro::Task<void> consumeAndValidateSource(
      method setTransactionExpectations (line 131) | void setTransactionExpectations(const SourceExpectations& expectatio...
    function CO_TEST_P_X (line 175) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, IngressFlow) {
    function CO_TEST_P_X (line 199) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, IngressBackPressure) {
    function CO_TEST_P_X (line 227) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, IngressError) {
    function CO_TEST_P_X (line 246) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, IngressEarlyTermination) {
    function CO_TEST_P_X (line 267) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, EgressFlow) {
    function CO_TEST_P_X (line 295) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, EgressBackPressure) {
    function CO_TEST_P_X (line 328) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, UpstreamEgressErrors) {
    function CO_TEST_P_X (line 356) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests,
    function CO_TEST_P_X (line 380) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, DownstreamErrors) {
    function CO_TEST_P_X (line 413) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests, IngressNoErrorAbortNoCr...
    function CO_TEST_P_X (line 441) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests,
    function CO_TEST_P_X (line 472) | CO_TEST_P_X(HTTPTransactionAdaptorSourceTests,

FILE: proxygen/lib/http/coro/test/HTTPUpstreamCoroSessionTests.cpp
  type proxygen::coro::test (line 26) | namespace proxygen::coro::test {
    class HTTPUpstreamSessionTest (line 28) | class HTTPUpstreamSessionTest : public HTTPCoroSessionTest {
      method HTTPUpstreamSessionTest (line 30) | HTTPUpstreamSessionTest()
      method SetUp (line 35) | void SetUp() override {
      method expectResponse (line 41) | folly::coro::Task<std::unique_ptr<HTTPFixedSource>> expectResponse(
      method serializeResponse (line 95) | void serializeResponse(HTTPCodec::StreamID id,
      method serializeResponse (line 104) | void serializeResponse(HTTPCodec::StreamID id,
      method HTTPMessage (line 117) | HTTPMessage makeResponse(uint16_t statusCode, bool eom = false) {
      method serializeResponseHeader (line 136) | void serializeResponseHeader(HTTPCodec::StreamID id,
      method serializeResponseHeader (line 142) | void serializeResponseHeader(HTTPCodec::StreamID id,
      method onPushPromise (line 155) | folly::coro::Task<void> onPushPromise(HTTPPushEvent pushEvent) {
      method serializePushPromise (line 168) | std::pair<HTTPCodec::StreamID, HTTPCodec::StreamID> serializePushPro...
      method testPush (line 209) | folly::coro::Task<HTTPCodec::StreamID> testPush(
      method expectH1ConnectionReset (line 243) | void expectH1ConnectionReset() {
    function CO_TEST_P_X (line 266) | CO_TEST_P_X(HTTPUpstreamSessionTest, Simple) {
    function CO_TEST_P_X (line 280) | CO_TEST_P_X(HTTPUpstreamSessionTest, SimplePost) {
    function CO_TEST_P_X (line 289) | CO_TEST_P_X(HTTPUpstreamSessionTest, LargePost) {
    function CO_TEST_P_X (line 320) | CO_TEST_P_X(HTTPUpstreamSessionTest, Padding) {
    function CO_TEST_P_X (line 339) | CO_TEST_P_X(H2QUpstreamSessionTest, ReceiveFullResponsePriorToRequestE...
    function CO_TEST_P_X (line 383) | CO_TEST_P_X(H2QUpstreamSessionTest, StopReadingOnAbort) {
    function CO_TEST_P_X (line 421) | CO_TEST_P_X(H2UpstreamSessionTest, RstStreamAfterEOM) {
    function CO_TEST_P_X (line 445) | CO_TEST_P_X(HQUpstreamSessionTest, ReceiveStopSendingStreamPriorToResp...
    function CO_TEST_P_X (line 494) | CO_TEST_P_X(HTTPUpstreamSessionTest, ReserveRequest) {
    function CO_TEST_P_X (line 556) | CO_TEST_P_X(H2QUpstreamSessionTest, IngressResetStream) {
    function CO_TEST_P_X (line 569) | CO_TEST_P_X(H2QUpstreamSessionTest, EgressStreamLimitExceeded) {
    function CO_TEST_P_X (line 588) | CO_TEST_P_X(HQUpstreamSessionTest, StreamsFull) {
    function CO_TEST_P_X (line 612) | CO_TEST_P_X(H2UpstreamSessionTest, IngressStreamLimitExceeded) {
    function CO_TEST_P_X (line 627) | CO_TEST_P_X(H2QUpstreamSessionTest, Push) {
    function CO_TEST_P_X (line 641) | CO_TEST_P_X(H2QUpstreamSessionTest, PushEgressRstStream) {
    function CO_TEST_P_X (line 669) | CO_TEST_P_X(H2QUpstreamSessionTest, PushIngressRstStream) {
    function CO_TEST_P_X (line 693) | CO_TEST_P_X(H2UpstreamSessionTest, PushParentReset) {
    function CO_TEST_P_X (line 732) | CO_TEST_P_X(HQUpstreamSessionTest, PromiseBeforePush) {
    function CO_TEST_P_X (line 770) | CO_TEST_P_X(HQUpstreamSessionTest, SendPushPriority) {
    function CO_TEST_P_X (line 818) | CO_TEST_P_X(H1UpstreamSessionTest, DrainAfterCodecNotReusable) {
    function CO_TEST_P_X (line 856) | CO_TEST_P_X(H1UpstreamSessionTest, ReceiveGoaway) {
    function CO_TEST_P_X (line 878) | CO_TEST_P_X(H1UpstreamSessionTest, SendGoaway) {
    function CO_TEST_P_X (line 903) | CO_TEST_P_X(H1UpstreamSessionTest, DrainAfterFailedUpgrade) {
    function TEST_P (line 920) | TEST_P(H2QUpstreamSessionTest, ReceiveGoaway) {
    function TEST_P (line 927) | TEST_P(HTTPUpstreamSessionTest, SendGoaway) {
    function TEST_P (line 932) | TEST_P(HTTPUpstreamSessionTest, LifecycleObserverTestNullptr) {
    function TEST_P (line 936) | TEST_P(HTTPUpstreamSessionTest, LifecycleObserverTests) {
    function CO_TEST_P_X (line 1012) | CO_TEST_P_X(HTTPUpstreamSessionTest, BodyError) {
    function CO_TEST_P_X (line 1040) | CO_TEST_P_X(H2QUpstreamSessionTest, ReceiveGoawayWithOpenStream) {
    function CO_TEST_P_X (line 1068) | CO_TEST_P_X(H2UpstreamSessionTest, ReceiveGoawayWithError) {
    function CO_TEST_P_X (line 1078) | CO_TEST_P_X(H2UpstreamSessionTest, ReceiveGoawayBeforeRequestEgress) {
    function TEST_P (line 1100) | TEST_P(HTTPUpstreamSessionTest, IdleTimeoutNoStreams) {
    function CO_TEST_P_X (line 1106) | CO_TEST_P_X(H12UpstreamSessionTest, WriteTimeout) {
    function CO_TEST_P_X (line 1120) | CO_TEST_P_X(H2UpstreamSessionTest, WriteErrorWithCompleteStreams) {
    function CO_TEST_P_X (line 1154) | CO_TEST_P_X(HTTPUpstreamSessionTest, PostBodyReadTimeout) {
    function CO_TEST_P_X (line 1172) | CO_TEST_P_X(HTTPUpstreamSessionTest, PostReadTimeout) {
    function CO_TEST_P_X (line 1187) | CO_TEST_P_X(HTTPUpstreamSessionTest, PostReadCustomTimeout) {
    function CO_TEST_P_X (line 1203) | CO_TEST_P_X(HTTPUpstreamSessionTest, GetReadTimeout) {
    function CO_TEST_P_X (line 1219) | CO_TEST_P_X(H2UpstreamSessionTest, ConnFlowControlOnBodyError) {
    function CO_TEST_P_X (line 1238) | CO_TEST_P_X(H2UpstreamSessionTest, StreamFlowControlOnBodyError) {
    function TEST_P (line 1259) | TEST_P(H2UpstreamSessionTest, ConnFlowControlOnWindowUpdateError) {
    function CO_TEST_P_X (line 1266) | CO_TEST_P_X(H2UpstreamSessionTest, StreamFlowControlOnWindowUpdateErro...
    function TEST_P (line 1278) | TEST_P(H1UpstreamSessionTest, CodecHTTPError) {
    function CO_TEST_P_X (line 1287) | CO_TEST_P_X(H2QUpstreamSessionTest, CodecHTTPError) {
    function CO_TEST_P_X (line 1305) | CO_TEST_P_X(H2QUpstreamSessionTest, OnDeactivateConnectionLifecycle) {
    function CO_TEST_P_X (line 1333) | CO_TEST_P_X(H2UpstreamSessionTest, PushPromiseParseError) {
    function CO_TEST_P_X (line 1365) | CO_TEST_P_X(H2UpstreamSessionTest, ResetReleaseConnFlowControl) {
    function CO_TEST_P_X (line 1393) | CO_TEST_P_X(H2UpstreamSessionTest, FreeConnFlowControlAfterRst) {
    function CO_TEST_P_X (line 1423) | CO_TEST_P_X(H2UpstreamSessionTest, EgressWhileWritesBlocked) {
    function TEST_P (line 1448) | TEST_P(HTTPUpstreamSessionTest, SessionCancelledNoStreams) {
    function CO_TEST_P_X (line 1458) | CO_TEST_P_X(HTTPUpstreamSessionTest, SessionCancelledWithStream) {
    function TEST_P (line 1470) | TEST_P(HTTPUpstreamSessionTest, SessionDropNoStreams) {
    function CO_TEST_P_X (line 1481) | CO_TEST_P_X(HTTPUpstreamSessionTest, SessionDropWithStream) {
    function CO_TEST_P_X (line 1495) | CO_TEST_P_X(HTTPUpstreamSessionTest, StreamIngressCompleteNoRST) {
    function CO_TEST_P_X (line 1507) | CO_TEST_P_X(HTTPUpstreamSessionTest, CancelBeforeSendingHeaders) {
    function CO_TEST_P_X (line 1526) | CO_TEST_P_X(HTTPUpstreamSessionTest, CancelDuringPostBody) {
    function CO_TEST_P_X (line 1549) | CO_TEST_P_X(HTTPUpstreamSessionTest, SupportsMoreTransactions) {
    function CO_TEST_P_X (line 1563) | CO_TEST_P_X(HTTPUpstreamSessionTest, SendRequestHeadersAvailable) {
    function CO_TEST_P_X (line 1592) | CO_TEST_P_X(H1UpstreamSessionTest, DrainStartOnReset) {
    function CO_TEST_P_X (line 1601) | CO_TEST_P_X(H12UpstreamSessionTest, CloseOnResponseWithoutRequest) {
    function CO_TEST_P_X (line 1616) | CO_TEST_P_X(H1UpstreamSessionTest, TrailingGarbage) {
    function CO_TEST_P_X (line 1658) | CO_TEST_P_X(HQUpstreamSessionTest, CreateBidiStreamFailure) {
    function CO_TEST_P_X (line 1678) | CO_TEST_P_X(HQUpstreamSessionTest, CreateControlStreamFail) {
    function CO_TEST_P_X (line 1706) | CO_TEST_P_X(HQUpstreamSessionTest, StopSending) {
    function CO_TEST_P_X (line 1723) | CO_TEST_P_X(HQUpstreamSessionTest, StopSendingEgressComplete) {
    function CO_TEST_P_X (line 1742) | CO_TEST_P_X(HQUpstreamSessionTest, CancelWithStopSending) {
    function CO_TEST_P_X (line 1754) | CO_TEST_P_X(HQUpstreamSessionTest, QPACKQueuedOnClose) {
    function CO_TEST_P_X (line 1777) | CO_TEST_P_X(HQUpstreamSessionTest, DrainSessionOnConnectionError) {
    function CO_TEST_P_X (line 1786) | CO_TEST_P_X(HQUpstreamSessionTest, QPACKQueuedOnCloseNoEncoderStream) {
    function CO_TEST_P_X (line 1807) | CO_TEST_P_X(HQUpstreamSessionTest, LargeRequest) {

FILE: proxygen/lib/http/coro/test/HttpWtUpstreamTests.cpp
  type proxygen::coro::test (line 29) | namespace proxygen::coro::test {
    type WtCapsuleCodecCallback (line 34) | struct WtCapsuleCodecCallback : public WebTransportCapsuleCodec::Callb...
      method onWTResetStreamCapsule (line 36) | void onWTResetStreamCapsule(WTResetStreamCapsule capsule) noexcept o...
      method onWTStopSendingCapsule (line 40) | void onWTStopSendingCapsule(WTStopSendingCapsule capsule) noexcept o...
      method onWTStreamCapsule (line 44) | void onWTStreamCapsule(WTStreamCapsule capsule) noexcept override {
      method onWTMaxDataCapsule (line 52) | void onWTMaxDataCapsule(WTMaxDataCapsule capsule) noexcept override {
      method onWTMaxStreamDataCapsule (line 56) | void onWTMaxStreamDataCapsule(
      method onWTMaxStreamsBidiCapsule (line 61) | void onWTMaxStreamsBidiCapsule(
      method onWTMaxStreamsUniCapsule (line 66) | void onWTMaxStreamsUniCapsule(WTMaxStreamsCapsule capsule) noexcept ...
      method onWTDataBlockedCapsule (line 71) | void onWTDataBlockedCapsule(WTDataBlockedCapsule) noexcept override {
      method onWTStreamDataBlockedCapsule (line 73) | void onWTStreamDataBlockedCapsule(
      method onPaddingCapsule (line 76) | void onPaddingCapsule(PaddingCapsule) noexcept override {
      method onWTStreamsBlockedBidiCapsule (line 78) | void onWTStreamsBlockedBidiCapsule(
      method onWTStreamsBlockedUniCapsule (line 81) | void onWTStreamsBlockedUniCapsule(WTStreamsBlockedCapsule) noexcept ...
      method onDatagramCapsule (line 83) | void onDatagramCapsule(DatagramCapsule) noexcept override {
      method onCloseWTSessionCapsule (line 85) | void onCloseWTSessionCapsule(
      method onDrainWTSessionCapsule (line 88) | void onDrainWTSessionCapsule(
      method onConnectionError (line 91) | void onConnectionError(
      method onCapsule (line 95) | void onCapsule(uint64_t capsuleType,
      method waitForEvent (line 101) | folly::coro::Task<void> waitForEvent() {
    class HttpWtUpstreamSessionTest (line 120) | class HttpWtUpstreamSessionTest : public HTTPCoroSessionTest {
      method HttpWtUpstreamSessionTest (line 122) | HttpWtUpstreamSessionTest()
      method SetUp (line 127) | void SetUp() override {
      method getHttpSettings (line 135) | std::array<HTTPSettings*, 2> getHttpSettings() {
      method setWtSupport (line 140) | void setWtSupport(bool enabled) {
      method HTTPMessage (line 150) | HTTPMessage makeResponse(uint16_t statusCode) {
      method deliverRespHeaders (line 157) | void deliverRespHeaders(HTTPCodec::StreamID id,
      method deliverRstStream (line 165) | void deliverRstStream(HTTPCodec::StreamID id) {
    function CO_TEST_P_X (line 176) | CO_TEST_P_X(H2WtUpstreamSessionTest, Simple) {
    function CO_TEST_P_X (line 212) | CO_TEST_P_X(H2WtUpstreamSessionTest, Non2xxResp) {
    function CO_TEST_P_X (line 232) | CO_TEST_P_X(H2WtUpstreamSessionTest, WtUpgradeReqRstErr) {
    function CO_TEST_P_X (line 248) | CO_TEST_P_X(H2WtUpstreamSessionTest, SendInvalidWtReq) {
    class WtTest (line 291) | class WtTest : public H2WtUpstreamSessionTest {
      method WtTest (line 293) | WtTest() = default;
      method SetUp (line 295) | void SetUp() override {
      method TearDown (line 320) | void TearDown() override {
      method establishWtSession (line 324) | void establishWtSession() {
      method coalesceWrites (line 353) | std::unique_ptr<folly::IOBuf> coalesceWrites() {
      method deliverWtData (line 362) | void deliverWtData(std::unique_ptr<folly::IOBuf> wtData, bool eom = ...
      method grantMaxData (line 372) | void grantMaxData(uint64_t streamId, uint64_t offset) {
    function CO_TEST_P_X (line 407) | CO_TEST_P_X(WtTest, SimpleUniEgress) {
    function CO_TEST_P_X (line 509) | CO_TEST_P_X(WtTest, SimpleUniIngress) {
    function CO_TEST_P_X (line 559) | CO_TEST_P_X(WtTest, SimpleBidiEcho) {
    function TEST_P (line 654) | TEST_P(WtTest, TestErrConditions) {
    function CO_TEST_P_X (line 694) | CO_TEST_P_X(WtTest, PeerBidiAndTransportEom) {
    function CO_TEST_P_X (line 738) | CO_TEST_P_X(WtTest, MaxStreamsBidiUni) {
    class HttpStreamTransport (line 789) | class HttpStreamTransport : public Test {
      method SetUp (line 791) | void SetUp() override {
      method TearDown (line 807) | void TearDown() override {
    function CO_TEST_F (line 822) | CO_TEST_F(HttpStreamTransport, ReadAfterIngressComplete) {
    function CO_TEST_F (line 849) | CO_TEST_F(HttpStreamTransport, SimpleRead) {
    function CO_TEST_F (line 864) | CO_TEST_F(HttpStreamTransport, DeferredEom) {
    function CO_TEST_F (line 910) | CO_TEST_F(HttpStreamTransport, WriteBackpressure) {
    function CO_TEST_F (line 949) | CO_TEST_F(HttpStreamTransport, WriteTimeout) {
    function CO_TEST_F (line 981) | CO_TEST_F(HttpStreamTransport, WriteCancellation) {
    function CO_TEST_F (line 992) | CO_TEST_F(HttpStreamTransport, EgressConsumerStopReading) {
    function CO_TEST_F (line 1004) | CO_TEST_F(HttpStreamTransport, Fatals) {

FILE: proxygen/lib/http/coro/test/Mocks.h
  function namespace (line 22) | namespace proxygen::coro::test {
  function sendHeaders (line 257) | void sendHeaders(const HTTPMessage &headers) override {
  function sendBody (line 270) | void sendBody(std::unique_ptr<folly::IOBuf> body) override {
  function sendEOM (line 276) | void sendEOM() override {
  function sendAbort (line 282) | void sendAbort() override {
  function wangle (line 289) | const wangle::TransportInfo &getSetupTransportInfo() const noexcept over...
  function describe (line 301) | void describe(std::ostream &) override {}

FILE: proxygen/lib/http/coro/test/TestUtils.h
  function namespace (line 13) | namespace proxygen::coro::test {

FILE: proxygen/lib/http/coro/test/WindowContainerTests.cpp
  type proxygen::coro::test (line 15) | namespace proxygen::coro::test {
    function TEST (line 17) | TEST(WindowContainerTest, BelowKMinThreshold) {
    function TEST (line 28) | TEST(WindowContainerTest, AboveKMinThreshold) {

FILE: proxygen/lib/http/coro/transport/CoroSSLTransport.cpp
  function CoroSSLTransport (line 28) | CoroSSLTransport* transportFromBio(BIO* bio) {
  function coroSSLTransportBioWrite (line 36) | int coroSSLTransportBioWrite(BIO* bio, const char* buf, int sz) {
  function coroSSLTransportBioWriteEx (line 40) | int coroSSLTransportBioWriteEx(BIO* bio,
  function coroSSLTransportBioRead (line 54) | int coroSSLTransportBioRead(BIO* bio, char* buf, int sz) {
  function coroSSLTransportBioReadEx (line 62) | int coroSSLTransportBioReadEx(BIO* bio, char* buf, size_t sz, size_t* nr) {
  function coroSSLTransportBioCtrl (line 70) | long coroSSLTransportBioCtrl(BIO* bio, int i, long l, void* p) {
  function coroSSLTransportBioCreate (line 73) | int coroSSLTransportBioCreate(BIO* bio) {
  function coroSSLTransportBioDestroy (line 77) | int coroSSLTransportBioDestroy(BIO* /*bio*/) {
  function coroSSLTransportBioCallbackCtrl (line 80) | long coroSSLTransportBioCallbackCtrl(BIO* bio, int idx, BIO_info_cb* cb) {
  function initBioMethod (line 84) | folly::ssl::BioMethodUniquePtr initBioMethod() {
  function BIO_METHOD (line 105) | BIO_METHOD* getCoroSSLBioMethod() {
  function deadlineFromTimeout (line 110) | std::optional<std::chrono::steady_clock::time_point> deadlineFromTimeout(
  function timeoutFromDeadline (line 119) | std::chrono::milliseconds timeoutFromDeadline(
  function zero_return (line 135) | inline bool zero_return(int error, int rc, int errno_copy) {
  function getCoroSSLTransportExDataIndex (line 162) | int getCoroSSLTransportExDataIndex() {
  function CoroSSLTransport (line 168) | CoroSSLTransport* getCoroSSLTransportFromSSL(const SSL* ssl) {
  function waitForIO (line 173) | folly::coro::Task<CoroSSLTransport::IOResult> waitForIO(
  type proxygen::coro (line 202) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/transport/CoroSSLTransport.h
  type TransportOptions (line 22) | struct TransportOptions {
  function setVerificationOption (line 44) | void setVerificationOption(folly::SSLContext::SSLVerifyPeerEnum verifyPe...
  function setSSLSession (line 55) | void setSSLSession(std::shared_ptr<folly::ssl::SSLSession> session) {
  type class (line 121) | enum class
  function transportBytesOutstanding_ (line 167) | size_t transportBytesOutstanding_{0}
  function writers_ (line 170) | size_t writers_{0}
  function pendingShutdown_ (line 171) | bool pendingShutdown_{false};

FILE: proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.cpp
  type proxygen::coro (line 12) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/transport/HTTPConnectAsyncTransport.h
  function namespace (line 16) | namespace proxygen::coro {
  function close (line 77) | void close() override {
  function closeNow (line 82) | void closeNow() override {
  function shutdownWrite (line 86) | void shutdownWrite() override;
  function attachEventBase (line 110) | void attachEventBase(folly::EventBase* /*eventBase*/) override {
  function detachEventBase (line 113) | void detachEventBase() override {
  function setSendTimeout (line 119) | void setSendTimeout(uint32_t sendTimeoutMs) override {
  function getLocalAddress (line 128) | void getLocalAddress(folly::SocketAddress* address) const override {
  function getPeerAddress (line 131) | void getPeerAddress(folly::SocketAddress* address) const override {
  function setEorTracking (line 139) | void setEorTracking(bool track) override {
  function getAppBytesWritten (line 146) | [[nodiscard]] size_t getAppBytesWritten() const override {
  function getAppBytesReceived (line 152) | [[nodiscard]] size_t getAppBytesReceived() const override {
  function ReadCallback (line 164) | ReadCallback* resetReadCb() {
  function egressOffset_ (line 178) | size_t egressOffset_{0}
  function flushedOffset_ (line 179) | size_t flushedOffset_{0}
  function ingressOffset_ (line 180) | size_t ingressOffset_{0}
  function inRead_ (line 184) | bool inRead_{false};

FILE: proxygen/lib/http/coro/transport/HTTPConnectStream.cpp
  type proxygen::coro (line 12) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/transport/HTTPConnectStream.h
  function setHTTPStreamSourceCallback (line 69) | void setHTTPStreamSourceCallback(HTTPStreamSource::Callback* callback) {
  function canRead (line 75) | [[nodiscard]] bool canRead() const;

FILE: proxygen/lib/http/coro/transport/HTTPConnectTransport.cpp
  type proxygen::coro (line 17) | namespace proxygen::coro {
    class ReadTimeout (line 87) | class ReadTimeout : public folly::HHWheelTimer::Callback {
      method ReadTimeout (line 89) | explicit ReadTimeout(HTTPConnectTransport& transportRef)
      method timeoutExpired (line 92) | void timeoutExpired() noexcept override {

FILE: proxygen/lib/http/coro/transport/HTTPConnectTransport.h
  function folly (line 89) | const folly::AsyncTransportCertificate* getPeerCertificate() const overr...
  function kMaxEvents (line 102) | static constexpr uint8_t kMaxEvents{2}
  function pendingEOM_ (line 108) | bool pendingEOM_{false};

FILE: proxygen/lib/http/coro/transport/test/Client.cpp
  class Callback (line 18) | class Callback : public folly::AsyncSocket::ConnectCallback {
    method connectSuccess (line 22) | void connectSuccess() noexcept override {
    method connectErr (line 27) | void connectErr(const folly::AsyncSocketException& ex) noexcept overri...
  function main (line 32) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/coro/transport/test/CoroSSLTransportTest.cpp
  function readAll (line 35) | folly::coro::Task<Unit> readAll(proxygen::coro::CoroSSLTransport& transp...
  class FlexibleWriteCallback (line 49) | class FlexibleWriteCallback : public folly::test::WriteCallbackBase {
  class FlexibleReadCallback (line 60) | class FlexibleReadCallback : public folly::test::ReadCallback {
    method FlexibleReadCallback (line 62) | explicit FlexibleReadCallback(folly::test::WriteCallbackBase* wcb)
  class FlexibleHandshakeCallback (line 75) | class FlexibleHandshakeCallback : public folly::test::HandshakeCallback {
    method FlexibleHandshakeCallback (line 77) | explicit FlexibleHandshakeCallback(folly::test::ReadCallback* wcb)
  type proxygen::coro (line 90) | namespace proxygen::coro {
    class TransportTest (line 92) | class TransportTest : public testing::Test {
      method run (line 95) | void run(F f) {
      method requestCancellation (line 99) | folly::coro::Task<> requestCancellation() {
    class CoroSSLTransportTest (line 108) | class CoroSSLTransportTest : public TransportTest {
      method CoroSSLTransportTest (line 110) | CoroSSLTransportTest()
      method connect (line 115) | folly::coro::Task<std::unique_ptr<CoroSSLTransport>> connect(
    function TEST_F (line 146) | TEST_F(CoroSSLTransportTest, ConnectFailure) {
    function TEST_F (line 157) | TEST_F(CoroSSLTransportTest, ConnectSuccess) {
    function TEST_F (line 176) | TEST_F(CoroSSLTransportTest, ConnectVerifySuccess) {
    function TEST_F (line 195) | TEST_F(CoroSSLTransportTest, ConnectResume) {
    function TEST_F (line 232) | TEST_F(CoroSSLTransportTest, ConnectVerifyFailure) {
    function TEST_F (line 265) | TEST_F(CoroSSLTransportTest, ConnectCancelled) {
    function TEST_F (line 287) | TEST_F(CoroSSLTransportTest, ConnectEOF) {
    function TEST_F (line 312) | TEST_F(CoroSSLTransportTest, SimpleReadWrite) {
    function TEST_F (line 337) | TEST_F(CoroSSLTransportTest, SimpleIOBufReadWrite) {
    function TEST_F (line 373) | TEST_F(CoroSSLTransportTest, ReadCancelled) {
    function TEST_F (line 401) | TEST_F(CoroSSLTransportTest, ReadTimeout) {
    function TEST_F (line 415) | TEST_F(CoroSSLTransportTest, ReadError) {
    function TEST_F (line 437) | TEST_F(CoroSSLTransportTest, SimpleWritev) {
    function TEST_F (line 463) | TEST_F(CoroSSLTransportTest, WriteCancelled) {
    function TEST_F (line 491) | TEST_F(CoroSSLTransportTest, ShutdownWrite) {
    function TEST_F (line 504) | TEST_F(CoroSSLTransportTest, CloseWithReadsWrites) {
    function TEST_F (line 542) | TEST_F(CoroSSLTransportTest, Close) {
    function TEST_F (line 551) | TEST_F(CoroSSLTransportTest, CloseWithReset) {
    function TEST_F (line 561) | TEST_F(CoroSSLTransportTest, AttemptWriteWithPendingShutdown) {
    function TEST_F (line 600) | TEST_F(CoroSSLTransportTest, ResetWithPendingWrites) {
    class CoroSSLTransportFakeTest (line 712) | class CoroSSLTransportFakeTest : public TransportTest {
      method connect (line 714) | folly::coro::Task<std::unique_ptr<CoroSSLTransport>> connect() {
      method accept (line 727) | folly::coro::Task<void> accept() {
      method setupSSLBio (line 765) | bool setupSSLBio() {
    function TEST_F (line 785) | TEST_F(CoroSSLTransportFakeTest, BackgroundWriteTimeout) {
    function TEST_F (line 811) | TEST_F(CoroSSLTransportFakeTest, WritesBlockedTimeout) {
    function TEST_F (line 829) | TEST_F(CoroSSLTransportFakeTest, ProtocolError) {
    function TEST_F (line 852) | TEST_F(CoroSSLTransportFakeTest, WriteFromSSLRead) {
  function TestCoroTransport (line 628) | TestCoroTransport* transportFromBio(BIO* bio) {
  function testSSLTransportBioWrite (line 636) | int testSSLTransportBioWrite(BIO* bio, const char* buf, int sz) {
  function testSSLTransportBioWriteEx (line 641) | int testSSLTransportBioWriteEx(BIO* bio,
  function testSSLTransportBioRead (line 653) | int testSSLTransportBioRead(BIO* bio, char* buf, int sz) {
  function testSSLTransportBioReadEx (line 676) | int testSSLTransportBioReadEx(BIO* bio, char* buf, size_t sz, size_t* nr) {
  function testSSLTransportBioCtrl (line 684) | long testSSLTransportBioCtrl(BIO*, int, long, void*) {
  function initBioMethod (line 688) | folly::ssl::BioMethodUniquePtr initBioMethod() {
  function BIO_METHOD (line 703) | BIO_METHOD* getTestSSLBioMethod() {
  type proxygen::coro (line 710) | namespace proxygen::coro {
    class TransportTest (line 92) | class TransportTest : public testing::Test {
      method run (line 95) | void run(F f) {
      method requestCancellation (line 99) | folly::coro::Task<> requestCancellation() {
    class CoroSSLTransportTest (line 108) | class CoroSSLTransportTest : public TransportTest {
      method CoroSSLTransportTest (line 110) | CoroSSLTransportTest()
      method connect (line 115) | folly::coro::Task<std::unique_ptr<CoroSSLTransport>> connect(
    function TEST_F (line 146) | TEST_F(CoroSSLTransportTest, ConnectFailure) {
    function TEST_F (line 157) | TEST_F(CoroSSLTransportTest, ConnectSuccess) {
    function TEST_F (line 176) | TEST_F(CoroSSLTransportTest, ConnectVerifySuccess) {
    function TEST_F (line 195) | TEST_F(CoroSSLTransportTest, ConnectResume) {
    function TEST_F (line 232) | TEST_F(CoroSSLTransportTest, ConnectVerifyFailure) {
    function TEST_F (line 265) | TEST_F(CoroSSLTransportTest, ConnectCancelled) {
    function TEST_F (line 287) | TEST_F(CoroSSLTransportTest, ConnectEOF) {
    function TEST_F (line 312) | TEST_F(CoroSSLTransportTest, SimpleReadWrite) {
    function TEST_F (line 337) | TEST_F(CoroSSLTransportTest, SimpleIOBufReadWrite) {
    function TEST_F (line 373) | TEST_F(CoroSSLTransportTest, ReadCancelled) {
    function TEST_F (line 401) | TEST_F(CoroSSLTransportTest, ReadTimeout) {
    function TEST_F (line 415) | TEST_F(CoroSSLTransportTest, ReadError) {
    function TEST_F (line 437) | TEST_F(CoroSSLTransportTest, SimpleWritev) {
    function TEST_F (line 463) | TEST_F(CoroSSLTransportTest, WriteCancelled) {
    function TEST_F (line 491) | TEST_F(CoroSSLTransportTest, ShutdownWrite) {
    function TEST_F (line 504) | TEST_F(CoroSSLTransportTest, CloseWithReadsWrites) {
    function TEST_F (line 542) | TEST_F(CoroSSLTransportTest, Close) {
    function TEST_F (line 551) | TEST_F(CoroSSLTransportTest, CloseWithReset) {
    function TEST_F (line 561) | TEST_F(CoroSSLTransportTest, AttemptWriteWithPendingShutdown) {
    function TEST_F (line 600) | TEST_F(CoroSSLTransportTest, ResetWithPendingWrites) {
    class CoroSSLTransportFakeTest (line 712) | class CoroSSLTransportFakeTest : public TransportTest {
      method connect (line 714) | folly::coro::Task<std::unique_ptr<CoroSSLTransport>> connect() {
      method accept (line 727) | folly::coro::Task<void> accept() {
      method setupSSLBio (line 765) | bool setupSSLBio() {
    function TEST_F (line 785) | TEST_F(CoroSSLTransportFakeTest, BackgroundWriteTimeout) {
    function TEST_F (line 811) | TEST_F(CoroSSLTransportFakeTest, WritesBlockedTimeout) {
    function TEST_F (line 829) | TEST_F(CoroSSLTransportFakeTest, ProtocolError) {
    function TEST_F (line 852) | TEST_F(CoroSSLTransportFakeTest, WriteFromSSLRead) {

FILE: proxygen/lib/http/coro/transport/test/HTTPConnectTransportTest.cpp
  function readAll (line 22) | folly::coro::Task<Unit> readAll(folly::coro::TransportIf& transport,
  type proxygen::coro (line 36) | namespace proxygen::coro {
    class ReadCallback (line 38) | class ReadCallback : public AsyncTransport::ReadCallback {
      method getReadBuffer (line 40) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
      method readDataAvailable (line 46) | void readDataAvailable(size_t len) noexcept override {
      method isBufferMovable (line 54) | bool isBufferMovable() noexcept override {
      method readBufferAvailable (line 58) | void readBufferAvailable(
      method readErr (line 66) | void readErr(const AsyncSocketException& ex) noexcept override {
      method readEOF (line 72) | void readEOF() noexcept override {
    class WriteCallback (line 89) | class WriteCallback : public AsyncTransport::WriteCallback {
      method writeSuccess (line 91) | void writeSuccess() noexcept override {
      method writeErr (line 96) | void writeErr(size_t nBytesWritten,
    class TransportTest (line 107) | class TransportTest : public testing::Test {
      method run (line 110) | void run(F f) {
      method TearDown (line 114) | void TearDown() override {
      method requestCancellation (line 118) | folly::coro::Task<> requestCancellation() {
    class HTTPConnectTransportTest (line 127) | class HTTPConnectTransportTest : public TransportTest {
      method SetUp (line 129) | void SetUp() override {
      method TearDown (line 140) | void TearDown() override {
      method connect (line 146) | folly::coro::Task<std::unique_ptr<HTTPConnectTransport>> connect(
      method connectAsync (line 173) | folly::coro::Task<std::shared_ptr<HTTPConnectAsyncTransport>> connec...
      method getConnParams (line 190) | HTTPCoroConnector::ConnectionParams getConnParams() {
    function TEST_F (line 204) | TEST_F(HTTPConnectTransportTest, ConnectSuccess) {
    function TEST_F (line 217) | TEST_F(HTTPConnectTransportTest, ConnectNon200) {
    function TEST_F (line 235) | TEST_F(HTTPConnectTransportTest, ConnectSlow) {
    function TEST_F (line 255) | TEST_F(HTTPConnectTransportTest, ConnectShared) {
    function TEST_F (line 276) | TEST_F(HTTPConnectTransportTest, ConnectCancelled) {
    function TEST_F (line 294) | TEST_F(HTTPConnectTransportTest, SimpleReadWrite) {
    function TEST_F (line 320) | TEST_F(HTTPConnectTransportTest, SimpleIOBufReadWrite) {
    function TEST_F (line 362) | TEST_F(HTTPConnectTransportTest, ReadCancelled) {
    function TEST_F (line 383) | TEST_F(HTTPConnectTransportTest, ReadTimeout) {
    function TEST_F (line 395) | TEST_F(HTTPConnectTransportTest, ReadAfterReadTimeout) {
    function TEST_F (line 456) | TEST_F(HTTPConnectTransportTest, ReadError) {
    function TEST_F (line 475) | TEST_F(HTTPConnectTransportTest, SimpleWritev) {
    function TEST_F (line 500) | TEST_F(HTTPConnectTransportTest, WriteCancelled) {
    function TEST_F (line 523) | TEST_F(HTTPConnectTransportTest, ShutdownWrite) {
    function TEST_F (line 544) | TEST_F(HTTPConnectTransportTest, CloseWithReadsWrites) {
    function TEST_F (line 579) | TEST_F(HTTPConnectTransportTest, CloseWithReset) {
    function TEST_F (line 587) | TEST_F(HTTPConnectTransportTest, WritesBlockedPendingEOF) {
    function TEST_F (line 617) | TEST_F(HTTPConnectTransportTest, WritesBlockedTimeout) {
    function TEST_F (line 638) | TEST_F(HTTPConnectTransportTest, AsyncConnectSuccess) {
    function TEST_F (line 646) | TEST_F(HTTPConnectTransportTest, AsyncReadWrite) {
    function TEST_F (line 665) | TEST_F(HTTPConnectTransportTest, AsyncReadWriteEom) {
    function TEST_F (line 683) | TEST_F(HTTPConnectTransportTest, AsyncReadWriteIOBuf) {

FILE: proxygen/lib/http/coro/transport/test/HTTPConnectTransportTest.h
  function class (line 29) | class ConnectHandler : public HTTPHandler {
  function resetExceptionExpected (line 107) | void resetExceptionExpected() {
  function expectExceptions (line 112) | void expectExceptions() {

FILE: proxygen/lib/http/coro/transport/test/TestCoroTransport.cpp
  type proxygen::coro::test (line 18) | namespace proxygen::coro::test {

FILE: proxygen/lib/http/coro/transport/test/TestCoroTransport.h
  function namespace (line 19) | namespace proxygen::coro::test {
  function setByteEventsEnabled (line 122) | void setByteEventsEnabled(bool enabled) {
  function setFastTxAckEvents (line 126) | void setFastTxAckEvents(bool fast) {
  function writesPaused_ (line 134) | bool writesPaused_{false};

FILE: proxygen/lib/http/coro/util/AwaitableKeepAlive.h
  function namespace (line 15) | namespace proxygen::coro::detail {

FILE: proxygen/lib/http/coro/util/CancellableBaton.cpp
  type proxygen::coro::detail (line 11) | namespace proxygen::coro::detail {

FILE: proxygen/lib/http/coro/util/CancellableBaton.h
  function namespace (line 13) | namespace proxygen::coro::detail {

FILE: proxygen/lib/http/coro/util/CoroWtSession.cpp
  function BufQueue (line 19) | BufQueue* asBodyEv(HTTPBodyEvent& event) {
  type proxygen::coro::detail (line 25) | namespace proxygen::coro::detail {
    function makeHttpSourceTransport (line 349) | std::unique_ptr<folly::coro::TransportIf> makeHttpSourceTransport(
  function makeSocketEx (line 194) | folly::exception_wrapper makeSocketEx(AsyncSocketExceptionType type,
  class HttpSourceTransport (line 206) | class HttpSourceTransport : public folly::coro::TransportIf {
    method HttpSourceTransport (line 208) | HttpSourceTransport(folly::EventBase* evb,
    method read (line 232) | folly::coro::Task<size_t> read(
    method write (line 270) | folly::coro::Task<folly::Unit> write(folly::IOBufQueue& ioBufQueue,
    method close (line 302) | void close() noexcept override {
    method shutdownWrite (line 307) | void shutdownWrite() noexcept override {
    method closeWithReset (line 311) | void closeWithReset() noexcept override {
    method write (line 317) | folly::coro::Task<folly::Unit> write(folly::ByteRange,
    method read (line 323) | folly::coro::Task<size_t> read(folly::MutableByteRange,
    method getLocalAddress (line 327) | folly::SocketAddress getLocalAddress() const noexcept override {
    method getPeerAddress (line 330) | folly::SocketAddress getPeerAddress() const noexcept override {
    method getId (line 335) | uint64_t getId() const {
  type proxygen::coro::detail (line 347) | namespace proxygen::coro::detail {
    function makeHttpSourceTransport (line 349) | std::unique_ptr<folly::coro::TransportIf> makeHttpSourceTransport(

FILE: proxygen/lib/http/coro/util/CoroWtSession.h
  function namespace (line 19) | namespace folly::coro {
  function namespace (line 23) | namespace proxygen::coro::detail {

FILE: proxygen/lib/http/coro/util/DetachableExecutor.cpp
  type proxygen::coro::detail (line 13) | namespace proxygen::coro::detail {

FILE: proxygen/lib/http/coro/util/DetachableExecutor.h
  function namespace (line 14) | namespace proxygen::coro::detail {

FILE: proxygen/lib/http/coro/util/ExecutorSourceFilter.cpp
  type proxygen::coro (line 11) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/util/ExecutorSourceFilter.h
  function namespace (line 13) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/util/Refcount.h
  function namespace (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/util/TimedBaton.h
  function namespace (line 18) | namespace proxygen::coro {
  function reset (line 66) | void reset() {
  function setTimeout (line 76) | void setTimeout(std::chrono::milliseconds timeout) {
  function callbackCanceled (line 140) | void callbackCanceled() noexcept override {
  function Status (line 148) | Status status_{Status::notReady};

FILE: proxygen/lib/http/coro/util/Transport.cpp
  type proxygen::coro::detail (line 15) | namespace proxygen::coro::detail {

FILE: proxygen/lib/http/coro/util/Transport.h
  function namespace (line 13) | namespace folly::coro {
  function namespace (line 17) | namespace proxygen::coro::detail {

FILE: proxygen/lib/http/coro/util/WindowContainer.h
  function namespace (line 14) | namespace proxygen::coro {

FILE: proxygen/lib/http/coro/util/test/AwaitableKeepAliveTest.cpp
  type proxygen::coro::test (line 15) | namespace proxygen::coro::test {
    class TestObject (line 19) | class TestObject : public detail::EnableAwaitableKeepAlive<TestObject> {
      method run (line 21) | folly::coro::Task<void> run() {
    class AwaitableSharedPtrTest (line 27) | class AwaitableSharedPtrTest : public testing::Test {
      method SetUp (line 29) | void SetUp() override {
    function CO_TEST_F (line 37) | CO_TEST_F(AwaitableSharedPtrTest, NoRefs) {
    function CO_TEST_F (line 41) | CO_TEST_F(AwaitableSharedPtrTest, OneRef) {
    function CO_TEST_F (line 53) | CO_TEST_F(AwaitableSharedPtrTest, TwoRefs) {
    class TestKeepAlive (line 70) | class TestKeepAlive : public testing::Test {
      class AwaitableNoop (line 74) | class AwaitableNoop : public detail::EnableAwaitableKeepAlive<Awaita...
    function TEST_F (line 82) | TEST_F(TestKeepAlive, CopyConstructorAssignment) {
    function TEST_F (line 105) | TEST_F(TestKeepAlive, MoveConstructorAssignment) {
    function TEST_F (line 130) | TEST_F(TestKeepAlive, ConcurrentAcquireAndReleaseKeepAlives) {
    function TEST_F (line 174) | TEST_F(TestKeepAlive, UseAfterFree) {
    function TEST_F (line 186) | TEST_F(TestKeepAlive, SimpleMemberAccess) {
    class RefcountTest (line 201) | class RefcountTest : public testing::Test {
    function TEST_F (line 207) | TEST_F(RefcountTest, IncDec) {
    function TEST_F (line 226) | TEST_F(RefcountTest, AlreadyZero) {

FILE: proxygen/lib/http/coro/util/test/CancellableBatonTest.cpp
  type proxygen::coro::test (line 20) | namespace proxygen::coro::test {
    function TEST (line 22) | TEST(CancellableBatonTest, Simple) {
    function TEST (line 43) | TEST(CancellableBatonTest, AlreadySignalled) {
    function TEST (line 60) | TEST(CancellableBatonTest, CancelViaAnotherThread) {
    function TEST (line 75) | TEST(CancellableBatonTest, Timeout) {
    function TEST (line 86) | TEST(CancellableBatonTest, TimeoutDetach) {
    function TEST (line 108) | TEST(CancellableBatonTest, PostBeforeTimeoutExpires) {

FILE: proxygen/lib/http/coro/util/test/DetachableExecutorTest.cpp
  function TEST (line 15) | TEST(DetachableExecutor, Simple) {
  function TEST (line 27) | TEST(DetachableExecutor, AcquireGuardTest) {
  function TEST (line 41) | TEST(DetachableExecutor, TestDetachPriorToAdd) {
  function TEST (line 56) | TEST(DetachableExecutor, TestDetachAfterAdd) {
  function TEST (line 93) | TEST(DetachableExecutor, AddWhenScheduled) {

FILE: proxygen/lib/http/coro/util/test/TimedBatonTest.cpp
  type proxygen::coro::test (line 16) | namespace proxygen::coro::test {
    class TimedBatonTest (line 18) | class TimedBatonTest : public testing::Test {
    function CO_TEST_F_X (line 29) | CO_TEST_F_X(TimedBatonTest, TimedBatonTimeOutTest) {
    function CO_TEST_F_X (line 39) | CO_TEST_F_X(TimedBatonTest, TimedBatonChangeTimeOutTest) {
    function CO_TEST_F_X (line 55) | CO_TEST_F_X(TimedBatonTest, TimedBatonNoTimeOutTest) {
    function CO_TEST_F_X (line 70) | CO_TEST_F_X(TimedBatonTest, TimedBatonDisableTimeOutTest) {
    function CO_TEST_F_X (line 88) | CO_TEST_F_X(TimedBatonTest, TimedBatonSignalTest) {
    function CO_TEST_F_X (line 100) | CO_TEST_F_X(TimedBatonTest, TimedBatonCancelTest) {
    function CO_TEST_F_X (line 137) | CO_TEST_F_X(TimedBatonTest, EarlySignal) {
    function CO_TEST_F_X (line 145) | CO_TEST_F_X(TimedBatonTest, TimedBatonRequestCancellationOutsideEvb) {
    function CO_TEST_F_X (line 175) | CO_TEST_F_X(TimedBatonTest, TimedBatonDestroyTest) {

FILE: proxygen/lib/http/experimental/RFC1867.cpp
  type BoundaryResult (line 22) | enum class BoundaryResult { YES, NO, PARTIAL }
  function BoundaryResult (line 24) | BoundaryResult isBoundary(const IOBuf& buf,
  type proxygen (line 54) | namespace proxygen {
    function IOBufQueue (line 220) | IOBufQueue RFC1867Codec::readToBoundary(bool& foundBoundary) {

FILE: proxygen/lib/http/experimental/RFC1867.h
  function explicit (line 46) | explicit RFC1867Codec(const std::string& boundary) {
  function setCallback (line 52) | void setCallback(Callback* callback) {
  type class (line 69) | enum class
  function onMessageBegin (line 79) | void onMessageBegin(HTTPCodec::StreamID /*stream*/,
  function onBody (line 84) | void onBody(HTTPCodec::StreamID /*stream*/,
  function onTrailersComplete (line 90) | void onTrailersComplete(HTTPCodec::StreamID /*stream*/,
  function onMessageComplete (line 95) | void onMessageComplete(HTTPCodec::StreamID /*stream*/,
  function onError (line 100) | void onError(HTTPCodec::StreamID /*stream*/,
  function bytesProcessed_ (line 117) | uint64_t bytesProcessed_{0}
  function parseError_ (line 118) | bool parseError_{false};

FILE: proxygen/lib/http/experimental/test/RFC1867Test.cpp
  function makePost (line 33) | unique_ptr<IOBuf> makePost(
  type proxygen (line 89) | namespace proxygen {
    class Mock1867Callback (line 91) | class Mock1867Callback : public RFC1867Codec::Callback {
      method onFieldStartImpl (line 99) | int onFieldStartImpl(const string& name,
      method onFieldStart (line 106) | int onFieldStart(const string& name,
      method onFieldData (line 114) | int onFieldData(std::unique_ptr<folly::IOBuf> data,
    class RFC1867Base (line 124) | class RFC1867Base {
      method SetUp (line 126) | void SetUp() {
      method parse (line 130) | void parse(unique_ptr<IOBuf> input, size_t chunkSize = 0) {
    class RFC1867Test (line 158) | class RFC1867Test
      method SetUp (line 162) | void SetUp() override {
    function TEST_F (line 200) | TEST_F(RFC1867Test, TestSimplePost) {
    function TEST_F (line 207) | TEST_F(RFC1867Test, TestSplits) {
    function TEST_F (line 216) | TEST_F(RFC1867Test, TestSplitsWithFilename) {
    function TEST_F (line 226) | TEST_F(RFC1867Test, TestHeadersChunkExtraCr) {
    class RFC1867CR (line 240) | class RFC1867CR
      method SetUp (line 244) | void SetUp() override {
    function TEST_P (line 249) | TEST_P(RFC1867CR, Test) {

FILE: proxygen/lib/http/observer/HTTPSessionObserverContainer.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/observer/HTTPSessionObserverInterface.cpp
  type proxygen (line 12) | namespace proxygen {

FILE: proxygen/lib/http/observer/HTTPSessionObserverInterface.h
  function namespace (line 16) | namespace proxygen {
  function virtual (line 163) | virtual void requestStarted(HTTPSessionObserverAccessor* /* session */,
  function virtual (line 174) | virtual void preWrite(HTTPSessionObserverAccessor* /* session */,
  function virtual (line 178) | virtual void pingReply(HTTPSessionObserverAccessor* /* session */,

FILE: proxygen/lib/http/observer/HTTPTransactionObserverContainer.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/observer/HTTPTransactionObserverInterface.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/observer/HTTPTransactionObserverInterface.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/AckLatencyEvent.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/ByteEventTracker.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/ByteEventTracker.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/session/ByteEvents.cpp
  type proxygen (line 17) | namespace proxygen {

FILE: proxygen/lib/http/session/ByteEvents.h
  type class (line 21) | enum class
  function unsigned (line 23) | enum EventType : unsigned {

FILE: proxygen/lib/http/session/CodecErrorResponseHandler.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/CodecErrorResponseHandler.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/HQByteEventTracker.cpp
  class HQTransportByteEvent (line 12) | class HQTransportByteEvent
    method onByteEvent (line 19) | void onByteEvent(quic::ByteEvent byteEvent) override {
    method onByteEventCanceled (line 33) | void onByteEventCanceled(
  type proxygen (line 40) | namespace proxygen {

FILE: proxygen/lib/http/session/HQByteEventTracker.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/HQDownstreamSession.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/session/HQDownstreamSession.h
  function namespace (line 13) | namespace proxygen {
  function dispatchPushStream (line 200) | void dispatchPushStream(quic::StreamId /* pushStreamId */,
  function transportReadyNotified_ (line 215) | bool transportReadyNotified_{false};

FILE: proxygen/lib/http/session/HQSession.cpp
  function noError (line 47) | bool noError(quic::QuicErrorCode error) {
  function isVlogLevel (line 60) | bool isVlogLevel(const quic::TransportErrorCode& code) {
  function isVlogLevel (line 64) | bool isVlogLevel(const quic::LocalErrorCode& code) {
  function isVlogLevel (line 68) | bool isVlogLevel(const quic::QuicErrorCode& error) {
  function quicControlStreamError (line 82) | quic::QuicErrorCode quicControlStreamError(quic::QuicErrorCode error) {
  function toQuicPriority (line 94) | quic::HTTPPriorityQueue::Priority toQuicPriority(
  function getWebTransportPrefaceSize (line 103) | folly::Expected<size_t, quic::QuicError> getWebTransportPrefaceSize(
  function writeWTStreamPrefaceToSock (line 127) | uint32_t writeWTStreamPrefaceToSock(
  type proxygen (line 150) | namespace proxygen {

FILE: proxygen/lib/http/session/HQSession.h
  function namespace (line 43) | namespace proxygen {
  function runLoopCallback (line 706) | void runLoopCallback() noexcept override;
  function isPeerUniStream (line 733) | bool isPeerUniStream(quic::StreamId id) {
  function isSelfUniStream (line 739) | bool isSelfUniStream(quic::StreamId id) {
  function virtual (line 750) | virtual folly::Optional<HTTPHeaders> getExtraHeaders(const HTTPMessage&,
  function ServerPushLifecycleCallback (line 763) | ServerPushLifecycleCallback* serverPushLifecycleCb_{nullptr};
  function writeBufferSize (line 1507) | size_t writeBufferSize() const;
  function setTransactionEnqueued (line 1542) | void setTransactionEnqueued(bool enqueued) {
  function setStreamTransportEnqueued (line 1546) | void setStreamTransportEnqueued(bool enqueued) {
  function setPriority (line 1554) | void setPriority(quic::HTTPPriorityQueue::Priority pri) {
  function calculateDepth (line 1562) | [[nodiscard]] uint64_t calculateDepth(
  function removeTransaction (line 1594) | void removeTransaction(HTTP2PriorityQueueBase::Handle /*handle*/) overri...
  function signalPendingEgress (line 1604) | void signalPendingEgress(HTTP2PriorityQueueBase::Handle /*h*/) override {
  function signalPendingEgressStreamTransport (line 1609) | void signalPendingEgressStreamTransport() {
  function clearPendingEgress (line 1625) | void clearPendingEgress(HTTP2PriorityQueueBase::Handle /*h*/) override {
  function clearPendingEgressStreamTransport (line 1636) | void clearPendingEgressStreamTransport() {
  function addPriorityNode (line 1645) | void addPriorityNode(HTTPCodec::StreamID /*id*/,
  type class (line 1687) | enum class
  function resetEgressHeadersAckOffset (line 1703) | void resetEgressHeadersAckOffset() {
  function bodyBytesEgressed_ (line 1739) | uint64_t bodyBytesEgressed_{0}
  type BodyByteOffset (line 1741) | struct BodyByteOffset {
  function getDatagramSizeLimit (line 1815) | uint16_t getDatagramSizeLimit() const noexcept override;
  function isPeerInitiatedStream (line 1823) | bool isPeerInitiatedStream(HTTPCodec::StreamID id) override {
  type class (line 1962) | enum class
  function maxToSend_ (line 1974) | uint64_t maxToSend_{0}
  function readsPerLoop_ (line 1983) | uint16_t readsPerLoop_{0}
  function minUnseenIncomingPushId_ (line 2001) | uint64_t minUnseenIncomingPushId_{0}
  function class (line 2037) | class ObserverAccessor : public HTTPSessionObserverAccessor {
  function sendPing (line 2045) | size_t sendPing(uint64_t data) override {
  function HTTPSessionObserverContainer (line 2066) | HTTPSessionObserverContainer* getHTTPSessionObserverContainer()
  function class (line 2072) | class WriteScheduler : public folly::EventBase::LoopCallback {

FILE: proxygen/lib/http/session/HQStreamBase.cpp
  type proxygen (line 13) | namespace proxygen {
    function HTTPCodec (line 25) | const HTTPCodec& HQStreamBase::getCodec() const noexcept {
    function HQSession (line 38) | HQSession& HQStreamBase::getSession() const noexcept {

FILE: proxygen/lib/http/session/HQStreamBase.h
  function namespace (line 116) | namespace proxygen {

FILE: proxygen/lib/http/session/HQStreamDispatcher.h
  function namespace (line 18) | namespace proxygen {
  function class (line 129) | class HQUniStreamDispatcher : public HQStreamDispatcherBase {
  function class (line 168) | class HQBidiStreamDispatcher : public HQStreamDispatcherBase {

FILE: proxygen/lib/http/session/HQUpstreamSession.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/HQUpstreamSession.h
  function namespace (line 15) | namespace proxygen {
  function numberOfIngressPushStreams (line 211) | uint32_t numberOfIngressPushStreams() const;
  function ConnectCallback (line 255) | ConnectCallback* connectCb_{nullptr};

FILE: proxygen/lib/http/session/HTTP2PriorityQueue.cpp
  type proxygen (line 14) | namespace proxygen {
    type WeightCmp (line 647) | struct WeightCmp {

FILE: proxygen/lib/http/session/HTTP2PriorityQueue.h
  function virtual (line 30) | virtual bool isEnqueued() const = 0;
  function class (line 69) | class HTTP2PriorityQueue : public HTTP2PriorityQueueBase {
  function setMaxVirtualNodes (line 95) | void setMaxVirtualNodes(uint32_t maxVirtualNodes) {
  function addPriorityNode (line 105) | void addPriorityNode(HTTPCodec::StreamID id,
  function dropPriorityNodes (line 117) | void dropPriorityNodes() {
  function setNodeLifetime (line 170) | static void setNodeLifetime(std::chrono::milliseconds lifetime) {
  function scheduleNodeExpiration (line 202) | void scheduleNodeExpiration(Node* node) {
  function setPermanent (line 232) | void setPermanent() {
  function Node (line 236) | Node* getParent() const {
  function HTTPTransaction (line 251) | HTTPTransaction* getTransaction() const {
  function clearTransaction (line 255) | void clearTransaction() {
  function refreshTimeout (line 330) | struct PendingNode {
  function enqueued_ (line 398) | bool enqueued_{false};
  function rebuildCount_ (line 417) | uint32_t rebuildCount_{0}
  function activeCount_ (line 419) | uint64_t activeCount_{0}
  function numVirtualNodes_ (line 421) | uint32_t numVirtualNodes_{0}
  function pendingWeightChange_ (line 423) | bool pendingWeightChange_{false};

FILE: proxygen/lib/http/session/HTTPDefaultSessionCodecFactory.cpp
  function getCodecConfigFromAcceptorConfig (line 15) | proxygen::HTTPCodecFactory::CodecConfig getCodecConfigFromAcceptorConfig(
  type proxygen (line 24) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPDefaultSessionCodecFactory.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPDirectResponseHandler.cpp
  type proxygen (line 18) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPDirectResponseHandler.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPDownstreamSession.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPDownstreamSession.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPErrorPage.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPErrorPage.h
  function namespace (line 17) | namespace folly {
  function namespace (line 21) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPEvent.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPEvent.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPSession.cpp
  type proxygen (line 51) | namespace proxygen {
    function HTTPTransaction (line 626) | HTTPTransaction* HTTPSession::newPushedTransaction(
    function SecondaryAuthManagerBase (line 1656) | SecondaryAuthManagerBase* HTTPSession::getSecondAuthManager() const {
    function HTTPTransaction (line 2502) | HTTPTransaction* HTTPSession::findTransaction(HTTPCodec::StreamID stre...
    function HTTPTransaction (line 2517) | HTTPTransaction* HTTPSession::createTransaction(

FILE: proxygen/lib/http/session/HTTPSession.h
  function setHTTPSessionActivityTracker (line 62) | void setHTTPSessionActivityTracker(std::unique_ptr<HTTPSessionActivityTr...
  function folly (line 82) | const folly::AsyncTransport* getTransport() const override {
  function ByteEventTracker (line 102) | ByteEventTracker* getByteEventTracker() {
  function HTTPSessionBase (line 106) | HTTPSessionBase* getHTTPSessionBase() override {
  function getHTTP2PrioritiesEnabled (line 133) | bool getHTTP2PrioritiesEnabled() const override {
  function noexcept (line 142) | const noexcept override {
  function folly (line 146) | const folly::SocketAddress& getLocalAddress() const noexcept override {
  function wangle (line 154) | const wangle::TransportInfo& getSetupTransportInfo() const noexcept over...
  function setAbortPushesOnRST (line 186) | void setAbortPushesOnRST(bool value) {
  function startNow (line 195) | void startNow() override;
  function isBusy (line 223) | bool isBusy() const override;
  function enableDoubleGoawayDrain (line 238) | void enableDoubleGoawayDrain() override {
  function connCloseByRemote (line 245) | bool connCloseByRemote() override {
  function virtual (line 367) | virtual void onHeadersSent(const HTTPMessage& /* headers */,
  function getCodecSendWindowSize (line 392) | size_t getCodecSendWindowSize() const;
  function onSettingsAck (line 443) | void onSettingsAck() override;
  function usesEncodedApplicationErrorCodes (line 488) | bool usesEncodedApplicationErrorCodes() override;
  function folly (line 508) | const folly::AsyncTransport* getUnderlyingTransport()
  function drain (line 520) | void drain() override;
  function writeSuccess (line 610) | void writeSuccess() noexcept override;
  function cancelLoopCallbacks (line 686) | void cancelLoopCallbacks() {
  function class (line 696) | class WriteTimeout : public folly::HHWheelTimer::Callback {
  function liveTransactions_ (line 728) | uint32_t liveTransactions_{0}
  function numActiveWrites_ (line 740) | unsigned numActiveWrites_{0}
  function isUpstream (line 759) | bool isUpstream() const;
  function onDeleteTxnByteEvent (line 800) | void onDeleteTxnByteEvent() noexcept override;
  function removeWaitingForReplaySafety (line 839) | void removeWaitingForReplaySafety(
  function onReplaySafe (line 856) | void onReplaySafe() noexcept override;
  function incomingStreams_ (line 919) | uint32_t incomingStreams_{0}
  function bytesWritten_ (line 924) | uint64_t bytesWritten_{0}
  function bytesScheduled_ (line 929) | uint64_t bytesScheduled_{0}
  function bodyBytesPerWriteBuf_ (line 934) | uint64_t bodyBytesPerWriteBuf_{0}
  function egressBytesLimit_ (line 950) | uint64_t egressBytesLimit_{0}
  function initialReceiveWindow_ (line 953) | size_t initialReceiveWindow_{0}
  function receiveStreamWindowSize_ (line 954) | size_t receiveStreamWindowSize_{0}
  function receiveSessionWindowSize_ (line 955) | size_t receiveSessionWindowSize_{0}
  function timeoutExpired (line 979) | void timeoutExpired() noexcept override {
  function setTimeoutDuration (line 987) | void setTimeoutDuration(std::chrono::milliseconds duration) {
  function class (line 997) | class DrainTimeout : public folly::HHWheelTimer::Callback {
  function timeoutExpired (line 1027) | void timeoutExpired() noexcept override;
  function extendIntervalOnIngress_ (line 1039) | bool extendIntervalOnIngress_{true};
  function SocketState (line 1046) | enum class SocketState : uint8_t {

FILE: proxygen/lib/http/session/HTTPSessionAcceptor.cpp
  type proxygen (line 20) | namespace proxygen {
    function HTTPErrorPage (line 43) | const HTTPErrorPage* HTTPSessionAcceptor::getErrorPage(

FILE: proxygen/lib/http/session/HTTPSessionAcceptor.h
  function namespace (line 20) | namespace proxygen {
  function HTTPSessionStats (line 111) | HTTPSessionStats* downstreamSessionStats_{nullptr};

FILE: proxygen/lib/http/session/HTTPSessionActivityTracker.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPSessionActivityTracker.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPSessionBase.cpp
  type proxygen (line 20) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPSessionBase.h
  function class (line 33) | class HTTPSessionBase : public wangle::ManagedConnection {
  function setHTTP2PrioritiesEnabled (line 272) | void setHTTP2PrioritiesEnabled(bool enabled) /*override*/ {
  function setMaxConcurrentOutgoingStreams (line 285) | void setMaxConcurrentOutgoingStreams(uint32_t num) {
  function setWriteBufferLimit (line 303) | void setWriteBufferLimit(uint32_t limit) {
  function setReadBufferLimit (line 308) | void setReadBufferLimit(uint32_t limit) {
  function virtual (line 337) | virtual size_t sendCertificateRequest(
  function virtual (line 359) | [[nodiscard]] virtual const folly::SocketAddress& getLocalAddress()
  function wangle (line 367) | [[nodiscard]] const wangle::TransportInfo& getSetupTransportInfo()
  function virtual (line 455) | [[nodiscard]] virtual bool isReplaySafe() const = 0;
  function setIngressTimeoutAfterEom (line 495) | void setIngressTimeoutAfterEom(bool setIngressTimeoutAfterEom) noexcept {
  function addObserver (line 506) | bool addObserver(HTTPSessionObserverContainer::Observer* observer) {
  function addObserver (line 522) | bool addObserver(
  function removeObserver (line 537) | bool removeObserver(HTTPSessionObserverContainer::Observer* observer) {
  function removeObserver (line 552) | bool removeObserver(
  function enableServerEarlyResponse (line 560) | void enableServerEarlyResponse() noexcept {
  function hasPendingEgress (line 575) | bool hasPendingEgress() {
  function setLatestActive (line 596) | void setLatestActive() {
  function onCreateTransaction (line 603) | void onCreateTransaction() {
  function incrementSeqNo (line 610) | void incrementSeqNo() {
  function setStreamLimitExceeded (line 614) | void setStreamLimitExceeded(bool streamLimitExceeded) {
  function onNewOutgoingStream (line 618) | void onNewOutgoingStream(uint32_t outgoingStreams) {
  function setCloseReason (line 624) | void setCloseReason(ConnectionCloseReason reason) {
  function virtual (line 676) | [[nodiscard]] virtual HTTPSessionObserverContainer*
  function TimePoint (line 752) | TimePoint latestActive_{}
  function transactionSeqNo_ (line 760) | uint32_t transactionSeqNo_{0}
  function historicalMaxOutgoingStreams_ (line 770) | uint32_t historicalMaxOutgoingStreams_{0}
  function pendingWriteSizeDelta_ (line 798) | int64_t pendingWriteSizeDelta_{0}
  function pendingReadSize_ (line 804) | uint32_t pendingReadSize_{0}
  function streamLimitExceeded_ (line 811) | bool streamLimitExceeded_{false};

FILE: proxygen/lib/http/session/HTTPSessionController.h
  function namespace (line 15) | namespace folly {
  function virtual (line 75) | virtual void onSessionCodecChange(HTTPSessionBase* /*session*/) {
  function virtual (line 88) | virtual void onTransportReady(HTTPSessionBase* /*session*/) {

FILE: proxygen/lib/http/session/HTTPSessionStats.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPTransaction.cpp
  type proxygen (line 26) | namespace proxygen {
    function HTTPException (line 35) | HTTPException stateMachineError(HTTPException::Direction dir, std::str...
    function ErrorCode (line 46) | inline ErrorCode getDefaultAbortErrorCode(bool isUpstream) {
  function CompressionInfo (line 1717) | const CompressionInfo& HTTPTransaction::getCompressionInfo() const {

FILE: proxygen/lib/http/session/HTTPTransaction.h
  function class (line 99) | class TransactionInfo {
  function virtual (line 1215) | virtual void sendChunkHeader(size_t length) {
  function virtual (line 1232) | virtual void sendChunkTerminator() {
  function virtual (line 1245) | virtual void sendTrailers(const HTTPHeaders& trailers) {
  function removePushedTransaction (line 1432) | void removePushedTransaction(HTTPCodec::StreamID pushStreamId) {
  function refreshTimeout (line 1439) | void refreshTimeout() override {
  function testAndSetFirstByteSent (line 1451) | bool testAndSetFirstByteSent() {
  function testAndClearIsCountedTowardsStreamLimit (line 1457) | bool testAndClearIsCountedTowardsStreamLimit() {
  function setIsCountedTowardsStreamLimit (line 1463) | void setIsCountedTowardsStreamLimit() {
  function testAndSetFirstHeaderByteSent (line 1471) | bool testAndSetFirstHeaderByteSent() {
  function incrementPendingByteEvents (line 1482) | void incrementPendingByteEvents() {
  function decrementPendingByteEvents (line 1488) | void decrementPendingByteEvents() {
  function timeoutExpired (line 1502) | void timeoutExpired() noexcept override {
  function callbackCanceled (line 1510) | void callbackCanceled() noexcept override {
  function virtual (line 1527) | virtual void addWaitingForReplaySafety(
  function virtual (line 1535) | virtual void removeWaitingForReplaySafety(
  function getRecvToAck (line 1544) | int32_t getRecvToAck() const;
  function setLastByteFlushedTrackingEnabled (line 1558) | void setLastByteFlushedTrackingEnabled(bool enabled) {
  function getDatagramSizeLimit (line 1574) | uint16_t getDatagramSizeLimit() const noexcept;
  function setWTTransportProvider (line 1599) | void setWTTransportProvider(WebTransportImpl::TransportProvider* tp) {
  function setEgressBufferLimit (line 1607) | static void setEgressBufferLimit(uint64_t limit) {
  function addObserver (line 1611) | bool addObserver(HTTPTransactionObserverContainer::Observer* observer) {
  function addObserver (line 1616) | bool addObserver(
  function removeObserver (line 1622) | bool removeObserver(HTTPTransactionObserverContainer::Observer* observer) {
  function removeObserver (line 1627) | bool removeObserver(
  function HTTPTransactionObserverAccessor (line 1633) | HTTPTransactionObserverAccessor* getObserverAccessor() {
  function dequeue (line 1641) | void dequeue() {
  function mustQueueIngress (line 1663) | bool mustQueueIngress() const;
  function isExpectingIngress (line 1707) | bool isExpectingIngress() const;
  function class (line 1769) | class RateLimitCallback : public folly::HHWheelTimer::Callback {
  function class (line 1785) | class ObserverAccessor : public HTTPTransactionObserverAccessor {
  function recvToAck_ (line 1832) | int32_t recvToAck_{0}
  function maxDeferredIngress_ (line 1836) | uint32_t maxDeferredIngress_{0}
  type Chunk (line 1864) | struct Chunk {
  function insertDepth_ (line 1908) | uint64_t insertDepth_{0}
  function currentDepth_ (line 1909) | uint64_t currentDepth_{0}
  function cumulativeRatio_ (line 1910) | double cumulativeRatio_{0}
  function egressCalls_ (line 1911) | uint64_t egressCalls_{0}
  function pendingByteEvents_ (line 1913) | uint64_t pendingByteEvents_{0}
  function bodyBytesEgressed_ (line 1918) | uint64_t bodyBytesEgressed_{0}
  function lastResponseStatus_ (line 1964) | uint16_t lastResponseStatus_{0}
  function egressLimitBytesPerMs_ (line 1969) | uint64_t egressLimitBytesPerMs_{0}
  function numLimitedBytesEgressed_ (line 1971) | uint64_t numLimitedBytesEgressed_{0}
  function ingressBodyOffset_ (line 1978) | uint64_t ingressBodyOffset_{0}
  function setIngressTimeoutAfterEom_ (line 1980) | bool setIngressTimeoutAfterEom_{false};

FILE: proxygen/lib/http/session/HTTPTransactionEgressSM.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPTransactionEgressSM.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPTransactionIngressSM.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPTransactionIngressSM.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/HTTPUpstreamSession.cpp
  type proxygen (line 18) | namespace proxygen {
    function HTTPTransaction (line 107) | HTTPTransaction* HTTPUpstreamSession::newTransaction(

FILE: proxygen/lib/http/session/HTTPUpstreamSession.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/session/QuicProtocolInfo.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/SecondaryAuthManager.cpp
  type proxygen (line 16) | namespace proxygen {

FILE: proxygen/lib/http/session/SecondaryAuthManager.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/http/session/SecondaryAuthManagerBase.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/ServerPushLifecycle.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/SimpleController.cpp
  type proxygen (line 15) | namespace proxygen {
    function HTTPTransactionHandler (line 21) | HTTPTransactionHandler* SimpleController::getRequestHandler(
    function HTTPTransactionHandler (line 27) | HTTPTransactionHandler* SimpleController::getParseErrorHandler(
    function HTTPTransactionHandler (line 43) | HTTPTransactionHandler* SimpleController::getTransactionTimeoutHandler(
    function HTTPTransactionHandler (line 56) | HTTPTransactionHandler* SimpleController::createErrorHandler(

FILE: proxygen/lib/http/session/SimpleController.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/TTLBAStats.h
  function namespace (line 11) | namespace proxygen {

FILE: proxygen/lib/http/session/TransactionByteEvents.h
  function namespace (line 14) | namespace proxygen {
  function class (line 55) | class Callback {

FILE: proxygen/lib/http/session/WebTransportFilter.h
  function namespace (line 18) | namespace proxygen {
  function std (line 56) | static std::unique_ptr<WebTransportFilter> make(HTTPTransaction* txn,
  function clearTransaction (line 66) | void clearTransaction() {
  function setHandler (line 70) | void setHandler(WebTransportHandler* handler) {
  function setWebTransportImpl (line 74) | void setWebTransportImpl(WebTransportImpl* wtImpl) {
  function onBody (line 78) | void onBody(std::unique_ptr<folly::IOBuf> chain) noexcept override {
  function onEOM (line 92) | void onEOM() noexcept override {
  function onDatagram (line 100) | void onDatagram(std::unique_ptr<folly::IOBuf> datagram) noexcept override {
  function onWebTransportBidiStream (line 106) | void onWebTransportBidiStream(
  function onWebTransportUniStream (line 114) | void onWebTransportUniStream(
  function noexcept (line 122) | noexcept override {
  function trackedByteEventTX (line 126) | void trackedByteEventTX(const ByteEvent& /*event*/) noexcept override {
  function firstHeaderByteFlushed (line 128) | void firstHeaderByteFlushed() noexcept override {
  function firstByteFlushed (line 130) | void firstByteFlushed() noexcept override {
  function lastByteFlushed (line 132) | void lastByteFlushed() noexcept override {
  function lastByteAcked (line 134) | void lastByteAcked(std::chrono::milliseconds /*latency*/) noexcept overr...
  function headerBytesGenerated (line 136) | void headerBytesGenerated(HTTPHeaderSize& /*size*/) noexcept override {
  function headerBytesReceived (line 138) | void headerBytesReceived(const HTTPHeaderSize& /*size*/) noexcept overri...
  function bodyBytesGenerated (line 140) | void bodyBytesGenerated(size_t /*nbytes*/) noexcept override {
  function bodyBytesReceived (line 142) | void bodyBytesReceived(size_t /*size*/) noexcept override {
  function WTMaxStreamsCapsule (line 201) | WTMaxStreamsCapsule capsule{maxStreams};
  function canCreateUniStream (line 298) | bool canCreateUniStream() override {
  function canCreateBidiStream (line 308) | bool canCreateBidiStream() override {
  function usesEncodedApplicationErrorCodes (line 324) | bool usesEncodedApplicationErrorCodes() override {
  function isPeerInitiatedStream (line 333) | bool isPeerInitiatedStream(HTTPCodec::StreamID id) override {
  function folly (line 341) | [[nodiscard]] const folly::SocketAddress& getLocalAddress() const overri...
  function onConnectionError (line 349) | void onConnectionError(CapsuleCodec::ErrorCode error) noexcept override {
  function onPaddingCapsule (line 352) | void onPaddingCapsule(PaddingCapsule /*capsule*/) noexcept override {
  function onWTResetStreamCapsule (line 355) | void onWTResetStreamCapsule(
  function onWTStopSendingCapsule (line 359) | void onWTStopSendingCapsule(
  function onWTStreamCapsule (line 363) | void onWTStreamCapsule(WTStreamCapsule /*capsule*/) noexcept override {
  function onWTMaxDataCapsule (line 366) | void onWTMaxDataCapsule(WTMaxDataCapsule capsule) noexcept override {
  function onWTMaxStreamDataCapsule (line 372) | void onWTMaxStreamDataCapsule(
  function onWTMaxStreamsBidiCapsule (line 376) | void onWTMaxStreamsBidiCapsule(
  function onWTMaxStreamsUniCapsule (line 384) | void onWTMaxStreamsUniCapsule(WTMaxStreamsCapsule capsule) noexcept over...
  function onWTDataBlockedCapsule (line 391) | void onWTDataBlockedCapsule(WTDataBlockedCapsule capsule) noexcept overr...
  function onWTStreamDataBlockedCapsule (line 397) | void onWTStreamDataBlockedCapsule(
  function onWTStreamsBlockedBidiCapsule (line 401) | void onWTStreamsBlockedBidiCapsule(
  function onWTStreamsBlockedUniCapsule (line 408) | void onWTStreamsBlockedUniCapsule(
  function onDatagramCapsule (line 415) | void onDatagramCapsule(DatagramCapsule /*capsule*/) noexcept override {
  function onCloseWTSessionCapsule (line 418) | void onCloseWTSessionCapsule(
  function onDrainWTSessionCapsule (line 438) | void onDrainWTSessionCapsule(
  function nextNewWTBidiStream_ (line 449) | uint64_t nextNewWTBidiStream_{0}
  function nextNewWTUniStream_ (line 450) | uint64_t nextNewWTUniStream_{2}
  type WriteCallback (line 455) | struct WriteCallback {
  function TransportProvider (line 463) | [[maybe_unused]] TransportProvider* h3Tp_{nullptr};

FILE: proxygen/lib/http/session/test/ByteEventTrackerMocks.h
  function class (line 14) | class MockByteEventTrackerCallback

FILE: proxygen/lib/http/session/test/ByteEventTrackerTest.cpp
  class ByteEventTrackerTest (line 21) | class ByteEventTrackerTest : public Test {
    method SetUp (line 23) | void SetUp() override {
  function TEST_F (line 47) | TEST_F(ByteEventTrackerTest, Ping) {
  function TEST_F (line 57) | TEST_F(ByteEventTrackerTest, Ttlb) {
  class MockTrackedByteEventCb (line 74) | class MockTrackedByteEventCb {
    method MockTrackedByteEventCb (line 76) | MockTrackedByteEventCb() = default;
  function TEST_F (line 80) | TEST_F(ByteEventTrackerTest, TrackBytes) {

FILE: proxygen/lib/http/session/test/DownstreamTransactionTest.cpp
  class DownstreamTransactionTest (line 22) | class DownstreamTransactionTest : public testing::Test {
    method DownstreamTransactionTest (line 24) | DownstreamTransactionTest() = default;
    method SetUp (line 26) | void SetUp() override {
    method setupRequestResponseFlow (line 30) | void setupRequestResponseFlow(HTTPTransaction* txn,
    method HTTPTransaction (line 95) | HTTPTransaction& makeTxn(bool useFlowControl = false,
    method HTTPTransaction (line 112) | HTTPTransaction& makeExTxn() {
  function TEST_F (line 134) | TEST_F(DownstreamTransactionTest, SimpleCallbackForwarding) {
  function TEST_F (line 143) | TEST_F(DownstreamTransactionTest, InvariantViolationHandler) {
  function TEST_F (line 169) | TEST_F(DownstreamTransactionTest, RegularWindowUpdate) {
  function TEST_F (line 184) | TEST_F(DownstreamTransactionTest, NoWindowUpdate) {
  function TEST_F (line 204) | TEST_F(DownstreamTransactionTest, FlowControlInfoCorrect) {
  function TEST_F (line 223) | TEST_F(DownstreamTransactionTest, ExpectingWindowUpdate) {
  function TEST_F (line 241) | TEST_F(DownstreamTransactionTest, NoWindowUpdateAfterDoneSending) {
  function TEST_F (line 262) | TEST_F(DownstreamTransactionTest, WindowIncrease) {
  function TEST_F (line 287) | TEST_F(DownstreamTransactionTest, WindowDecrease) {
  function TEST_F (line 306) | TEST_F(DownstreamTransactionTest, ParseErrorCbs) {
  function TEST_F (line 352) | TEST_F(DownstreamTransactionTest, DetachFromNotify) {
  function TEST_F (line 386) | TEST_F(DownstreamTransactionTest, DeferredEgress) {
  function TEST_F (line 433) | TEST_F(DownstreamTransactionTest, InternalError) {
  function TEST_F (line 462) | TEST_F(DownstreamTransactionTest, UnpausedFlowControlViolation) {
  function TEST_F (line 486) | TEST_F(DownstreamTransactionTest, ParseIngressErrorExTxnUnidirectional) {
  function TEST_F (line 524) | TEST_F(DownstreamTransactionTest, ParseIngressErrorExTxnNonUnidirectiona...
  function TEST_F (line 563) | TEST_F(DownstreamTransactionTest, IngressStateViolationWithByteEvents) {
  function TEST_F (line 600) | TEST_F(DownstreamTransactionTest, SetHandlerWhenPaused) {

FILE: proxygen/lib/http/session/test/HQByteEventTrackerTest.cpp
  class HQByteEventTrackerTest (line 26) | class HQByteEventTrackerTest : public Test {
    method SetUp (line 28) | void SetUp() override {
    method expectRegisterTxCallback (line 39) | std::unique_ptr<quic::ByteEventCallback*> expectRegisterTxCallback(
    method expectRegisterDeliveryCallback (line 56) | std::unique_ptr<quic::ByteEventCallback*> expectRegisterDeliveryCallback(
    method getByteEventMatcher (line 70) | static auto getByteEventMatcher(ByteEvent::EventType eventType,
  function TEST_F (line 101) | TEST_F(HQByteEventTrackerTest, FirstLastBodyByteSingleWrite) {
  function TEST_F (line 167) | TEST_F(HQByteEventTrackerTest, FirstLastBodyByteSeparateWrites) {
  function TEST_F (line 242) | TEST_F(HQByteEventTrackerTest,
  function TEST_F (line 311) | TEST_F(HQByteEventTrackerTest, FirstLastBodyByteSingleByte) {
  function TEST_F (line 378) | TEST_F(HQByteEventTrackerTest, FirstLastBodyByteSingleByteZeroOffset) {
  function TEST_F (line 443) | TEST_F(HQByteEventTrackerTest, FirstLastBodyByteCancellation) {
  function TEST_F (line 513) | TEST_F(HQByteEventTrackerTest, FirstLastBodyByteErrorOnRegistration) {

FILE: proxygen/lib/http/session/test/HQDownstreamSessionTest.cpp
  function HTTPMessage (line 42) | HTTPMessage getProgressiveGetRequest() {
  function TEST_P (line 296) | TEST_P(HQDownstreamSessionTest, GetMaxPushIdOK) {
  function TEST_P (line 302) | TEST_P(HQDownstreamSessionTest, SimpleGet) {
  function TEST_P (line 312) | TEST_P(HQDownstreamSessionTest, PriorityUpdateIntoTransport) {
  function TEST_P (line 329) | TEST_P(HQDownstreamSessionTest, DisableEgressPrioritization) {
  function TEST_P (line 348) | TEST_P(HQDownstreamSessionTest, ReplyResponsePriority) {
  function TEST_P (line 366) | TEST_P(HQDownstreamSessionTest, SetLocalPriorityOnHeadersComplete) {
  function TEST_P (line 394) | TEST_P(HQDownstreamSessionTest, SetLocalPriorityAfterClientEOM) {
  function TEST_P (line 422) | TEST_P(HQDownstreamSessionTestPush, PushPriority) {
  function TEST_P (line 474) | TEST_P(HQDownstreamSessionTest, OnPriorityCallback) {
  function TEST_P (line 498) | TEST_P(HQDownstreamSessionTest, GetStopSending) {
  function TEST_P (line 514) | TEST_P(HQDownstreamSessionTest, HttpRateLimitNormal) {
  function TEST_P (line 553) | TEST_P(HQDownstreamSessionTest, SimplePost) {
  function TEST_P (line 570) | TEST_P(HQDownstreamSessionTest, SimplePostWithPadding) {
  function TEST_P (line 594) | TEST_P(HQDownstreamSessionTest, PaddingSM) {
  function TEST_P (line 637) | TEST_P(HQDownstreamSessionTest, SimpleGetEofDelay) {
  function TEST_P (line 645) | TEST_P(HQDownstreamSessionTest, UnfinishedPost) {
  function TEST_P (line 670) | TEST_P(HQDownstreamSessionTest, Multiplexing) {
  function TEST_P (line 684) | TEST_P(HQDownstreamSessionTest, Maxreadsperloop) {
  function TEST_P (line 715) | TEST_P(HQDownstreamSessionTest, OnFlowControlUpdate) {
  function TEST_P (line 740) | TEST_P(HQDownstreamSessionTest, OnFlowControlUpdateOnUnknownStream) {
  function TEST_P (line 754) | TEST_P(HQDownstreamSessionTest, OnConnectionWindowPartialHeaders) {
  function TEST_P (line 781) | TEST_P(HQDownstreamSessionTest, OnConnectionWindowPartialBody) {
  function TEST_P (line 814) | TEST_P(HQDownstreamSessionTest, SeparateEom) {
  function getSimpleRequestData (line 836) | std::unique_ptr<folly::IOBuf> getSimpleRequestData() {
  function estimateResponseSize (line 841) | std::tuple<size_t, size_t, size_t> estimateResponseSize(bool isHq,
  function TEST_P (line 911) | TEST_P(HQDownstreamSessionTest, PendingEomBuffered) {
  function TEST_P (line 952) | TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushed) {
  function TEST_P (line 991) | TEST_P(HQDownstreamSessionTest, PendingEomQueuedNotFlushedConn) {
  function TEST_P (line 1042) | TEST_P(HQDownstreamSessionTest, SendEomLaterChunked) {
  function TEST_P (line 1062) | TEST_P(HQDownstreamSessionTest, SendEomLater) {
  function TEST_P (line 1086) | TEST_P(HQDownstreamSessionTest, ShutdownCloseIdle) {
  function TEST_P (line 1092) | TEST_P(HQDownstreamSessionTest, ShutdownCloseIdleReq) {
  function TEST_P (line 1106) | TEST_P(HQDownstreamSessionTest, ShutdownDropWithReq) {
  function TEST_P (line 1119) | TEST_P(HQDownstreamSessionTest, ShutdownDropWithPartialReq) {
  function TEST_P (line 1130) | TEST_P(HQDownstreamSessionTest, DropConnectionPendingEgress) {
  function TEST_P (line 1150) | TEST_P(HQDownstreamSessionTest, TestInfoCallbacks) {
  function TEST_P (line 1168) | TEST_P(HQDownstreamSessionTest, NotifyDropNoStreams) {
  function TEST_P (line 1173) | TEST_P(HQDownstreamSessionTest, ShutdownDropWithUnflushedResp) {
  function TEST_P (line 1190) | TEST_P(HQDownstreamSessionTest, Cancel) {
  function TEST_P (line 1206) | TEST_P(HQDownstreamSessionTest, EndOfStreamWithPartialFrame) {
  function TEST_P (line 1226) | TEST_P(HQDownstreamSessionTest, ReadErrorSync) {
  function TEST_P (line 1242) | TEST_P(HQDownstreamSessionTest, TransportErrorWithOpenStream) {
  function TEST_P (line 1261) | TEST_P(HQDownstreamSessionTest, WriteError) {
  function TEST_P (line 1278) | TEST_P(HQDownstreamSessionTest, WriteErrorPartialReq) {
  function TEST_P (line 1292) | TEST_P(HQDownstreamSessionTest, WriteNonWritableStream) {
  function TEST_P (line 1306) | TEST_P(HQDownstreamSessionTest, WriteErrorFlowControl) {
  function TEST_P (line 1320) | TEST_P(HQDownstreamSessionTest, ConnectionErrorIdle) {
  function TEST_P (line 1327) | TEST_P(HQDownstreamSessionTest, ConnectionEnd) {
  function TEST_P (line 1333) | TEST_P(HQDownstreamSessionTest, BadHttpHeaders) {
  function TEST_P (line 1352) | TEST_P(HQDownstreamSessionTest, BadHttpStrict) {
  function TEST_P (line 1370) | TEST_P(HQDownstreamSessionTest, BadHttpHeadersStrict) {
  function TEST_P (line 1390) | TEST_P(HQDownstreamSessionTest, SendFinOnly) {
  function TEST_P (line 1410) | TEST_P(HQDownstreamSessionTest, PauseResume) {
  function TEST_P (line 1455) | TEST_P(HQDownstreamSessionTest, EnqueuedAbort) {
  function TEST_P (line 1469) | TEST_P(HQDownstreamSessionTest, TransactionTimeout) {
  function TEST_P (line 1485) | TEST_P(HQDownstreamSessionTest, ManagedTimeoutUnidirectionalReadReset) {
  function TEST_P (line 1510) | TEST_P(HQDownstreamSessionTest, ManagedTimeoutActiveStreams) {
  function TEST_P (line 1545) | TEST_P(HQDownstreamSessionTest, ManagedTimeoutNoStreams) {
  function TEST_P (line 1556) | TEST_P(HQDownstreamSessionTest, TransactionTimeoutNoCodecId) {
  function TEST_P (line 1573) | TEST_P(HQDownstreamSessionTest, SendOnFlowControlPaused) {
  function TEST_P (line 1593) | TEST_P(HQDownstreamSessionTest, Http_100Continue) {
  function TEST_P (line 1616) | TEST_P(HQDownstreamSessionTest, ByteEvents) {
  function TEST_P (line 1635) | TEST_P(HQDownstreamSessionTest, Observer_Attach_Detach_Destroyed) {
  function TEST_P (line 1652) | TEST_P(HQDownstreamSessionTest, Observer_Attach_Detach_Destroyed_Shared) {
  function TEST_P (line 1669) | TEST_P(HQDownstreamSessionTest, Observer_RequestStarted) {
  function TEST_P (line 1715) | TEST_P(HQDownstreamSessionTest, AppRateLimited) {
  function TEST_P (line 1755) | TEST_P(HQDownstreamSessionTest, LastByteEventZeroSize) {
  function TEST_P (line 1785) | TEST_P(HQDownstreamSessionTest, DropWithByteEvents) {
  function TEST_P (line 1803) | TEST_P(HQDownstreamSessionTest, TransportInfo) {
  function TEST_P (line 1844) | TEST_P(HQDownstreamSessionTest, CurrentTransportInfo) {
  function TEST_P (line 1883) | TEST_P(HQDownstreamSessionTest, GetAddresses) {
  function TEST_P (line 1889) | TEST_P(HQDownstreamSessionTest, GetAddressesFromBase) {
  function TEST_P (line 1896) | TEST_P(HQDownstreamSessionTest, GetAddressesAfterDropConnection) {
  function TEST_P (line 1903) | TEST_P(HQDownstreamSessionTest, RstCancelled) {
  function TEST_P (line 1919) | TEST_P(HQDownstreamSessionTest, LocalErrQueuedEgress) {
  function TEST_P (line 1939) | TEST_P(HQDownstreamSessionTest, NoErrorNoStreams) {
  function TEST_P (line 1946) | TEST_P(HQDownstreamSessionTest, NoErrorOneStreams) {
  function TEST_P (line 1963) | TEST_P(HQDownstreamSessionTest, Connect) {
  function TEST_P (line 1997) | TEST_P(HQDownstreamSessionTest, ConnectUDP) {
  function TEST_P (line 2032) | TEST_P(HQDownstreamSessionTest, zeroBytes) {
  function TEST_P (line 2043) | TEST_P(HQDownstreamSessionTest, oneByte) {
  function TEST_P (line 2053) | TEST_P(HQDownstreamSessionTest, TestGoawayID) {
  function TEST_P (line 2077) | TEST_P(HQDownstreamSessionTest, TestReceiveGoaway) {
  function TEST_P (line 2089) | TEST_P(HQDownstreamSessionTest, TestGetGoaway) {
  function TEST_P (line 2138) | TEST_P(HQDownstreamSessionTest, DelayedQPACK) {
  function TEST_P (line 2157) | TEST_P(HQDownstreamSessionTest, cancelQPACK) {
  function TEST_P (line 2179) | TEST_P(HQDownstreamSessionTest, DelayedQPACKCanceled) {
  function TEST_P (line 2203) | TEST_P(HQDownstreamSessionTest, DelayedQPACKTimeout) {
  function TEST_P (line 2228) | TEST_P(HQDownstreamSessionTest, QPACKEncoderLimited) {
  function TEST_P (line 2251) | TEST_P(HQDownstreamSessionTest, DelayedQPACKStopSendingReset) {
  function TEST_P (line 2278) | TEST_P(ControlStreamsStallTest, StalledQpackStream) {
  function TEST_P (line 2322) | TEST_P(HQDownstreamSessionTest, QPACKHeadersTooLarge) {
  function TEST_P (line 2366) | TEST_P(HQDownstreamSessionBeforeTransportReadyTest, NotifyPendingShutdow...
  function TEST_P (line 2381) | TEST_P(HQDownstreamSessionTest, ProcessReadDataOnDetachedStream) {
  function TEST_P (line 2424) | TEST_P(HQDownstreamSessionTestNoSettings, SimpleGet) {
  function TEST_P (line 2439) | TEST_P(HQDownstreamSessionTest, ExtraSettings) {
  function TEST_P (line 2468) | TEST_P(HQDownstreamSessionFilterTestHQ, ControlStreamFilters) {
  function TEST_P (line 2490) | TEST_P(HQDownstreamSessionTest, onErrorEmptyEnqueued) {
  function TEST_P (line 2517) | TEST_P(HQDownstreamSessionTest, dropWhilePaused) {
  function TEST_P (line 2539) | TEST_P(HQDownstreamSessionTest, StopSendingOnUnknownUnidirectionalStream...
  function TEST_P (line 2558) | TEST_P(HQDownstreamSessionTest, DataOnUnknownControlStream) {
  function TEST_P (line 2575) | TEST_P(HQDownstreamSessionTest, eofControlStream) {
  function TEST_P (line 2591) | TEST_P(HQDownstreamSessionTest, resetControlStream) {
  function TEST_P (line 2610) | TEST_P(HQDownstreamSessionTest, controlStreamWriteError) {
  function TEST_P (line 2627) | TEST_P(HQDownstreamSessionTest, TooManyControlStreams) {
  function TEST_P (line 2652) | TEST_P(HQDownstreamSessionTest, TestGreaseFramePerSession) {
  function TEST_P (line 2685) | TEST_P(HQDownstreamSessionTest, getHTTPPriority) {
  function TEST_P (line 2718) | TEST_P(HQDownstreamSessionTest, IdleTimeoutNoStreams) {
  function TEST_P (line 2732) | TEST_P(HQDownstreamSessionTest, IdleTimeoutResetWithPing) {
  function TEST_P (line 2749) | TEST_P(HQDownstreamSessionTest, IdleTimeoutResetWithPingAcknowledged) {
  function TEST_P (line 2779) | TEST_P(HQDownstreamSessionTest, SendNoErrorAfterEomFlush) {
  function TEST_P (line 2806) | TEST_P(HQDownstreamSessionTest, SendDeferredNoError) {
  function TEST_P (line 2847) | TEST_P(HQDownstreamSessionTest, InvalidNoErrorAbort) {
  function TEST_P (line 2877) | TEST_P(HQDownstreamSessionTest, IncrementalStreamsRoundRobin) {
  function TEST_P (line 2987) | TEST_P(HQDownstreamSessionTestPush, SimplePush) {
  function TEST_P (line 3037) | TEST_P(HQDownstreamSessionTestPush, PushPriorityCallback) {
  function TEST_P (line 3089) | TEST_P(HQDownstreamSessionTestPush, StopSending) {
  class HQDownstreamSessionTestUnsupportedAlpn (line 3186) | class HQDownstreamSessionTestUnsupportedAlpn : public HQDownstreamSessio...
    method SetUp (line 3188) | void SetUp() override {
  function TEST_P (line 3193) | TEST_P(DropConnectionInTransportReadyTest, TransportReadyFailure) {
  function TEST_P (line 3206) | TEST_P(HQDownstreamSessionTestDeliveryAck,
  function TEST_P (line 3261) | TEST_P(HQDownstreamSessionTestDeliveryAck, TestBodyDeliveryAck) {
  function TEST_P (line 3288) | TEST_P(HQDownstreamSessionTestDeliveryAck, TestBodyTxCallback) {
  function TEST_P (line 3314) | TEST_P(HQDownstreamSessionTestDeliveryAck, TestBodyDeliveryAckMultiple) {
  function TEST_P (line 3349) | TEST_P(HQDownstreamSessionTestDeliveryAck, TestBodyDeliveryErr) {
  function TEST_P (line 3424) | TEST_P(HQDownstreamSessionTestDeliveryAck, TestBodyDeliveryCancel) {
  class HQDownstreamSessionTestWebTransport (line 3465) | class HQDownstreamSessionTestWebTransport : public HQDownstreamSessionTe...
  function TEST_P (line 3467) | TEST_P(HQDownstreamSessionTestWebTransport, WTRequestNegotiates) {

FILE: proxygen/lib/http/session/test/HQDownstreamSessionTest.h
  function firstByteFlushed (line 40) | void firstByteFlushed() noexcept override {
  function lastByteFlushed (line 43) | void lastByteFlushed() noexcept override {
  function trackedByteFlushed (line 47) | void trackedByteFlushed() noexcept override {
  function lastByteAcked (line 50) | void lastByteAcked(
  function headerBytesGenerated (line 55) | void headerBytesGenerated(proxygen::HTTPHeaderSize& size) noexcept overr...
  function headerBytesReceived (line 59) | void headerBytesReceived(
  function bodyBytesGenerated (line 63) | void bodyBytesGenerated(size_t nbytes) noexcept override {
  function bodyBytesReceived (line 67) | void bodyBytesReceived(size_t /* size */) noexcept override {
  function lastEgressHeaderByteAcked (line 70) | void lastEgressHeaderByteAcked() noexcept override {
  function bodyBytesTx (line 74) | void bodyBytesTx(uint64_t bodyOffset) noexcept override {
  function bodyBytesDelivered (line 79) | void bodyBytesDelivered(uint64_t bodyOffset) noexcept override {
  function bodyBytesDeliveryCancelled (line 84) | void bodyBytesDeliveryCancelled(uint64_t bodyOffset) noexcept override {
  function headerBytesGenerated_ (line 89) | uint64_t headerBytesGenerated_{0}
  function numBodyBytesDeliveredCalls_ (line 91) | uint64_t numBodyBytesDeliveredCalls_{0}
  function bodyBytesDeliveredOffset_ (line 92) | uint64_t bodyBytesDeliveredOffset_{0}
  function numBodyBytesTxCalls_ (line 93) | uint64_t numBodyBytesTxCalls_{0}
  function bodyBytesTxOffset_ (line 94) | uint64_t bodyBytesTxOffset_{0}
  function numBodyBytesCanceledCalls_ (line 95) | uint64_t numBodyBytesCanceledCalls_{0}
  function bodyBytesCanceledOffset_ (line 96) | uint64_t bodyBytesCanceledOffset_{0}
  function bodyBytesGenerated_ (line 97) | uint64_t bodyBytesGenerated_{0}
  function lastByteAcked_ (line 99) | bool lastByteAcked_{false};
  function class (line 102) | class HQDownstreamSessionTest : public HQSessionTest {
  function class (line 204) | class HQDownstreamSessionBeforeTransportReadyTest

FILE: proxygen/lib/http/session/test/HQSessionMocks.h
  function namespace (line 18) | namespace proxygen {
  function class (line 199) | class MockConnectCallback : public HQSession::ConnectCallback {
  function class (line 207) | class MockHQSession : public HQSession {
  function dispatchPushStream (line 360) | void dispatchPushStream(quic::StreamId /* streamId */,
  function class (line 382) | class FakeHQHTTPCodecCallback : public FakeHTTPCodecCallback {

FILE: proxygen/lib/http/session/test/HQSessionMocksTest.cpp
  class MocksTest (line 19) | class MocksTest : public Test {
    method SetUp (line 21) | void SetUp() override {
    method TearDown (line 31) | void TearDown() override {
  function TEST_F (line 42) | TEST_F(MocksTest, MockHQSessionNewTransaction) {
  function TEST_F (line 63) | TEST_F(MocksTest, MockHQSessionPropagatesQuickProtocolInfo) {

FILE: proxygen/lib/http/session/test/HQSessionTestCommon.cpp
  function encodeQuicIntegerWithAtLeast (line 18) | size_t encodeQuicIntegerWithAtLeast(uint64_t value,
  function generateStreamPreface (line 59) | size_t generateStreamPreface(folly::IOBufQueue& writeBuf,
  function paramsToTestName (line 69) | std::string paramsToTestName(const testing::TestParamInfo<TestParams>& i...
  function parseStreamPreface (line 92) | folly::Optional<std::pair<UnidirectionalStreamType, size_t>> parseStream...
  function parseReadData (line 116) | void parseReadData(HQUnidirectionalCodec* codec,
  function createControlStream (line 124) | void createControlStream(quic::MockQuicSocketDriver* socketDriver,

FILE: proxygen/lib/http/session/test/HQSessionTestCommon.h
  type TestParams (line 39) | struct TestParams {
  function shouldSendSettings_ (line 42) | bool shouldSendSettings_{true};
  function numCtrlStreams_ (line 434) | uint8_t numCtrlStreams_{0}
  function onTransactionSymmetricCounter (line 441) | uint64_t onTransactionSymmetricCounter{0}

FILE: proxygen/lib/http/session/test/HQStreamBaseTest.cpp
  class HQStreamBaseTest (line 26) | class HQStreamBaseTest : public Test {
    method SetUp (line 28) | void SetUp() override {
    method TearDown (line 45) | void TearDown() override {
  function TEST_F (line 60) | TEST_F(HQStreamBaseTest, TestSingleStreamBidir) {
  function TEST_F (line 71) | TEST_F(HQStreamBaseTest, TestSingleStreamEgressOnly) {
  function TEST_F (line 81) | TEST_F(HQStreamDeathTest, TestSingleStreamEgressOnly) {
  function TEST_F (line 87) | TEST_F(HQStreamBaseTest, TestCompositeBidirEmpty) {
  function TEST_F (line 93) | TEST_F(HQStreamDeathTest, TestCompositeBidirEmpty) {
  function TEST_F (line 105) | TEST_F(HQStreamBaseTest, TestCompositeBidirEgress) {
  function TEST_F (line 115) | TEST_F(HQStreamDeathTest, TestCompositeBidirEgress) {
  function TEST_F (line 124) | TEST_F(HQStreamBaseTest, TestCompositeBidirIngress) {
  function TEST_F (line 133) | TEST_F(HQStreamDeathTest, TestCompositeBidirIngress) {
  function TEST_F (line 142) | TEST_F(HQStreamBaseTest, TestCompositeBidirBoth) {
  function TEST_F (line 153) | TEST_F(HQStreamDeathTest, TestCompositeBidirEmptyEgress) {
  function TEST_F (line 159) | TEST_F(HQStreamBaseTest, TestGetStreamDirection) {

FILE: proxygen/lib/http/session/test/HQStreamDispatcherTest.cpp
  class MockDispatcher (line 18) | class MockDispatcher
    method MockDispatcher (line 35) | explicit MockDispatcher(folly::EventBase* evb) : evb_(evb) {
    method expectOnNewPushStream (line 38) | void expectOnNewPushStream(const NewPushStreamF& impl) {
    method expectOnNewWTUni (line 46) | void expectOnNewWTUni(const NewWTStreamF& impl) {
    method expectOnNewWTBidi (line 54) | void expectOnNewWTBidi(const NewWTStreamF& impl) {
    method expectOnNewRequest (line 62) | void expectOnNewRequest(const NewRequestF& impl) {
    method expectAssignReadCallback (line 69) | void expectAssignReadCallback(const ReadCallbackAssignF& impl) {
    method expectParsePreface (line 77) | void expectParsePreface(const PrefaceParseF& impl) {
    method expectParseBidiPreface (line 84) | void expectParseBidiPreface(const PrefaceBidiParseF& impl) {
    method expectRejectStream (line 91) | void expectRejectStream(const StreamRejectF& impl) {
    method getDispatchTimeout (line 102) | std::chrono::milliseconds getDispatchTimeout() const override {
  class HQStreamDispatcherTest (line 132) | class HQStreamDispatcherTest : public Test {
    method SetUp (line 138) | void SetUp() override {
    method TearDown (line 142) | void TearDown() override {
    method sendData (line 148) | void sendData(quic::StreamId id, uint64_t val, uint8_t atLeast) {
    method sendData (line 156) | void sendData(quic::StreamId id,
    method sendData (line 178) | void sendData(quic::StreamId id, std::unique_ptr<folly::IOBuf> data) {
  function TEST_F (line 198) | TEST_F(UnidirectionalReadDispatcherTest, TestDispatchControlPreface) {
  function TEST_F (line 228) | TEST_F(UnidirectionalReadDispatcherTest,
  function TEST_F (line 263) | TEST_F(UnidirectionalReadDispatcherTest, TestDispatchWTUni) {
  function TEST_F (line 297) | TEST_F(UnidirectionalReadDispatcherTest, TestRejectUnrecognizedPreface) {
  function TEST_F (line 321) | TEST_F(BidirectionalReadDispatcherTest, TestDispatchRequest) {
  function TEST_F (line 344) | TEST_F(BidirectionalReadDispatcherTest, TestDispatchWTBidi) {
  function TEST_F (line 377) | TEST_F(BidirectionalReadDispatcherTest, TestRejectUnrecognizedPreface) {

FILE: proxygen/lib/http/session/test/HQUpstreamSessionTest.cpp
  function TEST_P (line 223) | TEST_P(HQUpstreamSessionTest, SimpleGet) {
  function TEST_P (line 241) | TEST_P(HQUpstreamSessionTest, GetWithTrailers) {
  function TEST_P (line 269) | TEST_P(HQUpstreamSessionTest, AbortOnBodyWithBlockedQPACKTrailers) {
  function TEST_P (line 302) | TEST_P(HQUpstreamSessionTest, PriorityUpdateIntoTransport) {
  function TEST_P (line 326) | TEST_P(HQUpstreamSessionTest, DisableEgressPrioritization) {
  function TEST_P (line 350) | TEST_P(HQUpstreamSessionTest, TestSupportsMoreTransactions) {
  function TEST_P (line 388) | TEST_P(HQUpstreamSessionTest, SendPriorityUpdate) {
  function TEST_P (line 409) | TEST_P(HQUpstreamSessionTest, SkipPriorityUpdateAfterSeenEOM) {
  function TEST_P (line 432) | TEST_P(HQUpstreamSessionTest, NoNewTransactionIfSockIsNotGood) {
  function TEST_P (line 438) | TEST_P(HQUpstreamSessionTest, DropConnectionWithEarlyDataFailedError) {
  function TEST_P (line 454) | TEST_P(HQUpstreamSessionTest, TestGetHistoricalMaxOutgoingStreams) {
  function TEST_P (line 485) | TEST_P(HQUpstreamSessionTest, ResponseTermedByFin) {
  function TEST_P (line 502) | TEST_P(HQUpstreamSessionTest, WaitForReplaySafeCallback) {
  function TEST_P (line 526) | TEST_P(HQUpstreamSessionTest, AlreadyReplaySafe) {
  function TEST_P (line 542) | TEST_P(HQUpstreamSessionTest, Test100Continue) {
  function TEST_P (line 564) | TEST_P(HQUpstreamSessionTest, TestSetIngressTimeoutAfterSendEom) {
  function TEST_P (line 644) | TEST_P(HQUpstreamSessionTest, GetAddresses) {
  function TEST_P (line 650) | TEST_P(HQUpstreamSessionTest, GetAddressesFromBase) {
  function TEST_P (line 657) | TEST_P(HQUpstreamSessionTest, GetAddressesAfterDropConnection) {
  function TEST_P (line 664) | TEST_P(HQUpstreamSessionTest, DropConnectionTwice) {
  function TEST_P (line 670) | TEST_P(HQUpstreamSessionTest, DropConnectionTwiceWithPendingStreams) {
  function TEST_P (line 680) | TEST_P(HQUpstreamSessionTest, DropConnectionAfterCloseWhenIdle) {
  function TEST_P (line 687) | TEST_P(HQUpstreamSessionTest, DropConnectionWithStreamAfterCloseWhenIdle) {
  function TEST_P (line 701) | TEST_P(HQUpstreamSessionTest, NotifyConnectCallbackBeforeDestruct) {
  function TEST_P (line 709) | TEST_P(HQUpstreamSessionTest, DropFromConnectError) {
  function TEST_P (line 720) | TEST_P(HQUpstreamSessionTest, FirstPeerPacketProcessed) {
  function TEST_P (line 731) | TEST_P(HQUpstreamSessionTest, NotifyReplaySafeAfterTransportReady) {
  function TEST_P (line 745) | TEST_P(HQUpstreamSessionTest, TestConnectionToken) {
  function TEST_P (line 772) | TEST_P(HQUpstreamSessionTest, OnConnectionErrorWithOpenStreams) {
  function TEST_P (line 785) | TEST_P(HQUpstreamSessionTest, OnConnectionErrorWithOpenStreamsPause) {
  function TEST_P (line 819) | TEST_P(HQUpstreamSessionTest, GoawayStreamsUnacknowledged) {
  function TEST_P (line 870) | TEST_P(HQUpstreamSessionTest, GoawayIncreased) {
  function TEST_P (line 887) | TEST_P(HQUpstreamSessionTest, DelayedQPACK) {
  function TEST_P (line 914) | TEST_P(HQUpstreamSessionTest, DelayedQPACKTimeout) {
  function TEST_P (line 937) | TEST_P(HQUpstreamSessionTest, QPACKDecoderStreamFlushed) {
  function TEST_P (line 970) | TEST_P(HQUpstreamSessionTest, DelayedQPACKAfterReset) {
  function TEST_P (line 1040) | TEST_P(HQUpstreamSessionTestQPACK, QPACKQueuedOnClose) {
  function TEST_P (line 1062) | TEST_P(HQUpstreamSessionTest, TestDropConnectionSynchronously) {
  function TEST_P (line 1079) | TEST_P(HQUpstreamSessionTest, TestOnStopSendingHTTPRequestRejected) {
  function TEST_P (line 1104) | TEST_P(HQUpstreamSessionTest, TestGreaseFramePerSession) {
  function TEST_P (line 1160) | TEST_P(HQUpstreamSessionTest, TestIngressLimitedSessionWithNewRequests) {
  function TEST_P (line 1202) | TEST_P(HQUpstreamSessionTest, ExtraSettings) {
  function TEST_P (line 1227) | TEST_P(HQUpstreamSessionTest, Observer_Attach_Detach_Destroyed) {
  function TEST_P (line 1245) | TEST_P(HQUpstreamSessionTest, Observer_RequestStarted) {
  function TEST_P (line 1302) | TEST_P(HQUpstreamSessionTestNoSettings, SimpleGet) {
  function TEST_P (line 1308) | TEST_P(HQUpstreamSessionTestNoSettings, GoawayBeforeSettings) {
  class HQUpstreamSessionTestPush (line 1326) | class HQUpstreamSessionTestPush : public HQUpstreamSessionTest {
    method SetUp (line 1328) | void SetUp() override {
    method SetUpAssocHandler (line 1336) | void SetUpAssocHandler() {
    method TearDown (line 1343) | void TearDown() override {
    method SetUpServerPushLifecycleCallbacks (line 1347) | void SetUpServerPushLifecycleCallbacks() {
    method nextPushId (line 1354) | hq::PushId nextPushId() {
    method isPushIdValid (line 1362) | bool isPushIdValid(hq::PushId pushId) {
    method writeUpTo (line 1368) | folly::Optional<size_t> writeUpTo(quic::StreamId id,
    method writePushStreamPreface (line 1391) | folly::Optional<size_t> writePushStreamPreface(quic::StreamId id,
    method writeUnframedPushId (line 1401) | folly::Optional<size_t> writeUnframedPushId(quic::StreamId id,
    method expectPushPromiseBegin (line 1416) | void expectPushPromiseBegin(
    method expectPushPromise (line 1423) | void expectPushPromise(
    method expectNascentPushStreamBegin (line 1431) | void expectNascentPushStreamBegin(
    method expectNascentPushStream (line 1438) | void expectNascentPushStream(
    method expectNascentEof (line 1445) | void expectNascentEof(
    method expectOrphanedNascentStream (line 1453) | void expectOrphanedNascentStream(
    method expectHalfOpenPushedTxn (line 1462) | void expectHalfOpenPushedTxn(
    method expectPushedTxn (line 1473) | void expectPushedTxn(std::function<void(const HTTPTransaction*,
    method expectPushedTxnTimeout (line 1487) | void expectPushedTxnTimeout(
    method expectOrphanedHalfOpenPushedTxn (line 1494) | void expectOrphanedHalfOpenPushedTxn(
    method sendPushPromise (line 1501) | void sendPushPromise(quic::StreamId streamId,
    method sendPushPromise (line 1512) | void sendPushPromise(quic::StreamId streamId,
    method ServerStream (line 1553) | ServerStream& createPushStreamImpl(quic::StreamId streamId,
    method createPushStream (line 1583) | void createPushStream(quic::StreamId streamId,
    method createPushStream (line 1602) | void createPushStream(hq::PushId pushId,
    method createNascentPushStream (line 1611) | void createNascentPushStream(quic::StreamId streamId,
    method lastPushPromiseHeadersSizeValid (line 1618) | bool lastPushPromiseHeadersSizeValid() {
    method createNascentPushStream (line 1623) | void createNascentPushStream(hq::PushId pushId,
    method expectPushResponse (line 1630) | std::unique_ptr<MockHTTPHandler> expectPushResponse() {
  function TEST_P (line 1650) | TEST_P(HQUpstreamSessionTestPush, DelayedQPACKPush) {
  function TEST_P (line 1692) | TEST_P(HQUpstreamSessionTestPush, TestPushPromiseCallbacksInvoked) {
  function TEST_P (line 1758) | TEST_P(HQUpstreamSessionTestPush, TestIngressPushStream) {
  function TEST_P (line 1804) | TEST_P(HQUpstreamSessionTestPush, TestPushPromiseFollowedByPushStream) {
  function TEST_P (line 1875) | TEST_P(HQUpstreamSessionTestPush, TestAbortedPushedTransactionAfterPromi...
  function TEST_P (line 1910) | TEST_P(HQUpstreamSessionTestPush, TestAbortedPushedTransactionAfterRespo...
  function TEST_P (line 1953) | TEST_P(HQUpstreamSessionTestPush, TestOnPushedTransaction) {
  function TEST_P (line 1984) | TEST_P(HQUpstreamSessionTestPush, TestOnPushedTransactionOutOfOrder) {
  function TEST_P (line 2013) | TEST_P(HQUpstreamSessionTestPush, TestCloseDroppedConnection) {
  function TEST_P (line 2031) | TEST_P(HQUpstreamSessionTestPush, TestOrphanedPushStream) {
  function TEST_P (line 2048) | TEST_P(HQUpstreamSessionTest, TestNoDatagram) {
  function TEST_P (line 2067) | TEST_P(HQUpstreamSessionTestDatagram, TestDatagramSettings) {
  function TEST_P (line 2086) | TEST_P(HQUpstreamSessionTestDatagram, TestReceiveDatagram) {
  function TEST_P (line 2114) | TEST_P(HQUpstreamSessionTestDatagram, TestReceiveEarlyDatagramsSingleStr...
  function TEST_P (line 2143) | TEST_P(HQUpstreamSessionTestDatagram, TestReceiveEarlyDatagramsMultiStre...
  class HQUpstreamSessionTestWebTransport (line 2182) | class HQUpstreamSessionTestWebTransport : public HQUpstreamSessionTest {
    method SetUp (line 2184) | void SetUp() override {
    method openWTTransaction (line 2215) | std::unique_ptr<testing::StrictMock<proxygen::MockHTTPHandler>>
    method closeWTSession (line 2234) | void closeWTSession() {
    method HTTPMessage (line 2244) | static HTTPMessage getWTConnectRequest() {
    method HTTPMessage (line 2254) | static HTTPMessage getWTResponse() {
  class MockDeliveryCallback (line 2267) | class MockDeliveryCallback : public WebTransport::ByteEventCallback {
  function TEST_P (line 2277) | TEST_P(HQUpstreamSessionTestWebTransport, FilterInstallation) {
  function TEST_P (line 2286) | TEST_P(HQUpstreamSessionTestWebTransport, BidirectionalStream) {
  function TEST_P (line 2392) | TEST_P(HQUpstreamSessionTestWebTransport, RejectBidirectionalStream) {
  function TEST_P (line 2425) | TEST_P(HQUpstreamSessionTestWebTransport, PairOfUnisReset) {
  function TEST_P (line 2477) | TEST_P(HQUpstreamSessionTestWebTransport, Datagrams) {
  function TEST_P (line 2491) | TEST_P(HQUpstreamSessionTestWebTransport, CloseSessionCapsule) {
  function TEST_P (line 2519) | TEST_P(HQUpstreamSessionTestWebTransport, DrainSessionCapsule) {
  function TEST_P (line 2540) | TEST_P(HQUpstreamSessionTestWebTransport, CloseSessionCapsuleWithStreams) {
  function TEST_P (line 2614) | TEST_P(HQUpstreamSessionTestWebTransport, MaxStreamsBidiCapsule) {
  function TEST_P (line 2636) | TEST_P(HQUpstreamSessionTestWebTransport, MaxStreamsUniCapsule) {
  function TEST_P (line 2663) | TEST_P(HQUpstreamSessionTestWebTransport, SessionFlowControl) {
  function TEST_P (line 2705) | TEST_P(HQUpstreamSessionTestWebTransport, SessionFlowControlExceedLimit) {
  function TEST_P (line 2760) | TEST_P(HQUpstreamSessionTestWebTransport, ReceiveWTStreamsBlockedCapsule) {
  function TEST_P (line 2801) | TEST_P(HQUpstreamSessionTestWebTransport, ReceiveWTDataBlockedCapsule) {

FILE: proxygen/lib/http/session/test/HQUpstreamSessionTest.h
  type ServerStream (line 93) | struct ServerStream {
  function readEOF (line 104) | bool readEOF{false};

FILE: proxygen/lib/http/session/test/HTTP2PriorityQueueBench.cpp
  function BENCHMARK (line 25) | BENCHMARK(Encode, iters) {
  function main (line 35) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/session/test/HTTP2PriorityQueueTest.cpp
  function getTxnID (line 36) | proxygen::HTTPCodec::StreamID getTxnID(proxygen::HTTPTransaction* txn) {
  function rand32 (line 41) | uint32_t rand32(uint32_t max, folly::Random::DefaultGenerator& rng) {
  type proxygen (line 51) | namespace proxygen {
    class QueueTest (line 55) | class QueueTest : public testing::Test {
      method QueueTest (line 57) | explicit QueueTest(HHWheelTimer* timer = nullptr)
      method addTransaction (line 62) | void addTransaction(HTTPCodec::StreamID id,
      method removeTransaction (line 76) | void removeTransaction(HTTPCodec::StreamID id) {
      method updatePriority (line 80) | void updatePriority(HTTPCodec::StreamID id,
      method signalEgress (line 86) | void signalEgress(HTTPCodec::StreamID id, bool mark) {
      method buildSimpleTree (line 94) | void buildSimpleTree() {
      method visitNode (line 103) | bool visitNode(HTTP2PriorityQueue&,
      method dump (line 111) | void dump() {
      method dumpBFS (line 119) | void dumpBFS(const std::function<bool()>& stopFn) {
      method nextEgress (line 125) | void nextEgress() {
    function TEST_F (line 139) | TEST_F(QueueTest, Basic) {
    function TEST_F (line 153) | TEST_F(QueueTest, RemoveLeaf) {
    function TEST_F (line 162) | TEST_F(QueueTest, RemoveParent) {
    function TEST_F (line 171) | TEST_F(QueueTest, RemoveParentWeights) {
    function TEST_F (line 184) | TEST_F(QueueTest, NodeDepth) {
    function TEST_F (line 250) | TEST_F(QueueTest, UpdateWeight) {
    function TEST_F (line 264) | TEST_F(QueueTest, DuplicateID) {
    function TEST_F (line 280) | TEST_F(QueueTest, UpdateWeightNotEnqueued) {
    function TEST_F (line 296) | TEST_F(QueueTest, UpdateWeightExcl) {
    function TEST_F (line 308) | TEST_F(QueueTest, UpdateWeightExclDequeued) {
    function TEST_F (line 319) | TEST_F(QueueTest, UpdateWeightUnknownParent) {
    function TEST_F (line 343) | TEST_F(QueueTest, UpdateParentSibling) {
    function TEST_F (line 366) | TEST_F(QueueTest, UpdateParentSiblingExcl) {
    function TEST_F (line 380) | TEST_F(QueueTest, UpdateParentAncestor) {
    function TEST_F (line 392) | TEST_F(QueueTest, UpdateParentAncestorExcl) {
    function TEST_F (line 404) | TEST_F(QueueTest, UpdateParentDescendant) {
    function TEST_F (line 418) | TEST_F(QueueTest, UpdateParentDescendantExcl) {
    function TEST_F (line 433) | TEST_F(QueueTest, ExclusiveAdd) {
    function TEST_F (line 443) | TEST_F(QueueTest, AddUnknown) {
    function TEST_F (line 470) | TEST_F(QueueTest, AddMax) {
    function TEST_F (line 478) | TEST_F(QueueTest, Misc) {
    function TEST_F (line 492) | TEST_F(QueueTest, IterateBFS) {
    function TEST_F (line 501) | TEST_F(QueueTest, NextEgress) {
    function TEST_F (line 541) | TEST_F(QueueTest, NextEgressExclusiveAdd) {
    function TEST_F (line 562) | TEST_F(QueueTest, NextEgressExclusiveAddWithEgress) {
    function TEST_F (line 579) | TEST_F(QueueTest, UpdatePriorityReparentSubtree) {
    function TEST_F (line 600) | TEST_F(QueueTest, NextEgressRemoveParent) {
    function TEST_F (line 622) | TEST_F(QueueTest, AddExclusiveDescendantEnqueued) {
    function TEST_F (line 636) | TEST_F(QueueTest, NextEgressRemoveParentEnqueued) {
    function TEST_F (line 650) | TEST_F(QueueTest, NextEgressRemoveParentEnqueuedIndirect) {
    function TEST_F (line 665) | TEST_F(QueueTest, ChromeTest) {
    function TEST_F (line 741) | TEST_F(QueueTest, AddOrUpdate) {
    class DanglingQueueTestBase (line 754) | class DanglingQueueTestBase {
      method DanglingQueueTestBase (line 756) | DanglingQueueTestBase() {
      method expireNodes (line 769) | void expireNodes() {
      method tick (line 777) | void tick() {
    class DanglingQueueTest (line 793) | class DanglingQueueTest
      method DanglingQueueTest (line 797) | DanglingQueueTest() : DanglingQueueTestBase(), QueueTest(&timer_) {
    function TEST_F (line 801) | TEST_F(DanglingQueueTest, Basic) {
    function TEST_F (line 812) | TEST_F(DanglingQueueTest, Chain) {
    function TEST_F (line 834) | TEST_F(DanglingQueueTest, Drop) {
    function TEST_F (line 849) | TEST_F(DanglingQueueTest, ExpireParentOfMismatchedTwins) {
    function TEST_F (line 868) | TEST_F(DanglingQueueTest, AddExpireAdd) {
    class DummyTimeout (line 887) | class DummyTimeout : public HHWheelTimer::Callback {
      method timeoutExpired (line 888) | void timeoutExpired() noexcept override {
    function TEST_F (line 892) | TEST_F(DanglingQueueTest, Refresh) {
    function TEST_F (line 920) | TEST_F(DanglingQueueTest, Max) {
    function TEST_F (line 937) | TEST_F(QueueTest, Rebuild) {

FILE: proxygen/lib/http/session/test/HTTPDefaultSessionCodecFactoryTest.cpp
  function TEST (line 22) | TEST(HTTPDefaultSessionCodecFactoryTest, GetCodecH2) {
  function TEST (line 42) | TEST(HTTPDefaultSessionCodecFactoryTest, GetCodec) {
  type TestParams (line 65) | struct TestParams {
  class HTTPDefaultSessionCodecFactoryValidationTest (line 70) | class HTTPDefaultSessionCodecFactoryValidationTest
  function TEST_P (line 73) | TEST_P(HTTPDefaultSessionCodecFactoryValidationTest, StrictValidation) {

FILE: proxygen/lib/http/session/test/HTTPDownstreamSessionTest.cpp
  class HTTPDownstreamTest (line 47) | class HTTPDownstreamTest : public testing::Test {
    method HTTPDownstreamTest (line 49) | explicit HTTPDownstreamTest(std::vector<int64_t> flowControl = {-1, -1...
    method sendRequest (line 119) | HTTPCodec::StreamID sendRequest(const std::string& url = "/",
    method sendRequest (line 128) | HTTPCodec::StreamID sendRequest(const HTTPMessage& req, bool eom = tru...
    method sendHeader (line 134) | HTTPCodec::StreamID sendHeader() {
    method sendRequestLater (line 138) | Promise<folly::Unit> sendRequestLater(HTTPMessage req, bool eof = fals...
    method SetUp (line 150) | void SetUp() override {
    method TearDown (line 162) | void TearDown() override {
    method cleanup (line 166) | void cleanup() {
    method addSimpleStrictHandler (line 171) | std::unique_ptr<testing::StrictMock<MockHTTPHandler>>
    method addSimpleNiceHandler (line 189) | std::unique_ptr<testing::NiceMock<MockHTTPHandler>> addSimpleNiceHandl...
    method onEOMTerminateHandlerExpectShutdown (line 206) | void onEOMTerminateHandlerExpectShutdown(MockHTTPHandler& handler) {
    method expectDetachSession (line 212) | void expectDetachSession() {
    method addSingleByteReads (line 216) | void addSingleByteReads(const char* data, milliseconds delay = {}) {
    method flushRequestsAndLoop (line 222) | void flushRequestsAndLoop(
    method flushRequestsAndLoopN (line 231) | void flushRequestsAndLoopN(
    method flushRequests (line 243) | void flushRequests(
    method gracefulShutdown (line 263) | void gracefulShutdown() {
    method expectResponse (line 274) | void expectResponse(uint32_t code, bool expectBody, bool stopParsing =...
    method expectResponse (line 279) | void expectResponse(uint32_t code = 200,
    method expectResponses (line 288) | void expectResponses(uint32_t n,
    method parseOutput (line 372) | void parseOutput(HTTPCodec& clientCodec) {
    method resumeWritesInLoop (line 397) | void resumeWritesInLoop() {
    method resumeWritesAfterDelay (line 401) | void resumeWritesAfterDelay(milliseconds delay) {
    method MockByteEventTracker (line 406) | MockByteEventTracker* setMockByteEventTracker() {
    method addMockSessionObserver (line 422) | std::unique_ptr<MockSessionObserver> addMockSessionObserver(
    method addMockSessionObserverShared (line 430) | std::shared_ptr<MockSessionObserver> addMockSessionObserverShared(
    method evbLoopNonBlockN (line 439) | void evbLoopNonBlockN(size_t count) {
  class HTTP2DownstreamSessionTest (line 466) | class HTTP2DownstreamSessionTest : public HTTPDownstreamTest<HTTP2CodecP...
    method HTTP2DownstreamSessionTest (line 468) | HTTP2DownstreamSessionTest() : HTTPDownstreamTest<HTTP2CodecPair>() {
    method SetUp (line 471) | void SetUp() override {
    method TearDown (line 475) | void TearDown() override {
  class HTTP2DownstreamSessionEarlyShutdownTest (line 481) | class HTTP2DownstreamSessionEarlyShutdownTest
    method HTTP2DownstreamSessionEarlyShutdownTest (line 484) | HTTP2DownstreamSessionEarlyShutdownTest()
    method SetUp (line 488) | void SetUp() override {
    method TearDown (line 492) | void TearDown() override {
  function TEST_F (line 497) | TEST_F(HTTP2DownstreamSessionEarlyShutdownTest, EarlyShutdown) {
  function TEST_F (line 516) | TEST_F(HTTP2DownstreamSessionEarlyShutdownTest, EarlyShutdownDoubleGoawa...
  function TEST_F (line 533) | TEST_F(HTTP2DownstreamSessionTest, ShutdownDoubleGoaway) {
  function TEST_F (line 549) | TEST_F(HTTPDownstreamSessionTest, ImmediateEof) {
  function TEST_F (line 557) | TEST_F(HTTPDownstreamSessionTest, IdleTimeoutWithOpenStreamGraceful) {
  function TEST_F (line 590) | TEST_F(HTTPDownstreamSessionTest, IdleTimeoutNoStreams) {
  function TEST_F (line 596) | TEST_F(HTTPDownstreamSessionTest, IdleTimeoutWithOpenStreamUngraceful) {
  function TEST_F (line 632) | TEST_F(HTTPDownstreamSessionTest, Http10NoHeaders) {
  function TEST_F (line 653) | TEST_F(HTTPDownstreamSessionTest, Http10NoHeadersEof) {
  function TEST_F (line 673) | TEST_F(HTTPDownstreamSessionTest, SingleBytes) {
  function TEST_F (line 703) | TEST_F(HTTPDownstreamSessionTest, SingleBytesWithBody) {
  function TEST_F (line 742) | TEST_F(HTTPDownstreamSessionTest, SplitBody) {
  function TEST_F (line 768) | TEST_F(HTTPDownstreamSessionTest, MovableBuffer) {
  function TEST_F (line 798) | TEST_F(HTTPDownstreamSessionTest, MovableBufferChained) {
  function TEST_F (line 830) | TEST_F(HTTPDownstreamSessionTest, MovableBufferMultiple) {
  function TEST_F (line 861) | TEST_F(HTTPDownstreamSessionTest, MovableBufferChainedEmptyBuffer) {
  function TEST_F (line 894) | TEST_F(HTTPDownstreamSessionTest, PostChunked) {
  function TEST_F (line 954) | TEST_F(HTTPDownstreamSessionTest, MultiMessage) {
  function TEST_F (line 1002) | TEST_F(HTTPDownstreamSessionTest, ClientPipelined) {
  function TEST_F (line 1041) | TEST_F(HTTPDownstreamSessionTest, BadContentLength) {
  function TEST_F (line 1067) | TEST_F(HTTP2DownstreamSessionTest, FrameBasedPadding) {
  function TEST_F (line 1117) | TEST_F(HTTPDownstreamSessionTest, Connect) {
  function TEST_F (line 1143) | TEST_F(HTTPDownstreamSessionTest, ConnectRejected) {
  function TEST_F (line 1163) | TEST_F(HTTPDownstreamSessionTest, HttpUpgrade) {
  function TEST (line 1185) | TEST(HTTPDownstreamTest, ParseErrorNoTxn) {
  function TEST (line 1236) | TEST(HTTPDownstreamTest, ByteEventsDrained) {
  function TEST_F (line 1272) | TEST_F(HTTPDownstreamSessionTest, HttpWithAckTiming) {
  function TEST_F (line 1315) | TEST_F(HTTPDownstreamSessionTest, TestOnContentMismatch) {
  function TEST_F (line 1351) | TEST_F(HTTPDownstreamSessionTest, HttpWithAckTimingPipeline) {
  function TEST_F (line 1392) | TEST_F(HTTPDownstreamSessionTest, HttpWithAckTimingPipelineError) {
  function TEST_F (line 1442) | TEST_F(HTTPDownstreamSessionTest, HttpWithAckTimingConnError) {
  function TEST_F (line 1481) | TEST_F(HTTPDownstreamSessionTest, ServerStatusHeaderOnError) {
  function TEST_F (line 1515) | TEST_F(HTTP2DownstreamSessionTest, ServerStatusHeaderOnError) {
  function TEST_F (line 1542) | TEST_F(HTTP2DownstreamSessionTest, TestPing) {
  function TEST_F (line 1567) | TEST_F(HTTP2DownstreamSessionTest, TestPingWithPreSendSplit) {
  function TEST_F (line 1616) | TEST_F(HTTP2DownstreamSessionTest, SetByteEventTracker) {
  function TEST_F (line 1663) | TEST_F(HTTP2DownstreamSessionTest, SendNoErrorAfterEomFlush) {
  function TEST_F (line 1689) | TEST_F(HTTP2DownstreamSessionTest, SendDeferredNoError) {
  function TEST_F (line 1727) | TEST_F(HTTP2DownstreamSessionTest, InvalidNoErrorAbort) {
  function TEST_F (line 1755) | TEST_F(HTTPDownstreamSessionTest, TestTrackedByteEventTracker) {
  type TestOnTxnByteEventWrittenToBufParams (line 1782) | struct TestOnTxnByteEventWrittenToBufParams {
  class OnTxnByteEventWrittenToBufTest (line 1789) | class OnTxnByteEventWrittenToBufTest
    method getTestingValues (line 1794) | static std::vector<TestOnTxnByteEventWrittenToBufParams> getTestingVal...
  function TEST_P (line 1821) | TEST_P(OnTxnByteEventWrittenToBufTest, TestOnTxnByteEventWrittenToBuf) {
  function TEST_F (line 1867) | TEST_F(HTTP2DownstreamSessionTest, Trailers) {
  function TEST_F (line 1892) | TEST_F(HTTPDownstreamSessionTest, Trailers) {
  function TEST_F (line 1896) | TEST_F(HTTPDownstreamSessionTest, ExplicitChunks) {
  function TEST_F (line 1931) | TEST_F(HTTPDownstreamSessionTest, HttpDrain) {
  function TEST_F (line 1964) | TEST_F(HTTPDownstreamSessionTest, HttpDrainLongRunning) {
  function TEST_F (line 1987) | TEST_F(HTTPDownstreamSessionTest, EarlyAbort) {
  function TEST_F (line 2012) | TEST_F(HTTPDownstreamSessionTest, HttpWritesDrainingTimeout) {
  function TEST_F (line 2036) | TEST_F(HTTPDownstreamSessionTest, HttpRateLimitNormal) {
  function TEST_F (line 2078) | TEST_F(HTTP2DownstreamSessionTest, RateLimitNormal) {
  function TEST_F (line 2124) | TEST_F(HTTP2DownstreamSessionTest, RateLimitRst) {
  function TEST_F (line 2160) | TEST_F(HTTPDownstreamSessionTest, WriteTimeout) {
  function TEST_F (line 2192) | TEST_F(HTTPDownstreamSessionTest, WriteTimeoutPipeline) {
  function TEST_F (line 2232) | TEST_F(HTTPDownstreamSessionTest, BodyPacketization) {
  function TEST_F (line 2254) | TEST_F(HTTPDownstreamSessionTest, HttpMalformedPkt1) {
  function TEST_F (line 2264) | TEST_F(HTTPDownstreamSessionTest, BigExplcitChunkWrite) {
  function TEST_F (line 2294) | TEST_F(HTTPDownstreamSessionTest, HttpUpgradeNonNative) {
  function TEST_F (line 2338) | TEST_F(HTTPDownstreamSessionTest, HttpUpgradeNonNativeIgnore) {
  function TEST_F (line 2352) | TEST_F(HTTPDownstreamSessionTest, HttpUpgradeNonNativePipeline) {
  function TEST_F (line 2431) | TEST_F(HTTP2DownstreamSessionTest, H2Timeout) {
  function TEST_F (line 2451) | TEST_F(HTTP2DownstreamSessionTest, H2TimeoutWin) {
  function TYPED_TEST_P (line 2482) | TYPED_TEST_P(HTTPDownstreamTest, TestMaxTxnOverriding) {
  function TYPED_TEST_P (line 2507) | TYPED_TEST_P(HTTPDownstreamTest, TestWritesDraining) {
  function TYPED_TEST_P (line 2532) | TYPED_TEST_P(HTTPDownstreamTest, TestBodySizeLimit) {
  function TYPED_TEST_P (line 2578) | TYPED_TEST_P(HTTPDownstreamTest, TestMaxTxns) {
  function TEST_F (line 2620) | TEST_F(HTTP2DownstreamSessionTest, H2MaxConcurrentStreams) {
  function TEST_F (line 2649) | TEST_F(HTTP2DownstreamSessionTest, SlowDrainWithoutFIN) {
  class HTTP2DownstreamSessionFCTest (line 2705) | class HTTP2DownstreamSessionFCTest : public HTTPDownstreamTest<HTTP2Code...
    method HTTP2DownstreamSessionFCTest (line 2707) | HTTP2DownstreamSessionFCTest()
  function TEST_F (line 2713) | TEST_F(HTTP2DownstreamSessionFCTest, TestSessionFlowControl) {
  function TEST_F (line 2724) | TEST_F(HTTP2DownstreamSessionTest, TestEOFOnBlockedStream) {
  function TEST_F (line 2747) | TEST_F(HTTP2DownstreamSessionFCTest, TestEOFOnBlockedSession) {
  function TEST_F (line 2782) | TEST_F(HTTP2DownstreamSessionTest, NewTxnEgressPaused) {
  function TEST_F (line 2842) | TEST_F(HTTP2DownstreamSessionTest, ZeroDeltaWindowUpdate) {
  function TEST_F (line 2866) | TEST_F(HTTP2DownstreamSessionTest, PaddingFlowControl) {
  function TEST_F (line 2901) | TEST_F(HTTP2DownstreamSessionTest, GracefulDrainOnTimeout) {
  function TEST_F (line 2943) | TEST_F(HTTP2DownstreamSessionTest, ServerPush) {
  function TEST_F (line 3010) | TEST_F(HTTP2DownstreamSessionTest, ServerPushAbortPaused) {
  function TEST_F (line 3085) | TEST_F(HTTP2DownstreamSessionTest, ServerPushAfterWriteTimeout) {
  function TEST_F (line 3147) | TEST_F(HTTP2DownstreamSessionTest, TestPriorityFCBlocked) {
  function TEST_F (line 3214) | TEST_F(HTTP2DownstreamSessionTest, TestHeadersRateLimitExceeded) {
  function TEST_F (line 3242) | TEST_F(HTTP2DownstreamSessionTest, TestControlMsgRateLimitExceeded) {
  function TEST_F (line 3267) | TEST_F(HTTP2DownstreamSessionTest, TestControlMsgResetRateLimitTouched) {
  function TEST_F (line 3315) | TEST_F(HTTP2DownstreamSessionTest, DirectErrorHandlingLimitTouched) {
  function TEST_F (line 3351) | TEST_F(HTTP2DownstreamSessionTest, DirectErrorHandlingLimitExceeded) {
  function TEST_F (line 3374) | TEST_F(HTTP2DownstreamSessionTest, TestPriorityWeightsTinyWindow) {
  function TEST_F (line 3426) | TEST_F(HTTP2DownstreamSessionTest, TestShortContentLength) {
  function TEST_F (line 3449) | TEST_F(HTTP2DownstreamSessionTest, TestBadContentLengthUntieHandler) {
  function TEST_F (line 3469) | TEST_F(HTTP2DownstreamSessionTest, TestLongContentLength) {
  function TEST_F (line 3489) | TEST_F(HTTP2DownstreamSessionTest, TestMalformedContentLength) {
  function TEST_F (line 3507) | TEST_F(HTTP2DownstreamSessionTest, TestHeadContentLength) {
  function TEST_F (line 3526) | TEST_F(HTTP2DownstreamSessionTest, Test304ContentLength) {
  function TEST_F (line 3546) | TEST_F(HTTPDownstreamSessionTest, HttpShortContentLength) {
  function TEST_F (line 3571) | TEST_F(HTTP2DownstreamSessionTest, TestSessionStallByFlowControl) {
  function TEST_F (line 3613) | TEST_F(HTTP2DownstreamSessionTest, TestTransactionStallByFlowControl) {
  function TEST_F (line 3657) | TEST_F(HTTP2DownstreamSessionTest, TestTransactionNotStallByFlowControl) {
  function TEST_F (line 3688) | TEST_F(HTTP2DownstreamSessionTest, TestSetEgressSettings) {
  function TEST_F (line 3705) | TEST_F(HTTP2DownstreamSessionTest, TestDuplicateRequestStream) {
  function TEST_F (line 3738) | TEST_F(HTTP2DownstreamSessionTest, TestPingPreserveData) {
  function TEST_F (line 3749) | TEST_F(HTTP2DownstreamSessionTest, DropConnectionWithPendingShutdownCall...
  function TEST_F (line 3769) | TEST_F(HTTP2DownstreamSessionTest, DropAlreadyShuttingDownConnection) {
  function TEST_F (line 3786) | TEST_F(HTTP2DownstreamSessionTest, PingProbes) {
  function TEST_F (line 3807) | TEST_F(HTTP2DownstreamSessionTest, PingProbeTimeout) {
  function TEST_F (line 3824) | TEST_F(HTTP2DownstreamSessionTest, PingProbeTimeoutRefresh) {
  function TEST_F (line 3853) | TEST_F(HTTP2DownstreamSessionTest, PingProbeInvalid) {
  function TEST_F (line 3873) | TEST_F(HTTP2DownstreamSessionTest, CancelPingProbesOnRequest) {
  function TEST_F (line 3900) | TEST_F(HTTP2DownstreamSessionTest, Observer_Attach_Detach_Destroy) {
  function TEST_F (line 3934) | TEST_F(HTTP2DownstreamSessionTest, Observer_Attach_Detach_Destroy_Shared) {
  function TEST_F (line 3968) | TEST_F(HTTP2DownstreamSessionTest, Observer_RequestStarted) {
  function TEST_F (line 4016) | TEST_F(HTTP2DownstreamSessionTest, Observer_SendPingByObserver) {
  function TEST_F (line 4066) | TEST_F(HTTP2DownstreamSessionTest, Observer_PingReply) {
  function TEST_F (line 4096) | TEST_F(HTTP2DownstreamSessionTest, Observer_PreWrite) {
  function TEST_F (line 4139) | TEST_F(HTTPDownstreamSessionTest, InvariantViolation) {
  function TEST_F (line 4168) | TEST_F(HTTPDownstreamSessionTest, WebsocketUpgradeSessionUnresuable) {
  function TEST_F (line 4203) | TEST_F(HTTP2DownstreamSessionTest, InvariantViolation) {
  function TEST_F (line 4232) | TEST_F(HTTP2DownstreamSessionTest, EnableServerEarlyResponse) {
  function TEST_F (line 4265) | TEST_F(HTTP2DownstreamSessionTest, IdleSessionDoubleGoawayReadTimeout) {
  function TEST_F (line 4302) | TEST_F(HTTP2DownstreamSessionTest, ZeroContentLengthTest) {

FILE: proxygen/lib/http/session/test/HTTPSessionAcceptorTest.cpp
  class HTTPTargetSessionAcceptor (line 34) | class HTTPTargetSessionAcceptor : public HTTPSessionAcceptor {
    method HTTPTargetSessionAcceptor (line 36) | explicit HTTPTargetSessionAcceptor(
    method onCreate (line 46) | void onCreate(const HTTPSessionBase& session) override {
    method connectionReady (line 52) | void connectionReady(AsyncSocket::UniquePtr sock,
    method onSessionCreationError (line 64) | void onSessionCreationError(ProxygenError /*error*/) override {
  class HTTPSessionAcceptorTestBase (line 73) | class HTTPSessionAcceptorTestBase
    method setupSSL (line 76) | virtual void setupSSL() {
    method SetUp (line 89) | void SetUp() override {
    method newAcceptor (line 97) | void newAcceptor() {
  class HTTPSessionAcceptorTestNPN (line 111) | class HTTPSessionAcceptorTestNPN : public HTTPSessionAcceptorTestBase {}
  class HTTPSessionAcceptorTestNPNPlaintext (line 112) | class HTTPSessionAcceptorTestNPNPlaintext
  class HTTPSessionAcceptorTestNPNJunk (line 114) | class HTTPSessionAcceptorTestNPNJunk : public HTTPSessionAcceptorTestBas...
  function TEST_P (line 117) | TEST_P(HTTPSessionAcceptorTestNPN, Npn) {
  function TEST_P (line 143) | TEST_P(HTTPSessionAcceptorTestNPNPlaintext, PlaintextProtocols) {
  function TEST_F (line 167) | TEST_F(HTTPSessionAcceptorTestNPNJunk, Npn) {
  function TEST_F (line 179) | TEST_F(HTTPSessionAcceptorTestNPN, AcceptorConfigCapture) {

FILE: proxygen/lib/http/session/test/HTTPSessionActivityTrackerTest.cpp
  class MockHTTPSessionActivityTracker (line 19) | class MockHTTPSessionActivityTracker : public HTTPSessionActivityTracker {
    method MockHTTPSessionActivityTracker (line 21) | MockHTTPSessionActivityTracker(size_t ingressTH, size_t egressTH)
  class HTTPSessionActivityTrackerTest (line 27) | class HTTPSessionActivityTrackerTest : public Test {
    method SetUp (line 29) | void SetUp() override {
  function TEST_F (line 54) | TEST_F(HTTPSessionActivityTrackerTest, onIngress) {
  function TEST_F (line 63) | TEST_F(HTTPSessionActivityTrackerTest, addTrackedEgressByteEvent) {

FILE: proxygen/lib/http/session/test/HTTPSessionBenchmark.cpp
  class BenchTransportCallback (line 35) | class BenchTransportCallback : public HTTPTransaction::TransportCallback {
    method firstHeaderByteFlushed (line 37) | void firstHeaderByteFlushed() noexcept override {
    method firstByteFlushed (line 39) | void firstByteFlushed() noexcept override {
    method trackedByteFlushed (line 41) | void trackedByteFlushed() noexcept override {
    method lastByteFlushed (line 43) | void lastByteFlushed() noexcept override {
    method lastByteAcked (line 45) | void lastByteAcked(std::chrono::milliseconds) noexcept override {
    method trackedByteEventTX (line 47) | void trackedByteEventTX(const ByteEvent&) noexcept override {
    method trackedByteEventAck (line 49) | void trackedByteEventAck(const ByteEvent&) noexcept override {
    method egressBufferEmpty (line 51) | void egressBufferEmpty() noexcept override {
    method headerBytesGenerated (line 54) | void headerBytesGenerated(HTTPHeaderSize&) noexcept override {
    method headerBytesReceived (line 56) | void headerBytesReceived(const HTTPHeaderSize&) noexcept override {
    method bodyBytesGenerated (line 58) | void bodyBytesGenerated(size_t) noexcept override {
    method bodyBytesReceived (line 60) | void bodyBytesReceived(size_t) noexcept override {
    method transportAppRateLimited (line 62) | void transportAppRateLimited() noexcept override {
    method datagramBytesGenerated (line 64) | void datagramBytesGenerated(size_t) noexcept override {
    method datagramBytesReceived (line 66) | void datagramBytesReceived(size_t) noexcept override {
  class SessionBenchmarkHelper (line 77) | class SessionBenchmarkHelper {
    method SessionBenchmarkHelper (line 79) | explicit SessionBenchmarkHelper(uint32_t numTransactions)
    method invokeCheckOnAllTransactions (line 89) | void invokeCheckOnAllTransactions() {
    method setup (line 98) | void setup() {
    method teardown (line 182) | void teardown() {
  function benchCheckEgressRateLimited (line 213) | void benchCheckEgressRateLimited(uint32_t iters, uint32_t numTransaction...
  function main (line 238) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/session/test/HTTPSessionMocks.h
  function namespace (line 23) | namespace proxygen {
  function sendEOM (line 109) | void sendEOM() {
  function std (line 123) | const std::vector<char> buf(chunkSize, 'a');
  function HTTPTransaction (line 141) | HTTPTransaction* txn_{nullptr};
  function setTransaction (line 168) | void setTransaction(HTTPTransaction* txn) noexcept override {
  function detachTransaction (line 173) | void detachTransaction() noexcept override {
  function onHeadersComplete (line 178) | void onHeadersComplete(std::unique_ptr<HTTPMessage> msg) noexcept overri...
  function onBody (line 184) | void onBody(std::unique_ptr<folly::IOBuf> chain) noexcept override {
  function onBodyWithOffset (line 189) | void onBodyWithOffset(uint64_t bodyOffset,
  function onDatagram (line 198) | void onDatagram(std::unique_ptr<folly::IOBuf> chain) noexcept override {
  function onNewUniStream (line 216) | void onNewUniStream(
  function onNewBidiStream (line 221) | void onNewBidiStream(
  function onSessionEnd (line 226) | void onSessionEnd(folly::Optional<uint32_t> error) noexcept override {
  function onChunkHeader (line 232) | void onChunkHeader(size_t length) noexcept override {
  function onChunkComplete (line 237) | void onChunkComplete() noexcept override {
  function onTrailers (line 242) | void onTrailers(std::unique_ptr<HTTPHeaders> trailers) noexcept override {
  function onEOM (line 248) | void onEOM() noexcept override {
  function onUpgrade (line 253) | void onUpgrade(UpgradeProtocol protocol) noexcept override {
  function onError (line 258) | void onError(const HTTPException& error) noexcept override {
  function onInvariantViolation (line 263) | void onInvariantViolation(const HTTPException& error) noexcept override {
  function onGoaway (line 268) | void onGoaway(ErrorCode errCode) noexcept override {
  function onEgressPaused (line 273) | void onEgressPaused() noexcept override {
  function onEgressResumed (line 278) | void onEgressResumed() noexcept override {
  function onPushedTransaction (line 283) | void onPushedTransaction(HTTPTransaction* txn) noexcept override {
  function expectTransaction (line 288) | void expectTransaction(std::function<void(HTTPTransaction* txn)> callbac...
  function expectTransaction (line 294) | void expectTransaction(HTTPTransaction** pTxn = nullptr) {
  function expectHeaders (line 308) | void expectHeaders(std::function<void()> callback = std::function<void()...
  function expectHeaders (line 318) | void expectHeaders(std::function<void(std::shared_ptr<HTTPMessage>)> cb) {
  function expectTrailers (line 324) | void expectTrailers(
  function expectTrailers (line 335) | void expectTrailers(
  function expectChunkHeader (line 342) | void expectChunkHeader(
  function expectBody (line 352) | void expectBody(std::function<void()> callback = std::function<void()>()) {
  function expectDatagram (line 387) | void expectDatagram(
  function expectChunkComplete (line 393) | void expectChunkComplete(
  function expectEOM (line 403) | void expectEOM(std::function<void()> callback = std::function<void()>()) {
  function expectEgressPaused (line 411) | void expectEgressPaused(
  function expectEgressResumed (line 420) | void expectEgressResumed(
  function expectError (line 430) | void expectError(std::function<void(const HTTPException& ex)> callback =
  function expectGoaway (line 441) | void expectGoaway(std::function<void(ErrorCode)> callback =
  function expectDetachTransaction (line 451) | void expectDetachTransaction(
  function noexcept (line 474) | noexcept override {
  function detachTransaction (line 479) | void detachTransaction() noexcept override {
  function onError (line 484) | void onError(const HTTPException& error) noexcept override {
  function onGoaway (line 489) | void onGoaway(ErrorCode errCode) noexcept override {
  function onEgressPaused (line 494) | void onEgressPaused() noexcept override {
  function onEgressResumed (line 499) | void onEgressResumed() noexcept override {
  function sendPushHeaders (line 504) | void sendPushHeaders(const std::string& path,
  function class (line 516) | class MockController : public HTTPSessionController {
  function class (line 548) | class MockUpstreamController : public HTTPUpstreamSessionController {

FILE: proxygen/lib/http/session/test/HTTPTransactionMocks.h
  function namespace (line 17) | namespace proxygen {
  function setHandlerUnmocked (line 375) | void setHandlerUnmocked(HTTPTransactionHandler* handler) {
  function sendBody (line 387) | void sendBody(std::unique_ptr<folly::IOBuf> iob) noexcept override {
  function sendAbort (line 391) | void sendAbort() {

FILE: proxygen/lib/http/session/test/HTTPTransactionSMTest.cpp
  class EgressStateMachineFixture (line 15) | class EgressStateMachineFixture : public ::testing::Test {
    method EgressStateMachineFixture (line 17) | EgressStateMachineFixture()
    method follow (line 21) | void follow(HTTPTransactionEgressSM::Event e) {
    method fail (line 25) | void fail(HTTPTransactionEgressSM::Event e) {
  class IngressStateMachineFixture (line 33) | class IngressStateMachineFixture : public ::testing::Test {
    method IngressStateMachineFixture (line 35) | IngressStateMachineFixture()
    method follow (line 39) | void follow(HTTPTransactionIngressSM::Event e) {
    method fail (line 43) | void fail(HTTPTransactionIngressSM::Event e) {
  function TEST_F (line 53) | TEST_F(EgressStateMachineFixture, BadEgressTransitions1) {
  function TEST_F (line 60) | TEST_F(EgressStateMachineFixture, BadEgressTransitions2) {
  function TEST_F (line 64) | TEST_F(EgressStateMachineFixture, BadEgressTransitions3) {
  function TEST_F (line 72) | TEST_F(EgressStateMachineFixture, BadEgressTransitions4) {
  function TEST_F (line 81) | TEST_F(EgressStateMachineFixture, EgressChunkedTransitions) {
  function TEST_F (line 102) | TEST_F(EgressStateMachineFixture, NormalEgressTransitions) {
  function TEST_F (line 111) | TEST_F(EgressStateMachineFixture, NormalEgressTransitionsWithTrailers) {
  function TEST_F (line 122) | TEST_F(EgressStateMachineFixture, WeirdEgressTransitions) {
  function TEST_F (line 129) | TEST_F(EgressStateMachineFixture, NormalDatagramTransitions) {
  function TEST_F (line 137) | TEST_F(EgressStateMachineFixture, NormalDatagramTransitionsWithTrailers) {
  function TEST_F (line 146) | TEST_F(EgressStateMachineFixture, BadDatagramTransitionBeforeHeaders) {
  function TEST_F (line 150) | TEST_F(EgressStateMachineFixture, BadDatagramTransitionAfterBody) {
  function TEST_F (line 156) | TEST_F(EgressStateMachineFixture, BadDatagramTransitionAfterTrailers) {
  function TEST_F (line 164) | TEST_F(EgressStateMachineFixture, BadDatagramTransitionAfterEOM) {
  function TEST_F (line 174) | TEST_F(IngressStateMachineFixture, BadIngressTransitions1) {
  function TEST_F (line 181) | TEST_F(IngressStateMachineFixture, BadIngressTransitions2) {
  function TEST_F (line 185) | TEST_F(IngressStateMachineFixture, BadIngressTransitions3) {
  function TEST_F (line 193) | TEST_F(IngressStateMachineFixture, BadIngressTransitions4) {
  function TEST_F (line 202) | TEST_F(IngressStateMachineFixture, IngressChunkedTransitions) {
  function TEST_F (line 221) | TEST_F(IngressStateMachineFixture, NormalIngressTransitions) {
  function TEST_F (line 230) | TEST_F(IngressStateMachineFixture, WeirdIngressTransitions) {
  function TEST_F (line 239) | TEST_F(IngressStateMachineFixture, NormalDatagramTransitions) {
  function TEST_F (line 248) | TEST_F(IngressStateMachineFixture, NormalDatagramTransitionsWithTrailers) {
  function TEST_F (line 256) | TEST_F(IngressStateMachineFixture, BadDatagramTransitionBodyBeforeFinal) {
  function TEST_F (line 261) | TEST_F(IngressStateMachineFixture, BadDatagramTransitionTrailersBeforeFi...
  function TEST_F (line 266) | TEST_F(IngressStateMachineFixture, BadDatagramTransitionEOMBeforeFinal) {
  function TEST_F (line 271) | TEST_F(IngressStateMachineFixture, BadDatagramTransitionBeforeHeaders) {
  function TEST_F (line 275) | TEST_F(IngressStateMachineFixture, BadDatagramTransitionBeforeFinalHeade...
  function TEST_F (line 280) | TEST_F(IngressStateMachineFixture, BadDatagramTransitionAfterTrailers) {
  function TEST_F (line 288) | TEST_F(IngressStateMachineFixture, BadDatagramTransitionAfterEOM) {

FILE: proxygen/lib/http/session/test/HTTPTransactionTest.cpp
  class HTTPTransactionObservabilityTest (line 24) | class HTTPTransactionObservabilityTest : public ::testing::Test {
    method SetUp (line 26) | void SetUp() override {
    method TearDown (line 35) | void TearDown() override {
    method addMockTxnObserver (line 45) | std::unique_ptr<MockHTTPTransactionObserver> addMockTxnObserver(
    method addMockTxnObserverShared (line 54) | std::shared_ptr<MockHTTPTransactionObserver> addMockTxnObserverShared(
  function TEST_F (line 69) | TEST_F(HTTPTransactionObservabilityTest, ObserverAttachedDetached) {
  function TEST_F (line 76) | TEST_F(HTTPTransactionObservabilityTest, ObserverAttachedDestroyed) {
  function TEST_F (line 83) | TEST_F(HTTPTransactionObservabilityTest, ObserverAttachedDetachedSharedP...
  function TEST_F (line 90) | TEST_F(HTTPTransactionObservabilityTest, ObserverAttachedDestroyedShared...
  function TEST_F (line 97) | TEST_F(HTTPTransactionObservabilityTest,
  function TEST_F (line 106) | TEST_F(HTTPTransactionObservabilityTest,

FILE: proxygen/lib/http/session/test/HTTPTransactionWebTransportTest.cpp
  function makeOpt (line 20) | folly::Optional<uint32_t> makeOpt(uint32_t n) {
  type proxygen::test (line 25) | namespace proxygen::test {
    class HTTPTransactionWebTransportTest (line 26) | class HTTPTransactionWebTransportTest : public testing::Test {
      method SetUp (line 28) | void SetUp() override {
      method setup (line 32) | void setup(bool withHandler) {
      method TearDown (line 88) | void TearDown() override {
      method readCallback (line 102) | static void readCallback(
      method HTTPTransaction (line 130) | HTTPTransaction& makeTxn() {
    class MockDeliveryCallback (line 143) | class MockDeliveryCallback : public WebTransport::ByteEventCallback {
    function TEST_F (line 153) | TEST_F(HTTPTransactionWebTransportTest, CreateStreams) {
    function TEST_F (line 212) | TEST_F(HTTPTransactionWebTransportTest, ReadStream) {
    function TEST_F (line 273) | TEST_F(HTTPTransactionWebTransportTest, ReadStreamBufferedError) {
    function TEST_F (line 303) | TEST_F(HTTPTransactionWebTransportTest, ReadStreamError) {
    function TEST_F (line 334) | TEST_F(HTTPTransactionWebTransportTest, ReadStreamCancel) {
    function TEST_F (line 362) | TEST_F(HTTPTransactionWebTransportTest, WriteFails) {
    function TEST_F (line 383) | TEST_F(HTTPTransactionWebTransportTest, WriteStreamPauseStopSending) {
    function TEST_F (line 448) | TEST_F(HTTPTransactionWebTransportTest, AwaitWritableCancel) {
    function TEST_F (line 496) | TEST_F(HTTPTransactionWebTransportTest, BidiStreamEdgeCases) {
    function TEST_F (line 547) | TEST_F(HTTPTransactionWebTransportTest, StreamDetachWithOpenStreams) {
    function TEST_F (line 589) | TEST_F(HTTPTransactionWebTransportTest, NoHandler) {
    function TEST_F (line 605) | TEST_F(HTTPTransactionWebTransportTest, StreamIDAPIs) {
    function TEST_F (line 650) | TEST_F(HTTPTransactionWebTransportTest, InvalidStreamIDAPIs) {
    function TEST_F (line 663) | TEST_F(HTTPTransactionWebTransportTest, SendDatagram) {
    function TEST_F (line 668) | TEST_F(HTTPTransactionWebTransportTest, RefreshTimeout) {
    function TEST_F (line 695) | TEST_F(HTTPTransactionWebTransportTest, StopSendingThenAbort) {
    function TEST_F (line 714) | TEST_F(HTTPTransactionWebTransportTest, WriteBufferingBasic) {
    function TEST_F (line 747) | TEST_F(HTTPTransactionWebTransportTest, WriteBufferingEOF) {
    function TEST_F (line 771) | TEST_F(HTTPTransactionWebTransportTest, WriteBufferingPartialSend) {
    function TEST_F (line 804) | TEST_F(HTTPTransactionWebTransportTest, StreamWriteReadyCallback) {
    function TEST_F (line 847) | TEST_F(HTTPTransactionWebTransportTest, FlushBufferedWritesMultiple) {
    function TEST_F (line 904) | TEST_F(HTTPTransactionWebTransportTest, CoalescedWrites) {
    function TEST_F (line 943) | TEST_F(HTTPTransactionWebTransportTest, CoalescedWritesPartialFlowCont...
    function TEST_F (line 988) | TEST_F(HTTPTransactionWebTransportTest, RecvFlowControlCloseSession) {
    function TEST_F (line 1028) | TEST_F(HTTPTransactionWebTransportTest, ClientUniStreamRst) {
    function TEST_F (line 1048) | TEST_F(HTTPTransactionWebTransportTest, UniStreamCredit) {
    function TEST_F (line 1091) | TEST_F(HTTPTransactionWebTransportTest, BidiStreamCredit) {
    function TEST_F (line 1143) | TEST_F(HTTPTransactionWebTransportTest, SelfMaxStreams) {
    function TEST_F (line 1173) | TEST_F(HTTPTransactionWebTransportTest, PeerMaxStreams) {
    function TEST_F (line 1221) | TEST_F(HTTPTransactionWebTransportTest, MaxStreamsInvalid) {
    function TEST_F (line 1241) | TEST_F(HTTPTransactionWebTransportTest, NewBidiStreamFailsAtMaxStreamI...
    function TEST_F (line 1264) | TEST_F(HTTPTransactionWebTransportTest, NewUniStreamFailsAtMaxStreamID) {
    function TEST_F (line 1287) | TEST_F(HTTPTransactionWebTransportTest, ReceiveWTStreamsBlockedCapsule) {
    function TEST_F (line 1308) | TEST_F(HTTPTransactionWebTransportTest, ReceiveWTDataBlockedCapsule) {

FILE: proxygen/lib/http/session/test/HTTPUpstreamSessionTest.cpp
  class TestPriorityAdapter (line 37) | class TestPriorityAdapter : public HTTPUpstreamSession::PriorityAdapter {
    method getHTTPPriority (line 39) | folly::Optional<const HTTPMessage::HTTP2Priority> getHTTPPriority(
  class HTTPUpstreamTest (line 63) | class HTTPUpstreamTest
    method HTTPUpstreamTest (line 67) | explicit HTTPUpstreamTest(std::vector<int64_t> flowControl = {-1, -1, ...
    method resumeWrites (line 79) | void resumeWrites() {
    method onWriteChain (line 88) | virtual void onWriteChain(folly::AsyncTransport::WriteCallback* callback,
    method handleWrite (line 101) | void handleWrite(folly::AsyncTransport::WriteCallback* callback) {
    method SetUp (line 114) | void SetUp() override {
    method TearDown (line 118) | void TearDown() override {
    method commonSetUp (line 126) | void commonSetUp(unique_ptr<HTTPCodec> codec) {
    method makeServerCodec (line 178) | unique_ptr<typename C::Codec> makeServerCodec() {
    method enableExHeader (line 182) | void enableExHeader(typename C::Codec* serverCodec) {
    method parseOutput (line 195) | void parseOutput(HTTPCodec& serverCodec) {
    method readAndLoop (line 204) | void readAndLoop(const std::string& input) {
    method readAndLoop (line 208) | void readAndLoop(folly::IOBuf* buf) {
    method readAndLoop (line 213) | void readAndLoop(const uint8_t* input, size_t length) {
    method onCreate (line 235) | void onCreate(const HTTPSessionBase&) override {
    method onDestroy (line 238) | void onDestroy(const HTTPSessionBase&) override {
    method onSettingsOutgoingStreamsFull (line 241) | void onSettingsOutgoingStreamsFull(const HTTPSessionBase&) override {
    method onSettingsOutgoingStreamsNotFull (line 244) | void onSettingsOutgoingStreamsNotFull(const HTTPSessionBase&) override {
    method openTransaction (line 248) | std::unique_ptr<StrictMock<MockHTTPHandler>> openTransaction(
    method openNiceTransaction (line 261) | std::unique_ptr<NiceMock<MockHTTPHandler>> openNiceTransaction(
    method MockByteEventTracker (line 278) | MockByteEventTracker* setMockByteEventTracker() {
    method addMockSessionObserver (line 294) | std::unique_ptr<MockSessionObserver> addMockSessionObserver(
    method onTransactionAttached (line 303) | void onTransactionAttached(const HTTPSessionBase&) override {
    method onTransactionDetached (line 307) | void onTransactionDetached(const HTTPSessionBase&) override {
  class TimeoutableHTTPUpstreamTest (line 339) | class TimeoutableHTTPUpstreamTest : public HTTPUpstreamTest<C> {
    method TimeoutableHTTPUpstreamTest (line 341) | TimeoutableHTTPUpstreamTest() : HTTPUpstreamTest<C>() {
  function TEST_F (line 354) | TEST_F(HTTP2UpstreamSessionTest, IngressGoawayAbortUncreatedStreams) {
  function TEST_F (line 392) | TEST_F(HTTP2UpstreamSessionTest, IngressGoawaySessionError) {
  function TEST_F (line 447) | TEST_F(HTTP2UpstreamSessionTest, TestUnderLimitOnWriteError) {
  function TEST_F (line 492) | TEST_F(HTTP2UpstreamSessionTest, TestOverlimitResume) {
  function TEST_F (line 543) | TEST_F(HTTP2UpstreamSessionTest, TestSettingsAck) {
  function TEST_F (line 563) | TEST_F(HTTP2UpstreamSessionTest, TestSettingsInfoCallbacks) {
  function TEST_F (line 592) | TEST_F(HTTP2UpstreamSessionTest, TestSetControllerInitHeaderIndexingStra...
  function TEST_F (line 614) | TEST_F(HTTP2UpstreamSessionTest, FullResponsePriorToEgressCompleteNoErro...
  function TEST_F (line 680) | TEST_F(HTTP2UpstreamSessionTest, FullResponsePriorToEgressCompleteCancel...
  class HTTP2UpstreamSessionWithVirtualNodesTest (line 751) | class HTTP2UpstreamSessionWithVirtualNodesTest
    method SetUp (line 754) | void SetUp() override {
    method commonSetUp (line 772) | void commonSetUp(unique_ptr<HTTPCodec> codec) {
    method TearDown (line 799) | void TearDown() override {
  function TYPED_TEST_P (line 811) | TYPED_TEST_P(HTTPUpstreamTest, ImmediateEof) {
  function TEST_F (line 842) | TEST_F(HTTPUpstreamSessionTest, BasicRequest) {
  function TEST_F (line 847) | TEST_F(HTTPUpstreamSessionTest, TwoRequests) {
  function TEST_F (line 860) | TEST_F(HTTPUpstreamSessionTest, ResponseWithoutRequest) {
  function TEST_F (line 870) | TEST_F(HTTP2UpstreamSessionTest, ResponseWithoutRequest) {
  function TEST_F (line 890) | TEST_F(HTTPUpstreamSessionTest, TestFirstHeaderByteEventTracker) {
  function TEST_F (line 958) | TEST_F(HTTPUpstreamSessionTest, Http10Keepalive) {
  function TEST_F (line 963) | TEST_F(HTTPUpstreamSessionTest, BasicTrailers) {
  function TEST_F (line 989) | TEST_F(HTTP2UpstreamSessionTest, BasicTrailers) {
  function TEST_F (line 1028) | TEST_F(HTTP2UpstreamSessionTest, HeadersThenBodyThenHeaders) {
  function TEST_F (line 1070) | TEST_F(HTTPUpstreamSessionTest, TwoRequestsWithPause) {
  function TEST_F (line 1098) | TEST_F(HTTPUpstreamTimeoutTest, WriteTimeoutAfterResponse) {
  function TEST_F (line 1131) | TEST_F(HTTPUpstreamTimeoutTest, SetIngressTimeoutAfterSendEom) {
  function TEST_F (line 1203) | TEST_F(HTTPUpstreamSessionTest, SetTransactionTimeout) {
  function TEST_F (line 1218) | TEST_F(HTTPUpstreamSessionTest, ReadTimeout) {
  function TEST_F (line 1381) | TEST_F(HTTPUpstreamSessionTest, HttpUpgrade101Unexpected) {
  function TEST_F (line 1398) | TEST_F(HTTPUpstreamSessionTest, HttpUpgrade101MissingUpgrade) {
  function TEST_F (line 1413) | TEST_F(HTTPUpstreamSessionTest, HttpUpgrade101BogusHeader) {
  function TEST_F (line 1430) | TEST_F(HTTPUpstreamSessionTest, FailedUpgradeDrainsSession) {
  class HTTPUpstreamRecvStreamTest (line 1456) | class HTTPUpstreamRecvStreamTest : public HTTPUpstreamSessionTest {
    method HTTPUpstreamRecvStreamTest (line 1458) | HTTPUpstreamRecvStreamTest() : HTTPUpstreamTest({100000, 105000, 11000...
  class NoFlushUpstreamSessionTest (line 1462) | class NoFlushUpstreamSessionTest : public HTTPUpstreamTest<HTTP2CodecPai...
    method onWriteChain (line 1464) | void onWriteChain(folly::AsyncTransport::WriteCallback* callback,
  function TEST_F (line 1487) | TEST_F(NoFlushUpstreamSessionTest, DeleteTxnOnUnpause) {
  class MockHTTPUpstreamTest (line 1511) | class MockHTTPUpstreamTest : public HTTPUpstreamTest<MockHTTPCodecPair> {
    method SetUp (line 1513) | void SetUp() override {
    method TearDown (line 1550) | void TearDown() override {
    method openTransaction (line 1554) | std::unique_ptr<StrictMock<MockHTTPHandler>> openTransaction() {
  function TEST_F (line 1570) | TEST_F(HTTP2UpstreamSessionTest, ServerPush) {
  class MockHTTP2UpstreamTest (line 1644) | class MockHTTP2UpstreamTest : public MockHTTPUpstreamTest {
    method SetUp (line 1646) | void SetUp() override {
  function TEST_F (line 1657) | TEST_F(MockHTTP2UpstreamTest, ParseErrorNoTxn) {
  function TEST_F (line 1708) | TEST_F(MockHTTPUpstreamTest, OutgoingTxnSettings) {
  function TEST_F (line 1726) | TEST_F(MockHTTPUpstreamTest, IngressGoawayDrain) {
  function TEST_F (line 1761) | TEST_F(MockHTTPUpstreamTest, Goaway) {
  function TEST_F (line 1797) | TEST_F(MockHTTPUpstreamTest, GoawayPreHeaders) {
  function TEST_F (line 1841) | TEST_F(MockHTTPUpstreamTest, NoWindowUpdateOnDrain) {
  function TEST_F (line 1921) | TEST_F(MockHTTPUpstreamTest, GetWithBody) {
  function TEST_F (line 1941) | TEST_F(MockHTTPUpstreamTest, HeaderWithEom) {
  class TestAbortPost (line 1954) | class TestAbortPost : public MockHTTPUpstreamTest {
    method doAbortTest (line 1956) | void doAbortTest() {
  function TEST_F (line 2047) | TEST_F(TestAbortPost1, Test) {
  function TEST_F (line 2050) | TEST_F(TestAbortPost2, Test) {
  function TEST_F (line 2053) | TEST_F(TestAbortPost3, Test) {
  function TEST_F (line 2056) | TEST_F(TestAbortPost4, Test) {
  function TEST_F (line 2059) | TEST_F(TestAbortPost5, Test) {
  function TEST_F (line 2063) | TEST_F(MockHTTPUpstreamTest, AbortUpgrade) {
  function TEST_F (line 2095) | TEST_F(MockHTTPUpstreamTest, DrainBeforeSendHeaders) {
  function TEST_F (line 2116) | TEST_F(MockHTTP2UpstreamTest, ReceiveDoubleGoaway) {
  function TEST_F (line 2155) | TEST_F(MockHTTP2UpstreamTest, ReceiveDoubleGoaway2) {
  function TEST_F (line 2192) | TEST_F(MockHTTP2UpstreamTest, ServerPushInvalidAssoc) {
  function TEST_F (line 2234) | TEST_F(MockHTTP2UpstreamTest, ServerPushAfterFin) {
  function TEST_F (line 2280) | TEST_F(MockHTTP2UpstreamTest, ServerPushHandlerInstallFail) {
  function TEST_F (line 2330) | TEST_F(MockHTTP2UpstreamTest, ServerPushUnhandledAssoc) {
  function TEST_F (line 2364) | TEST_F(MockHTTPUpstreamTest, HeadersThenBodyThenHeaders) {
  function TEST_F (line 2390) | TEST_F(MockHTTP2UpstreamTest, DelayUpstreamWindowUpdate) {
  function TEST_F (line 2408) | TEST_F(MockHTTPUpstreamTest, ForceShutdownInSetTransaction) {
  function TEST_F (line 2425) | TEST_F(HTTP2UpstreamSessionTest, TestReplaySafetyCallback) {
  function TEST_F (line 2446) | TEST_F(HTTP2UpstreamSessionTest, TestAlreadyReplaySafe) {
  function TEST_F (line 2458) | TEST_F(HTTP2UpstreamSessionTest, TestChainedBufIngress) {
  function TEST_F (line 2471) | TEST_F(HTTP2UpstreamSessionTest, AttachDetach) {
  function TEST_F (line 2521) | TEST_F(HTTP2UpstreamSessionTest, DetachFlowControlTimeout) {
  function TEST_F (line 2587) | TEST_F(HTTP2UpstreamSessionTest, TestPingPreserveData) {
  class H2LargeFlowControl (line 2607) | class H2LargeFlowControl : public HTTP2UpstreamSessionTest {
    method SetUp (line 2608) | void SetUp() override {
  function TEST_F (line 2619) | TEST_F(H2LargeFlowControl, WindowUpdateThresholdTest) {
  function TEST_F (line 2675) | TEST_F(HTTP2UpstreamSessionTest, TestConnectionToken) {
  function TEST_F (line 2696) | TEST_F(HTTP2UpstreamSessionTest, HTTPPriority) {
  function TEST_F (line 2705) | TEST_F(HTTP2UpstreamSessionTest, Observer_Attach_Detach_Destroy) {
  function TEST_F (line 2749) | TEST_F(HTTP2UpstreamSessionTest, Observer_RequestStarted) {

FILE: proxygen/lib/http/session/test/MockByteEventTracker.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/test/MockCodecDownstreamTest.cpp
  class MockCodecDownstreamTest (line 45) | class MockCodecDownstreamTest : public testing::Test {
    method MockCodecDownstreamTest (line 47) | MockCodecDownstreamTest()
    method onWriteChain (line 138) | void onWriteChain(folly::AsyncTransport::WriteCallback* callback,
    method SetUp (line 156) | void SetUp() override {
    method onIngressImpl (line 163) | void onIngressImpl(T f) {
  function TEST_F (line 204) | TEST_F(MockCodecDownstreamTest, OnAbortThenTimeouts) {
  function TEST_F (line 277) | TEST_F(MockCodecDownstreamTest, ServerPush) {
  function TEST_F (line 325) | TEST_F(MockCodecDownstreamTest, ServerPushAfterGoaway) {
  function TEST_F (line 403) | TEST_F(MockCodecDownstreamTest, ServerPushAbort) {
  function TEST_F (line 473) | TEST_F(MockCodecDownstreamTest, ServerPushAbortAssoc) {
  function TEST_F (line 545) | TEST_F(MockCodecDownstreamTest, ServerPushClientMessage) {
  function TEST_F (line 605) | TEST_F(MockCodecDownstreamTest, ReadTimeout) {
  function TEST_F (line 655) | TEST_F(MockCodecDownstreamTest, Ping) {
  function TEST_F (line 692) | TEST_F(MockCodecDownstreamTest, FlowControlAbort) {
  function TEST_F (line 727) | TEST_F(MockCodecDownstreamTest, Buffering) {
  function TEST_F (line 779) | TEST_F(MockCodecDownstreamTest, FlowControlWindow) {
  function TEST_F (line 863) | TEST_F(MockCodecDownstreamTest, DoubleResume) {
  function TEST_F (line 1026) | TEST_F(MockCodecDownstreamTest, ConnFlowControlBlocked) {
  function TEST_F (line 1030) | TEST_F(MockCodecDownstreamTest, ConnFlowControlTimeout) {
  function TEST_F (line 1034) | TEST_F(MockCodecDownstreamTest, UnpausedLargePost) {
  function TEST_F (line 1073) | TEST_F(MockCodecDownstreamTest, IngressPausedWindowUpdate) {
  function TEST_F (line 1125) | TEST_F(MockCodecDownstreamTest, ShutdownThenSendPushHeaders) {
  function TEST_F (line 1173) | TEST_F(MockCodecDownstreamTest, ReadIobufChainShutdown) {
  function TEST_F (line 1293) | TEST_F(MockCodecDownstreamTest, SendDoubleGoawayTimeout) {
  function TEST_F (line 1296) | TEST_F(MockCodecDownstreamTest, SendDoubleGoawayIdle) {
  function TEST_F (line 1299) | TEST_F(MockCodecDownstreamTest, SendGoawayTimeout) {
  function TEST_F (line 1302) | TEST_F(MockCodecDownstreamTest, SendGoawayIdle) {
  function TEST_F (line 1306) | TEST_F(MockCodecDownstreamTest, DropConnection) {
  function TEST_F (line 1320) | TEST_F(MockCodecDownstreamTest, DropConnectionNogoaway) {
  function TEST_F (line 1334) | TEST_F(MockCodecDownstreamTest, ShutdownThenError) {
  function TEST_F (line 1360) | TEST_F(MockCodecDownstreamTest, PingDuringShutdown) {
  function TEST_F (line 1380) | TEST_F(MockCodecDownstreamTest, SettingsAck) {
  function TEST_F (line 1388) | TEST_F(MockCodecDownstreamTest, TestSendCertificateRequest) {

FILE: proxygen/lib/http/session/test/MockHTTPSessionStats.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/test/MockHTTPTransactionObserver.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/test/MockQuicSocketDriver.h
  function namespace (line 19) | namespace quic {
  function addDatagram (line 1284) | void addDatagram(ReadDatagram datagram) {
  function setReadError (line 1288) | void setReadError(StreamId streamId) {
  function setWriteError (line 1292) | void setWriteError(StreamId streamId) {
  function addOnConnectionEndEvent (line 1297) | void addOnConnectionEndEvent(uint32_t millisecondsDelay) {
  function isPeerStream (line 1519) | bool isPeerStream(quic::StreamId id) {
  function PauseResumeResult (line 1526) | enum class PauseResumeResult { NONE = 0, PAUSED = 1, RESUMED = 2 };
  function setStreamFlowControlWindow (line 1561) | void setStreamFlowControlWindow(StreamId streamId, uint64_t windowSize) {
  function pauseWrites (line 1571) | void pauseWrites(StreamId streamId) {
  function forceStreamClose (line 1581) | void forceStreamClose(StreamId streamId) {
  function getNumWriteChainInvocations (line 1690) | uint64_t getNumWriteChainInvocations(StreamId id) {
  function maxUniStreamID_ (line 1710) | uint64_t maxUniStreamID_{0}

FILE: proxygen/lib/http/session/test/MockSecondaryAuthManager.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/session/test/MockSessionObserver.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/session/test/SecondaryAuthManagerTest.cpp
  function TEST (line 44) | TEST(SecondaryAuthManagerTest, AuthenticatorRequest) {
  function TEST (line 64) | TEST(SecondaryAuthManagerTest, Authenticator) {

FILE: proxygen/lib/http/session/test/TestUtils.cpp
  type proxygen (line 15) | namespace proxygen {
    function makeInternalTimeoutSet (line 21) | folly::HHWheelTimer::UniquePtr makeInternalTimeoutSet(EventBase* evb) {
    function makeTimeoutSet (line 30) | folly::HHWheelTimer::UniquePtr makeTimeoutSet(EventBase* evb) {

FILE: proxygen/lib/http/session/test/TestUtils.h
  function namespace (line 20) | namespace proxygen {

FILE: proxygen/lib/http/session/test/WebTransportFilterTest.cpp
  class MockWebTransportFilter (line 25) | class MockWebTransportFilter : public WebTransportFilter {
    method MockWebTransportFilter (line 27) | MockWebTransportFilter(HTTPTransaction* txn, CodecVersion version)
  class WebTransportFilterTest (line 120) | class WebTransportFilterTest : public Test {
    method SetUp (line 122) | void SetUp() override {
    method TearDown (line 146) | void TearDown() override {
    method createCloseSessionCapsule (line 150) | std::unique_ptr<folly::IOBuf> createCloseSessionCapsule(
  function TEST_F (line 167) | TEST_F(WebTransportFilterTest, OnCloseWebTransportSessionCapsule) {
  function TEST_F (line 180) | TEST_F(WebTransportFilterTest, OnCloseWebTransportSessionCapsuleNoHandle...
  function TEST_F (line 189) | TEST_F(WebTransportFilterTest, MultipleCapsulesInOneBody) {
  function TEST_F (line 213) | TEST_F(WebTransportFilterTest, StreamCreationLimits) {
  function TEST_F (line 262) | TEST_F(WebTransportFilterTest,
  function TEST_F (line 310) | TEST_F(WebTransportFilterTest,

FILE: proxygen/lib/http/sink/FlowControlInfo.h
  type FlowControlInfo (line 12) | struct FlowControlInfo {
  function streamSendOutstanding_ (line 22) | int64_t streamSendOutstanding_{-1};

FILE: proxygen/lib/http/sink/HTTPSink.h
  function namespace (line 15) | namespace folly {
  function namespace (line 18) | namespace quic {
  function namespace (line 22) | namespace proxygen {

FILE: proxygen/lib/http/sink/HTTPTransactionSink.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/http/sink/HTTPTransactionSink.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/sink/HTTPTunnelSink.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/sink/HTTPTunnelSink.h
  function namespace (line 16) | namespace proxygen {
  function override (line 40) | const override {
  function CodecProtocol (line 44) | [[nodiscard]] CodecProtocol getCodecProtocol() const override {
  function folly (line 53) | [[nodiscard]] const folly::SocketAddress& getPeerAddress() const override {
  function override (line 62) | const override {
  function getTCPTransportFD (line 66) | [[nodiscard]] int getTCPTransportFD() const override {
  function CompressionInfo (line 83) | [[nodiscard]] CompressionInfo getHeaderCompressionInfo() const override {
  function sendChunkHeader (line 104) | void sendChunkHeader(size_t) override {
  function sendChunkTerminator (line 107) | void sendChunkTerminator() override {
  function sendTrailers (line 110) | void sendTrailers(const HTTPHeaders&) override {
  function sendPadding (line 113) | void sendPadding(uint16_t) override {
  function sendEOM (line 116) | void sendEOM() override;
  function trackEgressBodyOffset (line 125) | bool trackEgressBodyOffset(uint64_t, ByteEventFlags) override {
  function wangle (line 134) | const wangle::TransportInfo& getSetupTransportInfo() const noexcept over...
  function timeoutExpired (line 152) | void timeoutExpired() noexcept override;
  function describe (line 162) | void describe(std::ostream& os) override {
  function readEOF (line 171) | void readEOF() noexcept override;
  function outstandingWrites_ (line 202) | uint8_t outstandingWrites_{0}
  function egressEOMSeen_ (line 205) | bool egressEOMSeen_{false};

FILE: proxygen/lib/http/sink/test/HTTPConnectSinkTest.cpp
  type proxygen (line 19) | namespace proxygen {
    class TestHTTPConnectSink (line 24) | class TestHTTPConnectSink : public HTTPConnectSink {
    class HTTPConnectSinkTest (line 35) | class HTTPConnectSinkTest : public Test {
      method SetUp (line 37) | void SetUp() override {
      method TearDown (line 47) | void TearDown() override {
    function TEST_F (line 65) | TEST_F(HTTPConnectSinkTest, test_egress_backpressure) {
    function TEST_F (line 102) | TEST_F(HTTPConnectSinkTest, test_ingress_control) {
    function TEST_F (line 118) | TEST_F(HTTPConnectSinkTest, test_bytes_read) {
    function sleep_evb (line 137) | void sleep_evb(folly::EventBase *evb, std::chrono::milliseconds timeou...
    function TEST_F (line 145) | TEST_F(HTTPConnectSinkTest, test_idle_timeout) {
    function TEST_F (line 180) | TEST_F(HTTPConnectSinkTest, test_delayed_destruction) {
    function TEST_F (line 200) | TEST_F(HTTPConnectSinkTest, test_destruction_on_abort) {
    function TEST_F (line 213) | TEST_F(HTTPConnectSinkTest, test_ingress_eom) {
    function TEST_F (line 226) | TEST_F(HTTPConnectSinkTest, test_send_abort) {
    function TEST_F (line 232) | TEST_F(HTTPConnectSinkTest, test_read_error) {
    function TEST_F (line 239) | TEST_F(HTTPConnectSinkTest, test_read_error_with_abort) {
    function TEST_F (line 248) | TEST_F(HTTPConnectSinkTest, test_write_error) {
    function TEST_F (line 262) | TEST_F(HTTPConnectSinkTest, test_write_error_with_abort) {

FILE: proxygen/lib/http/stats/ConnectionStats.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/stats/ConnectionStats.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/http/stats/HTTPCodecStats.cpp
  type proxygen (line 34) | namespace proxygen {

FILE: proxygen/lib/http/stats/HTTPCodecStats.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/stats/HTTPCodecStatsFilter.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/http/stats/HTTPCodecStatsFilter.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/stats/HeaderCodecStats.cpp
  type proxygen (line 21) | namespace proxygen {

FILE: proxygen/lib/http/stats/HeaderCodecStats.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/stats/HttpServerStats.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/stats/ResponseCodeStatsMinute.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/stats/ResponseCodeStatsMinute.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/stats/TLResponseCodeStats.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/http/stats/TLResponseCodeStats.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/http/stats/ThreadLocalHTTPSessionStats.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/http/stats/ThreadLocalHTTPSessionStats.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersBuffer.cpp
  type proxygen (line 19) | namespace proxygen {
    function DecodeError (line 23) | DecodeError StructuredHeadersBuffer::parseItem(StructuredHeaderItem& r...
    function DecodeError (line 44) | DecodeError StructuredHeadersBuffer::parseNumber(StructuredHeaderItem&...
    function DecodeError (line 100) | DecodeError StructuredHeadersBuffer::parseBoolean(
    function DecodeError (line 123) | DecodeError StructuredHeadersBuffer::parseBinaryContent(
    function DecodeError (line 163) | DecodeError StructuredHeadersBuffer::parseIdentifier(
    function DecodeError (line 178) | DecodeError StructuredHeadersBuffer::parseIdentifier(std::string& resu...
    function DecodeError (line 200) | DecodeError StructuredHeadersBuffer::parseInteger(
    function DecodeError (line 211) | DecodeError StructuredHeadersBuffer::parseFloat(const std::string& input,
    function DecodeError (line 222) | DecodeError StructuredHeadersBuffer::parseString(StructuredHeaderItem&...
    function DecodeError (line 265) | DecodeError StructuredHeadersBuffer::removeOptionalWhitespace() {
    function DecodeError (line 272) | DecodeError StructuredHeadersBuffer::removeSymbol(const std::string& s...
    function DecodeError (line 286) | DecodeError StructuredHeadersBuffer::handleDecodeError(const DecodeErr...

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersBuffer.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersConstants.cpp
  type proxygen::StructuredHeaders (line 12) | namespace proxygen::StructuredHeaders {
    function decodeErrToString (line 14) | std::string_view decodeErrToString(DecodeError err) {
    function encodeErrToString (line 42) | std::string_view encodeErrToString(EncodeError err) {

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersConstants.h
  function namespace (line 17) | namespace proxygen::StructuredHeaders {
  type ParameterisedIdentifier (line 65) | struct ParameterisedIdentifier {
  function DecodeError (line 75) | enum class DecodeError : uint8_t {

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersDecoder.cpp
  type proxygen (line 11) | namespace proxygen {
    function DecodeError (line 15) | DecodeError StructuredHeadersDecoder::decodeItem(StructuredHeaderItem&...
    function DecodeError (line 25) | DecodeError StructuredHeadersDecoder::decodeList(
    function DecodeError (line 59) | DecodeError StructuredHeadersDecoder::decodeDictionary(Dictionary& res...
    function DecodeError (line 63) | DecodeError StructuredHeadersDecoder::decodeParameterisedList(
    function DecodeError (line 101) | DecodeError StructuredHeadersDecoder::decodeMap(

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersDecoder.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.cpp
  type proxygen (line 14) | namespace proxygen {
    function EncodeError (line 18) | EncodeError StructuredHeadersEncoder::encodeList(
    function EncodeError (line 39) | EncodeError StructuredHeadersEncoder::encodeDictionary(
    function EncodeError (line 71) | EncodeError StructuredHeadersEncoder::encodeParameterisedList(
    function EncodeError (line 121) | EncodeError StructuredHeadersEncoder::encodeItem(
    function EncodeError (line 144) | EncodeError StructuredHeadersEncoder::encodeBinaryContent(
    function EncodeError (line 154) | EncodeError StructuredHeadersEncoder::encodeString(const std::string& ...
    function EncodeError (line 186) | EncodeError StructuredHeadersEncoder::encodeInteger(int64_t input) {
    function EncodeError (line 198) | EncodeError StructuredHeadersEncoder::encodeBoolean(bool input) {
    function EncodeError (line 205) | EncodeError StructuredHeadersEncoder::encodeFloat(double input) {
    function EncodeError (line 212) | EncodeError StructuredHeadersEncoder::encodeIdentifier(
    function EncodeError (line 224) | EncodeError StructuredHeadersEncoder::handleEncodeError(
    function EncodeError (line 232) | EncodeError StructuredHeadersEncoder::handleEncodeError(EncodeError er...

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersEncoder.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersUtilities.cpp
  type proxygen::StructuredHeaders (line 12) | namespace proxygen::StructuredHeaders {
    function isAlpha (line 14) | bool isAlpha(uint8_t c) {
    function isLcAlpha (line 18) | bool isLcAlpha(char c) {
    function isDigit (line 22) | bool isDigit(char c) {
    function isValidIdentifierChar (line 26) | bool isValidIdentifierChar(char c) {
    function isValidEncodedBinaryContentChar (line 31) | bool isValidEncodedBinaryContentChar(char c) {
    function isValidStringChar (line 35) | bool isValidStringChar(char c) {
    function isValidIdentifier (line 46) | bool isValidIdentifier(const std::string& s) {
    function isValidString (line 60) | bool isValidString(const std::string& s) {
    function isValidEncodedBinaryContent (line 69) | bool isValidEncodedBinaryContent(const std::string& s) {
    function itemTypeMatchesContent (line 87) | bool itemTypeMatchesContent(const StructuredHeaderItem& input) {

FILE: proxygen/lib/http/structuredheaders/StructuredHeadersUtilities.h
  function namespace (line 14) | namespace proxygen::StructuredHeaders {

FILE: proxygen/lib/http/structuredheaders/test/StructuredHeadersBufferTest.cpp
  type proxygen (line 16) | namespace proxygen {
    class StructuredHeadersBufferTest (line 18) | class StructuredHeadersBufferTest : public testing::Test {}
    function TEST_F (line 20) | TEST_F(StructuredHeadersBufferTest, TestBinaryContent) {
    function TEST_F (line 30) | TEST_F(StructuredHeadersBufferTest, TestBinaryContentIllegalCharacters) {
    function TEST_F (line 38) | TEST_F(StructuredHeadersBufferTest, TestBinaryContentNoEndingAsterisk) {
    function TEST_F (line 46) | TEST_F(StructuredHeadersBufferTest, TestBinaryContentEmpty) {
    function TEST_F (line 56) | TEST_F(StructuredHeadersBufferTest, TestIdentifier) {
    function TEST_F (line 66) | TEST_F(StructuredHeadersBufferTest, TestIdentifierAllLegalCharacters) {
    function TEST_F (line 76) | TEST_F(StructuredHeadersBufferTest, TestIdentifierBeginningUnderscore) {
    function TEST_F (line 84) | TEST_F(StructuredHeadersBufferTest, TestString) {
    function TEST_F (line 94) | TEST_F(StructuredHeadersBufferTest, TestStringEscapedQuote) {
    function TEST_F (line 104) | TEST_F(StructuredHeadersBufferTest, TestStringEscapedBackslash) {
    function TEST_F (line 114) | TEST_F(StructuredHeadersBufferTest, TestStringStrayBackslash) {
    function TEST_F (line 122) | TEST_F(StructuredHeadersBufferTest, TestStringInvalidCharacter) {
    function TEST_F (line 130) | TEST_F(StructuredHeadersBufferTest, TestStringParsingRepeated) {
    function TEST_F (line 145) | TEST_F(StructuredHeadersBufferTest, TestInteger) {
    function TEST_F (line 155) | TEST_F(StructuredHeadersBufferTest, TestIntegerTwoNegatives) {
    function TEST_F (line 163) | TEST_F(StructuredHeadersBufferTest, TestIntegerEmptyAfterNegative) {
    function TEST_F (line 171) | TEST_F(StructuredHeadersBufferTest, TestIntegerNegative) {
    function TEST_F (line 181) | TEST_F(StructuredHeadersBufferTest, TestIntegerOverflow) {
    function TEST_F (line 189) | TEST_F(StructuredHeadersBufferTest, TestIntegerHighBorderline) {
    function TEST_F (line 199) | TEST_F(StructuredHeadersBufferTest, TestIntegerLowBorderline) {
    function TEST_F (line 209) | TEST_F(StructuredHeadersBufferTest, TestIntegerUnderflow) {
    function TEST_F (line 217) | TEST_F(StructuredHeadersBufferTest, TestBool) {
    function TEST_F (line 230) | TEST_F(StructuredHeadersBufferTest, TestBoolInvalidChars) {
    function TEST_F (line 238) | TEST_F(StructuredHeadersBufferTest, TestBoolWrongLength) {
    function TEST_F (line 251) | TEST_F(StructuredHeadersBufferTest, TestBool2) {
    function TEST_F (line 260) | TEST_F(StructuredHeadersBufferTest, TestFloat) {
    function TEST_F (line 270) | TEST_F(StructuredHeadersBufferTest, TestFloatPrecedingWhitespace) {
    function TEST_F (line 280) | TEST_F(StructuredHeadersBufferTest, TestFloatNoDigitPrecedingDecimal) {
    function TEST_F (line 288) | TEST_F(StructuredHeadersBufferTest, TestIntegerTooManyChars) {
    function TEST_F (line 296) | TEST_F(StructuredHeadersBufferTest, TestFloatTooManyChars) {
    function TEST_F (line 304) | TEST_F(StructuredHeadersBufferTest, TestFloatBorderlineNumChars) {
    function TEST_F (line 313) | TEST_F(StructuredHeadersBufferTest, TestFloatEndsWithDecimal) {
    function TEST_F (line 321) | TEST_F(StructuredHeadersBufferTest, TestConsumeComma) {
    function TEST_F (line 332) | TEST_F(StructuredHeadersBufferTest, TestConsumeEquals) {
    function TEST_F (line 343) | TEST_F(StructuredHeadersBufferTest, TestConsumeMessy) {
    function TEST_F (line 356) | TEST_F(StructuredHeadersBufferTest, TestInequalityOperator) {

FILE: proxygen/lib/http/structuredheaders/test/StructuredHeadersDecoderTest.cpp
  type proxygen (line 14) | namespace proxygen {
    class StructuredHeadersDecoderTest (line 16) | class StructuredHeadersDecoderTest : public testing::Test {}
    function TEST_F (line 18) | TEST_F(StructuredHeadersDecoderTest, TestItem) {
    function TEST_F (line 29) | TEST_F(StructuredHeadersDecoderTest, TestList) {
    function TEST_F (line 46) | TEST_F(StructuredHeadersDecoderTest, TestListBeginningWhitespace) {
    function TEST_F (line 61) | TEST_F(StructuredHeadersDecoderTest, TestListEndingWhitespace) {
    function TEST_F (line 76) | TEST_F(StructuredHeadersDecoderTest, TestListNoWhitespace) {
    function TEST_F (line 91) | TEST_F(StructuredHeadersDecoderTest, TestListOneItem) {
    function TEST_F (line 104) | TEST_F(StructuredHeadersDecoderTest, TestDictionaryManyElts) {
    function TEST_F (line 121) | TEST_F(StructuredHeadersDecoderTest, TestDictionaryOneElt) {
    function TEST_F (line 133) | TEST_F(StructuredHeadersDecoderTest, TestParamListOneElt) {
    function TEST_F (line 146) | TEST_F(StructuredHeadersDecoderTest, TestParamListManyElts) {
    function TEST_F (line 172) | TEST_F(StructuredHeadersDecoderTest, TestParamListNoParams) {
    function TEST_F (line 189) | TEST_F(StructuredHeadersDecoderTest, TestParamListWhitespace) {
    function TEST_F (line 206) | TEST_F(StructuredHeadersDecoderTest, TestParamListNullValues) {
    function TEST_F (line 231) | TEST_F(StructuredHeadersDecoderTest, PriorityWithIncremental) {
    function TEST_F (line 245) | TEST_F(StructuredHeadersDecoderTest, PriorityWithoutIncremental) {
    function TEST_F (line 257) | TEST_F(StructuredHeadersDecoderTest, PriorityWithoutIncrementalHasComm...
    function TEST_F (line 265) | TEST_F(StructuredHeadersDecoderTest, SpaceOnlyNoCrash) {

FILE: proxygen/lib/http/structuredheaders/test/StructuredHeadersEncoderTest.cpp
  type proxygen (line 18) | namespace proxygen {
    class StructuredHeadersEncoderTest (line 20) | class StructuredHeadersEncoderTest : public testing::Test {}
    function TEST_F (line 22) | TEST_F(StructuredHeadersEncoderTest, TestInteger) {
    function TEST_F (line 35) | TEST_F(StructuredHeadersEncoderTest, TestIntegerNegative) {
    function TEST_F (line 48) | TEST_F(StructuredHeadersEncoderTest, TestBoolean) {
    function TEST_F (line 63) | TEST_F(StructuredHeadersEncoderTest, TestFloat) {
    function TEST_F (line 76) | TEST_F(StructuredHeadersEncoderTest, TestFloatTooMuchPrecision) {
    function TEST_F (line 89) | TEST_F(StructuredHeadersEncoderTest, TestFloatNegative) {
    function TEST_F (line 102) | TEST_F(StructuredHeadersEncoderTest, TestString) {
    function TEST_F (line 115) | TEST_F(StructuredHeadersEncoderTest, TestStringBadContent) {
    function TEST_F (line 127) | TEST_F(StructuredHeadersEncoderTest, TestStringBackslash) {
    function TEST_F (line 140) | TEST_F(StructuredHeadersEncoderTest, TestStringQuote) {
    function TEST_F (line 153) | TEST_F(StructuredHeadersEncoderTest, TestBinaryContent) {
    function TEST_F (line 166) | TEST_F(StructuredHeadersEncoderTest, TestIdentifier) {
    function TEST_F (line 177) | TEST_F(StructuredHeadersEncoderTest, TestIdentifierBadContent) {
    function TEST_F (line 187) | TEST_F(StructuredHeadersEncoderTest, TestWrongType) {
    function TEST_F (line 199) | TEST_F(StructuredHeadersEncoderTest, TestListManyElts) {
    function TEST_F (line 225) | TEST_F(StructuredHeadersEncoderTest, TestListOneElt) {
    function TEST_F (line 241) | TEST_F(StructuredHeadersEncoderTest, TestListEmpty) {
    function TEST_F (line 250) | TEST_F(StructuredHeadersEncoderTest, TestListBadItem) {
    function TEST_F (line 265) | TEST_F(StructuredHeadersEncoderTest, TestDictionaryOneElt) {
    function TEST_F (line 282) | TEST_F(StructuredHeadersEncoderTest, TestDictionaryWithTrueBoolean) {
    function TEST_F (line 295) | TEST_F(StructuredHeadersEncoderTest, TestDictionaryWithFalseBoolean) {
    function TEST_F (line 308) | TEST_F(StructuredHeadersEncoderTest, TestDictionaryManyElts) {
    function TEST_F (line 343) | TEST_F(StructuredHeadersEncoderTest, TestDictionaryEmpty) {
    function TEST_F (line 352) | TEST_F(StructuredHeadersEncoderTest, TestDictionaryBadItem) {
    function TEST_F (line 368) | TEST_F(StructuredHeadersEncoderTest, TestDictionaryBadIdentifier) {
    function TEST_F (line 384) | TEST_F(StructuredHeadersEncoderTest, TestParamListOneElt) {
    function TEST_F (line 407) | TEST_F(StructuredHeadersEncoderTest, TestParamListSuccessiveNulls) {
    function TEST_F (line 429) | TEST_F(StructuredHeadersEncoderTest, TestParamListManyElts) {
    function TEST_F (line 482) | TEST_F(StructuredHeadersEncoderTest, TestParamListEmpty) {
    function TEST_F (line 490) | TEST_F(StructuredHeadersEncoderTest, TestParamListBadSecondaryIdentifi...
    function TEST_F (line 511) | TEST_F(StructuredHeadersEncoderTest, TestParamListBadPrimaryIdentifier) {
    function TEST_F (line 532) | TEST_F(StructuredHeadersEncoderTest, TestParamListBadItems) {

FILE: proxygen/lib/http/structuredheaders/test/StructuredHeadersStandardTest.cpp
  type proxygen (line 15) | namespace proxygen {
    class StructuredHeadersStandardTest (line 66) | class StructuredHeadersStandardTest : public testing::Test {
      method decode32 (line 68) | bool decode32(std::string input, std::string& output) {
      method convertBase32ToBinary (line 108) | std::string convertBase32ToBinary(const std::string& input) {
      method decode32Block (line 134) | bool decode32Block(std::string input,
    class LegalStringTests (line 177) | class LegalStringTests
    class LegalBinaryContentTests (line 182) | class LegalBinaryContentTests
    class LegalIntegerTests (line 187) | class LegalIntegerTests
    class LegalFloatTests (line 191) | class LegalFloatTests
    class IllegalItemTest (line 195) | class IllegalItemTest
    class IllegalListTest (line 199) | class IllegalListTest
    function TEST_P (line 203) | TEST_P(LegalStringTests, LegalStrings) {
    function TEST_P (line 213) | TEST_P(LegalBinaryContentTests, LegalBinaryContent) {
    function TEST_P (line 227) | TEST_P(LegalIntegerTests, LegalIntegers) {
    function TEST_P (line 237) | TEST_P(LegalFloatTests, LegalFloats) {
    function TEST_P (line 247) | TEST_P(IllegalItemTest, IllegalItem) {
    function TEST_P (line 254) | TEST_P(IllegalListTest, IllegalList) {
    function TEST_F (line 285) | TEST_F(StructuredHeadersStandardTest, TestBasicList) {
    function TEST_F (line 302) | TEST_F(StructuredHeadersStandardTest, TestSingleItemList) {
    function TEST_F (line 317) | TEST_F(StructuredHeadersStandardTest, TestNoWhitespaceList) {
    function TEST_F (line 334) | TEST_F(StructuredHeadersStandardTest, TestExtraWhitespaceList) {

FILE: proxygen/lib/http/structuredheaders/test/StructuredHeadersUtilitiesTest.cpp
  type proxygen::StructuredHeaders (line 14) | namespace proxygen::StructuredHeaders {
    class StructuredHeadersUtilitiesTest (line 16) | class StructuredHeadersUtilitiesTest : public testing::Test {}
    function TEST_F (line 18) | TEST_F(StructuredHeadersUtilitiesTest, TestLcalpha) {
    function TEST_F (line 29) | TEST_F(StructuredHeadersUtilitiesTest, TestIsValidIdentifierChar) {
    function TEST_F (line 41) | TEST_F(StructuredHeadersUtilitiesTest,
    function TEST_F (line 49) | TEST_F(StructuredHeadersUtilitiesTest,
    function TEST_F (line 56) | TEST_F(StructuredHeadersUtilitiesTest,
    function TEST_F (line 64) | TEST_F(StructuredHeadersUtilitiesTest, TestIsValidStringCharAllowed) {
    function TEST_F (line 74) | TEST_F(StructuredHeadersUtilitiesTest, TestIsValidStringCharDisallowed) {
    function TEST_F (line 81) | TEST_F(StructuredHeadersUtilitiesTest, TestIsValidIdentifierAllowed) {
    function TEST_F (line 87) | TEST_F(StructuredHeadersUtilitiesTest, TestIsValidIdentifierDisallowed) {
    function TEST_F (line 94) | TEST_F(StructuredHeadersUtilitiesTest, TestIsValidStringAllowed) {
    function TEST_F (line 101) | TEST_F(StructuredHeadersUtilitiesTest, TestIsValidStringDisallowed) {
    function TEST_F (line 108) | TEST_F(StructuredHeadersUtilitiesTest, TestGoodBinaryContent) {
    function TEST_F (line 114) | TEST_F(StructuredHeadersUtilitiesTest, TestBadBinaryContent) {
    function TEST_F (line 121) | TEST_F(StructuredHeadersUtilitiesTest, TestItemTypeMatchesContentGood) {
    function TEST_F (line 147) | TEST_F(StructuredHeadersUtilitiesTest, TestItemTypeMatchesContentBad) {

FILE: proxygen/lib/http/test/HTTPCommonHeadersTests.cpp
  class HTTPCommonHeadersTests (line 14) | class HTTPCommonHeadersTests : public testing::Test {}
  function TEST_F (line 16) | TEST_F(HTTPCommonHeadersTests, TestHashing) {
  function TEST_F (line 31) | TEST_F(HTTPCommonHeadersTests, TestTwoTablesInitialized) {
  function TEST_F (line 41) | TEST_F(HTTPCommonHeadersTests, TestIsCommonHeaderNameFromTable) {
  function TEST_F (line 73) | TEST_F(HTTPCommonHeadersTests, TestGetHeaderCodeFromTableCommonHeaderNam...

FILE: proxygen/lib/http/test/HTTPConnectorWithFizzTest.cpp
  class MockHTTPConnectorCallback (line 23) | class MockHTTPConnectorCallback : public HTTPConnector::Callback {
  class HTTPConnectorWithFizzTest (line 31) | class HTTPConnectorWithFizzTest : public testing::Test {
    method HTTPConnectorWithFizzTest (line 33) | HTTPConnectorWithFizzTest()
    method SetUp (line 37) | void SetUp() override {
    class DummyCallbackFactory (line 53) | class DummyCallbackFactory
      method DummyCallbackFactory (line 56) | explicit DummyCallbackFactory(fizz::server::test::MockHandshakeCallb...
    method SetupFailureCallbacks (line 71) | void SetupFailureCallbacks() {
  function TEST_F (line 94) | TEST_F(HTTPConnectorWithFizzTest, TestFizzConnect) {
  function TEST_F (line 113) | TEST_F(HTTPConnectorWithFizzTest, TestFizzConnectFailure) {

FILE: proxygen/lib/http/test/HTTPHeadersBenchmark.cpp
  function getTestHeaderCodes (line 30) | std::vector<HTTPHeaderCode> getTestHeaderCodes() {
  function getTestHeaderStrings (line 40) | std::vector<const std::string*> getTestHeaderStrings() {
  function HTTPCommonHeadersHashBench (line 61) | void HTTPCommonHeadersHashBench(int iters) {
  function HTTPCommonHeadersGetHeaderCodeFromTableCommonHeaderNameBench (line 69) | void HTTPCommonHeadersGetHeaderCodeFromTableCommonHeaderNameBench(int it...
  function BENCHMARK (line 80) | BENCHMARK(HTTPCommonHeadersHash, iters) {
  function BENCHMARK (line 84) | BENCHMARK(HTTPCommonHeadersGetHeaderCodeFromTableCommonHeaderName, iters) {
  function memchrBench (line 88) | void memchrBench(int iters) {
  function stdFindBench (line 100) | void stdFindBench(int iters) {
  function BENCHMARK (line 114) | BENCHMARK(memchr, iters) {
  function BENCHMARK (line 118) | BENCHMARK(stdFind, iters) {
  function addCodeBench (line 122) | void addCodeBench(int nHeaders, int hdrSize, int iters) {
  function BENCHMARK (line 132) | BENCHMARK(addCode4_headers_8_length, iters) {
  function BENCHMARK (line 136) | BENCHMARK(addCode4_headers_32_length, iters) {
  function BENCHMARK (line 140) | BENCHMARK(addCode16_headers_8_length, iters) {
  function BENCHMARK (line 144) | BENCHMARK(addCode16_headers_32_length, iters) {
  function BENCHMARK (line 148) | BENCHMARK(addCode24_headers_8_length, iters) {
  function BENCHMARK (line 152) | BENCHMARK(addCode24_headers_32_length, iters) {
  function main (line 156) | int main(int argc, char** argv) {

FILE: proxygen/lib/http/test/HTTPMessageFilterTest.cpp
  class TestFilter (line 16) | class TestFilter : public HTTPMessageFilter {
    method clone (line 17) | std::unique_ptr<HTTPMessageFilter> clone() noexcept override {
  function TEST (line 22) | TEST(HTTPMessageFilter, TestFilterPauseResumePropagatedToFilter) {
  function TEST (line 50) | TEST(HTTPMessageFilter, TestFilterPauseResumePropagatedToTxn) {
  function TEST (line 82) | TEST(HTTPMessageFilter, TestFilterOnBodyDataTracking) {
  function TEST (line 117) | TEST(HTTPMessageFilter, TestFilterPauseResumeAfterTxnDetached) {
  function TEST (line 147) | TEST(HTTPMessageFilter, TestFilterDetachHandlerFromTransaction) {
  function TEST (line 163) | TEST(HTTPMessageFilter, TestFilterDetachHandlerNoTransaction) {

FILE: proxygen/lib/http/test/HTTPMessageTest.cpp
  function TEST (line 19) | TEST(HTTPMessage, TestParseCookiesSimple) {
  function TEST (line 28) | TEST(HTTPMessage, TestParseCookiesSpaces) {
  function TEST (line 36) | TEST(HTTPMessage, TestParseCookiesSingleCookie) {
  function TEST (line 43) | TEST(HTTPMessage, TestParseCookiesMultipleCookies) {
  function TEST (line 58) | TEST(HTTPMessage, TestRemoveCookie) {
  function TEST (line 91) | TEST(HTTPMessage, TestRemoveCookieNonExistent) {
  function TEST (line 110) | TEST(HTTPMessage, TestRemoveCookieEmptyHeader) {
  function TEST (line 120) | TEST(HTTPMessage, TestParseQueryParamsSimple) {
  function TEST (line 148) | TEST(HTTPMessage, TestParseQueryParamsComplex) {
  function TEST (line 193) | TEST(HTTPMessage, SetInvalidURL) {
  function TEST (line 202) | TEST(HTTPMessage, SetURLEmpty) {
  function TEST (line 210) | TEST(HTTPMessage, SetAbsoluteURLNoPath) {
  function TEST (line 221) | TEST(HTTPMessage, TestHeaderPreservation) {
  function TEST (line 235) | TEST(HTTPMessage, TestHeaderRemove) {
  function TEST (line 249) | TEST(HTTPMessage, TestAllVersionsHeaderRemove) {
  function TEST (line 267) | TEST(HTTPMessage, TestSetHeader) {
  function TEST (line 286) | TEST(HTTPMessage, TestCombine) {
  function TEST (line 304) | TEST(HTTPMessage, TestProxification) {
  function TEST (line 319) | TEST(HTTPMessage, TestSetClientAddress) {
  function TEST (line 337) | TEST(HTTPMessage, BizarreVersions) {
  function TEST (line 346) | TEST(HTTPMessage, TestKeepaliveCheck) {
  function TEST (line 450) | TEST(HTTPMessage, TestHeaderStripPerHop) {
  function TEST (line 480) | TEST(HTTPMessage, TestEmptyName) {
  function TEST (line 485) | TEST(HTTPMessage, TestMethod) {
  function testPathAndQuery (line 501) | void testPathAndQuery(const string& url,
  function TEST (line 514) | TEST(GetPathAndQuery, ParseURL) {
  function TEST (line 522) | TEST(HTTPMessage, CheckHeaderForToken) {
  function TEST (line 540) | TEST(HTTPHeaders, AddStringPiece) {
  function TEST (line 550) | TEST(HTTPHeaders, InitializerList) {
  function TEST (line 563) | TEST(HTTPHeaders, InitializerListStringView) {
  function testRemoveQueryParam (line 575) | void testRemoveQueryParam(const string& url,
  function TEST (line 588) | TEST(HTTPMessage, RemoveQueryParamTests) {
  function testSetQueryParam (line 611) | void testSetQueryParam(const string& url,
  function TEST (line 625) | TEST(HTTPMessage, SetQueryParamTests) {
  function TEST (line 652) | TEST(HTTPMessage, TestCheckForHeaderToken) {
  function TEST (line 663) | TEST(HTTPMessage, TestProtocolStringHTTPVersion) {
  function TEST (line 670) | TEST(HTTPMessage, TestProtocolStringAdvancedProtocol) {
  function TEST (line 677) | TEST(HTTPMessage, TestExtractTrailers) {
  function TEST (line 688) | TEST(HTTPMessage, TestMoveCopy) {
  function TEST (line 701) | TEST(HTTPHeaders, GrowTest) {
  function TEST (line 710) | TEST(HTTPHeaders, ClearTest) {
  function copyAndMoveTest (line 724) | void copyAndMoveTest(size_t multiplier) {
  function TEST (line 743) | TEST(HTTPHeaders, CopyAndMoveTest) {
  function checkPrettyPrint (line 749) | void checkPrettyPrint(const HTTPHeaders& h) {
  function TEST (line 753) | TEST(HTTPHeaders, PrettyPrint) {
  function checkPrettyPrintMsg (line 762) | void checkPrettyPrintMsg(const HTTPMessage& m) {
  function TEST (line 766) | TEST(HTTPMessage, PrettyPrint) {
  function TEST (line 790) | TEST(HTTPMessage, NoDefaultHTTPPriority) {
  function TEST (line 795) | TEST(HTTPMessage, HTTPPrioritySetGet) {
  function TEST (line 815) | TEST(HTTPMessage, HTTPPrioritySetOutRangeUrgency) {
  function TEST (line 827) | TEST(HTTPMessage, HTTPPriorityOrderIdSetGet) {
  function TEST (line 838) | TEST(HTTPMessage, HTTPPriorityPausedSetGet) {
  function TEST (line 846) | TEST(HTTPHeaders, GetSetOnResize) {
  function TEST (line 860) | TEST(HTTPHeaders, MoveFromTest) {
  function TEST (line 875) | TEST(HTTPMessage, DefaultSchemeHttp) {
  function TEST (line 881) | TEST(HTTPMessage, SchemeHttps) {
  function TEST (line 891) | TEST(HTTPMessage, SchemeMasque) {
  function TEST (line 906) | TEST(HTTPMessage, StrictMode) {
  function TEST (line 937) | TEST(HTTPMessage, GetSingleOrNullptr) {
  function TEST (line 973) | TEST(HTTPMessage, BadAPIUsage) {

FILE: proxygen/lib/http/test/HTTPPriorityFunctionsTest.cpp
  function TEST (line 16) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderUrgencyOnly) {
  function TEST (line 34) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderIncrementalOnly) {
  function TEST (line 66) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderWhiteSpace) {
  function TEST (line 79) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderUrgencyAndIncremental) {
  function TEST (line 88) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderUrgencyAndIncrementalUpper...
  function TEST (line 95) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderBadUrgency) {
  function TEST (line 125) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderBadIncremental) {
  function TEST (line 132) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderBadPaused) {
  function TEST (line 139) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderDefaultOrderId) {
  function TEST (line 146) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderCustomOrderId) {
  function TEST (line 154) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderDefaultUnpaused) {
  function TEST (line 161) | TEST(HTTPPriorityFunctionsTest, PriorityHeaderPaused) {

FILE: proxygen/lib/http/test/MockHTTPHeaders.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/http/test/MockHTTPMessageFilter.h
  function namespace (line 16) | namespace proxygen {
  function trackHeadersPassedThrough_ (line 109) | bool trackHeadersPassedThrough_{false};

FILE: proxygen/lib/http/test/ProxyStatusTest.cpp
  function TEST (line 18) | TEST(ProxyStatusTest, TestUpdatingStatusType) {
  function TEST (line 40) | TEST(ProxyStatusTest, TestStatusSerialization) {
  function TEST (line 55) | TEST(ProxyStatusTest, TestEmpty) {
  function TEST (line 68) | TEST(ProxyStatusTest, TestMissingStatus) {
  function TEST (line 82) | TEST(ProxyStatusTest, TestUpstreamIP) {
  function TEST (line 102) | TEST(ProxyStatusTest, TestProxy) {
  function TEST (line 119) | TEST(ProxyStatusTest, TestSerialization) {
  function TEST (line 149) | TEST(ProxyStatusTest, TestSetProxyError) {
  function TEST (line 167) | TEST(ProxyStatusTest, TestSetServerError) {
  function TEST (line 185) | TEST(ProxyStatusTest, TestSetClientError) {

FILE: proxygen/lib/http/test/RFC2616Test.cpp
  function TEST (line 18) | TEST(QvalueTest, Basic) {
  function TEST (line 96) | TEST(QvalueTest, Extras) {
  function TEST (line 108) | TEST(QvalueTest, Invalids) {
  function TEST (line 130) | TEST(ParseEncodingTest, Simple) {
  function TEST (line 139) | TEST(ParseEncodingTest, Whitespace) {
  function TEST (line 148) | TEST(ParseEncodingTest, Invalid) {
  function TEST (line 167) | TEST(AcceptEncodingTest, Simple) {
  function TEST (line 174) | TEST(AcceptEncodingTest, QValues) {
  function TEST (line 181) | TEST(AcceptEncodingTest, Whitespace) {
  function TEST (line 190) | TEST(ByteRangeSpecTest, Valids) {
  function TEST (line 214) | TEST(ByteRangeSpecTest, Invalids) {

FILE: proxygen/lib/http/test/WindowTest.cpp
  function TEST (line 15) | TEST(WindowTest, Basic) {
  function TEST (line 30) | TEST(WindowTest, ChangeCapacity) {
  function TEST (line 50) | TEST(WindowTest, ExceedWindow) {
  function TEST (line 58) | TEST(WindowTest, Overflow) {
  function TEST (line 63) | TEST(WindowTest, Underflow) {
  function TEST (line 71) | TEST(WindowTest, HugeReserve) {
  function TEST (line 76) | TEST(WindowTest, HugeFree) {
  function TEST (line 83) | TEST(WindowTest, HugeFree2) {
  function TEST (line 91) | TEST(WindowTest, BytesOutstanding) {
  function TEST (line 101) | TEST(WindowTest, BytesOutstandingAfterFail) {
  function TEST (line 108) | TEST(WindowTest, NonStrict) {
  function TEST (line 115) | TEST(WindowTest, NewCapacityOverflow) {

FILE: proxygen/lib/http/webtransport/FlowController.h
  function class (line 16) | class FlowController {

FILE: proxygen/lib/http/webtransport/HTTPWebTransport.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/http/webtransport/HTTPWebTransport.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/http/webtransport/QuicWebTransport.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/http/webtransport/QuicWebTransport.h
  function namespace (line 15) | namespace proxygen {
  function setHandler (line 40) | void setHandler(WebTransportHandler* handler) {
  function onConnectionEnd (line 66) | void onConnectionEnd() noexcept override;
  function usesEncodedApplicationErrorCodes (line 168) | bool usesEncodedApplicationErrorCodes() override {
  function isPeerInitiatedStream (line 172) | bool isPeerInitiatedStream(HTTPCodec::StreamID id) override {
  function onDatagramsAvailable (line 181) | void onDatagramsAvailable() noexcept override;
  function WebTransportHandler (line 198) | WebTransportHandler* handler_{nullptr};

FILE: proxygen/lib/http/webtransport/QuicWtSession.cpp
  type proxygen (line 13) | namespace proxygen {
    function createConfig (line 18) | detail::WtStreamManager::WtConfig createConfig() {
    type WtEventVisitor (line 33) | struct WtEventVisitor {

FILE: proxygen/lib/http/webtransport/QuicWtSession.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/http/webtransport/StreamPriorityQueue.h
  function namespace (line 14) | namespace proxygen::detail {

FILE: proxygen/lib/http/webtransport/WebTransport.cpp
  function isTerminalEv (line 15) | bool isTerminalEv(const folly::Try<StreamData>& ev) {
  type proxygen (line 21) | namespace proxygen {

FILE: proxygen/lib/http/webtransport/WebTransport.h
  function ErrorCode (line 43) | enum class ErrorCode {

FILE: proxygen/lib/http/webtransport/WebTransportImpl.cpp
  function ReadPromiseT (line 20) | ReadPromiseT emptyReadPromise() {
  function WritePromiseT (line 25) | WritePromiseT emptyWritePromise() {
  type proxygen (line 31) | namespace proxygen {

FILE: proxygen/lib/http/webtransport/WebTransportImpl.h
  function namespace (line 22) | namespace proxygen {
  function class (line 119) | class SessionProvider {
  function noexcept (line 198) | noexcept override {
  function folly (line 222) | [[nodiscard]] const folly::SocketAddress& getLocalAddress() const overri...
  type BufferedWrite (line 279) | struct BufferedWrite {
  function streamWriteReady_ (line 301) | bool streamWriteReady_{false};
  function eof_ (line 335) | bool eof_{false};
  function FlowController (line 366) | FlowController sendFlowController_{quic::kMaxVarInt};

FILE: proxygen/lib/http/webtransport/WtEgressContainer.cpp
  type proxygen::detail (line 12) | namespace proxygen::detail {

FILE: proxygen/lib/http/webtransport/WtEgressContainer.h
  function namespace (line 19) | namespace proxygen::detail {
  function class (line 84) | class WtBufferedStreamData {

FILE: proxygen/lib/http/webtransport/WtStreamManager.cpp
  type ReadHandle (line 72) | struct ReadHandle
  type WriteHandle (line 73) | struct WriteHandle
  type proxygen::detail (line 83) | namespace proxygen::detail {
    type WtStreamManager::Accessor (line 88) | struct WtStreamManager::Accessor {
      method Accessor (line 89) | explicit Accessor(WtStreamManager& sm) : sm_(sm) {
      method isIngress (line 101) | bool isIngress(uint64_t id) {
      method isEgress (line 104) | bool isEgress(uint64_t id) {
    type WtStreamManager::BidiHandle (line 403) | struct WtStreamManager::BidiHandle {
      method BidiHandle (line 407) | BidiHandle(uint64_t id, WtStreamManager& sm)
      method make (line 433) | static std::unique_ptr<BidiHandle> make(uint64_t id, WtStreamManager...
    function Result (line 586) | Result WtStreamManager::enqueue(WtReadHandle& rh, StreamData data) noe...
  type BufferedData (line 125) | struct BufferedData {
  function computeChainLength (line 130) | size_t computeChainLength(std::unique_ptr<folly::IOBuf>& buf) {
  function ReadPromise (line 136) | ReadPromise emptyReadPromise() {
  function WritePromise (line 141) | WritePromise emptyWritePromise() {
  type HandleState (line 150) | enum HandleState : uint8_t { Closed = 0, Open = 1 }
  type ReadHandle (line 152) | struct ReadHandle : public WebTransport::StreamReadHandle {
  type WriteHandle (line 174) | struct WriteHandle : public WebTransport::StreamWriteHandle {
  type proxygen::detail (line 205) | namespace proxygen::detail {
    type WtStreamManager::Accessor (line 88) | struct WtStreamManager::Accessor {
      method Accessor (line 89) | explicit Accessor(WtStreamManager& sm) : sm_(sm) {
      method isIngress (line 101) | bool isIngress(uint64_t id) {
      method isEgress (line 104) | bool isEgress(uint64_t id) {
    type WtStreamManager::BidiHandle (line 403) | struct WtStreamManager::BidiHandle {
      method BidiHandle (line 407) | BidiHandle(uint64_t id, WtStreamManager& sm)
      method make (line 433) | static std::unique_ptr<BidiHandle> make(uint64_t id, WtStreamManager...
    function Result (line 586) | Result WtStreamManager::enqueue(WtReadHandle& rh, StreamData data) noe...
  function Result (line 773) | Result ReadHandle::enqueue(StreamData&& data) noexcept {
  function ReadPromise (line 824) | ReadPromise ReadHandle::resetPromise() noexcept {
  function Result (line 882) | Result WriteHandle::onMaxData(uint64_t offset) {
  function WritePromise (line 904) | WritePromise WriteHandle::resetPromise() noexcept {

FILE: proxygen/lib/http/webtransport/WtStreamManager.h
  function namespace (line 73) | namespace proxygen::detail {

FILE: proxygen/lib/http/webtransport/WtUtils.cpp
  type WtExpected (line 24) | struct WtExpected {
  function makeEmptyPromise (line 28) | folly::Promise<folly::Unit> makeEmptyPromise() {
  function resetPromise (line 32) | folly::Promise<folly::Unit> resetPromise(
  type proxygen::detail (line 39) | namespace proxygen::detail {
    function setEgressWtHttpSettings (line 42) | void setEgressWtHttpSettings(HTTPSettings* settings) {
    function getWtConfig (line 66) | WtStreamManager::WtConfig getWtConfig(const HTTPSettings* ingress,
    function supportsWt (line 112) | bool supportsWt(std::initializer_list<const HTTPSettings*> settings) {

FILE: proxygen/lib/http/webtransport/WtUtils.h
  function namespace (line 14) | namespace proxygen {
  function namespace (line 18) | namespace proxygen::detail {

FILE: proxygen/lib/http/webtransport/test/FakeSharedWebTransport.h
  function namespace (line 16) | namespace proxygen::test {
  function getID (line 37) | uint64_t getID() const {
  function GenericApiRet (line 70) | GenericApiRet stopSending(uint32_t code) override {
  function setImmediateDelivery (line 82) | void setImmediateDelivery(bool immediateDelivery) {
  function GenericApiRet (line 155) | GenericApiRet resetStream(uint32_t err) override {
  function class (line 205) | class FakeSharedWebTransport : public WebTransport {

FILE: proxygen/lib/http/webtransport/test/FlowControllerTest.cpp
  class FlowControllerTest (line 13) | class FlowControllerTest : public ::testing::Test {
    method SetUp (line 17) | void SetUp() override {
  function TEST_F (line 22) | TEST_F(FlowControllerTest, InitialState) {
  function TEST_F (line 27) | TEST_F(FlowControllerTest, ReserveWithinLimit) {
  function TEST_F (line 33) | TEST_F(FlowControllerTest, ReserveExceedsLimit) {
  function TEST_F (line 39) | TEST_F(FlowControllerTest, GrantIncreasesMaxOffset) {
  function TEST_F (line 46) | TEST_F(FlowControllerTest, GrantDoesNotDecreaseMaxOffset) {
  function TEST_F (line 51) | TEST_F(FlowControllerTest, GetAvailable) {

FILE: proxygen/lib/http/webtransport/test/Mocks.h
  function namespace (line 14) | namespace proxygen::test {
  function noexcept (line 161) | noexcept override {
  function onDatagram (line 164) | void onDatagram(std::unique_ptr<folly::IOBuf> datagram) noexcept override {
  function onSessionEnd (line 166) | void onSessionEnd(folly::Optional<uint32_t> error) noexcept override {
  function onSessionDrain (line 169) | void onSessionDrain() noexcept override {
  function onWebTransportSession (line 171) | void onWebTransportSession(
  function std (line 176) | static std::unique_ptr<DummyWtHandler> make() {
  type Ctx (line 180) | struct Ctx {

FILE: proxygen/lib/http/webtransport/test/QuicWebTransportTest.cpp
  class MockDeliveryCallback (line 21) | class MockDeliveryCallback : public WebTransport::ByteEventCallback {
  class QuicWebTransportTest (line 36) | class QuicWebTransportTest : public Test {
    method SetUp (line 38) | void SetUp() override {
    method TearDown (line 45) | void TearDown() override {
    method WebTransport (line 51) | WebTransport* webTransport() {
  function TEST_F (line 66) | TEST_F(QuicWebTransportTest, PeerUniStream) {
  function TEST_F (line 83) | TEST_F(QuicWebTransportTest, PeerBidiStream) {
  function TEST_F (line 105) | TEST_F(QuicWebTransportTest, NewUniStream) {
  function TEST_F (line 114) | TEST_F(QuicWebTransportTest, NewBidiStream) {
  function TEST_F (line 124) | TEST_F(QuicWebTransportTest, Datagram) {
  function TEST_F (line 136) | TEST_F(QuicWebTransportTest, OnStopSending) {
  function TEST_F (line 148) | TEST_F(QuicWebTransportTest, ConnectionError) {
  function TEST_F (line 162) | TEST_F(QuicWebTransportTest, ConnectionErrorHandlerDestroysTransport) {
  function TEST_F (line 181) | TEST_F(QuicWebTransportTest, SetPriority) {
  function TEST_F (line 191) | TEST_F(QuicWebTransportTest, WriteWithDeliveryCallback) {
  function TEST_F (line 214) | TEST_F(QuicWebTransportTest, CloseTransportCancelsReadTokens) {
  function TEST_F (line 272) | TEST_F(QuicWebTransportTest, DestructorTerminatesOpenStreams) {

FILE: proxygen/lib/http/webtransport/test/QuicWtSessionTest.cpp
  class MockConnectionState (line 26) | class MockConnectionState : public quic::QuicConnectionStateBase {
    method MockConnectionState (line 28) | explicit MockConnectionState(quic::QuicNodeType type)
  class MockDeliveryCallback (line 33) | class MockDeliveryCallback : public WebTransport::ByteEventCallback {
  class QuicWtSessionTest (line 44) | class QuicWtSessionTest : public Test {
    method SetUp (line 46) | void SetUp() override {
    method TearDown (line 57) | void TearDown() override {
    method WebTransport (line 63) | WebTransport* webTransport() {
  function TEST_F (line 79) | TEST_F(QuicWtSessionTest, PeerUniStream) {
  function TEST_F (line 96) | TEST_F(QuicWtSessionTest, PeerBidiStream) {
  function TEST_F (line 115) | TEST_F(QuicWtSessionTest, NewUniStream) {
  function TEST_F (line 124) | TEST_F(QuicWtSessionTest, NewBidiStream) {
  function TEST_F (line 134) | TEST_F(QuicWtSessionTest, AwaitUniStreamCredit) {
  function TEST_F (line 164) | TEST_F(QuicWtSessionTest, AwaitBidiStreamCredit) {
  function TEST_F (line 195) | TEST_F(QuicWtSessionTest, WriteStreamData) {
  function TEST_F (line 217) | TEST_F(QuicWtSessionTest, ReadStreamData) {
  function TEST_F (line 250) | TEST_F(QuicWtSessionTest, Datagram) {
  function TEST_F (line 292) | TEST_F(QuicWtSessionTest, StopSending) {
  function TEST_F (line 332) | TEST_F(QuicWtSessionTest, ResetStream) {
  function TEST_F (line 350) | TEST_F(QuicWtSessionTest, SetPriority) {
  function TEST_F (line 368) | TEST_F(QuicWtSessionTest, AwaitWritable) {
  function TEST_F (line 396) | TEST_F(QuicWtSessionTest, ConnectionError) {
  function TEST_F (line 407) | TEST_F(QuicWtSessionTest, ConnectionEnd) {
  function TEST_F (line 416) | TEST_F(QuicWtSessionTest, DeliveryCallback) {
  function TEST_F (line 433) | TEST_F(QuicWtSessionTest, CloseTransportCancelsReadTokens) {
  function TEST_F (line 480) | TEST_F(QuicWtSessionTest, DestructorTerminatesOpenStreams) {
  function TEST_F (line 552) | TEST_F(QuicWtSessionTest, ReadError) {
  function TEST_F (line 578) | TEST_F(QuicWtSessionTest, ConnectionEndWithError) {
  function TEST_F (line 593) | TEST_F(QuicWtSessionTest, ReadAvailableReadFails) {
  function TEST_F (line 612) | TEST_F(QuicWtSessionTest, WriteFlowControlBlocked) {
  function TEST_F (line 639) | TEST_F(QuicWtSessionTest, WriteChainFails) {
  function TEST_F (line 680) | TEST_F(QuicWtSessionTest, StreamWriteError) {
  function TEST_F (line 707) | TEST_F(QuicWtSessionTest, IngressBackpressure) {

FILE: proxygen/lib/http/webtransport/test/WebTransportAPITest.cpp
  type proxygen::test (line 14) | namespace proxygen::test {
    function TEST (line 16) | TEST(WebTransportTest, ErrorCodes) {
    function TEST (line 30) | TEST(WebTransportTest, AwaitNextRead) {
    function TEST (line 51) | TEST(WebTransportTest, AwaitNextReadTimeout) {

FILE: proxygen/lib/http/webtransport/test/WtStreamManagerTest.cpp
  type proxygen::coro::test (line 16) | namespace proxygen::coro::test {
    function expectNextWritable (line 21) | void expectNextWritable(const quic::PriorityQueue& pq,
    type WtSmEgressCb (line 29) | struct WtSmEgressCb : WtStreamManager::EgressCallback {
      method WtSmEgressCb (line 30) | WtSmEgressCb() = default;
      method eventsAvailable (line 32) | void eventsAvailable() noexcept override {
    type WtSmIngressCb (line 38) | struct WtSmIngressCb : WtStreamManager::IngressCallback {
      method WtSmIngressCb (line 39) | WtSmIngressCb() = default;
      method onNewPeerStream (line 41) | void onNewPeerStream(uint64_t streamId) noexcept override {
    function TEST (line 58) | TEST(WtStreamManager, BasicSelfBidi) {
    function TEST (line 86) | TEST(WtStreamManager, BasicSelfUni) {
    function TEST (line 114) | TEST(WtStreamManager, BasicPeerBidi) {
    function TEST (line 143) | TEST(WtStreamManager, BasicPeerUni) {
    function TEST (line 173) | TEST(WtStreamManager, NextBidiUniHandle) {
    function TEST (line 201) | TEST(WtStreamManager, StreamLimits) {
    function TEST (line 241) | TEST(WtStreamManager, EnqueueIngressData) {
    function TEST (line 262) | TEST(WtStreamManager, EnqueueIngressDataRwnd) {
    function TEST (line 299) | TEST(WtStreamManager, WriteEgressHandle) {
    function TEST (line 383) | TEST(WtStreamManager, DequeueWriteConnFcBlocked) {
    function TEST (line 404) | TEST(WtStreamManager, BidiHandleCancellation) {
    function TEST (line 437) | TEST(WtStreamManager, GrantFlowControlCredit) {
    function TEST (line 492) | TEST(WtStreamManager, GrantConnFlowControlCreditAfterRead) {
    function TEST (line 528) | TEST(WtStreamManager, NonDefaultFlowControlValues) {
    function TEST (line 586) | TEST(WtStreamManager, ResetStreamReleasesConnFlowControl) {
    function TEST (line 621) | TEST(WtStreamManager, StopSendingResetStreamTest) {
    function TEST (line 673) | TEST(WtStreamManager, AwaitWritableTest) {
    function TEST (line 712) | TEST(WtStreamManager, WritableStreams) {
    function TEST (line 784) | TEST(WtStreamManager, DrainWtSession) {
    function TEST (line 813) | TEST(WtStreamManager, CloseWtSession) {
    function TEST (line 847) | TEST(WtStreamManager, ResetStreamReliableSize) {
    function TEST (line 879) | TEST(WtStreamManager, InvalidCtrlFrames) {
    function TEST (line 903) | TEST(WtStreamManager, IssueMaxStreamsBidiUni) {
    function TEST (line 936) | TEST(WtStreamManager, ShutdownOpenStreams) {
    function TEST (line 955) | TEST(WtStreamManager, NoopNonExistentStreams) {
    function TEST (line 986) | TEST(WtStreamManager, OnlyFinPending) {
    function TEST (line 1016) | TEST(WtStreamManager, NextWritableReturnsNullptrWhenQueueEmpty) {
    function TEST (line 1038) | TEST(WtStreamManager, NextWritableReturnsNullptrWhenHeadIsDatagram) {
    type WtReadCallback (line 1075) | struct WtReadCallback : WtStreamManager::ReadCallback {
      method readReady (line 1077) | void readReady(WtReadHandle&) noexcept override {
    type MockDeliveryCallback (line 1084) | struct MockDeliveryCallback : WebTransport::ByteEventCallback {
    function TEST (line 1092) | TEST(WtStreamManager, PerStreamCallbacks) {
    function TEST (line 1125) | TEST(WtStreamManager, DeliveryCallback) {
    function TEST (line 1209) | TEST(WtStreamManager, ByteEventCancellation) {

FILE: proxygen/lib/pools/generators/FileServerListGenerator.cpp
  type proxygen (line 22) | namespace proxygen {

FILE: proxygen/lib/pools/generators/FileServerListGenerator.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/pools/generators/MemberGroupConfig.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/pools/generators/ServerConfig.h
  function namespace (line 19) | namespace proxygen {

FILE: proxygen/lib/pools/generators/ServerListGenerator.cpp
  type proxygen (line 17) | namespace proxygen {

FILE: proxygen/lib/pools/generators/ServerListGenerator.h
  function setGroupId (line 43) | void setGroupId(const MemberGroupId serverGroupId) {
  function MemberGroupId (line 64) | MemberGroupId groupId_{kInvalidPoolMemberGroupId};
  function class (line 94) | class Callback {
  function Generator (line 177) | Generator* gen_{nullptr};
  function class (line 224) | class ServerListCallback : public ServerListGenerator::Callback {

FILE: proxygen/lib/pools/generators/coro/CoroServerListGenerator.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/pools/generators/coro/FileCoroServerListGenerator.cpp
  type proxygen (line 12) | namespace proxygen {

FILE: proxygen/lib/pools/generators/coro/FileCoroServerListGenerator.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/pools/generators/coro/JsonFileCoroServerListGenerator.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/pools/generators/coro/JsonFileCoroServerListGenerator.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/pools/generators/coro/PlainTextFileCoroServerListGenerator.cpp
  type proxygen (line 16) | namespace proxygen {

FILE: proxygen/lib/pools/generators/coro/PlainTextFileCoroServerListGenerator.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/sampling/MultiSampled.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/sampling/Sampled.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/sampling/Sampling.cpp
  type proxygen (line 18) | namespace proxygen {

FILE: proxygen/lib/sampling/Sampling.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/sampling/SamplingFunctions.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/sampling/test/SamplingTest.cpp
  function TEST (line 17) | TEST(SamplingTests, Basic) {
  function TEST (line 40) | TEST(SamplingTests, UpdateRate) {
  function TEST (line 47) | TEST(SamplingTests, Key) {
  function TEST (line 56) | TEST(SamplingTests, HashKey) {
  function TEST (line 68) | TEST(SamplingTests, runSampled) {

FILE: proxygen/lib/services/AcceptorConfiguration.h
  type AcceptorConfiguration (line 33) | struct AcceptorConfiguration
  function maxConcurrentIncomingStreams (line 65) | uint32_t maxConcurrentIncomingStreams{0}
  function serverEarlyResponseEnabled (line 100) | bool serverEarlyResponseEnabled{false};

FILE: proxygen/lib/services/HTTPAcceptor.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/services/RequestWorkerThread.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/services/RequestWorkerThread.h
  function getWorkerId (line 55) | [[nodiscard]] uint8_t getWorkerId() const;
  function ServiceWorker (line 73) | ServiceWorker* getServiceWorker(Service* service) const {
  function setLoadShedConfig (line 89) | void setLoadShedConfig(

FILE: proxygen/lib/services/RequestWorkerThreadNoExecutor.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/services/RequestWorkerThreadNoExecutor.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/services/Service.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/services/Service.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/services/ServiceConfiguration.h
  function namespace (line 11) | namespace proxygen {

FILE: proxygen/lib/services/ServiceWorker.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/services/WorkerThread.cpp
  function getEventBaseBackend (line 56) | std::unique_ptr<folly::EventBaseBackendBase> getEventBaseBackend() {
  type proxygen (line 63) | namespace proxygen {

FILE: proxygen/lib/services/WorkerThread.h
  function namespace (line 18) | namespace folly {
  function WorkerThread (line 110) | static WorkerThread* getCurrentWorkerThread() {
  type class (line 126) | enum class
  function State (line 140) | State state_{State::IDLE};

FILE: proxygen/lib/services/test/AcceptorTest.cpp
  class TestConnection (line 18) | class TestConnection : public wangle::ManagedConnection {
    method timeoutExpired (line 20) | void timeoutExpired() noexcept override {
    method describe (line 22) | void describe(std::ostream& /*os*/) const override {
    method isBusy (line 24) | [[nodiscard]] bool isBusy() const override {
    method notifyPendingShutdown (line 27) | void notifyPendingShutdown() override {
    method closeWhenIdle (line 29) | void closeWhenIdle() override {
    method dropConnection (line 31) | void dropConnection(const std::string& /* errorMsg */ = "") override {
    method dumpConnectionState (line 34) | void dumpConnectionState(uint8_t /*loglevel*/) override {
  class TestAcceptor (line 45) | class TestAcceptor : public Acceptor {
    method TestAcceptor (line 47) | explicit TestAcceptor(std::shared_ptr<const ServerSocketConfig> accCon...
    method onNewConnection (line 51) | void onNewConnection(folly::AsyncTransport::UniquePtr /*sock*/,
  function TEST (line 62) | TEST(AcceptorTest, Basic) {

FILE: proxygen/lib/services/test/RequestWorkerThreadTest.cpp
  type proxygen (line 14) | namespace proxygen {
    class FinishCallbackTest (line 16) | class FinishCallbackTest : public RequestWorkerThread::FinishCallback {
      method FinishCallbackTest (line 18) | FinishCallbackTest(uint64_t* requestId,
      method workerStarted (line 23) | void workerStarted(RequestWorkerThread*) override {
      method workerFinished (line 25) | void workerFinished(RequestWorkerThread* worker) override {
    function TEST (line 41) | TEST(RequestWorkerThreadTest, nextRequestIdDuringShutdown) {

FILE: proxygen/lib/ssl/ProxygenSSL.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/ssl/ThreadLocalSSLStats.cpp
  type proxygen (line 16) | namespace proxygen {

FILE: proxygen/lib/ssl/ThreadLocalSSLStats.h
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/stats/BaseStats.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/stats/PeriodicStats.h
  function namespace (line 19) | namespace proxygen {
  function stopRefresh (line 119) | void stopRefresh() {
  function updateCachedData (line 186) | void updateCachedData() {

FILE: proxygen/lib/stats/PeriodicStatsDataBase.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/stats/ResourceData.h
  function namespace (line 19) | namespace proxygen {
  function getPctFromRatio (line 133) | static double getPctFromRatio(double ratio) {
  function setCpuStats (line 356) | void setCpuStats(CpuStats&& cpuStats) {
  function setMemStats (line 365) | void setMemStats(uint64_t usedMemBytes, uint64_t totalMemBytes) {
  function setCpuPressureStats (line 370) | void setCpuPressureStats(double avg10, double avg60, double avg300) {
  function setMemPressureFullStats (line 376) | void setMemPressureFullStats(double avg10, double avg60, double avg300) {
  function setMemPressureSomeStats (line 382) | void setMemPressureSomeStats(double avg10, double avg60, double avg300) {
  function setMemEventsStats (line 388) | void setMemEventsStats(int64_t highCount, int64_t maxCount) {
  function setIoPressureStats (line 393) | void setIoPressureStats(double avg10, double avg60, double avg300) {
  function setTcpMemStats (line 402) | void setTcpMemStats(uint64_t current,
  function setUdpMemStats (line 415) | void setUdpMemStats(uint64_t current,
  function setNicStats (line 428) | void setNicStats(double utilRatio) {
  function cpuRatioUtil_ (line 442) | double cpuRatioUtil_{0}
  function cpuRatioUtilPercentile_ (line 444) | double cpuRatioUtilPercentile_{0}
  function cpuUtilPercentileConfigured_ (line 445) | double cpuUtilPercentileConfigured_{61};

FILE: proxygen/lib/stats/ResourceStats.cpp
  type proxygen (line 11) | namespace proxygen {
    function ResourceData (line 25) | ResourceData* ResourceStats::getNewData() const {

FILE: proxygen/lib/stats/ResourceStats.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/stats/test/BaseStatsTest.cpp
  type proxygen (line 14) | namespace proxygen {
    class TestLazyQuantileStatWrapper (line 15) | class TestLazyQuantileStatWrapper : public BaseStats::LazyQuantileStat...
      method TestLazyQuantileStatWrapper (line 17) | explicit TestLazyQuantileStatWrapper(
      method quantileStatCreated (line 28) | bool quantileStatCreated() {
      method metadataExists (line 32) | bool metadataExists() {
      method getNumSavedCounters (line 36) | size_t getNumSavedCounters() {
    function TEST (line 41) | TEST(ProxyStatsWrapperTest, LazyQuantileStatWrapper) {
    function TEST (line 53) | TEST(ProxyStatsWrapperTest, MultipleLazyQuantileStatWrapper) {
    function TEST (line 68) | TEST(ProxyStatsWrapperTest, TestSavingsCounter) {
    function TEST (line 82) | TEST(ProxyStatsWrapperTest, LazyQuantileStatWrapperConcurrency) {

FILE: proxygen/lib/stats/test/MockARLResourceStats.h
  function namespace (line 20) | namespace proxygen {

FILE: proxygen/lib/stats/test/MockResources.h
  function expectNextCallsToReturnValue (line 27) | void expectNextCallsToReturnValue(const proxygen::ResourceData& data,
  function expectAllCallsToReturnValue (line 34) | void expectAllCallsToReturnValue(const proxygen::ResourceData& data) {
  type GetTestResourceDataParams (line 38) | struct GetTestResourceDataParams {
  function numCpuCores (line 41) | uint64_t numCpuCores{1}
  function proxygen (line 52) | static proxygen::ResourceData getTestResourceData(

FILE: proxygen/lib/stats/test/PeriodicStatsTest.cpp
  class PeriodicStatsData (line 19) | class PeriodicStatsData {
    method getLastUpdateTime (line 21) | [[nodiscard]] std::chrono::milliseconds getLastUpdateTime() const {
    method setLastUpdateTime (line 25) | void setLastUpdateTime(
  class PeriodicStatsUnderTest (line 37) | class PeriodicStatsUnderTest : public PeriodicStats<PeriodicStatsData> {
    method PeriodicStatsUnderTest (line 39) | PeriodicStatsUnderTest(PeriodicStatsData* initialData)
    method PeriodicStatsData (line 43) | PeriodicStatsData& getMutableData() {
    method PeriodicStatsData (line 51) | PeriodicStatsData* getNewData() const override {
  class PeriodicStatsTest (line 61) | class PeriodicStatsTest : public ::testing::Test {
    method SetUp (line 63) | void SetUp() override {
    method TearDown (line 74) | void TearDown() override {
  function TEST_F (line 87) | TEST_F(PeriodicStatsTest, GetCurrentData) {
  function TEST_F (line 92) | TEST_F(PeriodicStatsTest, GetCurrentDataRefreshes) {

FILE: proxygen/lib/stats/test/PeriodicStatsTestHelper.h
  type WaitForRefreshParams (line 28) | struct WaitForRefreshParams {
  function waitForRefresh (line 39) | void waitForRefresh(WaitForRefreshParams params) {

FILE: proxygen/lib/stats/test/ResourceDataTest.cpp
  class ResourceDataTest (line 14) | class ResourceDataTest : public ::testing::Test {}

FILE: proxygen/lib/stats/test/ResourceStatsTest.cpp
  class ResourceStatsUnderTest (line 17) | class ResourceStatsUnderTest : public ResourceStats {
    method ResourceStatsUnderTest (line 19) | explicit ResourceStatsUnderTest(std::unique_ptr<MockResources> resources)
    method MockResources (line 25) | MockResources* getMockResources() const {
  class ResourceStatsTest (line 30) | class ResourceStatsTest : public ::testing::Test {
    method SetUp (line 32) | void SetUp() override {
    method TearDown (line 45) | void TearDown() override {
  function TEST_F (line 57) | TEST_F(ResourceStatsTest, Constructs) {
  function TEST_F (line 78) | TEST_F(ResourceStatsTest, GetCurrentDataOnRefresh) {

FILE: proxygen/lib/test/TestAsyncTransport.cpp
  class TestAsyncTransport::ReadEvent (line 32) | class TestAsyncTransport::ReadEvent {
    method ReadEvent (line 34) | ReadEvent(const void* buf, size_t buflen, std::chrono::milliseconds de...
    method ReadEvent (line 56) | ReadEvent(const folly::AsyncSocketException& ex,
    method ReadEvent (line 66) | ReadEvent(std::unique_ptr<IOBuf> buf, std::chrono::milliseconds delay)
    method getDelay (line 80) | [[nodiscard]] std::chrono::milliseconds getDelay() const {
    method isFinalEvent (line 84) | [[nodiscard]] bool isFinalEvent() const {
    method getLength (line 92) | [[nodiscard]] size_t getLength() const {
    method consumeData (line 96) | void consumeData(size_t length) {
    method isError (line 101) | [[nodiscard]] bool isError() const {
    method isMovableBuffer (line 109) | [[nodiscard]] bool isMovableBuffer() const {
    method getMovableBuffer (line 113) | std::unique_ptr<IOBuf> getMovableBuffer() {
  type iovec (line 151) | struct iovec
  type iovec (line 153) | struct iovec
  function EventBase (line 371) | EventBase* TestAsyncTransport::getEventBase() const {

FILE: proxygen/lib/test/TestAsyncTransport.h
  type iovec (line 24) | struct iovec
  type iovec (line 30) | struct iovec
  type iovec (line 45) | struct iovec
  type iovec (line 58) | struct iovec
  function close (line 64) | void close() override;
  function getEORCount (line 106) | uint32_t getEORCount() {
  function getCorkCount (line 110) | uint32_t getCorkCount() {
  function setAppBytesWritten (line 114) | void setAppBytesWritten(size_t bytes) {
  function setRawBytesWritten (line 117) | void setRawBytesWritten(size_t bytes) {
  function getAppBytesWritten (line 121) | [[nodiscard]] size_t getAppBytesWritten() const override {
  function isEorTrackingEnabled (line 133) | [[nodiscard]] bool isEorTrackingEnabled() const override {
  type StateEnum (line 141) | enum StateEnum {
  function timeoutExpired (line 165) | void timeoutExpired() noexcept override;
  function appBytesWritten_ (line 181) | size_t appBytesWritten_{0}
  function rawBytesWritten_ (line 182) | size_t rawBytesWritten_{0}
  function eorTrackingEnabled_ (line 183) | bool eorTrackingEnabled_{false};

FILE: proxygen/lib/test/TestMain.cpp
  function main (line 14) | int main(int argc, char* argv[]) {

FILE: proxygen/lib/transport/AsyncUDPSocketFactory.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/transport/AsyncUDPSocketFactory.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/transport/ConnectUDPUtils.cpp
  type proxygen (line 16) | namespace proxygen {
    function percentEncodeIPv6 (line 20) | std::string percentEncodeIPv6(const std::string& host) {
    function ConnectUDPTarget (line 34) | ConnectUDPTarget expandConnectUDPTemplate(const std::string& uriTemplate,
    function prependContextId (line 86) | std::unique_ptr<folly::IOBuf> prependContextId(
    function stripContextId (line 97) | folly::Optional<std::unique_ptr<folly::IOBuf>> stripContextId(

FILE: proxygen/lib/transport/ConnectUDPUtils.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/transport/H3DatagramAsyncSocket.cpp
  type proxygen (line 20) | namespace proxygen {
    type msghdr (line 185) | struct msghdr
    type mmsghdr (line 202) | struct mmsghdr
    type timespec (line 205) | struct timespec

FILE: proxygen/lib/transport/H3DatagramAsyncSocket.h
  function namespace (line 18) | namespace proxygen {
  type Options (line 43) | struct Options {
  function rfcMode_ (line 52) | bool rfcMode_{false};  // When true, use RFC 9298 Extended CONNECT
  function HTTPTransaction (line 75) | HTTPTransaction* getTransaction() {
  function folly (line 84) | const folly::SocketAddress& address() const override;
  function connect (line 91) | void connect(const folly::SocketAddress& address) override {
  function setFD (line 97) | void setFD(folly::NetworkSocket /*fd*/, FDOwnership /*ownership*/) overr...
  function setCmsgs (line 101) | void setCmsgs(const folly::SocketCmsgMap& /*cmsgs*/) override {
  function appendCmsgs (line 105) | void appendCmsgs(const folly::SocketCmsgMap& /*cmsgs*/) override {
  function writem (line 112) | int writem(folly::Range<folly::SocketAddress const*> /*addrs*/,
  function writeGSO (line 118) | ssize_t writeGSO(const folly::SocketAddress& /*address*/,
  function writeChain (line 124) | ssize_t writeChain(const folly::SocketAddress& /*address*/,
  function writemGSO (line 130) | int writemGSO(folly::Range<folly::SocketAddress const*> /*addrs*/,
  function writev (line 137) | ssize_t writev(const folly::SocketAddress& /*address*/,
  function writev (line 144) | ssize_t writev(const folly::SocketAddress& /*address*/,
  type msghdr (line 150) | struct msghdr
  type mmsghdr (line 152) | struct mmsghdr
  type timespec (line 155) | struct timespec
  function pauseRead (line 159) | void pauseRead() override {
  function close (line 163) | void close() override {
  function setReusePort (line 178) | void setReusePort(bool /*reusePort*/) override {
  function setReuseAddr (line 182) | void setReuseAddr(bool /*reuseAddr*/) override {
  function setRcvBuf (line 186) | void setRcvBuf(int rcvBuf) override {
  function setSndBuf (line 194) | void setSndBuf(int sndBuf) override {
  function setBusyPoll (line 202) | void setBusyPoll(int /*busyPollUs*/) override {
  function dontFragment (line 206) | void dontFragment(bool /*df*/) override {
  function setDFAndTurnOffPMTU (line 210) | void setDFAndTurnOffPMTU() override {
  function setErrMessageCallback (line 214) | void setErrMessageCallback(ErrMessageCallback*) override {
  function detachEventBase (line 227) | void detachEventBase() override {
  function attachEventBase (line 232) | void attachEventBase(folly::EventBase* /*evb*/) override {
  function getGSO (line 237) | int getGSO() override {
  function setOverrideNetOpsDispatcher (line 241) | void setOverrideNetOpsDispatcher(
  function override (line 248) | const override {
  function onReplaySafe (line 258) | void onReplaySafe() override;
  function onDestroy (line 287) | void onDestroy(const HTTPSessionBase&) override {
  function closeRead (line 297) | void closeRead() {
  function rcvBufPkts_ (line 314) | unsigned int rcvBufPkts_{100};

FILE: proxygen/lib/transport/PersistentFizzPskCache.cpp
  type folly (line 11) | namespace folly {
    function dynamic (line 14) | dynamic toDynamic(const proxygen::PersistentCachedPsk& cached) {
    function convertTo (line 22) | proxygen::PersistentCachedPsk convertTo(const dynamic& d) {

FILE: proxygen/lib/transport/PersistentFizzPskCache.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/transport/PersistentQuicPskCache.cpp
  type proxygen (line 23) | namespace proxygen {
  type folly (line 114) | namespace folly {
    function dynamic (line 117) | dynamic toDynamic(const proxygen::PersistentQuicCachedPsk& cached) {
    function convertTo (line 126) | proxygen::PersistentQuicCachedPsk convertTo(const dynamic& d) {

FILE: proxygen/lib/transport/PersistentQuicPskCache.h
  function namespace (line 24) | namespace proxygen {

FILE: proxygen/lib/transport/PersistentQuicTokenCache.cpp
  type proxygen (line 11) | namespace proxygen {

FILE: proxygen/lib/transport/PersistentQuicTokenCache.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/transport/test/AsyncUDPSocketFactoryTest.cpp
  function getV6TestAddress (line 14) | folly::SocketAddress getV6TestAddress() {
  function getV4TestAddress (line 18) | folly::SocketAddress getV4TestAddress() {
  type proxygen (line 23) | namespace proxygen {
    class AsyncUDPSocketFactoryTest (line 25) | class AsyncUDPSocketFactoryTest : public testing::Test {
      method TearDown (line 27) | void TearDown() override {
    function TEST_F (line 35) | TEST_F(AsyncUDPSocketFactoryTest, CreateSuccessV6) {
    function TEST_F (line 42) | TEST_F(AsyncUDPSocketFactoryTest, CreateSuccessV4) {
    function TEST_F (line 49) | TEST_F(AsyncUDPSocketFactoryTest, EmptyV4BindAddresses) {
    function TEST_F (line 55) | TEST_F(AsyncUDPSocketFactoryTest, BindFailure) {

FILE: proxygen/lib/transport/test/ConnectUDPUtilsTest.cpp
  function TEST (line 15) | TEST(ConnectUDPUtilsTest, ExpandTemplateBasic) {
  function TEST (line 25) | TEST(ConnectUDPUtilsTest, ExpandTemplateIPv6) {
  function TEST (line 35) | TEST(ConnectUDPUtilsTest, ExpandTemplateWellKnown) {
  function TEST (line 46) | TEST(ConnectUDPUtilsTest, ExpandTemplateNoPath) {
  function TEST (line 54) | TEST(ConnectUDPUtilsTest, PrependContextId) {
  function TEST (line 64) | TEST(ConnectUDPUtilsTest, StripContextIdZero) {
  function TEST (line 79) | TEST(ConnectUDPUtilsTest, StripContextIdNonZero) {
  function TEST (line 90) | TEST(ConnectUDPUtilsTest, StripContextIdEmpty) {
  function TEST (line 95) | TEST(ConnectUDPUtilsTest, StripContextIdEmptyPayload) {

FILE: proxygen/lib/transport/test/H3DatagramAsyncSocketTest.cpp
  function TEST_F (line 90) | TEST_F(H3DatagramAsyncSocketTest, Connect) {
  function TEST_P (line 94) | TEST_P(H3DatagramAsyncSocketModeTest, ConnectAndReady) {
  function TEST_F (line 107) | TEST_F(H3DatagramAsyncSocketTest, ConnectErrorBeforeReadCallbackSet) {
  function TEST_F (line 122) | TEST_F(H3DatagramAsyncSocketTest, ConnectErrorAfterReadCallbackSet) {
  function TEST_F (line 137) | TEST_F(H3DatagramAsyncSocketTest, HTTPNon200Response) {
  function TEST_F (line 154) | TEST_F(H3DatagramAsyncSocketTest, CloseAfter200Response) {
  function TEST_F (line 163) | TEST_F(H3DatagramAsyncSocketTest, EOMAfter200Response) {
  function TEST_F (line 173) | TEST_F(H3DatagramAsyncSocketTest, DatagramsBeforeReadCallback) {
  function TEST_F (line 202) | TEST_F(H3DatagramAsyncSocketTest, DatagramsAndEOMBeforeReadCallback) {
  function TEST_F (line 226) | TEST_F(H3DatagramAsyncSocketTest, DiscardDatagramsBufferTooSmall) {
  function TEST_F (line 257) | TEST_F(H3DatagramAsyncSocketTest, WriteBeforeConnect) {
  function TEST_F (line 264) | TEST_F(H3DatagramAsyncSocketTest, WriteInvalidBuf) {
  function TEST_F (line 271) | TEST_F(H3DatagramAsyncSocketTest, WriteWrongAddress) {
  function TEST_F (line 284) | TEST_F(H3DatagramAsyncSocketTest, BufferWriteBeforeConnectSuccess) {
  function TEST_F (line 296) | TEST_F(H3DatagramAsyncSocketTest, DiscardWhenApplicationWriteBufferFull) {
  function TEST_F (line 314) | TEST_F(H3DatagramAsyncSocketTest, CheckErrorWhenTransportFails) {
  function TEST_F (line 329) | TEST_F(H3DatagramAsyncSocketTest, WriteLargerThanDatagramSizeLimit) {
  function TEST_F (line 342) | TEST_F(H3DatagramAsyncSocketTest, DatagramsPauseResumeRead) {
  function TEST_F (line 362) | TEST_F(H3DatagramAsyncSocketTest, DatagramsTriggerPauseRead) {
  function TEST_F (line 395) | TEST_F(H3DatagramAsyncSocketTest, ResumeReadReentrancy) {
  function TEST_F (line 420) | TEST_F(H3DatagramAsyncSocketTest, DeleteSocketBeforeTransportReady) {
  function TEST_F (line 431) | TEST_F(H3DatagramAsyncSocketTest, CloseTwice) {
  function TEST_F (line 439) | TEST_F(H3DatagramAsyncSocketTest, RfcModeDatagramContextIdStrip) {
  function TEST_F (line 466) | TEST_F(H3DatagramAsyncSocketTest, RfcModeDropNonZeroContextId) {

FILE: proxygen/lib/transport/test/H3DatagramAsyncSocketTest.h
  function class (line 23) | class MockUDPReadCallback : public folly::AsyncUDPSocket::ReadCallback {
  function namespace (line 54) | namespace proxygen {

FILE: proxygen/lib/transport/test/MockAsyncTransportCertificate.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/transport/test/PersistentFizzPskCacheTest.cpp
  type proxygen::test (line 18) | namespace proxygen::test {
    class PersistentFizzPskCacheTest (line 20) | class PersistentFizzPskCacheTest : public Test {
      method SetUp (line 22) | void SetUp() override {
      method TearDown (line 71) | void TearDown() override {
      method createCache (line 76) | void createCache() {
    function expectMatch (line 92) | static void expectMatch(const fizz::client::CachedPsk& a,
    function TEST_F (line 113) | TEST_F(PersistentFizzPskCacheTest, TestInsert2Hosts) {
    function TEST_F (line 128) | TEST_F(PersistentFizzPskCacheTest, TestOverwrite) {
    function TEST_F (line 139) | TEST_F(PersistentFizzPskCacheTest, TestRemove) {
    function TEST_F (line 146) | TEST_F(PersistentFizzPskCacheTest, TestCompletelyCorruptedCache) {
    function TEST_F (line 156) | TEST_F(PersistentFizzPskCacheTest, TestSomewhatCorruptedCache) {
    function TEST_F (line 173) | TEST_F(PersistentFizzPskCacheTest, TestEntryCorruptedCache) {
    function TEST_F (line 191) | TEST_F(PersistentFizzPskCacheTest, TestTruncatedEntry) {
    function TEST_F (line 217) | TEST_F(PersistentFizzPskCacheTest, TestTruncatedHandshakeTime) {
    function TEST_F (line 249) | TEST_F(PersistentFizzPskCacheTest, TestUnlimitedUses) {
    function TEST_F (line 259) | TEST_F(PersistentFizzPskCacheTest, TestLimitedUses) {
    function TEST_F (line 271) | TEST_F(PersistentFizzPskCacheTest, TestLimitedUsesSerialize) {
    function TEST_F (line 287) | TEST_F(PersistentFizzPskCacheTest, TestGetPskUses) {
    function TEST_F (line 307) | TEST_F(PersistentFizzPskCacheTest, TestPeekPsk) {

FILE: proxygen/lib/transport/test/PersistentQuicPskCacheTest.cpp
  type proxygen::test (line 19) | namespace proxygen::test {
    class PersistentQuicPskCacheTest (line 21) | class PersistentQuicPskCacheTest : public Test {
      method SetUp (line 23) | void SetUp() override {
      method TearDown (line 98) | void TearDown() override {
      method createCache (line 103) | void createCache() {
    function expectMatch (line 119) | static void expectMatch(const QuicCachedPsk& a, const QuicCachedPsk& b) {
    function TEST_F (line 164) | TEST_F(PersistentQuicPskCacheTest, TestInsert2Hosts) {
    function TEST_F (line 179) | TEST_F(PersistentQuicPskCacheTest, TestOverwrite) {
    function TEST_F (line 190) | TEST_F(PersistentQuicPskCacheTest, TestRemove) {
    function TEST_F (line 197) | TEST_F(PersistentQuicPskCacheTest, TestCompletelyCorruptedCache) {
    function TEST_F (line 207) | TEST_F(PersistentQuicPskCacheTest, TestSomewhatCorruptedCache) {
    function TEST_F (line 225) | TEST_F(PersistentQuicPskCacheTest, TestEntryCorruptedCache) {
    function TEST_F (line 245) | TEST_F(PersistentQuicPskCacheTest, TestUnlimitedUses) {
    function TEST_F (line 255) | TEST_F(PersistentQuicPskCacheTest, TestLimitedUses) {
    function TEST_F (line 267) | TEST_F(PersistentQuicPskCacheTest, TestLimitedUsesSerialize) {
    function TEST_F (line 283) | TEST_F(PersistentQuicPskCacheTest, TestGetPskUses) {

FILE: proxygen/lib/utils/AcceptorAddress.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/utils/AsyncTimeoutSet.cpp
  type proxygen (line 16) | namespace proxygen {
    class SimpleTimeoutClock (line 18) | class SimpleTimeoutClock : public AsyncTimeoutSet::TimeoutClock {
      method millisecondsSinceEpoch (line 20) | std::chrono::milliseconds millisecondsSinceEpoch() override {

FILE: proxygen/lib/utils/AsyncTimeoutSet.h
  function namespace (line 19) | namespace proxygen {

FILE: proxygen/lib/utils/CobHelper.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/utils/CompressionFilterUtils.h
  function namespace (line 17) | namespace proxygen {
  function shouldCompress (line 74) | static bool shouldCompress(const HTTPMessage& msg,
  function isMinimumCompressibleSize (line 88) | static bool isMinimumCompressibleSize(const HTTPMessage& msg,
  function isCompressibleContentType (line 102) | static bool isCompressibleContentType(const HTTPMessage& msg,
  function CodecType (line 122) | enum class CodecType : uint8_t {

FILE: proxygen/lib/utils/ConditionalGate.h
  function namespace (line 17) | namespace proxygen {
  function describe (line 77) | void describe(std::ostream& os) const {
  function namespace (line 102) | namespace detail {

FILE: proxygen/lib/utils/ConsistentHash.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/utils/CryptUtil.cpp
  type proxygen (line 17) | namespace proxygen {
    function base64Encode (line 20) | std::string base64Encode(folly::ByteRange text) {
    function md5Encode (line 59) | std::string md5Encode(folly::ByteRange text) {

FILE: proxygen/lib/utils/CryptUtil.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/utils/Exception.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/utils/Exception.h
  function namespace (line 16) | namespace proxygen {

FILE: proxygen/lib/utils/FilterChain.h
  function namespace (line 17) | namespace proxygen {
  function append (line 73) | void append(Filter* nextFilter) {
  function drop (line 123) | void drop() {
  function T1 (line 156) | T1* call_{nullptr};

FILE: proxygen/lib/utils/HTTPTime.cpp
  type proxygen (line 13) | namespace proxygen {
    function parseHTTPDateTime (line 15) | folly::Optional<int64_t> parseHTTPDateTime(const std::string& s) {

FILE: proxygen/lib/utils/HTTPTime.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/utils/Logging.cpp
  type proxygen (line 39) | namespace proxygen {
    function string (line 41) | string hexStr(StringPiece sp) {
    function string (line 49) | string HexFollyPrinter::print(const IOBuf* buf) {
    function string (line 53) | string Hex16Printer::print(const IOBuf* buf) {
    function string (line 70) | string ChainInfoPrinter::print(const IOBuf* buf) {
    function string (line 76) | string BinPrinter::print(const IOBuf* buf) {
    function string (line 96) | string IOBufPrinter::printChain(const IOBuf* buf,
    function dumpBinToFile (line 125) | void dumpBinToFile(const string& filename, const IOBuf* buf) {

FILE: proxygen/lib/utils/Logging.h
  function namespace (line 16) | namespace proxygen {
  function std (line 41) | static std::string printChainInfo(const folly::IOBuf* buf) {
  function class (line 55) | class Hex16Printer : public IOBufPrinter {
  function class (line 60) | class HexFollyPrinter : public IOBufPrinter {
  function class (line 65) | class ChainInfoPrinter : public IOBufPrinter {
  function class (line 70) | class BinPrinter : public IOBufPrinter {

FILE: proxygen/lib/utils/NullTraceEventObserver.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/utils/ParseURL.cpp
  function startsWith (line 22) | constexpr inline bool startsWith(std::string_view str,
  type proxygen (line 34) | namespace proxygen {
    function validateScheme (line 61) | static bool validateScheme(std::string_view url) {
    type http_parser_url (line 124) | struct http_parser_url
    type http_parser_url (line 125) | struct http_parser_url

FILE: proxygen/lib/utils/ParseURL.h
  function namespace (line 19) | namespace proxygen {
  function FB_EXPORT (line 157) | FB_EXPORT void stripBrackets() noexcept;
  function port_ (line 212) | uint16_t port_{0}
  function valid_ (line 213) | bool valid_{false};

FILE: proxygen/lib/utils/PerfectIndexMap.h
  function namespace (line 24) | namespace proxygen {
  function update (line 76) | bool update(Key key,
  function add (line 97) | void add(const std::string &keyStr, const std::string &value) {
  function add (line 107) | void add(Key key, const std::string &value) {
  function set (line 116) | void set(const std::string &keyStr, const std::string &value) {
  function set (line 125) | void set(Key key, const std::string &value) {
  function remove (line 134) | bool remove(const std::string &keyStr) {
  function remove (line 142) | bool remove(Key key) {
  function size (line 147) | size_t size() {
  function setOtherKey (line 151) | void setOtherKey(const std::string &keyStr, const std::string &value) {
  function std (line 192) | const std::string *getSingleKey(Key key) const {
  function std (line 205) | [[nodiscard]] const std::string *getSingleOtherKey(
  function setKey (line 218) | void setKey(Key key, const std::string &value) {
  function removeKey (line 243) | bool removeKey(Key key) {
  function removeOtherKey (line 260) | bool removeOtherKey(const std::string &keyStr) {
  function addKeyToIndex (line 312) | void addKeyToIndex(Key key, const std::string &value) {
  function addOtherKeyToIndex (line 316) | void addOtherKeyToIndex(const std::string &keyStr, const std::string &va...
  function replaceKeyAtIndex (line 323) | void replaceKeyAtIndex(std::ptrdiff_t index,
  function replaceOtherKeyAtIndex (line 329) | void replaceOtherKeyAtIndex(size_t namesIndex,
  function removeAtIndex (line 337) | void removeAtIndex(std::ptrdiff_t index) {
  function otherKeyCount_ (line 388) | size_t otherKeyCount_{0}
  function noneKeyCount_ (line 389) | size_t noneKeyCount_{0}

FILE: proxygen/lib/utils/RendezvousHash.cpp
  type proxygen (line 18) | namespace proxygen {

FILE: proxygen/lib/utils/RendezvousHash.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/utils/SafePathUtils.cpp
  type proxygen (line 32) | namespace proxygen {
    function string (line 150) | string SafePath::cleanPath(const string& path) {

FILE: proxygen/lib/utils/SafePathUtils.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/utils/StateMachine.h
  function namespace (line 15) | namespace proxygen {

FILE: proxygen/lib/utils/StreamCompressor.h
  function namespace (line 13) | namespace folly {
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/utils/StreamDecompressor.h
  function namespace (line 14) | namespace folly {
  function namespace (line 18) | namespace proxygen {

FILE: proxygen/lib/utils/TestUtils.h
  function folly (line 34) | inline folly::StringPiece getContainingDirectory(folly::StringPiece inpu...
  function queryStringsAreEquivalent (line 44) | inline bool queryStringsAreEquivalent(const std::string& query,
  function urlsAreEquivalent (line 66) | inline bool urlsAreEquivalent(const std::string& url,

FILE: proxygen/lib/utils/Time.h
  function namespace (line 16) | namespace proxygen {
  function std (line 41) | inline std::chrono::system_clock::time_point toSystemTimePoint(TimePoint...
  function time_t (line 47) | inline time_t toTimeT(TimePoint t) {
  function std (line 51) | inline std::chrono::microseconds microsecondsSinceEpoch() {
  function std (line 56) | inline std::chrono::milliseconds millisecondsSinceEpoch() {
  function std (line 61) | inline std::chrono::seconds secondsSinceEpoch() {
  function std (line 66) | inline std::chrono::microseconds microsecondsSinceEpoch(TimePoint t) {
  function std (line 71) | inline std::chrono::milliseconds millisecondsSinceEpoch(TimePoint t) {
  function std (line 76) | inline std::chrono::seconds secondsSinceEpoch(TimePoint t) {
  type tm (line 124) | struct tm
  function getDateOffsetStr (line 137) | inline void getDateOffsetStr(char datebuf[32], int dayOffset) {
  function std (line 153) | inline std::string getDateTimeStr(TimePoint tp) {
  function std (line 176) | static const std::chrono::time_point<ClockType>& getZeroTimePoint() {
  function virtual (line 185) | virtual uint64_t msSinceEpoch() {
  function virtual (line 189) | virtual uint64_t microsSinceEpoch() {
  function stopWatch_ (line 211) | stopWatch_(stopWatch) {
  function Duration (line 265) | Duration elapsed_{0};

FILE: proxygen/lib/utils/TraceEvent.cpp
  type proxygen (line 16) | namespace proxygen {

FILE: proxygen/lib/utils/TraceEvent.h
  function namespace (line 27) | namespace proxygen {
  function class (line 99) | class Iterator {
  function hasStarted (line 158) | [[nodiscard]] bool hasStarted() const;
  function setParentID (line 181) | void setParentID(uint32_t parent) {
  function hasTraceField (line 189) | [[nodiscard]] bool hasTraceField(TraceFieldType field) const {
  function setMetaData (line 200) | void setMetaData(MetaDataMap&& input) {
  function Iterator (line 208) | [[nodiscard]] Iterator getMetaDataItr() const {
  type State (line 258) | enum State {
  function stateFlags_ (line 264) | uint8_t stateFlags_{0};
  function string (line 274) | struct TraceEvent::MetaData::ConvVisitor<std::vector<std::string>> {

FILE: proxygen/lib/utils/TraceEventContext.cpp
  type proxygen (line 12) | namespace proxygen {

FILE: proxygen/lib/utils/TraceEventContext.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/utils/TraceEventObserver.h
  function namespace (line 13) | namespace proxygen {

FILE: proxygen/lib/utils/URL.h
  function namespace (line 28) | namespace proxygen {

FILE: proxygen/lib/utils/UtilInl.h
  function namespace (line 22) | namespace proxygen {
  function caseUnderscoreInsensitiveEqual (line 42) | inline bool caseUnderscoreInsensitiveEqual(folly::StringPiece s,
  function URLValidateMode (line 47) | enum class URLValidateMode { STRICT_COMPAT, STRICT };
  function findLastOf (line 60) | inline size_t findLastOf(folly::StringPiece sp, char c) {
  function isAlpha (line 76) | inline bool isAlpha(uint8_t c) {

FILE: proxygen/lib/utils/WeakRefCountedPtr.h
  function T (line 59) | T* ptr{nullptr};
  function virtual (line 80) | virtual ~EnableWeakRefCountedPtr() {
  function T2 (line 192) | T2* get() const {
  function reset (line 207) | void reset() {
  function initPtr (line 220) | void initPtr(WeakRefCountedPtrState<T1>* state) {
  function destroyPtr (line 238) | void destroyPtr() {

FILE: proxygen/lib/utils/WheelTimerInstance.cpp
  type proxygen (line 15) | namespace proxygen {
    function WheelTimerInstance (line 74) | WheelTimerInstance& WheelTimerInstance::operator=(

FILE: proxygen/lib/utils/WheelTimerInstance.h
  function namespace (line 16) | namespace folly {
  function namespace (line 22) | namespace proxygen {

FILE: proxygen/lib/utils/ZlibStreamCompressor.cpp
  type proxygen (line 22) | namespace proxygen {
    function addOutputBuffer (line 26) | std::unique_ptr<IOBuf> addOutputBuffer(z_stream* stream, uint32_t leng...
    function deflateHelper (line 38) | int deflateHelper(z_stream* stream, IOBuf* out, int flush) {

FILE: proxygen/lib/utils/ZlibStreamCompressor.h
  function namespace (line 17) | namespace folly {
  function getStatus (line 36) | int getStatus() {
  function hasError (line 40) | bool hasError() override {
  function finished (line 44) | bool finished() {
  function status_ (line 52) | int status_{Z_OK};

FILE: proxygen/lib/utils/ZlibStreamDecompressor.cpp
  type proxygen (line 15) | namespace proxygen {

FILE: proxygen/lib/utils/ZlibStreamDecompressor.h
  function namespace (line 15) | namespace folly {
  function getStatus (line 50) | int getStatus() {
  function hasError (line 54) | bool hasError() override {
  function finished (line 58) | bool finished() override {
  function decompressor_buffer_minsize_ (line 65) | uint64_t decompressor_buffer_minsize_{kZlibDecompressorBufferMinsizeDefa...

FILE: proxygen/lib/utils/ZstdStreamCompressor.cpp
  type proxygen (line 13) | namespace proxygen {

FILE: proxygen/lib/utils/ZstdStreamCompressor.h
  function namespace (line 16) | namespace folly {
  function namespace (line 26) | namespace proxygen {

FILE: proxygen/lib/utils/ZstdStreamDecompressor.cpp
  type proxygen (line 14) | namespace proxygen {

FILE: proxygen/lib/utils/ZstdStreamDecompressor.h
  function namespace (line 29) | namespace proxygen {

FILE: proxygen/lib/utils/gen_trace_event_constants.py
  function main (line 15) | def main(argv):
  function gen_java (line 103) | def gen_java(items, class_name, install_dir, output_scope):
  function gen_cpp_header (line 131) | def gen_cpp_header(items, class_name, install_dir, output_scope):
  function gen_cpp_source (line 172) | def gen_cpp_source(items, class_name, install_dir, header_path, output_s...

FILE: proxygen/lib/utils/perfect_hash_table_template.h
  function namespace (line 17) | namespace proxygen {

FILE: proxygen/lib/utils/test/AsyncTimeoutSetTest.cpp
  class MockTimeoutClock (line 28) | class MockTimeoutClock : public AsyncTimeoutSet::TimeoutClock {
    method MockTimeoutClock (line 30) | MockTimeoutClock() = default;
  class TestTimeout (line 35) | class TestTimeout : public AsyncTimeoutSet::Callback {
    method TestTimeout (line 38) | explicit TestTimeout(Args&&... args) {
    method TestTimeout (line 42) | TestTimeout() = default;
    method addTimeout (line 44) | void addTimeout(AsyncTimeoutSet* set) {
    method addTimeout (line 49) | void addTimeout(AsyncTimeoutSet* set, Args&&... args) {
    method timeoutExpired (line 54) | void timeoutExpired() noexcept override {
    method _scheduleNext (line 62) | void _scheduleNext() {
    method setTimeoutClock (line 74) | static void setTimeoutClock(MockTimeoutClock& clock) {
  class TimeoutTest (line 85) | class TimeoutTest : public testing::Test {
    method SetUp (line 87) | void SetUp() override {
    method loop (line 113) | void loop() {
    method setClock (line 121) | void setClock(milliseconds ms) {
  function TEST_F (line 144) | TEST_F(TimeoutTest, FireOnce) {
  function TEST_F (line 195) | TEST_F(TimeoutTest, SwitchTimeoutSet) {
  function TEST_F (line 231) | TEST_F(TimeoutTest, CancelTimeout) {
  function TEST_F (line 313) | TEST_F(TimeoutTest, DestroyTimeoutSet) {
  function TEST_F (line 350) | TEST_F(TimeoutTest, AtMostEveryN) {

FILE: proxygen/lib/utils/test/CompressionFilterUtilsTest.cpp
  class DetermineCompressionTypeTest (line 16) | class DetermineCompressionTypeTest : public ::testing::Test {
    method CodecType (line 20) | CodecType determineType(const std::string& acceptEncoding,
  function TEST_F (line 28) | TEST_F(DetermineCompressionTypeTest, Zstd) {
  function TEST_F (line 32) | TEST_F(DetermineCompressionTypeTest, Gzip) {
  function TEST_F (line 36) | TEST_F(DetermineCompressionTypeTest, GzipWithQuality) {
  function TEST_F (line 40) | TEST_F(DetermineCompressionTypeTest, Empty) {
  function TEST_F (line 44) | TEST_F(DetermineCompressionTypeTest, UnsupportedEncoding) {
  function TEST_F (line 48) | TEST_F(DetermineCompressionTypeTest, ZstdDisabled) {
  function TEST_F (line 52) | TEST_F(DetermineCompressionTypeTest, GzipDisabled) {
  function TEST_F (line 56) | TEST_F(DetermineCompressionTypeTest, MultipleEncodingsZstdFirst) {
  function TEST_F (line 60) | TEST_F(DetermineCompressionTypeTest, MultipleEncodingsGzipFirst) {
  function TEST_F (line 64) | TEST_F(DetermineCompressionTypeTest, ZstdDisabledFallbackToGzip) {

FILE: proxygen/lib/utils/test/ConditionalGateTest.cpp
  class ConditionalGateTest (line 15) | class ConditionalGateTest : public testing::Test {
    type Things (line 17) | enum class Things : uint8_t { Thing1 = 0, Thing2 }
  function TEST_F (line 22) | TEST_F(ConditionalGateTest, Delay) {
  function TEST_F (line 31) | TEST_F(ConditionalGateTest, DelayMulti) {
  function TEST_F (line 45) | TEST_F(ConditionalGateTest, Immediate) {
  function TEST (line 57) | TEST(ReadyGateTest, Delay) {
  function TEST (line 66) | TEST(ReadyGateTest, Immediate) {
  function TEST (line 75) | TEST(ConditionalGateDeleteTest, DeleteFromCallback) {

FILE: proxygen/lib/utils/test/CryptUtilTest.cpp
  function TEST (line 18) | TEST(CryptUtilTest, Base64EncodeTest) {
  function TEST (line 34) | TEST(CryptUtilTest, MD5EncodeTest) {

FILE: proxygen/lib/utils/test/GenericFilterTest.cpp
  type detail (line 21) | namespace detail {
    function T (line 26) | T* get_pointer(const unique_ptr<T>& ptr) {
    function T (line 31) | T* get_pointer(T* ptr) {
  class TesterInterface (line 37) | class TesterInterface {
    class Callback (line 39) | class Callback {
  class MockTester (line 49) | class MockTester : public TesterInterface {
    method setCallback (line 52) | void setCallback(Callback* cb) override {
  class MockTesterCallback (line 58) | class MockTesterCallback : public TesterInterface::Callback {
  class TestFilter (line 64) | class TestFilter
    method TestFilter (line 70) | TestFilter()
    method TestFilter (line 77) | TestFilter(bool calls, bool callbacks)
    method setCallback (line 84) | void setCallback(TesterInterface::Callback* cb) override {
    method doA (line 87) | void doA() override {
    method onA (line 91) | void onA() override {
  class TestFilterNoCallback (line 104) | class TestFilterNoCallback : public TestFilter<Owned> {
    method TestFilterNoCallback (line 106) | TestFilterNoCallback() : TestFilter<Owned>(true, false) {
  class TestFilterNoCall (line 111) | class TestFilterNoCall : public TestFilter<Owned> {
    method TestFilterNoCall (line 113) | TestFilterNoCall() : TestFilter<Owned>(false, true) {
  class TestFilterNoCallbackNoCall (line 118) | class TestFilterNoCallbackNoCall : public TestFilter<Owned> {
    method TestFilterNoCallbackNoCall (line 120) | TestFilterNoCallbackNoCall() : TestFilter<Owned>(false, false) {
  function getTester (line 125) | typename std::enable_if<Owned, unique_ptr<MockTester>>::type getTester() {
  function getTester (line 130) | typename std::enable_if<!Owned, MockTester*>::type getTester() {
  class GenericFilterTest (line 135) | class GenericFilterTest : public testing::Test {
    method SetUp (line 142) | void SetUp() override {
    method getFilter (line 161) | typename std::enable_if<!Owned, FilterT*>::type getFilter() {
    method getFilter (line 166) | typename std::enable_if<Owned, unique_ptr<FilterT>>::type getFilter() {
    method addFilterToChain (line 171) | void addFilterToChain(std::deque<TestFilter<Owned>*>& refs) {
    method getRandomFilters (line 177) | std::deque<TestFilter<Owned>*> getRandomFilters(unsigned num) {
  function TEST_F (line 254) | TEST_F(OwnedGenericFilterTest, EmptyChain) {
  function TEST_F (line 258) | TEST_F(OwnedGenericFilterTest, SingleElemChain) {
  function TEST_F (line 269) | TEST_F(OwnedGenericFilterTest, MultiElemChain) {
  function TEST_F (line 286) | TEST_F(OwnedGenericFilterTest, MultiElemMultiAdd) {
  function TEST_F (line 300) | TEST_F(OwnedGenericFilterTest, Wants) {
  function TEST_F (line 325) | TEST_F(OwnedGenericFilterTest, WantsMultiAdd) {
  function TEST_F (line 347) | TEST_F(OwnedGenericFilterTest, WantsMultiAddHard) {
  function TEST_F (line 367) | TEST_F(OwnedGenericFilterTest, ChangeCallback) {
  function TEST_F (line 388) | TEST_F(UnownedGenericFilterTest, All) {
  function TEST_F (line 410) | TEST_F(OwnedGenericFilterTest, SetNullCb) {
  class TestFilterOddDeleteDo (line 436) | class TestFilterOddDeleteDo : public TestFilter<false> {
    method TestFilterOddDeleteDo (line 438) | explicit TestFilterOddDeleteDo(int* deletions)
    method doA (line 445) | void doA() override {
  function TEST_F (line 458) | TEST_F(UnownedGenericFilterTest, DeleteDo) {
  class TestFilterOddDeleteOn (line 478) | class TestFilterOddDeleteOn : public TestFilter<Owned> {
    method TestFilterOddDeleteOn (line 480) | explicit TestFilterOddDeleteOn(int* deletions)
    method onA (line 487) | void onA() override {
  function TEST_F (line 500) | TEST_F(UnownedGenericFilterTest, DeleteOn) {
  function TEST_F (line 519) | TEST_F(OwnedGenericFilterTest, DeleteChain) {
  function TEST_F (line 532) | TEST_F(OwnedGenericFilterTest, GetChainEnd) {
  function TEST_F (line 539) | TEST_F(OwnedGenericFilterTest, SetDestination) {
  function TEST_F (line 550) | TEST_F(OwnedGenericFilterTest, Foreach) {

FILE: proxygen/lib/utils/test/HTTPTimeTest.cpp
  function TEST (line 15) | TEST(HTTPTimeTests, InvalidTimeTest) {
  function TEST (line 21) | TEST(HTTPTimeTests, ValidTimeTest) {
  function TEST (line 28) | TEST(HTTPTimeTests, EqualTimeTest) {
  function TEST (line 41) | TEST(HTTPTimeTests, ReallyOldTimeTest) {
  function TEST (line 54) | TEST(HTTPTimeTests, TzToUnixTsTest) {

FILE: proxygen/lib/utils/test/LoggingTests.cpp
  class LoggingTests (line 18) | class LoggingTests : public testing::Test {}
  function TEST_F (line 20) | TEST_F(LoggingTests, PrintHexIobuf) {
  function TEST_F (line 46) | TEST_F(LoggingTests, HexString) {
  function TEST_F (line 52) | TEST_F(LoggingTests, DumpBin) {
  function TEST_F (line 71) | TEST_F(LoggingTests, DumpBinToFile) {

FILE: proxygen/lib/utils/test/MockTime.h
  function namespace (line 14) | namespace proxygen {

FILE: proxygen/lib/utils/test/ParseURLTest.cpp
  function testParseURL (line 16) | void testParseURL(const string& url,
  function testHostIsIpAddress (line 42) | void testHostIsIpAddress(const string& url, const bool expected) {
  function TEST (line 48) | TEST(ParseURL, HostNoBrackets) {
  function TEST (line 71) | TEST(ParseURL, FullyFormedURL) {
  function TEST (line 114) | TEST(ParseURL, ValidNonHttpScheme) {
  function TEST (line 152) | TEST(ParseURL, InvalidScheme) {
  function TEST (line 160) | TEST(ParseURL, NoScheme) {
  function TEST (line 182) | TEST(ParseURL, NoSchemeIP) {
  function TEST (line 194) | TEST(ParseURL, PathOnly) {
  function TEST (line 204) | TEST(ParseURL, QueryIsURL) {
  function TEST (line 221) | TEST(ParseURL, InvalidURL) {
  function TEST (line 251) | TEST(ParseURL, IsHostIPAddress) {
  function TEST (line 274) | TEST(ParseURL, SupportedScheme) {
  function TEST (line 288) | TEST(ParseURL, NotSupportedScheme) {
  function TEST (line 299) | TEST(ParseURL, PortOverflow) {
  function TEST (line 306) | TEST(ParseURL, GetQueryParam) {

FILE: proxygen/lib/utils/test/PerfectIndexMapBenchmark.cpp
  function getTestHeaderCodes (line 39) | std::vector<HTTPHeaderCode> getTestHeaderCodes() {
  function getTestHeaderCodeStrings (line 49) | std::vector<const std::string*> getTestHeaderCodeStrings() {
  function getTestHeaderOtherStrings (line 60) | std::vector<const std::string*> getTestHeaderOtherStrings() {
  function UnorderedMapInsertBench (line 89) | void UnorderedMapInsertBench(
  function F14InsertBench (line 100) | void F14InsertBench(folly::F14FastMap<std::string, std::string>& testMap,
  function F14GetBench (line 111) | void F14GetBench(folly::F14FastMap<std::string, std::string>& testMap,
  function PerfectIndexMapInsertCodeBench (line 126) | void PerfectIndexMapInsertCodeBench(
  function PerfectIndexMapInsertHashBench (line 138) | void PerfectIndexMapInsertHashBench(
  function UnorderedMapGetBench (line 149) | void UnorderedMapGetBench(std::unordered_map<std::string, std::string>& ...
  function PerfectIndexMapGetCodeBench (line 164) | void PerfectIndexMapGetCodeBench(DefaultPerfectIndexMap& map,
  function PerfectIndexMapGetStringBench (line 174) | void PerfectIndexMapGetStringBench(DefaultPerfectIndexMap& map,
  function BENCHMARK (line 185) | BENCHMARK(F14UniqueInserts, iters) {
  function getBenchF14UniqueGetsTestMap (line 189) | folly::F14FastMap<std::string, std::string> getBenchF14UniqueGetsTestMap...
  function BENCHMARK (line 197) | BENCHMARK(F14UniqueGets, iters) {
  function BENCHMARK (line 202) | BENCHMARK(UnorderedMapUniqueInserts, iters) {
  function getBenchUnorderedMapUniqueGetsTestMap (line 207) | std::unordered_map<std::string, std::string>
  function BENCHMARK (line 216) | BENCHMARK(UnorderedMapUniqueGets, iters) {
  function BENCHMARK (line 222) | BENCHMARK(PerfectIndexMapUniqueInsertsCode, iters) {
  function BENCHMARK (line 230) | BENCHMARK(PerfectIndexMapUniqueInsertsHashCodeString, iters) {
  function BENCHMARK (line 238) | BENCHMARK(PerfectIndexMapUniqueInsertsHashOtherString, iters) {
  function DefaultPerfectIndexMap (line 245) | DefaultPerfectIndexMap getBenchPerfectIndexMapUniqueGetsCodeTestMap() {
  function BENCHMARK (line 253) | BENCHMARK(PerfectIndexMapUniqueGetsCode, iters) {
  function BENCHMARK (line 260) | BENCHMARK(PerfectIndexMapUniqueGetsCodeString, iters) {
  function DefaultPerfectIndexMap (line 265) | DefaultPerfectIndexMap getBenchPerfectIndexMapUniqueGetsOtherStringTestM...
  function BENCHMARK (line 272) | BENCHMARK(PerfectIndexMapUniqueGetsOtherString, iters) {
  function main (line 277) | int main(int argc, char** argv) {

FILE: proxygen/lib/utils/test/PerfectIndexMapTest.cpp
  type PerfectIndexMapTestsTemplateParams (line 30) | struct PerfectIndexMapTestsTemplateParams {
    method Key (line 40) | static Key Hash(const std::string& name) {
  class PerfectIndexMapTests (line 51) | class PerfectIndexMapTests : public testing::Test {
  function TYPED_TEST (line 99) | TYPED_TEST(PerfectIndexMapTests, BasicKeySetAddRemoveGetSingleOrNone) {
  function TYPED_TEST (line 139) | TYPED_TEST(PerfectIndexMapTests, BasicOtherKeySetAddRemoveGetSingleOrNon...
  function TYPED_TEST (line 182) | TYPED_TEST(PerfectIndexMapTests, OtherStringCaseSensitivity) {

FILE: proxygen/lib/utils/test/RendezvousHashTest.cpp
  function TEST (line 19) | TEST(RendezvousHash, Consistency) {
  function TEST (line 39) | TEST(RendezvousHash, ConsistencyWithNewNode) {
  function TEST (line 62) | TEST(RendezvousHash, ConsistencyWithIncreasedWeight) {
  function TEST (line 90) | TEST(RendezvousHash, ConsistentFlowToIncreasedWeightNode) {
  function TEST (line 121) | TEST(RendezvousHash, ConsistentFlowToDecreasedWeightNodes) {
  function TEST (line 155) | TEST(RendezvousHash, ConsistentFlowToDecreasedWeightNode) {
  function TEST (line 190) | TEST(RendezvousHash, ConsistencyWithDecreasedWeight) {
  function TEST (line 218) | TEST(ConsistentHashRing, DistributionAccuracy) {
  function TEST (line 262) | TEST(RendezvousHash, selectNUnweighted) {

FILE: proxygen/lib/utils/test/TimeTest.cpp
  function TEST (line 17) | TEST(TimeTest, GetDateTimeStr) {
  function TEST (line 33) | TEST(StopWatchTest, StartStopReset) {
  function TEST (line 49) | TEST(StopWatchTest, StartTwiceReset) {
  function TEST (line 62) | TEST(StopWatchTest, ContinueWithoutReset) {
  function TEST (line 80) | TEST(StopWatchTest, StopWatchTimedScope) {

FILE: proxygen/lib/utils/test/TraceEventTest.cpp
  function TEST (line 23) | TEST(TraceEventTest, IntegralDataIntegralValue) {
  function TEST (line 33) | TEST(TraceEventTest, IntegralDataStringValue) {
  function TEST (line 46) | TEST(TraceEventTest, IntegralDataVectorValue) {
  function TEST (line 57) | TEST(TraceEventTest, StringDataIntegralValueConvertible) {
  function TEST (line 68) | TEST(TraceEventTest, StringDataIntegralValueNonConvertible) {
  function TEST (line 78) | TEST(TraceEventTest, StringDataStringValue) {
  function TEST (line 89) | TEST(TraceEventTest, StringDataVectorValue) {
  function TEST (line 100) | TEST(TraceEventTest, VectorDataIntegralValue) {
  function TEST (line 114) | TEST(TraceEventTest, VectorDataStringValue) {
  function TEST (line 128) | TEST(TraceEventTest, VectorDataVectorValue) {
  function TEST (line 143) | TEST(TraceEventTest, IteratorValueTypeCheckInteger) {
  function TEST (line 157) | TEST(TraceEventTest, IteratorValueTypeCheckString) {
  function TEST (line 171) | TEST(TraceEventTest, IteratorValueTypeCheckStringArray) {
  function TEST (line 189) | TEST(TraceEventTest, IntegerValueToString) {
  function TEST (line 208) | TEST(TraceEventTest, StringValueToString) {
  function TEST (line 227) | TEST(TraceEventTest, StringArrayValueToString) {

FILE: proxygen/lib/utils/test/URLTest.cpp
  function TEST (line 15) | TEST(URLTest, Root) {
  function TEST (line 21) | TEST(URLTest, CapitalSheme) {
  function TEST (line 27) | TEST(URLTest, Invalid) {
  function TEST (line 38) | TEST(URLTest, NonHTTPScheme) {
  function TEST (line 46) | TEST(URLTest, GetPort) {

FILE: proxygen/lib/utils/test/UtilTest.cpp
  function TEST (line 16) | TEST(UtilTest, CaseInsensitiveEqual) {
  function TEST (line 24) | TEST(UtilTest, findLastOf) {
  function TEST (line 38) | TEST(UtilTest, validateURL) {
  function TEST (line 43) | TEST(UtilTest, clamped) {
  function TEST (line 68) | TEST(UtilTest, isAlpha) {

FILE: proxygen/lib/utils/test/WeakRefCountedPtrTest.cpp
  type proxygen::test (line 16) | namespace proxygen::test {
    class TestClass (line 18) | class TestClass : public EnableWeakRefCountedPtr<TestClass> {
    class TestDerivedClass (line 24) | class TestDerivedClass : public TestClass {
      method onlyDerivedFunc (line 27) | void onlyDerivedFunc() const {
    function TEST (line 31) | TEST(WeakRefCountedPtrTest, JustTarget) {
    function TEST (line 35) | TEST(WeakRefCountedPtrTest, DestroyTarget) {
    function TEST (line 46) | TEST(WeakRefCountedPtrTest, DestroyPtr) {
    function TEST (line 70) | TEST(WeakRefCountedPtrTest, JustTargetDerived) {
    function TEST (line 75) | TEST(WeakRefCountedPtrTest, DestroyTargetDerived) {
    function TEST (line 87) | TEST(WeakRefCountedPtrTest, DestroyPtrDerived) {
    function TEST (line 115) | TEST(WeakRefCountedPtrTest, DestroyPtrMulti) {
    function TEST (line 145) | TEST(WeakRefCountedPtrTest, MoveConstruct) {
    function TEST (line 165) | TEST(WeakRefCountedPtrTest, MoveConstructEmpty) {
    function TEST (line 183) | TEST(WeakRefCountedPtrTest, MoveAssign) {
    function TEST (line 203) | TEST(WeakRefCountedPtrTest, MoveAssignToExistingActivePtr) {
    function TEST (line 231) | TEST(WeakRefCountedPtrTest, MoveAssignToExistingInactivePtr) {
    function TEST (line 252) | TEST(WeakRefCountedPtrTest, MoveAssignEmptyToExistingActivePtr) {
    function TEST (line 276) | TEST(WeakRefCountedPtrTest, MoveAssignEmptyToExistingInactivePtr) {
    function TEST (line 295) | TEST(WeakRefCountedPtrTest, MoveAssignDestroyTarget) {
    function TEST (line 314) | TEST(WeakRefCountedPtrTest, MoveConstructDestroyTarget) {
    function TEST (line 331) | TEST(WeakRefCountedPtrTest, MoveAssignDestroySrcDestroyTarget) {
    function TEST (line 352) | TEST(WeakRefCountedPtrTest, MoveConstructDestroySrcDestroyTarget) {
    function TEST (line 375) | TEST(WeakRefCountedPtrTest, CopyConstruct) {
    function TEST (line 394) | TEST(WeakRefCountedPtrTest, CopyConstructEmpty) {
    function TEST (line 411) | TEST(WeakRefCountedPtrTest, CopyAssign) {
    function TEST (line 430) | TEST(WeakRefCountedPtrTest, CopyAssignToExistingActivePtr) {
    function TEST (line 458) | TEST(WeakRefCountedPtrTest, CopyAssignToExistingInactivePtr) {
    function TEST (line 479) | TEST(WeakRefCountedPtrTest, CopyAssignEmptyToExistingActivePtr) {
    function TEST (line 501) | TEST(WeakRefCountedPtrTest, CopyAssignEmptyToExistingInactivePtr) {
    function TEST (line 519) | TEST(WeakRefCountedPtrTest, CopyAssignDestroyTarget) {
    function TEST (line 538) | TEST(WeakRefCountedPtrTest, CopyConstructDestroyTarget) {
    function TEST (line 557) | TEST(WeakRefCountedPtrTest, CopyAssignDestroySrcDestroyTarget) {
    function TEST (line 581) | TEST(WeakRefCountedPtrTest, CopyConstructDestroySrcDestroyTarget) {

FILE: proxygen/lib/utils/test/ZlibTests.cpp
  class ZlibTests (line 24) | class ZlibTests : public testing::Test {}
  function makeBuf (line 26) | std::unique_ptr<folly::IOBuf> makeBuf(uint32_t size) {
  function verify (line 40) | void verify(CompressionType type,
  function compressThenDecompress (line 52) | void compressThenDecompress(CompressionType type,
  function TEST_F (line 69) | TEST_F(ZlibTests, CompressDecompressGzip5000) {
  function TEST_F (line 74) | TEST_F(ZlibTests, CompressDecompressGzip2000) {
  function TEST_F (line 79) | TEST_F(ZlibTests, CompressDecompressGzip1024) {
  function TEST_F (line 84) | TEST_F(ZlibTests, CompressDecompressGzip500) {
  function TEST_F (line 89) | TEST_F(ZlibTests, CompressDecompressGzip50) {
  function TEST_F (line 94) | TEST_F(ZlibTests, CompressDecompressDeflate) {
  function TEST_F (line 99) | TEST_F(ZlibTests, CompressDecompressEmpty) {
  function TEST_F (line 104) | TEST_F(ZlibTests, CompressDecompressChain) {
  function TEST_F (line 114) | TEST_F(ZlibTests, CompressDecompressStreaming) {
  function TEST_F (line 137) | TEST_F(ZlibTests, CompressDecompressSmallBuffer) {

FILE: proxygen/lib/utils/test/ZstdTests.cpp
  class ZstdTests (line 26) | class ZstdTests : public Test {}
  function makeBuf (line 28) | std::unique_ptr<folly::IOBuf> makeBuf(uint32_t size) {
  function verify (line 42) | void verify(std::unique_ptr<IOBuf> original,
  function verifyPieces (line 56) | void verifyPieces(std::unique_ptr<IOBuf> original,
  function compress (line 77) | std::unique_ptr<folly::IOBuf> compress(
  function compressThenDecompress (line 85) | void compressThenDecompress(unique_ptr<IOBuf> buf, bool reuseBuf) {
  function compressThenDecompressPieces (line 90) | void compressThenDecompressPieces(
  function compressDecompressPiecesProxygenCodec (line 127) | void compressDecompressPiecesProxygenCodec(
  function TEST_F (line 155) | TEST_F(ZstdTests, CompressDecompress1M) {
  function TEST_F (line 162) | TEST_F(ZstdTests, CompressDecompress2000) {
  function TEST_F (line 169) | TEST_F(ZstdTests, CompressDecompress1024) {
  function TEST_F (line 176) | TEST_F(ZstdTests, CompressDecompress500) {
  function TEST_F (line 183) | TEST_F(ZstdTests, CompressDecompress50) {
  function TEST_F (line 189) | TEST_F(ZstdTests, CompressDecompressEmpty) {
  function TEST_F (line 195) | TEST_F(ZstdTests, CompressDecompressChain) {
  function TEST_F (line 207) | TEST_F(ZstdTests, CompressDecompressStreaming) {
  function TEST_F (line 220) | TEST_F(ZstdTests, CompressDecompressStreamingProxygen) {
  function TEST_F (line 233) | TEST_F(ZstdTests, CompressDecompressStreamingProxygenIndependent) {
  function makeCompressibleBuf (line 249) | static std::unique_ptr<folly::IOBuf> makeCompressibleBuf(size_t size) {
  function TEST_F (line 256) | TEST_F(ZstdTests, MaxDecompressionRatio_FailsWhenRatioTooSmall) {
  function TEST_F (line 271) | TEST_F(ZstdTests, MaxDecompressionRatio_PassesWhenRatioLargeEnough) {
  function TEST_F (line 287) | TEST_F(ZstdTests, MaxDecompressionRatio_PassesWhenUnspecified) {
  function TEST_F (line 302) | TEST_F(ZstdTests, MaxDecompressionRatio_StreamingChunksFailure) {