module_finder_unittest.py (revision c2e18aaa1096c836b086f94603d04f4eb9cf37f5) - OpenGrok cross reference for /aosp_15_r20/tools/asuite/atest/test_finders/module_finder_unittest.py

#!/usr/bin/env python3
#
# Copyright 2018, The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Unittests for module_finder."""

# pylint: disable=invalid-name
# pylint: disable=missing-function-docstring
# pylint: disable=too-many-lines
# pylint: disable=unsubscriptable-object

import copy
import os
import pathlib
import re
import tempfile
import unittest
from unittest import mock
from atest import atest_error
from atest import atest_utils
from atest import constants
from atest import module_info
from atest import module_info_unittest_base
from atest import unittest_constants as uc
from atest import unittest_utils
from atest.test_finders import module_finder
from atest.test_finders import test_filter_utils
from atest.test_finders import test_finder_utils
from atest.test_finders import test_info
from atest.test_runners import atest_tf_test_runner as atf_tr
from pyfakefs import fake_filesystem_unittest

MODULE_CLASS = '%s:%s' % (uc.MODULE_NAME, uc.CLASS_NAME)
MODULE_PACKAGE = '%s:%s' % (uc.MODULE_NAME, uc.PACKAGE)
CC_MODULE_CLASS = '%s:%s' % (uc.CC_MODULE_NAME, uc.CC_CLASS_NAME)
KERNEL_TEST_CLASS = 'test_class_1'
KERNEL_TEST_CONFIG = 'KernelTest.xml.data'
KERNEL_MODULE_CLASS = '%s:%s' % (
    constants.REQUIRED_LTP_TEST_MODULES[0],
    KERNEL_TEST_CLASS,
)
KERNEL_CONFIG_FILE = os.path.join(uc.TEST_DATA_DIR, KERNEL_TEST_CONFIG)
KERNEL_CLASS_FILTER = test_info.TestFilter(KERNEL_TEST_CLASS, frozenset())
KERNEL_MODULE_CLASS_DATA = {
    constants.TI_REL_CONFIG: KERNEL_CONFIG_FILE,
    constants.TI_FILTER: frozenset([KERNEL_CLASS_FILTER]),
}
KERNEL_MODULE_CLASS_INFO = test_info.TestInfo(
    constants.REQUIRED_LTP_TEST_MODULES[0],
    atf_tr.AtestTradefedTestRunner.NAME,
    uc.CLASS_BUILD_TARGETS,
    KERNEL_MODULE_CLASS_DATA,
)
FLAT_METHOD_INFO = test_info.TestInfo(
    uc.MODULE_NAME,
    atf_tr.AtestTradefedTestRunner.NAME,
    uc.MODULE_BUILD_TARGETS,
    data={
        constants.TI_FILTER: frozenset([uc.FLAT_METHOD_FILTER]),
        constants.TI_REL_CONFIG: uc.CONFIG_FILE,
    },
)
MODULE_CLASS_METHOD = '%s#%s' % (MODULE_CLASS, uc.METHOD_NAME)
CC_MODULE_CLASS_METHOD = '%s#%s' % (CC_MODULE_CLASS, uc.CC_METHOD_NAME)
CLASS_INFO_MODULE_2 = test_info.TestInfo(
    uc.MODULE2_NAME,
    atf_tr.AtestTradefedTestRunner.NAME,
    uc.CLASS_BUILD_TARGETS,
    data={
        constants.TI_FILTER: frozenset([uc.CLASS_FILTER]),
        constants.TI_REL_CONFIG: uc.CONFIG2_FILE,
    },
)
CC_CLASS_INFO_MODULE_2 = test_info.TestInfo(
    uc.CC_MODULE2_NAME,
    atf_tr.AtestTradefedTestRunner.NAME,
    uc.CLASS_BUILD_TARGETS,
    data={
        constants.TI_FILTER: frozenset([uc.CC_CLASS_FILTER]),
        constants.TI_REL_CONFIG: uc.CC_CONFIG2_FILE,
    },
)
DEFAULT_INSTALL_PATH = ['/path/to/install']
ROBO_MOD_PATH = ['/shared/robo/path']
NON_RUN_ROBO_MOD_NAME = 'robo_mod'
RUN_ROBO_MOD_NAME = 'run_robo_mod'
NON_RUN_ROBO_MOD = {
    constants.MODULE_NAME: NON_RUN_ROBO_MOD_NAME,
    constants.MODULE_PATH: ROBO_MOD_PATH,
    constants.MODULE_CLASS: ['random_class'],
}
RUN_ROBO_MOD = {
    constants.MODULE_NAME: RUN_ROBO_MOD_NAME,
    constants.MODULE_PATH: ROBO_MOD_PATH,
    constants.MODULE_CLASS: [constants.MODULE_CLASS_ROBOLECTRIC],
}

SEARCH_DIR_RE = re.compile(r'^find ([^ ]*).*$')


# pylint: disable=unused-argument
def classoutside_side_effect(find_cmd, shell=False):
  """Mock the check output of a find cmd where class outside module path."""
  search_dir = SEARCH_DIR_RE.match(find_cmd).group(1).strip()
  if search_dir == uc.ROOT:
    return uc.FIND_ONE
  return None


class ModuleFinderFindTestByModuleClassName(
    module_info_unittest_base.ModuleInfoTest
):

  def setUp(self):
    super().setUp()
    self.build_top = pathlib.Path('/main')

  def test_find_test_by_module_name_single_module_exists(self):
    module_name = 'SingleModuleTestCases'
    test_module = module_info_unittest_base.device_driven_test_module(
        name=module_name,
    )
    finder = self.create_finder_with_module(test_module)

    t_infos = finder.find_test_by_module_name(module_name=module_name)

    with self.subTest(name='returns_one_test_info'):
      self.assertEqual(len(t_infos), 1)
    with self.subTest(name='test_name_is_module_name'):
      self.assert_test_info_has_test_name(t_infos[0], module_name)
      self.assert_test_info_has_raw_test_name(t_infos[0], module_name)
    with self.subTest(name='contains_expected_build_targets'):
      self.assert_test_info_contains_build_targets(t_infos[0], module_name)
      self.assert_test_info_contains_build_targets(
          t_infos[0],
          'example_module-project',
      )

  @mock.patch(
      'subprocess.check_output',
      return_value=(
          'path/to/testmodule/src/com/android/myjavatests/MyJavaTestClass.java'
      ),
  )
  def test_find_test_by_module_class_name_native_found(self, find_cmd):
    module_name = 'MyModuleTestCases'
    test_module = module_info_unittest_base.device_driven_test_module(
        name=module_name, class_type=['NATIVE_TESTS']
    )
    finder = self.create_finder_with_module(test_module)

    t_infos = finder.find_test_by_module_and_class(
        'MyModuleTestCases:MyJavaTestClass'
    )

    with self.subTest(name='returns_one_test_info'):
      self.assertEqual(len(t_infos), 1)
    with self.subTest(name='test_name_is_module_name'):
      self.assert_test_info_has_test_name(t_infos[0], module_name)
      self.assert_test_info_has_raw_test_name(t_infos[0], module_name)
    with self.subTest(name='contains_expected_filters'):
      self.assert_test_info_has_class_filter(t_infos[0], 'MyJavaTestClass')
    with self.subTest(name='contains_expected_build_targets'):
      self.assert_test_info_contains_build_targets(t_infos[0], module_name)
      self.assert_test_info_contains_build_targets(
          t_infos[0],
          'example_module-project',
      )

  @mock.patch(
      'subprocess.check_output',
  )
  def test_find_test_by_module_class_module_name_unknown_test_info_is_none(
      self, find_cmd
  ):
    self.create_module_paths(['/project/module'])
    test_file_src = self.create_class_in_module(
        module_path='/project/module', class_name='MyJavaTestClass.java'
    )
    test_module = module_info_unittest_base.device_driven_test_module(
        name='MyModuleTestCases',
        class_type=['NATIVE_TESTS'],
        module_path='project/module',
        srcs=[test_file_src],
    )
    find_cmd.return_value = test_file_src
    finder = self.create_finder_with_module(test_module)

    t_infos = finder.find_test_by_class_name(
        class_name='MyJavaTestClass', module_name='Unknown'
    )

    self.assertIsNone(t_infos)

  @mock.patch(
      'subprocess.check_output',
      return_value=[
          'example_module/project/src/com/android/myjavatests/MyJavaTestClass.java'
      ],
  )
  @mock.patch.object(
      test_finder_utils, 'get_multiple_selection_answer', return_value='A'
  )
  def test_find_test_by_module_class_multiple_configs_tests_found(
      self, mock_test_selection, mock_run_cmd
  ):
    module_name = 'MyModuleTestCases'
    test_module = (
        module_info_unittest_base.device_driven_multi_config_test_module(
            name=module_name,
            class_type=['NATIVE_TESTS'],
        )
    )
    finder = self.create_finder_with_module(test_module)

    t_infos = finder.find_test_by_module_and_class(
        'MyModuleTestCases:MyMultiConfigJavaTestClass'
    )

    with self.subTest(name='first_test_name_corresponds_to_module_name'):
      self.assert_test_info_has_test_name(t_infos[0], module_name)
    with self.subTest(name='second_test_name_corresponds_to_config_name'):
      self.assert_test_info_has_test_name(t_infos[1], 'Config2')
    with self.subTest(name='raw_test_name_corresponds_to_module_name'):
      self.assert_test_info_has_raw_test_name(t_infos[0], module_name)
      self.assert_test_info_has_raw_test_name(t_infos[1], module_name)
    with self.subTest(name='contains_expected_filters'):
      self.assert_test_info_has_class_filter(
          t_infos[0], 'MyMultiConfigJavaTestClass'
      )
      self.assert_test_info_has_config(
          t_infos[0], 'example_module/project/configs/Config1.xml'
      )
      self.assert_test_info_has_class_filter(
          t_infos[1], 'MyMultiConfigJavaTestClass'
      )
      self.assert_test_info_has_config(
          t_infos[1], 'example_module/project/configs/Config2.xml'
      )
    with self.subTest(name='contains_expected_build_targets'):
      self.assert_test_info_contains_build_targets(t_infos[0], module_name)
      self.assert_test_info_contains_build_targets(
          t_infos[0],
          'example_module-project',
      )
      self.assert_test_info_contains_build_targets(t_infos[1], module_name)
      self.assert_test_info_contains_build_targets(
          t_infos[1],
          'example_module-project',
      )

  @mock.patch('subprocess.check_output')
  def test_find_test_by_class_unique_class_name_finds_class(self, mock_run_cmd):
    self.create_module_paths(['/project/tests/module1'])
    test_file_src = self.create_class_in_module(
        '/project/tests/module1', 'ClassOneTest.java'
    )
    mock_run_cmd.return_value = test_file_src
    test_module = module_info_unittest_base.device_driven_test_module(
        name='module_name',
        module_path='project/tests/module1',
        srcs=[
            test_file_src,
            '/project/tests/module1/src/tests/test2/ClassTwoTest.java',
        ],
    )
    finder = self.create_finder_with_module(test_module)

    t_infos = finder.find_test_by_class_name(class_name='ClassOneTest')

    with self.subTest(name='returns_one_test_info'):
      self.assertEqual(len(t_infos), 1)
    with self.subTest(name='test_info_has_expected_module_name'):
      self.assert_test_info_has_test_name(
          t_infos[0], test_module.get(constants.MODULE_NAME, [])
      )
    with self.subTest(name='contains_expected_class_filter'):
      self.assert_test_info_has_class_filter(
          t_infos[0], 'project.tests.module1.ClassOneTest'
      )

  @mock.patch.object(test_finder_utils, 'get_multiple_selection_answer')
  @mock.patch('subprocess.check_output')
  def test_find_test_by_class_multiple_class_names_returns_selection_menu(
      self, mock_run_cmd, mock_test_selection
  ):
    self.create_module_paths(
        ['/tests/android/module1', '/tests/android/module2']
    )
    test1_file_src = self.create_class_in_module(
        '/tests/android/module1', 'ClassOneTest.java'
    )
    test2_file_src = self.create_class_in_module(
        '/tests/android/module2', 'ClassOneTest.java'
    )
    mock_run_cmd.return_value = test1_file_src + '\n' + test2_file_src
    mock_test_selection.return_value = '0'
    test1_module = module_info_unittest_base.device_driven_test_module(
        name='module1',
        module_path='tests/android/module1',
        srcs=[test1_file_src],
    )
    test2_module = module_info_unittest_base.device_driven_test_module(
        name='module2',
        module_path='tests/android/module2',
        srcs=[test2_file_src],
    )
    finder = self.create_finder_with_multiple_modules(
        [test1_module, test2_module]
    )

    t_infos = finder.find_test_by_class_name(class_name='ClassOneTest')

    with self.subTest(name='returns_one_test_info'):
      self.assertEqual(len(t_infos), 1)
    with self.subTest(name='test_info_has_expected_module_name'):
      self.assert_test_info_has_test_name(
          t_infos[0], test1_module.get(constants.MODULE_NAME, [])
      )
    with self.subTest(name='contains_expected_class_filter'):
      self.assert_test_info_has_class_filter(
          t_infos[0], 'tests.android.module1.ClassOneTest'
      )

  @mock.patch('subprocess.check_output')
  def test_find_test_by_class_multiple_classes_in_module_finds_class(
      self, mock_run_cmd
  ):
    self.create_module_paths(['/tests/android/module'])
    test1_file_src = self.create_class_in_module(
        '/tests/android/module', 'ClassOneTest.java'
    )
    test2_file_src = self.create_class_in_module(
        '/tests/android/module', 'ClassTwoTest.java'
    )
    mock_run_cmd.return_value = test1_file_src
    test_module = module_info_unittest_base.device_driven_test_module(
        name='module1',
        module_path='tests/android/module',
        srcs=[test1_file_src, test2_file_src],
    )
    finder = self.create_finder_with_module(test_module)

    t_infos = finder.find_test_by_class_name(class_name='ClassOneTest')

    with self.subTest(name='returns_one_test_info'):
      self.assertEqual(len(t_infos), 1)
    with self.subTest(name='test_info_has_expected_module_name'):
      self.assert_test_info_has_test_name(
          t_infos[0], test_module.get(constants.MODULE_NAME, [])
      )
    with self.subTest(name='contains_expected_class_filter'):
      self.assert_test_info_has_class_filter(
          t_infos[0], 'tests.android.module.ClassOneTest'
      )

  @mock.patch('atest.module_info.Loader.get_testable_module_from_memory')
  @mock.patch('subprocess.check_output')
  def test_find_test_by_class_multiple_modules_with_same_path_finds_class(
      self, mock_run_cmd, mock_loader
  ):
    self.create_module_paths(['/tests/android/multi_module'])
    test1_file_src = self.create_class_in_module(
        '/tests/android/multi_module', 'ClassOneTest.java'
    )
    test2_file_src = self.create_class_in_module(
        '/tests/android/multi_module', 'ClassTwoTest.java'
    )
    mock_run_cmd.return_value = test1_file_src
    test1_module = module_info_unittest_base.device_driven_test_module(
        name='multi_module1',
        module_path='tests/android/multi_module',
        srcs=[test1_file_src],
    )
    test2_module = module_info_unittest_base.device_driven_test_module(
        name='multi_module2',
        module_path='tests/android/multi_module',
        srcs=[test2_file_src],
    )
    finder = self.create_finder_with_multiple_modules(
        [test1_module, test2_module]
    )
    mock_loader.return_value = set(
        finder.module_info.name_to_module_info.keys()
    )

    t_infos = finder.find_test_by_class_name(class_name='ClassOneTest')

    with self.subTest(name='returns_one_test_info'):
      self.assertEqual(len(t_infos), 1)
    with self.subTest(name='test_info_has_expected_module_name'):
      self.assert_test_info_has_test_name(
          t_infos[0], test1_module.get(constants.MODULE_NAME, [])
      )
    with self.subTest(name='contains_expected_class_filter'):
      self.assert_test_info_has_class_filter(
          t_infos[0], 'tests.android.multi_module.ClassOneTest'
      )

  @mock.patch.object(test_finder_utils, 'get_multiple_selection_answer')
  @mock.patch('subprocess.check_output')
  def test_find_test_by_class_multiple_configs_one_test_per_config_found(
      self, mock_run_cmd, mock_test_selection
  ):
    module_name = 'multi_config_module'
    module_path = 'tests/android/multi_config_module'
    mock_test_selection.return_value = 'A'
    test1_file_src = self.create_class_in_module(
        '/tests/android/multi_config_module', 'ClassOneTest.java'
    )
    test_module = (
        module_info_unittest_base.device_driven_multi_config_test_module(
            name=module_name,
            module_path=module_path,
            srcs=[test1_file_src],
        )
    )
    mock_run_cmd.return_value = test1_file_src
    finder = self.create_finder_with_module(test_module)

    t_infos = finder.find_test_by_class_name(class_name='ClassOneTest')

    with self.subTest(name='returns_two_test_info'):
      self.assertEqual(len(t_infos), 2)
    with self.subTest(name='first_test_name_corresponds_to_module_name'):
      self.assert_test_info_has_test_name(t_infos[0], module_name)
    with self.subTest(name='second_test_name_corresponds_to_config_name'):
      self.assert_test_info_has_test_name(t_infos[1], 'Config2')
    with self.subTest(name='contains_expected_class_filter'):
      self.assert_test_info_has_class_filter(
          t_infos[0], 'tests.android.multi_config_module.ClassOneTest'
      )
      self.assert_test_info_has_config(
          t_infos[0], f'{module_path}/configs/Config1.xml'
      )
      self.assert_test_info_has_class_filter(
          t_infos[1], 'tests.android.multi_config_module.ClassOneTest'
      )
      self.assert_test_info_has_config(
          t_infos[1], f'{module_path}/configs/Config2.xml'
      )
    with self.subTest(name='raw_test_name_corresponds_to_module_name'):
      self.assert_test_info_has_raw_test_name(t_infos[0], module_name)
      self.assert_test_info_has_raw_test_name(t_infos[1], module_name)
    with self.subTest(name='contains_expected_build_targets'):
      self.assert_test_info_contains_build_targets(t_infos[0], module_name)
      self.assert_test_info_contains_build_targets(
          t_infos[0],
          module_name,
      )
      self.assert_test_info_contains_build_targets(t_infos[1], module_name)
      self.assert_test_info_contains_build_targets(
          t_infos[1],
          module_name,
      )

  def create_class_in_module(self, module_path: str, class_name: str) -> str:
    file_path = module_path + '/src/' + class_name
    self.fs.create_file(
        file_path, contents='package ' + module_path[1:].replace('/', '.')
    )
    return file_path

  def create_module_paths(self, modules: list[str]):
    for m in modules:
      module_path = pathlib.Path(m)
      module_path.mkdir(parents=True, exist_ok=True)

  def create_finder_with_module(
      self, test_module: dict
  ) -> module_finder.ModuleFinder:
    return module_finder.ModuleFinder(self.create_module_info([test_module]))

  def create_finder_with_multiple_modules(
      self, test_modules: list[dict]
  ) -> module_finder.ModuleFinder:
    return module_finder.ModuleFinder(self.create_module_info(test_modules))

  def assert_test_info_has_test_name(
      self, t_info: test_info.TestInfo, test_name: str
  ):
    self.assertEqual(t_info.test_name, test_name)

  def assert_test_info_has_raw_test_name(
      self, t_info: test_info.TestInfo, test_name: str
  ):
    self.assertEqual(t_info.raw_test_name, test_name)

  def assert_test_info_has_class_filter(
      self, t_info: test_info.TestInfo, class_name: str
  ):
    self.assertSetEqual(
        frozenset([test_info.TestFilter(class_name, frozenset())]),
        t_info.data[constants.TI_FILTER],
    )

  def assert_test_info_has_config(
      self, t_info: test_info.TestInfo, config: str
  ):
    self.assertEqual(config, t_info.data[constants.TI_REL_CONFIG])

  def assert_test_info_contains_build_targets(
      self, t_info: test_info.TestInfo, expected_build_target: str
  ):
    self.assertTrue(
        any(expected_build_target in target for target in t_info.build_targets)
    )


class ModuleFinderFindTestByPath(fake_filesystem_unittest.TestCase):
  """Test cases that invoke find_test_by_path."""

  def setUp(self):
    super().setUp()
    self.setUpPyfakefs()

  # pylint: disable=protected-access
  def create_empty_module_info(self):
    fake_temp_file_name = next(tempfile._get_candidate_names())
    self.fs.create_file(fake_temp_file_name, contents='{}')
    return module_info.load_from_file(module_file=fake_temp_file_name)

  def create_module_info(self, modules=None):
    modules = modules or []
    name_to_module_info = {}

    for m in modules:
      name_to_module_info[m['module_name']] = m

    return module_info.load_from_dict(name_to_module_info=name_to_module_info)

  # TODO: remove below mocks and hide unnecessary information.
  @mock.patch.object(module_finder.ModuleFinder, '_get_test_info_filter')
  @mock.patch.object(
      test_finder_utils, 'find_parent_module_dir', return_value=None
  )
  # pylint: disable=unused-argument
  def test_find_test_by_path_belong_to_dependencies(
      self, _mock_find_parent, _mock_test_filter
  ):
    """Test find_test_by_path if belong to test dependencies."""
    test1 = module(
        name='test1',
        classes=['class'],
        dependencies=['lib1'],
        installed=['install/test1'],
        auto_test_config=[True],
    )
    test2 = module(
        name='test2',
        classes=['class'],
        dependencies=['lib2'],
        installed=['install/test2'],
        auto_test_config=[True],
    )
    lib1 = module(name='lib1', srcs=['path/src1'])
    lib2 = module(name='lib2', srcs=['path/src2'])
    mod_info = self.create_module_info([test1, test2, lib1, lib2])
    mod_finder = module_finder.ModuleFinder(module_info=mod_info)
    self.fs.create_file('path/src1/main.cpp', contents='')
    test1_filter = test_info.TestFilter('test1Filter', frozenset())
    _mock_test_filter.return_value = test1_filter

    t_infos = mod_finder.find_test_by_path('path/src1')

    unittest_utils.assert_equal_testinfos(
        self,
        test_info.TestInfo(
            'test1',
            atf_tr.AtestTradefedTestRunner.NAME,
            {'test1', 'MODULES-IN-'},
            {
                constants.TI_FILTER: test1_filter,
                constants.TI_REL_CONFIG: 'AndroidTest.xml',
            },
            module_class=['class'],
        ),
        t_infos[0],
    )


# pylint: disable=protected-access
class ModuleFinderUnittests(unittest.TestCase):
  """Unit tests for module_finder.py"""

  def setUp(self):
    """Set up stuff for testing."""
    super().setUp()
    self.mod_finder = module_finder.ModuleFinder()
    self.mod_finder.module_info = mock.Mock(spec=module_info.ModuleInfo)
    self.mod_finder.module_info.path_to_module_info = {}
    self.mod_finder.module_info.is_mobly_module.return_value = False
    self.mod_finder.root_dir = uc.ROOT

  def test_is_vts_module(self):
    """Test _load_module_info_file regular operation."""
    mod_name = 'mod'
    is_vts_module_info = {'compatibility_suites': ['vts10', 'tests']}
    self.mod_finder.module_info.get_module_info.return_value = (
        is_vts_module_info
    )
    self.assertTrue(self.mod_finder._is_vts_module(mod_name))

    is_not_vts_module = {'compatibility_suites': ['vts10', 'cts']}
    self.mod_finder.module_info.get_module_info.return_value = is_not_vts_module
    self.assertFalse(self.mod_finder._is_vts_module(mod_name))

  # pylint: disable=unused-argument
  @mock.patch.object(
      module_finder.ModuleFinder,
      '_get_build_targets',
      return_value=copy.deepcopy(uc.MODULE_BUILD_TARGETS),
  )
  def test_find_test_by_module_name(self, _get_targ):
    """Test find_test_by_module_name."""
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    self.mod_finder.module_info.has_test_config.return_value = True
    mod_info = {
        'installed': ['/path/to/install'],
        'path': [uc.MODULE_DIR],
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    t_infos = self.mod_finder.find_test_by_module_name(uc.MODULE_NAME)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.MODULE_INFO)
    self.mod_finder.module_info.get_module_info.return_value = None
    self.mod_finder.module_info.is_testable_module.return_value = False
    self.assertIsNone(self.mod_finder.find_test_by_module_name('Not_Module'))

  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[])
  @mock.patch.object(atest_utils, 'is_build_file', return_value=True)
  @mock.patch.object(
      test_filter_utils, 'is_parameterized_java_class', return_value=False
  )
  @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True)
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value=uc.FIND_ONE)
  @mock.patch.object(
      test_filter_utils,
      'get_fully_qualified_class_name',
      return_value=uc.FULL_CLASS_NAME,
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch('os.path.isdir', return_value=True)
  # pylint: disable=unused-argument
  def test_find_test_by_class_name(
      self,
      _isdir,
      _isfile,
      _fqcn,
      mock_checkoutput,
      mock_build,
      _vts,
      _has_method_in_file,
      _is_parameterized,
      _is_build_file,
      _mock_unit_tests,
      mods_to_test,
  ):
    """Test find_test_by_class_name."""
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    self.mod_finder.module_info.has_test_config.return_value = True
    self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    mods_to_test.return_value = [uc.MODULE_NAME]
    t_infos = self.mod_finder.find_test_by_class_name(uc.CLASS_NAME)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CLASS_INFO)

    # with method
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    class_with_method = '%s#%s' % (uc.CLASS_NAME, uc.METHOD_NAME)
    t_infos = self.mod_finder.find_test_by_class_name(class_with_method)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.METHOD_INFO)
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    class_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME)
    t_infos = self.mod_finder.find_test_by_class_name(class_methods)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], FLAT_METHOD_INFO)
    # module and rel_config passed in
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    t_infos = self.mod_finder.find_test_by_class_name(
        uc.CLASS_NAME, uc.MODULE_NAME, uc.CONFIG_FILE
    )
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CLASS_INFO)
    # find output fails to find class file
    mock_checkoutput.return_value = ''
    self.assertIsNone(self.mod_finder.find_test_by_class_name('Not class'))
    # class is outside given module path
    mock_checkoutput.side_effect = classoutside_side_effect
    t_infos = self.mod_finder.find_test_by_class_name(
        uc.CLASS_NAME, uc.MODULE2_NAME, uc.CONFIG2_FILE
    )
    unittest_utils.assert_equal_testinfos(self, t_infos[0], CLASS_INFO_MODULE_2)

  @mock.patch.object(
      test_finder_utils, 'find_parent_module_dir', return_value='foo/bar/jank'
  )
  @mock.patch.object(
      test_filter_utils, 'is_parameterized_java_class', return_value=False
  )
  @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True)
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value=uc.FIND_ONE)
  @mock.patch.object(
      test_filter_utils,
      'get_fully_qualified_class_name',
      return_value=uc.FULL_CLASS_NAME,
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  # pylint: disable=unused-argument
  def test_find_test_by_module_and_class(
      self,
      _isfile,
      _fqcn,
      mock_checkoutput,
      mock_build,
      _vts,
      _has_method_in_file,
      _is_parameterized,
      mock_parent_dir,
  ):
    """Test find_test_by_module_and_class."""
    # Native test was tested in test_find_test_by_cc_class_name().
    self.mod_finder.module_info.is_native_test.return_value = False
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    mod_info = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_PATH: [uc.MODULE_DIR],
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    t_infos = self.mod_finder.find_test_by_module_and_class(MODULE_CLASS)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CLASS_INFO)
    # with method
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    t_infos = self.mod_finder.find_test_by_module_and_class(MODULE_CLASS_METHOD)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.METHOD_INFO)
    self.mod_finder.module_info.is_testable_module.return_value = False
    # bad module, good class, returns None
    bad_module = '%s:%s' % ('BadMod', uc.CLASS_NAME)
    self.mod_finder.module_info.get_module_info.return_value = None
    self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_module))
    # find output fails to find class file
    mock_checkoutput.return_value = ''
    bad_class = '%s:%s' % (uc.MODULE_NAME, 'Anything')
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_class))

  @mock.patch.object(module_finder.test_finder_utils, 'get_cc_class_info')
  @mock.patch.object(
      module_finder.ModuleFinder,
      'find_test_by_kernel_class_name',
      return_value=None,
  )
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value=uc.FIND_CC_ONE)
  @mock.patch.object(
      test_finder_utils, 'find_class_file', side_effect=[None, None, '/']
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  # pylint: disable=unused-argument
  def test_find_test_by_module_and_class_part_2(
      self,
      _isfile,
      mock_fcf,
      mock_checkoutput,
      mock_build,
      _vts,
      _find_kernel,
      _class_info,
  ):
    """Test find_test_by_module_and_class for MODULE:CC_CLASS."""
    # Native test was tested in test_find_test_by_cc_class_name()
    self.mod_finder.module_info.is_native_test.return_value = False
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    self.mod_finder.module_info.get_paths.return_value = []
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    mod_info = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_PATH: [uc.CC_MODULE_DIR],
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    _class_info.return_value = {
        'PFTest': {
            'methods': {'test1', 'test2'},
            'prefixes': set(),
            'typed': False,
        }
    }
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    t_infos = self.mod_finder.find_test_by_module_and_class(CC_MODULE_CLASS)
    unittest_utils.assert_equal_testinfos(
        self, t_infos[0], uc.CC_MODULE_CLASS_INFO
    )
    # with method
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    mock_fcf.side_effect = [None, None, '/']
    t_infos = self.mod_finder.find_test_by_module_and_class(
        CC_MODULE_CLASS_METHOD
    )
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CC_METHOD3_INFO)
    # bad module, good class, returns None
    bad_module = '%s:%s' % ('BadMod', uc.CC_CLASS_NAME)
    self.mod_finder.module_info.get_module_info.return_value = None
    self.mod_finder.module_info.is_testable_module.return_value = False
    self.assertIsNone(self.mod_finder.find_test_by_module_and_class(bad_module))

  @mock.patch.object(
      module_finder.ModuleFinder,
      '_get_module_test_config',
      return_value=[KERNEL_CONFIG_FILE],
  )
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value=uc.FIND_CC_ONE)
  @mock.patch.object(
      test_finder_utils, 'find_class_file', side_effect=[None, None, '/']
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  # pylint: disable=unused-argument
  def test_find_test_by_module_and_class_for_kernel_test(
      self, _isfile, mock_fcf, mock_checkoutput, mock_build, _vts, _test_config
  ):
    """Test find_test_by_module_and_class for MODULE:CC_CLASS."""
    # Kernel test was tested in find_test_by_kernel_class_name()
    self.mod_finder.module_info.is_native_test.return_value = False
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    self.mod_finder.module_info.get_paths.return_value = []
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    mod_info = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_PATH: [uc.CC_MODULE_DIR],
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    t_infos = self.mod_finder.find_test_by_module_and_class(KERNEL_MODULE_CLASS)
    unittest_utils.assert_equal_testinfos(
        self, t_infos[0], KERNEL_MODULE_CLASS_INFO
    )

  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[])
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value=uc.FIND_PKG)
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch('os.path.isdir', return_value=True)
  # pylint: disable=unused-argument
  def test_find_test_by_package_name(
      self,
      _isdir,
      _isfile,
      mock_checkoutput,
      mock_build,
      _vts,
      _mock_unit_tests,
      mods_to_test,
  ):
    """Test find_test_by_package_name."""
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    mods_to_test.return_value = [uc.MODULE_NAME]
    t_infos = self.mod_finder.find_test_by_package_name(uc.PACKAGE)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.PACKAGE_INFO)
    # with method, should raise
    pkg_with_method = '%s#%s' % (uc.PACKAGE, uc.METHOD_NAME)
    self.assertRaises(
        atest_error.MethodWithoutClassError,
        self.mod_finder.find_test_by_package_name,
        pkg_with_method,
    )
    # module and rel_config passed in
    t_infos = self.mod_finder.find_test_by_package_name(
        uc.PACKAGE, uc.MODULE_NAME, uc.CONFIG_FILE
    )
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.PACKAGE_INFO)
    # find output fails to find class file
    mock_checkoutput.return_value = ''
    self.assertIsNone(self.mod_finder.find_test_by_package_name('Not pkg'))

  @mock.patch('os.path.isdir', return_value=False)
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value=uc.FIND_PKG)
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  # pylint: disable=unused-argument
  def test_find_test_by_module_and_package(
      self, _isfile, mock_checkoutput, mock_build, _vts, _isdir
  ):
    """Test find_test_by_module_and_package."""
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    self.mod_finder.module_info.get_paths.return_value = []
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    mod_info = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_PATH: [uc.MODULE_DIR],
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    t_infos = self.mod_finder.find_test_by_module_and_package(MODULE_PACKAGE)
    self.assertEqual(t_infos, None)
    _isdir.return_value = True
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    t_infos = self.mod_finder.find_test_by_module_and_package(MODULE_PACKAGE)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.PACKAGE_INFO)

    # with method, raises
    module_pkg_with_method = '%s:%s#%s' % (
        uc.MODULE2_NAME,
        uc.PACKAGE,
        uc.METHOD_NAME,
    )
    self.assertRaises(
        atest_error.MethodWithoutClassError,
        self.mod_finder.find_test_by_module_and_package,
        module_pkg_with_method,
    )
    # bad module, good pkg, returns None
    self.mod_finder.module_info.is_testable_module.return_value = False
    bad_module = '%s:%s' % ('BadMod', uc.PACKAGE)
    self.mod_finder.module_info.get_module_info.return_value = None
    self.assertIsNone(
        self.mod_finder.find_test_by_module_and_package(bad_module)
    )
    # find output fails to find package path
    mock_checkoutput.return_value = ''
    bad_pkg = '%s:%s' % (uc.MODULE_NAME, 'Anything')
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    self.assertIsNone(self.mod_finder.find_test_by_module_and_package(bad_pkg))

  # TODO: Move and rewite it to ModuleFinderFindTestByPath.
  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[])
  @mock.patch.object(test_finder_utils, 'get_cc_class_info', return_value={})
  @mock.patch.object(atest_utils, 'is_build_file', return_value=True)
  @mock.patch.object(
      test_filter_utils, 'is_parameterized_java_class', return_value=False
  )
  @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True)
  @mock.patch.object(test_finder_utils, 'has_cc_class', return_value=True)
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(
      test_filter_utils,
      'get_fully_qualified_class_name',
      return_value=uc.FULL_CLASS_NAME,
  )
  @mock.patch(
      'os.path.realpath', side_effect=unittest_utils.realpath_side_effect
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch.object(test_finder_utils, 'find_parent_module_dir')
  @mock.patch('os.path.exists')
  # pylint: disable=unused-argument
  def test_find_test_by_path(
      self,
      mock_pathexists,
      mock_dir,
      _isfile,
      _real,
      _fqcn,
      _vts,
      mock_build,
      _has_cc_class,
      _has_method_in_file,
      _is_parameterized,
      _is_build_file,
      _get_cc_class_info,
      _mock_unit_tests,
      mods_to_test,
  ):
    """Test find_test_by_path."""
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    self.mod_finder.module_info.get_modules_by_include_deps.return_value = set()
    mock_build.return_value = set()
    mods_to_test.return_value = [uc.MODULE_NAME]
    # Check that we don't return anything with invalid test references.
    mock_pathexists.return_value = False
    unittest_utils.assert_equal_testinfos(
        self, None, self.mod_finder.find_test_by_path('bad/path')
    )
    mock_pathexists.return_value = True
    mock_dir.return_value = None
    unittest_utils.assert_equal_testinfos(
        self, None, self.mod_finder.find_test_by_path('no/module')
    )
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }

    # Happy path testing.
    mock_dir.return_value = uc.MODULE_DIR

    class_path = '%s.kt' % uc.CLASS_NAME
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    t_infos = self.mod_finder.find_test_by_path(class_path)
    unittest_utils.assert_equal_testinfos(self, uc.CLASS_INFO, t_infos[0])

    class_with_method = '%s#%s' % (class_path, uc.METHOD_NAME)
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    t_infos = self.mod_finder.find_test_by_path(class_with_method)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.METHOD_INFO)

    class_path = '%s.java' % uc.CLASS_NAME
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    t_infos = self.mod_finder.find_test_by_path(class_path)
    unittest_utils.assert_equal_testinfos(self, uc.CLASS_INFO, t_infos[0])

    class_with_method = '%s#%s' % (class_path, uc.METHOD_NAME)
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    t_infos = self.mod_finder.find_test_by_path(class_with_method)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.METHOD_INFO)

    class_with_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME)
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    t_infos = self.mod_finder.find_test_by_path(class_with_methods)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], FLAT_METHOD_INFO)

    # Cc path testing.
    mods_to_test.return_value = [uc.CC_MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.CC_MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    mock_dir.return_value = uc.CC_MODULE_DIR
    class_path = '%s' % uc.CC_PATH
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    t_infos = self.mod_finder.find_test_by_path(class_path)
    unittest_utils.assert_equal_testinfos(self, uc.CC_PATH_INFO2, t_infos[0])

  # TODO: Move and rewite it to ModuleFinderFindTestByPath.
  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(
      module_finder.ModuleFinder,
      '_get_build_targets',
      return_value=copy.deepcopy(uc.MODULE_BUILD_TARGETS),
  )
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(
      test_finder_utils,
      'find_parent_module_dir',
      return_value=os.path.relpath(uc.TEST_DATA_DIR, uc.ROOT),
  )
  # pylint: disable=unused-argument
  def test_find_test_by_path_part_2(
      self, _find_parent, _is_vts, _get_build, mods_to_test
  ):
    """Test find_test_by_path for directories."""
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    # Dir with java files in it, should run as package
    class_dir = os.path.join(uc.TEST_DATA_DIR, 'path_testing')
    mods_to_test.return_value = [uc.MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    t_infos = self.mod_finder.find_test_by_path(class_dir)
    unittest_utils.assert_equal_testinfos(self, uc.PATH_INFO, t_infos[0])
    # Dir with no java files in it, should run whole module
    empty_dir = os.path.join(uc.TEST_DATA_DIR, 'path_testing_empty')
    t_infos = self.mod_finder.find_test_by_path(empty_dir)
    unittest_utils.assert_equal_testinfos(self, uc.EMPTY_PATH_INFO, t_infos[0])
    # Dir with cc files in it, should run as cc class
    class_dir = os.path.join(uc.TEST_DATA_DIR, 'cc_path_testing')
    mods_to_test.return_value = [uc.CC_MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.CC_MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    t_infos = self.mod_finder.find_test_by_path(class_dir)
    unittest_utils.assert_equal_testinfos(self, uc.CC_PATH_INFO, t_infos[0])

  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(module_finder.test_finder_utils, 'get_cc_class_info')
  @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[])
  @mock.patch.object(atest_utils, 'is_build_file', return_value=True)
  @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True)
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value=uc.CC_FIND_ONE)
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch('os.path.isdir', return_value=True)
  # pylint: disable=unused-argument
  def test_find_test_by_cc_class_name(
      self,
      _isdir,
      _isfile,
      mock_checkoutput,
      mock_build,
      _vts,
      _has_method,
      _is_build_file,
      _mock_unit_tests,
      _class_info,
      candicate_mods,
  ):
    """Test find_test_by_cc_class_name."""
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    candicate_mods.return_value = [uc.CC_MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.CC_MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    _class_info.return_value = {
        'PFTest': {
            'methods': {'test1', 'test2'},
            'prefixes': set(),
            'typed': False,
        }
    }
    t_infos = self.mod_finder.find_test_by_cc_class_name(uc.CC_CLASS_NAME)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CC_CLASS_INFO)

    # with method
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    class_with_method = '%s#%s' % (uc.CC_CLASS_NAME, uc.CC_METHOD_NAME)
    t_infos = self.mod_finder.find_test_by_cc_class_name(class_with_method)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CC_METHOD_INFO)
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    class_methods = '%s,%s' % (class_with_method, uc.CC_METHOD2_NAME)
    t_infos = self.mod_finder.find_test_by_cc_class_name(class_methods)
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CC_METHOD2_INFO)
    # module and rel_config passed in
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    t_infos = self.mod_finder.find_test_by_cc_class_name(
        uc.CC_CLASS_NAME, uc.CC_MODULE_NAME, uc.CC_CONFIG_FILE
    )
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CC_CLASS_INFO)
    # find output fails to find class file
    mock_checkoutput.return_value = ''
    self.assertIsNone(self.mod_finder.find_test_by_cc_class_name('Not class'))
    # class is outside given module path
    mock_checkoutput.return_value = uc.CC_FIND_ONE
    t_infos = self.mod_finder.find_test_by_cc_class_name(
        uc.CC_CLASS_NAME, uc.CC_MODULE2_NAME, uc.CC_CONFIG2_FILE
    )
    unittest_utils.assert_equal_testinfos(
        self, t_infos[0], CC_CLASS_INFO_MODULE_2
    )

  def test_get_testable_modules_with_ld(self):
    """Test get_testable_modules_with_ld"""
    self.mod_finder.module_info.get_testable_modules.return_value = [
        uc.MODULE_NAME,
        uc.MODULE2_NAME,
    ]
    # Without a misfit constraint
    ld1 = self.mod_finder.get_testable_modules_with_ld(uc.TYPO_MODULE_NAME)
    self.assertEqual([[16, uc.MODULE2_NAME], [1, uc.MODULE_NAME]], ld1)
    # With a misfit constraint
    ld2 = self.mod_finder.get_testable_modules_with_ld(uc.TYPO_MODULE_NAME, 2)
    self.assertEqual([[1, uc.MODULE_NAME]], ld2)

  def test_get_fuzzy_searching_modules(self):
    """Test get_fuzzy_searching_modules"""
    self.mod_finder.module_info.get_testable_modules.return_value = [
        uc.MODULE_NAME,
        uc.MODULE2_NAME,
    ]
    result = self.mod_finder.get_fuzzy_searching_results(uc.TYPO_MODULE_NAME)
    self.assertEqual(uc.MODULE_NAME, result[0])

  def test_get_build_targets_w_vts_core(self):
    """Test _get_build_targets."""
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = True
    self.mod_finder.module_info.get_paths.return_value = []
    mod_info = {
        constants.MODULE_COMPATIBILITY_SUITES: [constants.VTS_CORE_SUITE]
    }
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    self.assertEqual(
        self.mod_finder._get_build_targets('', ''),
        {constants.VTS_CORE_TF_MODULE},
    )

  def test_get_build_targets_w_mts(self):
    """Test _get_build_targets if module belong to mts."""
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = True
    self.mod_finder.module_info.get_paths.return_value = []
    mod_info = {constants.MODULE_COMPATIBILITY_SUITES: [constants.MTS_SUITE]}
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    self.assertEqual(
        self.mod_finder._get_build_targets('', ''), {constants.CTS_JAR}
    )

  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(
      test_filter_utils, 'is_parameterized_java_class', return_value=False
  )
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value='')
  @mock.patch.object(
      test_filter_utils,
      'get_fully_qualified_class_name',
      return_value=uc.FULL_CLASS_NAME,
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch('os.path.isdir', return_value=True)
  # pylint: disable=unused-argument
  def test_find_test_by_class_name_w_module(
      self,
      _isdir,
      _isfile,
      _fqcn,
      mock_checkoutput,
      mock_build,
      _vts,
      _is_parameterized,
      mods_to_test,
  ):
    """Test test_find_test_by_class_name with module but without class found."""
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    mods_to_test.return_value = [uc.MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_paths.return_value = [uc.TEST_DATA_CONFIG]
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    t_infos = self.mod_finder.find_test_by_class_name(
        uc.FULL_CLASS_NAME,
        module_name=uc.MODULE_NAME,
        rel_config_path=uc.CONFIG_FILE,
    )
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.CLASS_INFO)

  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value='')
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch('os.path.isdir', return_value=True)
  # pylint: disable=unused-argument
  def test_find_test_by_package_name_w_module(
      self, _isdir, _isfile, mock_checkoutput, mock_build, _vts
  ):
    """Test find_test_by_package_name with module but without package found."""
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    self.mod_finder.module_info.get_module_names.return_value = [uc.MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_paths.return_value = [uc.TEST_DATA_CONFIG]
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    t_infos = self.mod_finder.find_test_by_package_name(
        uc.PACKAGE, module_name=uc.MODULE_NAME, rel_config=uc.CONFIG_FILE
    )
    unittest_utils.assert_equal_testinfos(self, t_infos[0], uc.PACKAGE_INFO)

  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(atest_utils, 'is_build_file', return_value=True)
  @mock.patch.object(
      test_filter_utils, 'is_parameterized_java_class', return_value=True
  )
  @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True)
  @mock.patch.object(test_finder_utils, 'has_cc_class', return_value=True)
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(
      test_filter_utils,
      'get_fully_qualified_class_name',
      return_value=uc.FULL_CLASS_NAME,
  )
  @mock.patch(
      'os.path.realpath', side_effect=unittest_utils.realpath_side_effect
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch.object(test_finder_utils, 'find_parent_module_dir')
  @mock.patch('os.path.exists')
  # pylint: disable=unused-argument
  def test_find_test_by_path_is_parameterized_java(
      self,
      mock_pathexists,
      mock_dir,
      _isfile,
      _real,
      _fqcn,
      _vts,
      mock_build,
      _has_cc_class,
      _has_method_in_file,
      _is_parameterized,
      _is_build_file,
      mods_to_test,
  ):
    """Test find_test_by_path and input path is parameterized class."""
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    mock_build.return_value = set()
    mock_pathexists.return_value = True
    mods_to_test.return_value = [uc.MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    # Happy path testing.
    mock_dir.return_value = uc.MODULE_DIR
    class_path = '%s.java' % uc.CLASS_NAME
    # Input include only one method
    class_with_method = '%s#%s' % (class_path, uc.METHOD_NAME)
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    t_infos = self.mod_finder.find_test_by_path(class_with_method)
    unittest_utils.assert_equal_testinfos(
        self, t_infos[0], uc.PARAMETERIZED_METHOD_INFO
    )
    # Input include multiple methods
    class_with_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME)
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    t_infos = self.mod_finder.find_test_by_path(class_with_methods)
    unittest_utils.assert_equal_testinfos(
        self, t_infos[0], uc.PARAMETERIZED_FLAT_METHOD_INFO
    )

  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(test_finder_utils, 'find_host_unit_tests', return_value=[])
  @mock.patch.object(atest_utils, 'is_build_file', return_value=True)
  @mock.patch.object(
      test_filter_utils, 'is_parameterized_java_class', return_value=True
  )
  @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True)
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch('subprocess.check_output', return_value=uc.FIND_ONE)
  @mock.patch.object(
      test_filter_utils,
      'get_fully_qualified_class_name',
      return_value=uc.FULL_CLASS_NAME,
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch('os.path.isdir', return_value=True)
  # pylint: disable=unused-argument
  def test_find_test_by_class_name_is_parameterized(
      self,
      _isdir,
      _isfile,
      _fqcn,
      mock_checkoutput,
      mock_build,
      _vts,
      _has_method_in_file,
      _is_parameterized,
      _is_build_file,
      _mock_unit_tests,
      mods_to_test,
  ):
    """Test find_test_by_class_name and the class is parameterized java."""
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = False
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    self.mod_finder.module_info.has_test_config.return_value = True
    mods_to_test.return_value = [uc.MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    # With method
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    class_with_method = '%s#%s' % (uc.CLASS_NAME, uc.METHOD_NAME)
    t_infos = self.mod_finder.find_test_by_class_name(class_with_method)
    unittest_utils.assert_equal_testinfos(
        self, t_infos[0], uc.PARAMETERIZED_METHOD_INFO
    )
    # With multiple method
    mock_build.return_value = copy.deepcopy(uc.MODULE_BUILD_TARGETS)
    class_methods = '%s,%s' % (class_with_method, uc.METHOD2_NAME)
    t_infos = self.mod_finder.find_test_by_class_name(class_methods)
    unittest_utils.assert_equal_testinfos(
        self, t_infos[0], uc.PARAMETERIZED_FLAT_METHOD_INFO
    )

  # pylint: disable=unused-argument
  @mock.patch.object(
      module_finder.ModuleFinder,
      '_get_build_targets',
      return_value=copy.deepcopy(uc.MODULE_BUILD_TARGETS),
  )
  def test_find_test_by_config_name(self, _get_targ):
    """Test find_test_by_config_name."""
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True

    mod_info = {
        'installed': ['/path/to/install'],
        'path': [uc.MODULE_DIR],
        constants.MODULE_TEST_CONFIG: [uc.CONFIG_FILE, uc.EXTRA_CONFIG_FILE],
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    name_to_module_info = {uc.MODULE_NAME: mod_info}
    self.mod_finder.module_info.name_to_module_info = name_to_module_info
    t_infos = self.mod_finder.find_test_by_config_name(uc.MODULE_CONFIG_NAME)
    unittest_utils.assert_equal_testinfos(
        self, t_infos[0], uc.TEST_CONFIG_MODULE_INFO
    )

  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(
      test_filter_utils, 'is_parameterized_java_class', return_value=False
  )
  @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True)
  @mock.patch.object(test_finder_utils, 'has_cc_class', return_value=True)
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(
      test_filter_utils,
      'get_fully_qualified_class_name',
      return_value=uc.FULL_CLASS_NAME,
  )
  @mock.patch(
      'os.path.realpath', side_effect=unittest_utils.realpath_side_effect
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch.object(test_finder_utils, 'find_parent_module_dir')
  @mock.patch('os.path.exists')
  # pylint: disable=unused-argument
  def test_find_test_by_path_w_src_verify(
      self,
      mock_pathexists,
      mock_dir,
      _isfile,
      _real,
      _fqcn,
      _vts,
      mock_build,
      _has_cc_class,
      _has_method_in_file,
      _is_parameterized,
      mods_to_test,
  ):
    """Test find_test_by_path with src information."""
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    mods_to_test.return_value = [uc.MODULE_NAME]
    mock_build.return_value = uc.CLASS_BUILD_TARGETS

    # Happy path testing.
    mock_dir.return_value = uc.MODULE_DIR
    # Test path not in module's `srcs` but `path`.
    class_path = f'somewhere/to/module/{uc.CLASS_NAME}.java'
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_PATH: ['somewhere/to/module'],
        constants.MODULE_TEST_CONFIG: [uc.CONFIG_FILE],
        constants.MODULE_COMPATIBILITY_SUITES: [],
        constants.MODULE_SRCS: [],
    }
    t_infos = self.mod_finder.find_test_by_path(class_path)
    unittest_utils.assert_equal_testinfos(self, uc.CLASS_INFO, t_infos[0])

    # Test input file is in module's `srcs`.
    class_path = '%s.java' % uc.CLASS_NAME
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
        constants.MODULE_SRCS: [class_path],
    }

    t_infos = self.mod_finder.find_test_by_path(class_path)
    unittest_utils.assert_equal_testinfos(self, uc.CLASS_INFO, t_infos[0])

  @mock.patch.object(module_finder.ModuleFinder, '_determine_modules_to_test')
  @mock.patch.object(test_finder_utils, 'get_cc_class_info')
  @mock.patch.object(atest_utils, 'is_build_file', return_value=True)
  @mock.patch.object(
      test_filter_utils, 'is_parameterized_java_class', return_value=False
  )
  @mock.patch.object(test_finder_utils, 'has_method_in_file', return_value=True)
  @mock.patch.object(test_finder_utils, 'has_cc_class', return_value=True)
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(
      test_filter_utils,
      'get_fully_qualified_class_name',
      return_value=uc.FULL_CLASS_NAME,
  )
  @mock.patch(
      'os.path.realpath', side_effect=unittest_utils.realpath_side_effect
  )
  @mock.patch('os.path.isfile', side_effect=unittest_utils.isfile_side_effect)
  @mock.patch.object(test_finder_utils, 'find_parent_module_dir')
  @mock.patch('os.path.exists')
  # pylint: disable=unused-argument
  def test_find_test_by_path_for_cc_file(
      self,
      mock_pathexists,
      mock_dir,
      _isfile,
      _real,
      _fqcn,
      _vts,
      mock_build,
      _has_cc_class,
      _has_method_in_file,
      _is_parameterized,
      _is_build_file,
      _mock_cc_class_info,
      mods_to_test,
  ):
    """Test find_test_by_path for handling correct CC filter."""
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.has_test_config.return_value = True
    mock_build.return_value = set()
    # Check that we don't return anything with invalid test references.
    mock_pathexists.return_value = False
    mock_pathexists.return_value = True
    mock_dir.return_value = None
    mods_to_test.return_value = [uc.MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    # Happy path testing.
    mock_dir.return_value = uc.MODULE_DIR
    # Cc path testing if get_cc_class_info found those information.
    mods_to_test.return_value = [uc.CC_MODULE_NAME]
    self.mod_finder.module_info.get_module_info.return_value = {
        constants.MODULE_INSTALLED: DEFAULT_INSTALL_PATH,
        constants.MODULE_NAME: uc.CC_MODULE_NAME,
        constants.MODULE_CLASS: [],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    mock_dir.return_value = uc.CC_MODULE_DIR
    class_path = '%s' % uc.CC_PATH
    mock_build.return_value = uc.CLASS_BUILD_TARGETS
    # Test without parameterized test
    founded_classed = 'class1'
    founded_methods = {'method1'}
    founded_prefixes = set()
    _mock_cc_class_info.return_value = {
        founded_classed: {
            'methods': founded_methods,
            'prefixes': founded_prefixes,
            'typed': False,
        }
    }
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    cc_path_data = {
        constants.TI_REL_CONFIG: uc.CC_CONFIG_FILE,
        constants.TI_FILTER: frozenset(
            {test_info.TestFilter(class_name='class1.*', methods=frozenset())}
        ),
    }
    cc_path_info = test_info.TestInfo(
        uc.CC_MODULE_NAME,
        atf_tr.AtestTradefedTestRunner.NAME,
        uc.CLASS_BUILD_TARGETS,
        cc_path_data,
    )
    t_infos = self.mod_finder.find_test_by_path(class_path)
    unittest_utils.assert_equal_testinfos(self, cc_path_info, t_infos[0])
    # Test with parameterize test defined in input path
    founded_prefixes = {'class1'}
    _mock_cc_class_info.return_value = {
        founded_classed: {
            'methods': founded_methods,
            'prefixes': founded_prefixes,
            'typed': False,
        }
    }
    cc_path_data = {
        constants.TI_REL_CONFIG: uc.CC_CONFIG_FILE,
        constants.TI_FILTER: frozenset(
            {test_info.TestFilter(class_name='*/class1.*', methods=frozenset())}
        ),
    }
    cc_path_info = test_info.TestInfo(
        uc.CC_MODULE_NAME,
        atf_tr.AtestTradefedTestRunner.NAME,
        uc.CLASS_BUILD_TARGETS,
        cc_path_data,
    )
    t_infos = self.mod_finder.find_test_by_path(class_path)
    unittest_utils.assert_equal_testinfos(self, cc_path_info, t_infos[0])

  # pylint: disable=unused-argument
  @mock.patch.object(
      module_finder.ModuleFinder, '_is_vts_module', return_value=False
  )
  @mock.patch.object(
      module_finder.ModuleFinder,
      '_get_build_targets',
      return_value=copy.deepcopy(uc.MODULE_BUILD_TARGETS),
  )
  def test_process_test_info(self, _get_targ, _is_vts):
    """Test _process_test_info."""
    mod_info = {
        'installed': ['/path/to/install'],
        'path': [uc.MODULE_DIR],
        constants.MODULE_CLASS: [constants.MODULE_CLASS_JAVA_LIBRARIES],
        constants.MODULE_COMPATIBILITY_SUITES: [],
    }
    self.mod_finder.module_info.is_robolectric_test.return_value = False
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = True
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    self.mod_finder.module_info.get_instrumentation_target_apps.return_value = (
        {}
    )
    self.mod_finder.module_info.get_module_info.return_value = mod_info
    processed_info = self.mod_finder._process_test_info(
        copy.deepcopy(uc.MODULE_INFO)
    )
    unittest_utils.assert_equal_testinfos(
        self, processed_info, uc.MODULE_INFO_W_DALVIK
    )

  # pylint: disable=unused-argument
  @mock.patch.object(module_finder.ModuleFinder, '_get_build_targets')
  @mock.patch.object(module_info.ModuleInfo, 'get_instrumentation_target_apps')
  @mock.patch.object(module_info.ModuleInfo, 'get_robolectric_type')
  @mock.patch.object(module_info.ModuleInfo, 'is_testable_module')
  def test_process_test_info_with_instrumentation_target_apps(
      self, testable, robotype, tapps, btargets
  ):
    """Test _process_test_info."""
    testable.return_value = True
    robotype.return_value = 0
    target_module = 'AmSlam'
    test_module = 'AmSlamTests'
    artifact_path = '/out/somewhere/app/AmSlam.apk'
    tapps.return_value = {target_module: {artifact_path}}
    btargets.return_value = {target_module}
    self.mod_finder.module_info.is_auto_gen_test_config.return_value = True
    self.mod_finder.module_info.get_robolectric_type.return_value = 0
    test1 = module(
        name=target_module,
        classes=['APPS'],
        path=['foo/bar/AmSlam'],
        installed=[artifact_path],
    )
    test2 = module(
        name=test_module,
        classes=['APPS'],
        path=['foo/bar/AmSlam/test'],
        installed=['/out/somewhere/app/AmSlamTests.apk'],
    )
    info = test_info.TestInfo(
        test_module,
        atf_tr.AtestTradefedTestRunner.NAME,
        set(),
        {
            constants.TI_REL_CONFIG: uc.CONFIG_FILE,
            constants.TI_FILTER: frozenset(),
        },
    )

    self.mod_finder.module_info = create_module_info([test1, test2])
    t_infos = self.mod_finder._process_test_info(info)

    self.assertTrue(target_module in t_infos.build_targets)
    self.assertEqual([artifact_path], t_infos.artifacts)

  @mock.patch.object(test_finder_utils, 'get_annotated_methods')
  def test_is_srcs_match_method_annotation_include_anno(
      self, _mock_get_anno_methods
  ):
    """Test _is_srcs_match_method_annotation with include annotation."""
    annotation_dict = {constants.INCLUDE_ANNOTATION: 'includeAnnotation1'}
    input_method = 'my_input_method'
    input_srcs = ['src1']
    # Test if input method matched include annotation.
    _mock_get_anno_methods.return_value = {input_method, 'not_my_input_method'}

    is_matched = self.mod_finder._is_srcs_match_method_annotation(
        input_method, input_srcs, annotation_dict
    )

    self.assertTrue(is_matched)
    # Test if input method not matched include annotation.
    _mock_get_anno_methods.return_value = {'not_my_input_method'}

    is_matched = self.mod_finder._is_srcs_match_method_annotation(
        input_method, input_srcs, annotation_dict
    )

    self.assertFalse(is_matched)

  @mock.patch.object(test_finder_utils, 'get_annotated_methods')
  @mock.patch.object(test_finder_utils, 'get_java_methods')
  def test_is_srcs_match_method_exclude_anno(
      self, _mock_get_java_methods, _mock_get_exclude_anno_methods
  ):
    """Test _is_srcs_match_method_annotation with exclude annotation."""
    annotation_dict = {constants.EXCLUDE_ANNOTATION: 'excludeAnnotation1'}
    input_method = 'my_input_method'
    input_srcs = ['src1']
    _mock_get_java_methods.return_value = {input_method, 'method1', 'method2'}
    # Test if input method matched exclude annotation.
    _mock_get_exclude_anno_methods.return_value = {input_method, 'method1'}

    is_matched = self.mod_finder._is_srcs_match_method_annotation(
        input_method, input_srcs, annotation_dict
    )

    self.assertFalse(is_matched)

    # Test if input method not matched exclude annotation.
    _mock_get_exclude_anno_methods.return_value = {'method2'}

    is_matched = self.mod_finder._is_srcs_match_method_annotation(
        input_method, input_srcs, annotation_dict
    )

    self.assertTrue(is_matched)

  @mock.patch.object(atest_utils, 'get_android_junit_config_filters')
  @mock.patch.object(test_finder_utils, 'get_test_config_and_srcs')
  def test_get_matched_test_infos_no_filter(
      self, _mock_get_conf_srcs, _mock_get_filters
  ):
    """Test _get_matched_test_infos without test filters."""
    test_info1 = 'test_info1'
    test_infos = [test_info1]
    test_config = 'test_config'
    test_srcs = ['src1', 'src2']
    _mock_get_conf_srcs.return_value = test_config, test_srcs
    filter_dict = {}
    _mock_get_filters.return_value = filter_dict

    self.assertEqual(
        self.mod_finder._get_matched_test_infos(test_infos, {'method'}),
        test_infos,
    )

  @mock.patch.object(
      module_finder.ModuleFinder, '_is_srcs_match_method_annotation'
  )
  @mock.patch.object(atest_utils, 'get_android_junit_config_filters')
  @mock.patch.object(test_finder_utils, 'get_test_config_and_srcs')
  def test_get_matched_test_infos_get_filter_method_match(
      self, _mock_get_conf_srcs, _mock_get_filters, _mock_method_match
  ):
    """Test _get_matched_test_infos with test filters and method match."""
    test_infos = [KERNEL_MODULE_CLASS_INFO]
    test_config = 'test_config'
    test_srcs = ['src1', 'src2']
    _mock_get_conf_srcs.return_value = test_config, test_srcs
    filter_dict = {'include-annotation': 'annotate1'}
    _mock_get_filters.return_value = filter_dict
    _mock_method_match.return_value = True

    unittest_utils.assert_strict_equal(
        self,
        self.mod_finder._get_matched_test_infos(test_infos, {'method'}),
        test_infos,
    )

  @mock.patch.object(
      module_finder.ModuleFinder, '_is_srcs_match_method_annotation'
  )
  @mock.patch.object(atest_utils, 'get_android_junit_config_filters')
  @mock.patch.object(test_finder_utils, 'get_test_config_and_srcs')
  def test_get_matched_test_infos_filter_method_not_match(
      self, _mock_get_conf_srcs, _mock_get_filters, _mock_method_match
  ):
    """Test _get_matched_test_infos but method not match."""
    test_infos = [KERNEL_MODULE_CLASS_INFO]
    test_config = 'test_config'
    test_srcs = ['src1', 'src2']
    _mock_get_conf_srcs.return_value = test_config, test_srcs
    filter_dict = {'include-annotation': 'annotate1'}
    _mock_get_filters.return_value = filter_dict
    _mock_method_match.return_value = False

    self.assertEqual(
        self.mod_finder._get_matched_test_infos(test_infos, {'method'}), []
    )

  @mock.patch.object(module_finder.ModuleFinder, '_get_matched_test_infos')
  @mock.patch.object(
      module_finder.ModuleFinder, '_get_test_infos', return_value=uc.MODULE_INFO
  )
  @mock.patch.object(
      module_finder.ModuleFinder,
      '_get_test_info_filter',
      return_value=uc.CLASS_FILTER,
  )
  @mock.patch.object(
      test_finder_utils, 'find_class_file', return_value=['path1']
  )
  def test_find_test_by_class_name_not_matched_filters(
      self,
      _mock_class_path,
      _mock_test_filters,
      _mock_test_infos,
      _mock_matched_test_infos,
  ):
    """Test find_test_by_class_name which has not matched filters."""
    found_test_infos = [uc.MODULE_INFO, uc.MODULE_INFO2]
    _mock_test_infos.return_value = found_test_infos
    matched_test_infos = [uc.MODULE_INFO2]
    _mock_matched_test_infos.return_value = matched_test_infos

    # Test if class without method
    test_infos = self.mod_finder.find_test_by_class_name('my.test.class')
    self.assertEqual(len(test_infos), 2)
    unittest_utils.assert_equal_testinfos(self, test_infos[0], uc.MODULE_INFO)
    unittest_utils.assert_equal_testinfos(self, test_infos[1], uc.MODULE_INFO2)

    # Test if class with method
    test_infos = self.mod_finder.find_test_by_class_name(
        'my.test.class#myMethod'
    )
    self.assertEqual(len(test_infos), 1)
    unittest_utils.assert_equal_testinfos(self, test_infos[0], uc.MODULE_INFO2)

  @mock.patch.object(
      module_finder.ModuleFinder, '_get_test_infos', return_value=None
  )
  @mock.patch.object(
      module_finder.ModuleFinder,
      '_get_test_info_filter',
      return_value=uc.CLASS_FILTER,
  )
  @mock.patch.object(
      test_finder_utils, 'find_class_file', return_value=['path1']
  )
  def test_find_test_by_class_name_get_test_infos_none(
      self, _mock_class_path, _mock_test_filters, _mock_test_infos
  ):
    """Test find_test_by_class_name which has not matched test infos."""
    self.assertEqual(
        self.mod_finder.find_test_by_class_name('my.test.class'), None
    )


def create_empty_module_info():
  with fake_filesystem_unittest.Patcher() as patcher:
    # pylint: disable=protected-access
    fake_temp_file_name = next(tempfile._get_candidate_names())
    patcher.fs.create_file(fake_temp_file_name, contents='{}')
    return module_info.load_from_file(module_file=fake_temp_file_name)


def create_module_info(modules=None):
  name_to_module_info = {}
  modules = modules or []

  for m in modules:
    name_to_module_info[m['module_name']] = m

  return module_info.load_from_dict(name_to_module_info)


# pylint: disable=too-many-arguments
def module(
    name=None,
    path=None,
    installed=None,
    classes=None,
    auto_test_config=None,
    shared_libs=None,
    dependencies=None,
    runtime_dependencies=None,
    data=None,
    data_dependencies=None,
    compatibility_suites=None,
    host_dependencies=None,
    srcs=None,
):
  name = name or 'libhello'

  m = {}

  m['module_name'] = name
  m['class'] = classes
  m['path'] = path or ['']
  m['installed'] = installed or []
  m['is_unit_test'] = 'false'
  m['auto_test_config'] = auto_test_config or []
  m['shared_libs'] = shared_libs or []
  m['runtime_dependencies'] = runtime_dependencies or []
  m['dependencies'] = dependencies or []
  m['data'] = data or []
  m['data_dependencies'] = data_dependencies or []
  m['compatibility_suites'] = compatibility_suites or []
  m['host_dependencies'] = host_dependencies or []
  m['srcs'] = srcs or []
  return m


# pylint: disable=too-many-locals
def create_test_info(**kwargs):
  test_name = kwargs.pop('test_name')
  test_runner = kwargs.pop('test_runner')
  build_targets = kwargs.pop('build_targets')
  data = kwargs.pop('data', None)
  suite = kwargs.pop('suite', None)
  module_class = kwargs.pop('module_class', None)
  install_locations = kwargs.pop('install_locations', None)
  test_finder = kwargs.pop('test_finder', '')
  compatibility_suites = kwargs.pop('compatibility_suites', None)

  t_info = test_info.TestInfo(
      test_name=test_name,
      test_runner=test_runner,
      build_targets=build_targets,
      data=data,
      suite=suite,
      module_class=module_class,
      install_locations=install_locations,
      test_finder=test_finder,
      compatibility_suites=compatibility_suites,
  )
  raw_test_name = kwargs.pop('raw_test_name', None)
  if raw_test_name:
    t_info.raw_test_name = raw_test_name
  artifacts = kwargs.pop('artifacts', set())
  if artifacts:
    t_info.artifacts = artifacts
  robo_type = kwargs.pop('robo_type', None)
  if robo_type:
    t_info.robo_type = robo_type
  mainline_modules = kwargs.pop('mainline_modules', set())
  if mainline_modules:
    t_info._mainline_modules = mainline_modules
  for keyword in ['from_test_mapping', 'host', 'aggregate_metrics_result']:
    value = kwargs.pop(keyword, 'None')
    if isinstance(value, bool):
      setattr(t_info, keyword, value)
  if kwargs:
    assert f'Unknown keyword(s) for test_info: {kwargs.keys()}'
  return t_info


if __name__ == '__main__':
  unittest.main()