#!/usr/bin/env python3
#
# Copyright 2022 The Fuchsia Authors
#
# 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.

import shutil
import tempfile
import unittest

import mock
import mock_controller

from antlion import asserts
from antlion import base_test
from antlion import signals

from mobly import base_test as mobly_base_test
import mobly.config_parser as mobly_config_parser

MSG_EXPECTED_EXCEPTION = 'This is an expected exception.'
MSG_EXPECTED_TEST_FAILURE = 'This is an expected test failure.'
MSG_UNEXPECTED_EXCEPTION = 'Unexpected exception!'

MOCK_EXTRA = {'key': 'value', 'answer_to_everything': 42}


def never_call():
    raise Exception(MSG_UNEXPECTED_EXCEPTION)


class SomeError(Exception):
    """A custom exception class used for tests in this module."""


class ActsBaseClassTest(unittest.TestCase):
    def setUp(self):
        self.tmp_dir = tempfile.mkdtemp()
        self.tb_key = 'testbed_configs'
        self.test_run_config = mobly_config_parser.TestRunConfig()
        self.test_run_config.testbed_name = 'SampleTestBed'
        self.test_run_config.controller_configs = {
            self.tb_key: {
                'name': self.test_run_config.testbed_name,
            },
        }
        self.test_run_config.log_path = self.tmp_dir
        self.test_run_config.user_params = {'some_param': 'hahaha'}
        self.test_run_config.summary_writer = mock.MagicMock()
        self.mock_test_name = 'test_something'

    def tearDown(self):
        shutil.rmtree(self.tmp_dir)

    def test_current_test_case_name(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.assert_true(
                    self.current_test_name == 'test_func',
                    'Got unexpected test name %s.' % self.current_test_name)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_func'])
        actual_record = bt_cls.results.passed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertIsNone(actual_record.details)
        self.assertIsNone(actual_record.extras)

    def test_self_tests_list(self):
        class MockBaseTest(base_test.BaseTestClass):
            def __init__(self, controllers):
                super(MockBaseTest, self).__init__(controllers)
                self.tests = ('test_something', )

            def test_something(self):
                pass

            def test_never(self):
                # This should not execute it's not on default test list.
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.passed[0]
        self.assertEqual(actual_record.test_name, 'test_something')

    def test_cli_test_selection_match_self_tests_list(self):
        class MockBaseTest(base_test.BaseTestClass):
            def __init__(self, controllers):
                super(MockBaseTest, self).__init__(controllers)
                self.tests = ('test_star1', 'test_star2', 'test_question_mark',
                              'test_char_seq', 'test_no_match')

            def test_star1(self):
                pass

            def test_star2(self):
                pass

            def test_question_mark(self):
                pass

            def test_char_seq(self):
                pass

            def test_no_match(self):
                # This should not execute because it does not match any regex
                # in the cmd line input.
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        test_names = [
            'test_st*r1', 'test_*2', 'test_?uestion_mark', 'test_c[fghi]ar_seq'
        ]
        bt_cls.run(test_names=test_names)
        passed_names = [p.test_name for p in bt_cls.results.passed]
        self.assertEqual(len(passed_names), len(test_names))
        for test in [
                'test_star1', 'test_star2', 'test_question_mark',
                'test_char_seq'
        ]:
            self.assertIn(test, passed_names)

    def test_default_execution_of_all_tests(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_something(self):
                pass

            def not_a_test(self):
                # This should not execute its name doesn't follow test case
                # naming convention.
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.passed[0]
        self.assertEqual(actual_record.test_name, 'test_something')

    def test_setup_class_fail_by_exception(self):
        call_check = mock.MagicMock()

        class MockBaseTest(base_test.BaseTestClass):
            def setup_class(self):
                raise Exception(MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                # This should not execute because setup_class failed.
                never_call()

            def on_skip(self, test_name, begin_time):
                call_check('haha')

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, 'test_something')
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)
        call_check.assert_called_once_with('haha')

    def test_setup_test_fail_by_exception(self):
        class MockBaseTest(base_test.BaseTestClass):
            def setup_test(self):
                raise Exception(MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                # This should not execute because setup_test failed.
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_something'])
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_setup_test_fail_by_test_signal(self):
        class MockBaseTest(base_test.BaseTestClass):
            def setup_test(self):
                raise signals.TestFailure(MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                # This should not execute because setup_test failed.
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_something'])
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 0,
            'Executed': 1,
            'Failed': 1,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_setup_test_fail_by_return_False(self):
        class MockBaseTest(base_test.BaseTestClass):
            def setup_test(self):
                return False

            def test_something(self):
                # This should not execute because setup_test failed.
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_something'])
        actual_record = bt_cls.results.failed[0]
        expected_msg = 'Setup for %s failed.' % self.mock_test_name
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, expected_msg)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 0,
            'Executed': 1,
            'Failed': 1,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_teardown_test_assert_fail(self):
        class MockBaseTest(base_test.BaseTestClass):
            def teardown_test(self):
                asserts.assert_true(False, MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_teardown_test_raise_exception(self):
        class MockBaseTest(base_test.BaseTestClass):
            def teardown_test(self):
                raise Exception(MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_teardown_test_executed_if_test_pass(self):
        my_mock = mock.MagicMock()

        class MockBaseTest(base_test.BaseTestClass):
            def teardown_test(self):
                my_mock('teardown_test')

            def test_something(self):
                pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.passed[0]
        my_mock.assert_called_once_with('teardown_test')
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertIsNone(actual_record.details)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 0,
            'Executed': 1,
            'Failed': 0,
            'Passed': 1,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_teardown_test_executed_if_setup_test_fails(self):
        my_mock = mock.MagicMock()

        class MockBaseTest(base_test.BaseTestClass):
            def setup_test(self):
                raise Exception(MSG_EXPECTED_EXCEPTION)

            def teardown_test(self):
                my_mock('teardown_test')

            def test_something(self):
                pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        my_mock.assert_called_once_with('teardown_test')
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_teardown_test_executed_if_test_fails(self):
        my_mock = mock.MagicMock()

        class MockBaseTest(base_test.BaseTestClass):
            def teardown_test(self):
                my_mock('teardown_test')

            def test_something(self):
                raise Exception(MSG_EXPECTED_EXCEPTION)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        my_mock.assert_called_once_with('teardown_test')
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_on_exception_executed_if_teardown_test_fails(self):
        my_mock = mock.MagicMock()

        class MockBaseTest(base_test.BaseTestClass):
            def on_exception(self, test_name, begin_time):
                my_mock('on_exception')

            def teardown_test(self):
                raise Exception(MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        my_mock.assert_called_once_with('on_exception')
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_on_fail_executed_if_test_fails(self):
        my_mock = mock.MagicMock()

        class MockBaseTest(base_test.BaseTestClass):
            def on_fail(self, test_name, begin_time):
                my_mock('on_fail')

            def test_something(self):
                asserts.assert_true(False, MSG_EXPECTED_EXCEPTION)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        my_mock.assert_called_once_with('on_fail')
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 0,
            'Executed': 1,
            'Failed': 1,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_on_fail_executed_if_test_setup_fails_by_exception(self):
        my_mock = mock.MagicMock()

        class MockBaseTest(base_test.BaseTestClass):
            def setup_test(self):
                raise Exception(MSG_EXPECTED_EXCEPTION)

            def on_fail(self, test_name, begin_time):
                my_mock('on_fail')

            def test_something(self):
                pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        my_mock.assert_called_once_with('on_fail')
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_on_fail_executed_if_test_setup_fails_by_return_False(self):
        my_mock = mock.MagicMock()

        class MockBaseTest(base_test.BaseTestClass):
            def setup_test(self):
                return False

            def on_fail(self, test_name, begin_time):
                my_mock('on_fail')

            def test_something(self):
                pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        my_mock.assert_called_once_with('on_fail')
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details,
                         'Setup for test_something failed.')
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 0,
            'Executed': 1,
            'Failed': 1,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_failure_to_call_procedure_function_is_recorded(self):
        class MockBaseTest(base_test.BaseTestClass):
            # Wrong method signature; will raise exception
            def on_pass(self):
                pass

            def test_something(self):
                asserts.explicit_pass(MSG_EXPECTED_EXCEPTION)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertIn('_on_pass', actual_record.extra_errors)
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_failure_in_procedure_functions_is_recorded(self):
        expected_msg = 'Something failed in on_pass.'

        class MockBaseTest(base_test.BaseTestClass):
            def on_pass(self, test_name, begin_time):
                raise Exception(expected_msg)

            def test_something(self):
                asserts.explicit_pass(MSG_EXPECTED_EXCEPTION)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_both_teardown_and_test_body_raise_exceptions(self):
        class MockBaseTest(base_test.BaseTestClass):
            def teardown_test(self):
                asserts.assert_true(False, MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                raise Exception('Test Body Exception.')

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, 'Test Body Exception.')
        self.assertIsNone(actual_record.extras)
        self.assertEqual(actual_record.extra_errors['teardown_test'].details,
                         'This is an expected exception.')
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_explicit_pass_but_teardown_test_raises_an_exception(self):
        """Test record result should be marked as UNKNOWN as opposed to PASS.
        """
        class MockBaseTest(base_test.BaseTestClass):
            def teardown_test(self):
                asserts.assert_true(False, MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                asserts.explicit_pass('Test Passed!')

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, 'Test Passed!')
        self.assertIsNone(actual_record.extras)
        self.assertEqual(actual_record.extra_errors['teardown_test'].details,
                         'This is an expected exception.')
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_on_pass_raise_exception(self):
        class MockBaseTest(base_test.BaseTestClass):
            def on_pass(self, test_name, begin_time):
                raise Exception(MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                asserts.explicit_pass(MSG_EXPECTED_EXCEPTION,
                                      extras=MOCK_EXTRA)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)
        expected_summary = {
            'Error': 1,
            'Executed': 1,
            'Failed': 0,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_on_fail_raise_exception(self):
        class MockBaseTest(base_test.BaseTestClass):
            def on_fail(self, test_name, begin_time):
                raise Exception(MSG_EXPECTED_EXCEPTION)

            def test_something(self):
                asserts.fail(MSG_EXPECTED_EXCEPTION, extras=MOCK_EXTRA)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(bt_cls.results.error, [])
        self.assertEqual(actual_record.test_name, self.mock_test_name)
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)
        expected_summary = {
            'Error': 0,
            'Executed': 1,
            'Failed': 1,
            'Passed': 0,
            'Requested': 1,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_abort_class(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_1(self):
                pass

            def test_2(self):
                asserts.abort_class(MSG_EXPECTED_EXCEPTION)
                never_call()

            def test_3(self):
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_1', 'test_2', 'test_3'])
        self.assertEqual(bt_cls.results.passed[0].test_name, 'test_1')
        self.assertEqual(bt_cls.results.failed[0].details,
                         MSG_EXPECTED_EXCEPTION)
        expected_summary = {
            'Error': 0,
            'Executed': 2,
            'Failed': 1,
            'Passed': 1,
            'Requested': 3,
            'Skipped': 0
        }
        self.assertEqual(bt_cls.results.summary_dict(), expected_summary)

    def test_uncaught_exception(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                raise Exception(MSG_EXPECTED_EXCEPTION)
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_func'])
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)

    def test_fail(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.fail(MSG_EXPECTED_EXCEPTION, extras=MOCK_EXTRA)
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_func'])
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_assert_true(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.assert_true(False,
                                    MSG_EXPECTED_EXCEPTION,
                                    extras=MOCK_EXTRA)
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_func'])
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_assert_equal_pass(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.assert_equal(1, 1, extras=MOCK_EXTRA)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.passed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertIsNone(actual_record.details)
        self.assertIsNone(actual_record.extras)

    def test_assert_equal_fail(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.assert_equal(1, 2, extras=MOCK_EXTRA)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertIn('1 != 2', actual_record.details)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_assert_equal_fail_with_msg(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.assert_equal(1,
                                     2,
                                     msg=MSG_EXPECTED_EXCEPTION,
                                     extras=MOCK_EXTRA)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        expected_msg = '1 != 2 ' + MSG_EXPECTED_EXCEPTION
        self.assertIn(expected_msg, actual_record.details)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_assert_raises_pass(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                with asserts.assert_raises(SomeError, extras=MOCK_EXTRA):
                    raise SomeError(MSG_EXPECTED_EXCEPTION)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.passed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertIsNone(actual_record.details)
        self.assertIsNone(actual_record.extras)

    def test_assert_raises_regex_pass(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                with asserts.assert_raises_regex(
                        SomeError,
                        expected_regex=MSG_EXPECTED_EXCEPTION,
                        extras=MOCK_EXTRA):
                    raise SomeError(MSG_EXPECTED_EXCEPTION)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.passed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertIsNone(actual_record.details)
        self.assertIsNone(actual_record.extras)

    def test_assert_raises_fail_with_noop(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                with asserts.assert_raises_regex(
                        SomeError,
                        expected_regex=MSG_EXPECTED_EXCEPTION,
                        extras=MOCK_EXTRA):
                    pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertEqual(actual_record.details, 'SomeError not raised')
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_assert_raises_fail_with_wrong_regex(self):
        wrong_msg = 'ha'

        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                with asserts.assert_raises_regex(
                        SomeError,
                        expected_regex=MSG_EXPECTED_EXCEPTION,
                        extras=MOCK_EXTRA):
                    raise SomeError(wrong_msg)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.failed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        expected_details = ('"This is an expected exception." does not match '
                            '"%s"') % wrong_msg
        self.assertEqual(actual_record.details, expected_details)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_assert_raises_fail_with_wrong_error(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                with asserts.assert_raises_regex(
                        SomeError,
                        expected_regex=MSG_EXPECTED_EXCEPTION,
                        extras=MOCK_EXTRA):
                    raise AttributeError(MSG_UNEXPECTED_EXCEPTION)

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run()
        actual_record = bt_cls.results.error[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertEqual(actual_record.details, MSG_UNEXPECTED_EXCEPTION)
        self.assertIsNone(actual_record.extras)

    def test_explicit_pass(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.explicit_pass(MSG_EXPECTED_EXCEPTION,
                                      extras=MOCK_EXTRA)
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_func'])
        actual_record = bt_cls.results.passed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_implicit_pass(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                pass

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_func'])
        actual_record = bt_cls.results.passed[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertIsNone(actual_record.details)
        self.assertIsNone(actual_record.extras)

    def test_skip(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.skip(MSG_EXPECTED_EXCEPTION, extras=MOCK_EXTRA)
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_func'])
        actual_record = bt_cls.results.skipped[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_skip_if(self):
        class MockBaseTest(base_test.BaseTestClass):
            def test_func(self):
                asserts.skip_if(False, MSG_UNEXPECTED_EXCEPTION)
                asserts.skip_if(True,
                                MSG_EXPECTED_EXCEPTION,
                                extras=MOCK_EXTRA)
                never_call()

        bt_cls = MockBaseTest(self.test_run_config)
        bt_cls.run(test_names=['test_func'])
        actual_record = bt_cls.results.skipped[0]
        self.assertEqual(actual_record.test_name, 'test_func')
        self.assertEqual(actual_record.details, MSG_EXPECTED_EXCEPTION)
        self.assertEqual(actual_record.extras, MOCK_EXTRA)

    def test_unpack_userparams_required(self):
        """Missing a required param should raise an error."""
        required = ['some_param']
        bc = base_test.BaseTestClass(self.test_run_config)
        bc.unpack_userparams(required)
        expected_value = self.test_run_config.user_params['some_param']
        self.assertEqual(bc.some_param, expected_value)

    def test_unpack_userparams_required_missing(self):
        """Missing a required param should raise an error."""
        required = ['something']
        bc = base_test.BaseTestClass(self.test_run_config)
        expected_msg = ('Missing required user param "%s" in test '
                        'configuration.') % required[0]
        with self.assertRaises(mobly_base_test.Error, msg=expected_msg):
            bc.unpack_userparams(required)

    def test_unpack_userparams_optional(self):
        """If an optional param is specified, the value should be what's in the
        config.
        """
        opt = ['some_param']
        bc = base_test.BaseTestClass(self.test_run_config)
        bc.unpack_userparams(opt_param_names=opt)
        expected_value = self.test_run_config.user_params['some_param']
        self.assertEqual(bc.some_param, expected_value)

    def test_unpack_userparams_optional_with_default(self):
        """If an optional param is specified with a default value, and the
        param is not in the config, the value should be the default value.
        """
        bc = base_test.BaseTestClass(self.test_run_config)
        bc.unpack_userparams(optional_thing='whatever')
        self.assertEqual(bc.optional_thing, 'whatever')

    def test_unpack_userparams_default_overwrite_by_optional_param_list(self):
        """If an optional param is specified in kwargs, and the param is in the
        config, the value should be the one in the config.
        """
        bc = base_test.BaseTestClass(self.test_run_config)
        bc.unpack_userparams(some_param='whatever')
        expected_value = self.test_run_config.user_params['some_param']
        self.assertEqual(bc.some_param, expected_value)

    def test_unpack_userparams_default_overwrite_by_required_param_list(self):
        """If an optional param is specified in kwargs, the param is in the
        required param list, and the param is not specified in the config, the
        param's alue should be the default value and there should be no error
        thrown.
        """
        bc = base_test.BaseTestClass(self.test_run_config)
        bc.unpack_userparams(req_param_names=['a_kwarg_param'],
                             a_kwarg_param='whatever')
        self.assertEqual(bc.a_kwarg_param, 'whatever')

    def test_unpack_userparams_optional_missing(self):
        """Missing an optional param should not raise an error."""
        opt = ['something']
        bc = base_test.BaseTestClass(self.test_run_config)
        bc.unpack_userparams(opt_param_names=opt)

    def test_unpack_userparams_basic(self):
        """Required and optional params are unpacked properly."""
        required = ['something']
        optional = ['something_else']
        configs = self.test_run_config.copy()
        configs.user_params['something'] = 42
        configs.user_params['something_else'] = 53
        bc = base_test.BaseTestClass(configs)
        bc.unpack_userparams(req_param_names=required,
                             opt_param_names=optional)
        self.assertEqual(bc.something, 42)
        self.assertEqual(bc.something_else, 53)

    def test_unpack_userparams_default_overwrite(self):
        default_arg_val = 'haha'
        actual_arg_val = 'wawa'
        arg_name = 'arg1'
        configs = self.test_run_config.copy()
        configs.user_params[arg_name] = actual_arg_val
        bc = base_test.BaseTestClass(configs)
        bc.unpack_userparams(opt_param_names=[arg_name], arg1=default_arg_val)
        self.assertEqual(bc.arg1, actual_arg_val)

    def test_unpack_userparams_default_None(self):
        bc = base_test.BaseTestClass(self.test_run_config)
        bc.unpack_userparams(arg1='haha')
        self.assertEqual(bc.arg1, 'haha')

    def test_register_controller_no_config(self):
        base_cls = base_test.BaseTestClass(self.test_run_config)
        with self.assertRaisesRegexp(signals.ControllerError,
                                     'No corresponding config found for'):
            base_cls.register_controller(mock_controller)

    def test_register_optional_controller_no_config(self):
        base_cls = base_test.BaseTestClass(self.test_run_config)
        self.assertIsNone(
            base_cls.register_controller(mock_controller, required=False))

    def test_register_controller_third_party_dup_register(self):
        """Verifies correctness of registration, internal tally of controllers
        objects, and the right error happen when a controller module is
        registered twice.
        """
        mock_test_config = self.test_run_config.copy()
        mock_ctrlr_config_name = mock_controller.MOBLY_CONTROLLER_CONFIG_NAME
        mock_test_config.controller_configs[mock_ctrlr_config_name] = [
            'magic1', 'magic2'
        ]
        base_cls = base_test.BaseTestClass(mock_test_config)
        base_cls.register_controller(mock_controller)
        registered_name = 'mock_controller'
        controller_objects = base_cls._controller_manager._controller_objects
        self.assertTrue(registered_name in controller_objects)
        mock_ctrlrs = controller_objects[registered_name]
        self.assertEqual(mock_ctrlrs[0].magic, 'magic1')
        self.assertEqual(mock_ctrlrs[1].magic, 'magic2')
        expected_msg = 'Controller module .* has already been registered.'
        with self.assertRaisesRegexp(signals.ControllerError, expected_msg):
            base_cls.register_controller(mock_controller)

    def test_register_optional_controller_third_party_dup_register(self):
        """Verifies correctness of registration, internal tally of controllers
        objects, and the right error happen when an optional controller module
        is registered twice.
        """
        mock_test_config = self.test_run_config.copy()
        mock_ctrlr_config_name = mock_controller.MOBLY_CONTROLLER_CONFIG_NAME
        mock_test_config.controller_configs[mock_ctrlr_config_name] = [
            'magic1', 'magic2'
        ]
        base_cls = base_test.BaseTestClass(mock_test_config)
        base_cls.register_controller(mock_controller, required=False)
        expected_msg = 'Controller module .* has already been registered.'
        with self.assertRaisesRegexp(signals.ControllerError, expected_msg):
            base_cls.register_controller(mock_controller, required=False)

    def test_register_controller_builtin_dup_register(self):
        """Same as test_register_controller_third_party_dup_register, except
        this is for a builtin controller module.
        """
        mock_test_config = self.test_run_config.copy()
        mock_ctrlr_config_name = mock_controller.MOBLY_CONTROLLER_CONFIG_NAME
        mock_ref_name = 'haha'
        setattr(mock_controller, 'ACTS_CONTROLLER_REFERENCE_NAME',
                mock_ref_name)
        try:
            mock_ctrlr_ref_name = mock_controller.ACTS_CONTROLLER_REFERENCE_NAME
            mock_test_config.controller_configs[mock_ctrlr_config_name] = [
                'magic1', 'magic2'
            ]
            base_cls = base_test.BaseTestClass(mock_test_config)
            base_cls.register_controller(mock_controller, builtin=True)
            self.assertTrue(hasattr(base_cls, mock_ref_name))
            self.assertTrue(mock_controller.__name__ in
                            base_cls._controller_manager._controller_objects)
            mock_ctrlrs = getattr(base_cls, mock_ctrlr_ref_name)
            self.assertEqual(mock_ctrlrs[0].magic, 'magic1')
            self.assertEqual(mock_ctrlrs[1].magic, 'magic2')
            expected_msg = 'Controller module .* has already been registered.'
            with self.assertRaisesRegexp(signals.ControllerError,
                                         expected_msg):
                base_cls.register_controller(mock_controller, builtin=True)
        finally:
            delattr(mock_controller, 'ACTS_CONTROLLER_REFERENCE_NAME')

    def test_register_controller_no_get_info(self):
        mock_test_config = self.test_run_config.copy()
        mock_ctrlr_config_name = mock_controller.MOBLY_CONTROLLER_CONFIG_NAME
        mock_ref_name = 'haha'
        get_info = getattr(mock_controller, 'get_info')
        delattr(mock_controller, 'get_info')
        try:
            mock_test_config.controller_configs[mock_ctrlr_config_name] = [
                'magic1', 'magic2'
            ]
            base_cls = base_test.BaseTestClass(mock_test_config)
            base_cls.register_controller(mock_controller)
            self.assertEqual(base_cls.results.controller_info, [])
        finally:
            setattr(mock_controller, 'get_info', get_info)

    def test_register_controller_return_value(self):
        mock_test_config = self.test_run_config.copy()
        mock_ctrlr_config_name = mock_controller.MOBLY_CONTROLLER_CONFIG_NAME
        mock_test_config.controller_configs[mock_ctrlr_config_name] = [
            'magic1', 'magic2'
        ]
        base_cls = base_test.BaseTestClass(mock_test_config)
        magic_devices = base_cls.register_controller(mock_controller)
        self.assertEqual(magic_devices[0].magic, 'magic1')
        self.assertEqual(magic_devices[1].magic, 'magic2')

    def test_handle_file_user_params_does_not_overwrite_existing_params(self):
        test_run_config = self.test_run_config.copy()
        test_run_config.user_params = {
            'foo': ['good_value'],
            'local_files': {
                'foo': ['bad_value']
            }
        }
        test = base_test.BaseTestClass(test_run_config)

        self.assertEqual(test.user_params['foo'], ['good_value'])

    def test_handle_file_user_params_dumps_files_dict(self):
        test_run_config = self.test_run_config.copy()
        test_run_config.user_params = {
            'my_files': {
                'foo': ['good_value']
            }
        }
        test = base_test.BaseTestClass(test_run_config)

        self.assertEqual(test.user_params['foo'], ['good_value'])

    def test_handle_file_user_params_is_called_in_init(self):
        test_run_config = self.test_run_config.copy()
        test_run_config.user_params['files'] = {
            'file_a': ['/some/path']
        }
        test = base_test.BaseTestClass(test_run_config)

        self.assertEqual(test.user_params['file_a'], ['/some/path'])


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