# Copyright 2016 Google Inc.
#
# 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 unittest

from mobly import asserts
from mobly import signals

MSG_EXPECTED_EXCEPTION = 'This is an expected exception.'
_OBJECT_1 = object()
_OBJECT_2 = object()


class AssertsTest(unittest.TestCase):
  """Verifies that asserts.xxx functions raise the correct test signals."""

  def test_assert_false(self):
    asserts.assert_false(False, MSG_EXPECTED_EXCEPTION)
    with self.assertRaisesRegex(signals.TestFailure, MSG_EXPECTED_EXCEPTION):
      asserts.assert_false(True, MSG_EXPECTED_EXCEPTION)

  def test_assert_not_equal_pass(self):
    asserts.assert_not_equal(1, 2)

  def test_assert_not_equal_pass_with_msg_and_extras(self):
    asserts.assert_not_equal(1, 2, msg='Message', extras='Extras')

  def test_assert_not_equal_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_equal(1, 1)
    self.assertEqual(cm.exception.details, '1 == 1')

  def test_assert_not_equal_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_equal(1, 1, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details, '1 == 1 Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_almost_equal_pass(self):
    asserts.assert_almost_equal(1.000001, 1.000002, places=3)
    asserts.assert_almost_equal(1.0, 1.05, delta=0.1)

  def test_assert_almost_equal_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_almost_equal(1, 1.0005, places=7)
    self.assertRegex(cm.exception.details, r'1 != 1\.0005 within 7 places')

  def test_assert_almost_equal_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_almost_equal(1,
                                  2,
                                  delta=0.1,
                                  msg='Message',
                                  extras='Extras')
    self.assertRegex(cm.exception.details, r'1 != 2 within 0\.1 delta.*Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_not_almost_equal_pass(self):
    asserts.assert_not_almost_equal(1.001, 1.002, places=3)
    asserts.assert_not_almost_equal(1.0, 1.05, delta=0.01)

  def test_assert_not_almost_equal_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_almost_equal(1, 1.0005, places=3)
    self.assertRegex(cm.exception.details, r'1 == 1\.0005 within 3 places')

  def test_assert_not_almost_equal_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_almost_equal(1,
                                      2,
                                      delta=1,
                                      msg='Message',
                                      extras='Extras')
    self.assertRegex(cm.exception.details, r'1 == 2 within 1 delta.*Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_in_pass(self):
    asserts.assert_in(1, [1, 2, 3])
    asserts.assert_in(1, (1, 2, 3))
    asserts.assert_in(1, {1: 2, 3: 4})
    asserts.assert_in('a', 'abcd')

  def test_assert_in_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_in(4, [1, 2, 3])
    self.assertEqual(cm.exception.details, '4 not found in [1, 2, 3]')

  def test_assert_in_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_in(4, [1, 2, 3], msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details, '4 not found in [1, 2, 3] Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_not_in_pass(self):
    asserts.assert_not_in(4, [1, 2, 3])
    asserts.assert_not_in(4, (1, 2, 3))
    asserts.assert_not_in(4, {1: 2, 3: 4})
    asserts.assert_not_in('e', 'abcd')

  def test_assert_not_in_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_in(1, [1, 2, 3])
    self.assertEqual(cm.exception.details, '1 unexpectedly found in [1, 2, 3]')

  def test_assert_not_in_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_in(1, [1, 2, 3], msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details,
                     '1 unexpectedly found in [1, 2, 3] Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_is_pass(self):
    asserts.assert_is(_OBJECT_1, _OBJECT_1)

  def test_assert_is_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is(_OBJECT_1, _OBJECT_2)
    self.assertEqual(cm.exception.details, f'{_OBJECT_1} is not {_OBJECT_2}')

  def test_assert_is_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is(_OBJECT_1, _OBJECT_2, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details,
                     f'{_OBJECT_1} is not {_OBJECT_2} Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_is_not_pass(self):
    asserts.assert_is_not(_OBJECT_1, _OBJECT_2)

  def test_assert_is_not_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is_not(_OBJECT_1, _OBJECT_1)
    self.assertEqual(cm.exception.details,
                     f'unexpectedly identical: {_OBJECT_1}')

  def test_assert_is_not_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is_not(_OBJECT_1,
                            _OBJECT_1,
                            msg='Message',
                            extras='Extras')
    self.assertEqual(cm.exception.details,
                     f'unexpectedly identical: {_OBJECT_1} Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_count_equal_pass(self):
    asserts.assert_count_equal((1, 3, 3), [3, 1, 3])

  def test_assert_count_equal_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_count_equal([3, 3], [3])
    self.assertEqual(
        cm.exception.details,
        'Element counts were not equal:\nFirst has 2, Second has 1:  3')

  def test_assert_count_equal_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_count_equal((3, 3), (4, 4), msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details,
                     ('Element counts were not equal:\n'
                      'First has 2, Second has 0:  3\n'
                      'First has 0, Second has 2:  4 Message'))
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_less_pass(self):
    asserts.assert_less(1.0, 2)

  def test_assert_less_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_less(1, 1)
    self.assertEqual(cm.exception.details, '1 not less than 1')

  def test_assert_less_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_less(2, 1, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details, '2 not less than 1 Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_less_equal_pass(self):
    asserts.assert_less_equal(1.0, 2)
    asserts.assert_less_equal(1, 1)

  def test_assert_less_equal_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_less_equal(2, 1)
    self.assertEqual(cm.exception.details, '2 not less than or equal to 1')

  def test_assert_less_equal_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_less_equal(2, 1, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details,
                     '2 not less than or equal to 1 Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_greater_pass(self):
    asserts.assert_greater(2, 1.0)

  def test_assert_greater_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_greater(1, 1)
    self.assertEqual(cm.exception.details, '1 not greater than 1')

  def test_assert_greater_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_greater(1, 2, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details, '1 not greater than 2 Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_greater_equal_pass(self):
    asserts.assert_greater_equal(2, 1.0)
    asserts.assert_greater_equal(1, 1)

  def test_assert_greater_equal_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_greater_equal(1, 2)
    self.assertEqual(cm.exception.details, '1 not greater than or equal to 2')

  def test_assert_greater_equal_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_greater_equal(1, 2, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details,
                     '1 not greater than or equal to 2 Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_is_none_pass(self):
    asserts.assert_is_none(None)

  def test_assert_is_none_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is_none(1)
    self.assertEqual(cm.exception.details, '1 is not None')

  def test_assert_is_none_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is_none(1, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details, '1 is not None Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_is_not_none_pass(self):
    asserts.assert_is_not_none(1)

  def test_assert_is_not_none_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is_not_none(None)
    self.assertEqual(cm.exception.details, 'unexpectedly None')

  def test_assert_is_none_not_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is_not_none(None, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details, 'unexpectedly None Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_is_instance_pass(self):
    asserts.assert_is_instance('foo', str)
    asserts.assert_is_instance(1, int)
    asserts.assert_is_instance(1.0, float)

  def test_assert_is_instance_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is_instance(1, str)
    self.assertEqual(cm.exception.details, f'1 is not an instance of {str}')

  def test_assert_is_instance_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_is_instance(1.0, int, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details,
                     f'1.0 is not an instance of {int} Message')
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_not_is_instance_pass(self):
    asserts.assert_not_is_instance('foo', int)
    asserts.assert_not_is_instance(1, float)
    asserts.assert_not_is_instance(1.0, int)

  def test_assert_not_is_instance_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_is_instance(1, int)
    self.assertEqual(cm.exception.details, f'1 is an instance of {int}')

  def test_assert_not_is_instance_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_is_instance('foo', str, msg='Message', extras='Extras')
    self.assertEqual(cm.exception.details,
                     f"'foo' is an instance of {str} Message")
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_regex_pass(self):
    asserts.assert_regex('Big rocks', r'(r|m)ocks')

  def test_assert_regex_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_regex('Big socks', r'(r|m)ocks')
    self.assertEqual(
        cm.exception.details,
        "Regex didn't match: '(r|m)ocks' not found in 'Big socks'")

  def test_assert_regex_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_regex('Big socks',
                           r'(r|m)ocks',
                           msg='Message',
                           extras='Extras')
    self.assertEqual(
        cm.exception.details,
        ("Regex didn't match: '(r|m)ocks' not found in 'Big socks' "
         'Message'))
    self.assertEqual(cm.exception.extras, 'Extras')

  def test_assert_not_regex_pass(self):
    asserts.assert_not_regex('Big socks', r'(r|m)ocks')

  def test_assert_not_regex_fail(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_regex('Big rocks', r'(r|m)ocks')
    self.assertEqual(
        cm.exception.details,
        "Regex matched: 'rocks' matches '(r|m)ocks' in 'Big rocks'")

  def test_assert_not_regex_fail_with_msg_and_extras(self):
    with self.assertRaises(signals.TestFailure) as cm:
      asserts.assert_not_regex('Big mocks',
                               r'(r|m)ocks',
                               msg='Message',
                               extras='Extras')
    self.assertEqual(
        cm.exception.details,
        ("Regex matched: 'mocks' matches '(r|m)ocks' in 'Big mocks' "
         'Message'))
    self.assertEqual(cm.exception.extras, 'Extras')


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