code: def main():
      args = parse_args()
  
      # Reduce the number of repeated compilations and improve
      # testing speed.
      setup_cache_size_limit_of_dynamo()
  
      # load config
      cfg = Config.fromfile(args.config)
      cfg.launcher = args.launcher
      if args.cfg_options is not None:
          cfg.merge_from_dict(args.cfg_options)
  
      # work_dir is determined in this priority: CLI > segment in file > filename
      if args.work_dir is not None:
          # update configs according to CLI args if args.work_dir is not None
          cfg.work_dir = args.work_dir
      elif cfg.get("work_dir", None) is None:
          # use config filename as default work_dir if cfg.work_dir is None
          cfg.work_dir = osp.join(
              "./work_dirs", osp.splitext(osp.basename(args.config))[0]
          )
  
      cfg.load_from = args.checkpoint
  
      if args.show or args.show_dir:
          cfg = trigger_visualization_hook(cfg, args)
  
      if args.tta:
          if "tta_model" not in cfg:
              warnings.warn(
                  "Cannot find ``tta_model`` in config, "
                  "we will set it as default."
              )
              cfg.tta_model = dict(
                  type="DetTTAModel",
                  tta_cfg=dict(
                      nms=dict(type="nms", iou_threshold=0.5),
                      max_per_img=100,
                  ),
              )
          if "tta_pipeline" not in cfg:
              warnings.warn(
                  "Cannot find ``tta_pipeline`` in config, "
                  "we will set it as default."
              )
              test_data_cfg = cfg.test_dataloader.dataset
              while "dataset" in test_data_cfg:
                  test_data_cfg = test_data_cfg["dataset"]
              cfg.tta_pipeline = deepcopy(test_data_cfg.pipeline)
              flip_tta = dict(
                  type="TestTimeAug",
                  transforms=[
                      [
                          dict(type="RandomFlip", prob=1.0),
                          dict(type="RandomFlip", prob=0.0),
                      ],
                      [
                          dict(
                              type="PackDetInputs",
                              meta_keys=(
                                  "img_id",
                                  "img_path",
                                  "ori_shape",
                                  "img_shape",
                                  "scale_factor",
                                  "flip",
                                  "flip_direction",
                              ),
                          )
                      ],
                  ],
              )
              cfg.tta_pipeline[-1] = flip_tta
          cfg.model = ConfigDict(**cfg.tta_model, module=cfg.model)
          cfg.test_dataloader.dataset.pipeline = cfg.tta_pipeline
  
      # build the runner from config
      if "runner_type" not in cfg:
          # build the default runner
          runner = Runner.from_cfg(cfg)
      else:
          # build customized runner from the registry
          # if 'runner_type' is set in the cfg
          runner = RUNNERS.build(cfg)
  
      # add `DumpResults` dummy metric
      if args.out is not None:
          assert args.out.endswith(
              (".pkl", ".pickle")
          ), "The dump file must be a pkl file."
          runner.test_evaluator.metrics.append(
              DumpDetResults(out_file_path=args.out)
          )
  
      # start testing
      runner.test()
  
file_path: mmdetection/tools/test.py
imports: import argparse
  import os
  import os.path
  import warnings
  from copy import deepcopy
  from mmengine import ConfigDict
  from mmengine.config import Config, DictAction
  from mmengine.runner import Runner
  from mmdet.engine.hooks.utils import trigger_visualization_hook
  from mmdet.evaluation import DumpDetResults
  from mmdet.registry import RUNNERS
  from mmdet.utils import setup_cache_size_limit_of_dynamo
label_desc: Use image node_id 2 for calling a global function with example usage: main() without return types