• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# Copyright 2016 Google Inc.
2#
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain a copy of the License at
6#
7#     http://www.apache.org/licenses/LICENSE-2.0
8#
9# Unless required by applicable law or agreed to in writing, software
10# distributed under the License is distributed on an "AS IS" BASIS,
11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12# See the License for the specific language governing permissions and
13# limitations under the License.
14
15import unittest
16
17from mobly import asserts
18from mobly import signals
19
20MSG_EXPECTED_EXCEPTION = 'This is an expected exception.'
21_OBJECT_1 = object()
22_OBJECT_2 = object()
23
24
25class AssertsTest(unittest.TestCase):
26  """Verifies that asserts.xxx functions raise the correct test signals."""
27
28  def test_assert_false(self):
29    asserts.assert_false(False, MSG_EXPECTED_EXCEPTION)
30    with self.assertRaisesRegex(signals.TestFailure, MSG_EXPECTED_EXCEPTION):
31      asserts.assert_false(True, MSG_EXPECTED_EXCEPTION)
32
33  def test_assert_not_equal_pass(self):
34    asserts.assert_not_equal(1, 2)
35
36  def test_assert_not_equal_pass_with_msg_and_extras(self):
37    asserts.assert_not_equal(1, 2, msg='Message', extras='Extras')
38
39  def test_assert_not_equal_fail(self):
40    with self.assertRaises(signals.TestFailure) as cm:
41      asserts.assert_not_equal(1, 1)
42    self.assertEqual(cm.exception.details, '1 == 1')
43
44  def test_assert_not_equal_fail_with_msg_and_extras(self):
45    with self.assertRaises(signals.TestFailure) as cm:
46      asserts.assert_not_equal(1, 1, msg='Message', extras='Extras')
47    self.assertEqual(cm.exception.details, '1 == 1 Message')
48    self.assertEqual(cm.exception.extras, 'Extras')
49
50  def test_assert_almost_equal_pass(self):
51    asserts.assert_almost_equal(1.000001, 1.000002, places=3)
52    asserts.assert_almost_equal(1.0, 1.05, delta=0.1)
53
54  def test_assert_almost_equal_fail(self):
55    with self.assertRaises(signals.TestFailure) as cm:
56      asserts.assert_almost_equal(1, 1.0005, places=7)
57    self.assertRegex(cm.exception.details, r'1 != 1\.0005 within 7 places')
58
59  def test_assert_almost_equal_fail_with_msg_and_extras(self):
60    with self.assertRaises(signals.TestFailure) as cm:
61      asserts.assert_almost_equal(1,
62                                  2,
63                                  delta=0.1,
64                                  msg='Message',
65                                  extras='Extras')
66    self.assertRegex(cm.exception.details, r'1 != 2 within 0\.1 delta.*Message')
67    self.assertEqual(cm.exception.extras, 'Extras')
68
69  def test_assert_not_almost_equal_pass(self):
70    asserts.assert_not_almost_equal(1.001, 1.002, places=3)
71    asserts.assert_not_almost_equal(1.0, 1.05, delta=0.01)
72
73  def test_assert_not_almost_equal_fail(self):
74    with self.assertRaises(signals.TestFailure) as cm:
75      asserts.assert_not_almost_equal(1, 1.0005, places=3)
76    self.assertRegex(cm.exception.details, r'1 == 1\.0005 within 3 places')
77
78  def test_assert_not_almost_equal_fail_with_msg_and_extras(self):
79    with self.assertRaises(signals.TestFailure) as cm:
80      asserts.assert_not_almost_equal(1,
81                                      2,
82                                      delta=1,
83                                      msg='Message',
84                                      extras='Extras')
85    self.assertRegex(cm.exception.details, r'1 == 2 within 1 delta.*Message')
86    self.assertEqual(cm.exception.extras, 'Extras')
87
88  def test_assert_in_pass(self):
89    asserts.assert_in(1, [1, 2, 3])
90    asserts.assert_in(1, (1, 2, 3))
91    asserts.assert_in(1, {1: 2, 3: 4})
92    asserts.assert_in('a', 'abcd')
93
94  def test_assert_in_fail(self):
95    with self.assertRaises(signals.TestFailure) as cm:
96      asserts.assert_in(4, [1, 2, 3])
97    self.assertEqual(cm.exception.details, '4 not found in [1, 2, 3]')
98
99  def test_assert_in_fail_with_msg_and_extras(self):
100    with self.assertRaises(signals.TestFailure) as cm:
101      asserts.assert_in(4, [1, 2, 3], msg='Message', extras='Extras')
102    self.assertEqual(cm.exception.details, '4 not found in [1, 2, 3] Message')
103    self.assertEqual(cm.exception.extras, 'Extras')
104
105  def test_assert_not_in_pass(self):
106    asserts.assert_not_in(4, [1, 2, 3])
107    asserts.assert_not_in(4, (1, 2, 3))
108    asserts.assert_not_in(4, {1: 2, 3: 4})
109    asserts.assert_not_in('e', 'abcd')
110
111  def test_assert_not_in_fail(self):
112    with self.assertRaises(signals.TestFailure) as cm:
113      asserts.assert_not_in(1, [1, 2, 3])
114    self.assertEqual(cm.exception.details, '1 unexpectedly found in [1, 2, 3]')
115
116  def test_assert_not_in_fail_with_msg_and_extras(self):
117    with self.assertRaises(signals.TestFailure) as cm:
118      asserts.assert_not_in(1, [1, 2, 3], msg='Message', extras='Extras')
119    self.assertEqual(cm.exception.details,
120                     '1 unexpectedly found in [1, 2, 3] Message')
121    self.assertEqual(cm.exception.extras, 'Extras')
122
123  def test_assert_is_pass(self):
124    asserts.assert_is(_OBJECT_1, _OBJECT_1)
125
126  def test_assert_is_fail(self):
127    with self.assertRaises(signals.TestFailure) as cm:
128      asserts.assert_is(_OBJECT_1, _OBJECT_2)
129    self.assertEqual(cm.exception.details, f'{_OBJECT_1} is not {_OBJECT_2}')
130
131  def test_assert_is_fail_with_msg_and_extras(self):
132    with self.assertRaises(signals.TestFailure) as cm:
133      asserts.assert_is(_OBJECT_1, _OBJECT_2, msg='Message', extras='Extras')
134    self.assertEqual(cm.exception.details,
135                     f'{_OBJECT_1} is not {_OBJECT_2} Message')
136    self.assertEqual(cm.exception.extras, 'Extras')
137
138  def test_assert_is_not_pass(self):
139    asserts.assert_is_not(_OBJECT_1, _OBJECT_2)
140
141  def test_assert_is_not_fail(self):
142    with self.assertRaises(signals.TestFailure) as cm:
143      asserts.assert_is_not(_OBJECT_1, _OBJECT_1)
144    self.assertEqual(cm.exception.details,
145                     f'unexpectedly identical: {_OBJECT_1}')
146
147  def test_assert_is_not_fail_with_msg_and_extras(self):
148    with self.assertRaises(signals.TestFailure) as cm:
149      asserts.assert_is_not(_OBJECT_1,
150                            _OBJECT_1,
151                            msg='Message',
152                            extras='Extras')
153    self.assertEqual(cm.exception.details,
154                     f'unexpectedly identical: {_OBJECT_1} Message')
155    self.assertEqual(cm.exception.extras, 'Extras')
156
157  def test_assert_count_equal_pass(self):
158    asserts.assert_count_equal((1, 3, 3), [3, 1, 3])
159
160  def test_assert_count_equal_fail(self):
161    with self.assertRaises(signals.TestFailure) as cm:
162      asserts.assert_count_equal([3, 3], [3])
163    self.assertEqual(
164        cm.exception.details,
165        'Element counts were not equal:\nFirst has 2, Second has 1:  3')
166
167  def test_assert_count_equal_fail_with_msg_and_extras(self):
168    with self.assertRaises(signals.TestFailure) as cm:
169      asserts.assert_count_equal((3, 3), (4, 4), msg='Message', extras='Extras')
170    self.assertEqual(cm.exception.details,
171                     ('Element counts were not equal:\n'
172                      'First has 2, Second has 0:  3\n'
173                      'First has 0, Second has 2:  4 Message'))
174    self.assertEqual(cm.exception.extras, 'Extras')
175
176  def test_assert_less_pass(self):
177    asserts.assert_less(1.0, 2)
178
179  def test_assert_less_fail(self):
180    with self.assertRaises(signals.TestFailure) as cm:
181      asserts.assert_less(1, 1)
182    self.assertEqual(cm.exception.details, '1 not less than 1')
183
184  def test_assert_less_fail_with_msg_and_extras(self):
185    with self.assertRaises(signals.TestFailure) as cm:
186      asserts.assert_less(2, 1, msg='Message', extras='Extras')
187    self.assertEqual(cm.exception.details, '2 not less than 1 Message')
188    self.assertEqual(cm.exception.extras, 'Extras')
189
190  def test_assert_less_equal_pass(self):
191    asserts.assert_less_equal(1.0, 2)
192    asserts.assert_less_equal(1, 1)
193
194  def test_assert_less_equal_fail(self):
195    with self.assertRaises(signals.TestFailure) as cm:
196      asserts.assert_less_equal(2, 1)
197    self.assertEqual(cm.exception.details, '2 not less than or equal to 1')
198
199  def test_assert_less_equal_fail_with_msg_and_extras(self):
200    with self.assertRaises(signals.TestFailure) as cm:
201      asserts.assert_less_equal(2, 1, msg='Message', extras='Extras')
202    self.assertEqual(cm.exception.details,
203                     '2 not less than or equal to 1 Message')
204    self.assertEqual(cm.exception.extras, 'Extras')
205
206  def test_assert_greater_pass(self):
207    asserts.assert_greater(2, 1.0)
208
209  def test_assert_greater_fail(self):
210    with self.assertRaises(signals.TestFailure) as cm:
211      asserts.assert_greater(1, 1)
212    self.assertEqual(cm.exception.details, '1 not greater than 1')
213
214  def test_assert_greater_fail_with_msg_and_extras(self):
215    with self.assertRaises(signals.TestFailure) as cm:
216      asserts.assert_greater(1, 2, msg='Message', extras='Extras')
217    self.assertEqual(cm.exception.details, '1 not greater than 2 Message')
218    self.assertEqual(cm.exception.extras, 'Extras')
219
220  def test_assert_greater_equal_pass(self):
221    asserts.assert_greater_equal(2, 1.0)
222    asserts.assert_greater_equal(1, 1)
223
224  def test_assert_greater_equal_fail(self):
225    with self.assertRaises(signals.TestFailure) as cm:
226      asserts.assert_greater_equal(1, 2)
227    self.assertEqual(cm.exception.details, '1 not greater than or equal to 2')
228
229  def test_assert_greater_equal_fail_with_msg_and_extras(self):
230    with self.assertRaises(signals.TestFailure) as cm:
231      asserts.assert_greater_equal(1, 2, msg='Message', extras='Extras')
232    self.assertEqual(cm.exception.details,
233                     '1 not greater than or equal to 2 Message')
234    self.assertEqual(cm.exception.extras, 'Extras')
235
236  def test_assert_is_none_pass(self):
237    asserts.assert_is_none(None)
238
239  def test_assert_is_none_fail(self):
240    with self.assertRaises(signals.TestFailure) as cm:
241      asserts.assert_is_none(1)
242    self.assertEqual(cm.exception.details, '1 is not None')
243
244  def test_assert_is_none_fail_with_msg_and_extras(self):
245    with self.assertRaises(signals.TestFailure) as cm:
246      asserts.assert_is_none(1, msg='Message', extras='Extras')
247    self.assertEqual(cm.exception.details, '1 is not None Message')
248    self.assertEqual(cm.exception.extras, 'Extras')
249
250  def test_assert_is_not_none_pass(self):
251    asserts.assert_is_not_none(1)
252
253  def test_assert_is_not_none_fail(self):
254    with self.assertRaises(signals.TestFailure) as cm:
255      asserts.assert_is_not_none(None)
256    self.assertEqual(cm.exception.details, 'unexpectedly None')
257
258  def test_assert_is_none_not_fail_with_msg_and_extras(self):
259    with self.assertRaises(signals.TestFailure) as cm:
260      asserts.assert_is_not_none(None, msg='Message', extras='Extras')
261    self.assertEqual(cm.exception.details, 'unexpectedly None Message')
262    self.assertEqual(cm.exception.extras, 'Extras')
263
264  def test_assert_is_instance_pass(self):
265    asserts.assert_is_instance('foo', str)
266    asserts.assert_is_instance(1, int)
267    asserts.assert_is_instance(1.0, float)
268
269  def test_assert_is_instance_fail(self):
270    with self.assertRaises(signals.TestFailure) as cm:
271      asserts.assert_is_instance(1, str)
272    self.assertEqual(cm.exception.details, f'1 is not an instance of {str}')
273
274  def test_assert_is_instance_fail_with_msg_and_extras(self):
275    with self.assertRaises(signals.TestFailure) as cm:
276      asserts.assert_is_instance(1.0, int, msg='Message', extras='Extras')
277    self.assertEqual(cm.exception.details,
278                     f'1.0 is not an instance of {int} Message')
279    self.assertEqual(cm.exception.extras, 'Extras')
280
281  def test_assert_not_is_instance_pass(self):
282    asserts.assert_not_is_instance('foo', int)
283    asserts.assert_not_is_instance(1, float)
284    asserts.assert_not_is_instance(1.0, int)
285
286  def test_assert_not_is_instance_fail(self):
287    with self.assertRaises(signals.TestFailure) as cm:
288      asserts.assert_not_is_instance(1, int)
289    self.assertEqual(cm.exception.details, f'1 is an instance of {int}')
290
291  def test_assert_not_is_instance_fail_with_msg_and_extras(self):
292    with self.assertRaises(signals.TestFailure) as cm:
293      asserts.assert_not_is_instance('foo', str, msg='Message', extras='Extras')
294    self.assertEqual(cm.exception.details,
295                     f"'foo' is an instance of {str} Message")
296    self.assertEqual(cm.exception.extras, 'Extras')
297
298  def test_assert_regex_pass(self):
299    asserts.assert_regex('Big rocks', r'(r|m)ocks')
300
301  def test_assert_regex_fail(self):
302    with self.assertRaises(signals.TestFailure) as cm:
303      asserts.assert_regex('Big socks', r'(r|m)ocks')
304    self.assertEqual(
305        cm.exception.details,
306        "Regex didn't match: '(r|m)ocks' not found in 'Big socks'")
307
308  def test_assert_regex_fail_with_msg_and_extras(self):
309    with self.assertRaises(signals.TestFailure) as cm:
310      asserts.assert_regex('Big socks',
311                           r'(r|m)ocks',
312                           msg='Message',
313                           extras='Extras')
314    self.assertEqual(
315        cm.exception.details,
316        ("Regex didn't match: '(r|m)ocks' not found in 'Big socks' "
317         'Message'))
318    self.assertEqual(cm.exception.extras, 'Extras')
319
320  def test_assert_not_regex_pass(self):
321    asserts.assert_not_regex('Big socks', r'(r|m)ocks')
322
323  def test_assert_not_regex_fail(self):
324    with self.assertRaises(signals.TestFailure) as cm:
325      asserts.assert_not_regex('Big rocks', r'(r|m)ocks')
326    self.assertEqual(
327        cm.exception.details,
328        "Regex matched: 'rocks' matches '(r|m)ocks' in 'Big rocks'")
329
330  def test_assert_not_regex_fail_with_msg_and_extras(self):
331    with self.assertRaises(signals.TestFailure) as cm:
332      asserts.assert_not_regex('Big mocks',
333                               r'(r|m)ocks',
334                               msg='Message',
335                               extras='Extras')
336    self.assertEqual(
337        cm.exception.details,
338        ("Regex matched: 'mocks' matches '(r|m)ocks' in 'Big mocks' "
339         'Message'))
340    self.assertEqual(cm.exception.extras, 'Extras')
341
342
343if __name__ == '__main__':
344  unittest.main()
345