def test_CONSTRUCTOR(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') # TEST DISABLE DEBUG x = mp.FixedFormatMessageParser('') self.assertEqual(x._message, '') self.assertFalse(x._enable_debug_mode) self.assertEqual(x._cursor, 0) self.assertEqual(x._cursor_last_parse, 0) self.assertIs(x._logger, mock_logger.return_value) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST ENABLE DEBUG msg = 'message' x = mp.FixedFormatMessageParser(msg, True) self.assertEqual(x._message, msg) self.assertTrue(x._enable_debug_mode) self.assertEqual(x._cursor, 0) self.assertEqual(x._cursor_last_parse, 0) self.assertIs(x._logger, mock_logger.return_value) expected_calls = [ call.l.info("About to parse '{}'", msg), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_get_integer_from_hex_ascii_hex(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') x = mp.FixedFormatMessageParser('3132414243444546', True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST N = VALUE result = x.get_integer_from_hex_ascii_hex(4) self.assertEqual(result, 0x12AB) self.assertEqual(x._cursor, 8) expected_calls = [ call.l.info("Read '{}'", '31324142'), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST N NOT SPECIFIED result = x.get_integer_from_hex_ascii_hex() self.assertEqual(result, 0xCDEF) self.assertEqual(x._cursor, 16) expected_calls = [ call.l.info("Read '{}'", '43444546'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_get_remaining_message(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = '0123456789ABCDEF' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() self.assertEqual(x.get_remaining_message(), '0123456789ABCDEF') self.assertEqual(x.get_remaining_message_length(), 16) x.get_characters(4) self.assertEqual(x.get_remaining_message(), '456789ABCDEF') self.assertEqual(x.get_remaining_message_length(), 12) x.get_characters() self.assertEqual(x.get_remaining_message(), '') self.assertEqual(x.get_remaining_message_length(), 0) expected_calls = [ call.l.info("Read '{}'", '0123'), call.l.info("Read '{}'", '456789ABCDEF'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test__parse_as_hex_ascii(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = '0123456789ABCDEF' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST ODD LENGTH emsg = "ParseException: Even number of characters required for hex-ascii '414': '' starting_here=>'0123456789ABCDEF'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x._parse_as_hex_ascii, 0, '414' ) self.assertEqual(x._parse_as_hex_ascii(0, ''), '') self.assertEqual(x._parse_as_hex_ascii(0, '4142'), 'AB') emsg = "ParseException: Not a valid hex-ascii value '4X': '01' starting_here=>'23456789ABCDEF'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x._parse_as_hex_ascii, 0, '414X43' )
def test_assert_at_end_of_message(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = 'message' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST NOT AT END OF MESSAGE emsg = "ParseException: Unexpected text at end of message: '' starting_here=>'message'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.assert_at_end_of_message ) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST AT END OF MESSAGE x._cursor = len(msg) x.assert_at_end_of_message() expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_test_equal(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = '0123456789ABCDEF' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST VALUE IS NONE emsg = "ParseException: Attempt to compare using a null value: '' starting_here=>'0123456789ABCDEF'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.peek_equal, None ) # TEST HAPPY PATH self.assertTrue(x.test_equal('0123')) self.assertTrue(x.test_equal('4567')) self.assertFalse(x.test_equal('4567')) self.assertEqual(x._cursor, 12)
def test_get_hex_ascii(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') x = mp.FixedFormatMessageParser('4142434445464748', True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST N = VALUE result = x.get_hex_ascii(4) self.assertEqual(result, 'ABCD') self.assertEqual(x._cursor, 8) expected_calls = [ call.l.info("Read '{}'", '41424344'), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST N NOT SPECIFIED result = x.get_hex_ascii() self.assertEqual(result, 'EFGH') self.assertEqual(x._cursor, 16) expected_calls = [ call.l.info("Read '{}'", '45464748'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_get_integer_from_hex_ascii_decimal(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') x = mp.FixedFormatMessageParser('3132333435363738', True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST N = VALUE result = x.get_integer_from_hex_ascii_decimal(4) self.assertEqual(result, 1234) self.assertEqual(x._cursor, 8) expected_calls = [ call.l.info("Read '{}'", '31323334'), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST N NOT SPECIFIED result = x.get_integer_from_hex_ascii_decimal() self.assertEqual(result, 5678) self.assertEqual(x._cursor, 16) expected_calls = [ call.l.info("Read '{}'", '35363738'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_get_characters(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg1 = 'message1' msg2 = 'message2' msg = msg1 + msg2 x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST N = ZERO result = x.get_characters(0) self.assertEqual(result, '') self.assertEqual(x._cursor, 0) expected_calls = [ call.l.info("Read '{}'", ''), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST N = NON-ZERO VALUE result = x.get_characters(len(msg1)) self.assertEqual(result, msg1) self.assertEqual(x._cursor, len(msg1)) expected_calls = [ call.l.info("Read '{}'", msg1), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST N = None result = x.get_characters() self.assertEqual(result, msg2) self.assertEqual(x._cursor, len(msg)) expected_calls = [ call.l.info("Read '{}'", msg2), ] verify_mock_calls(self, mm.mock_calls, expected_calls) emsg = "ParseException: Attempt to read past end-of-message (cursor=16 length=5): 'message1message2' starting_here=>''" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.get_characters, 5 ) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_execute__null_executor(self): mm = mock.Mock() report_mock = mock.Mock() mm.attach_mock(report_mock, 'rm') parser = mp.FixedFormatMessageParser('3C5A3445556666aaaaaccccccdddddddffffffff') bitmap = mp.BitMap(parser, parser.get_characters(4)) row_object = {} x = mp.BitMapExecutor() x.execute(bitmap, row_object) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls) self.assertEqual(parser.get_remaining_message(), '3445556666aaaaaccccccdddddddffffffff')
def test_execute(self): mm = mock.Mock() report_mock = mock.Mock() mm.attach_mock(report_mock, 'rm') parser = mp.FixedFormatMessageParser('3C5A3445556666aaaaaccccccdddddddffffffff') bitmap = mp.BitMap(parser, parser.get_characters(4)) row_object = {} def unexpected(bm, row, bit): report_mock.parse(bm, row, bit) def parse(bm, row, bit, expected): bitmap.get_parser().assert_equal(expected) report_mock.parse(bm, row, bit, expected) x = mp.BitMapExecutor() x.add_exec(1, lambda bitmap, row: unexpected(bitmap, row, 1)) x.add_exec(2, lambda bitmap, row: unexpected(bitmap, row, 2)) x.add_exec(3, lambda bitmap, row: parse(bitmap, row, 3, '3')) x.add_exec(4, lambda bitmap, row: parse(bitmap, row, 4, '44')) x.add_exec(5, lambda bitmap, row: parse(bitmap, row, 5, '555')) x.add_exec(6, lambda bitmap, row: parse(bitmap, row, 6, '6666')) x.add_exec(7, lambda bitmap, row: unexpected(bitmap, row, 7)) x.add_exec(8, lambda bitmap, row: unexpected(bitmap, row, 8)) x.add_exec(9, lambda bitmap, row: unexpected(bitmap, row, 9)) x.add_exec(10, lambda bitmap, row: parse(bitmap, row, 10, 'aaaaa')) x.add_exec(11, lambda bitmap, row: unexpected(bitmap, row, 11)) x.add_exec(12, lambda bitmap, row: parse(bitmap, row, 12, 'cccccc')) x.add_exec(13, lambda bitmap, row: parse(bitmap, row, 13, 'ddddddd')) x.add_exec(14, lambda bitmap, row: unexpected(bitmap, row, 14)) x.add_exec(15, lambda bitmap, row: parse(bitmap, row, 15, 'ffffffff')) x.add_exec(16, lambda bitmap, row: unexpected(bitmap, row, 16)) x.execute(bitmap, row_object) parser.assert_at_end_of_message() expected_calls = [ call.rm.parse(bitmap, row_object, 3, '3'), call.rm.parse(bitmap, row_object, 4, '44'), call.rm.parse(bitmap, row_object, 5, '555'), call.rm.parse(bitmap, row_object, 6, '6666'), call.rm.parse(bitmap, row_object, 10, 'aaaaa'), call.rm.parse(bitmap, row_object, 12, 'cccccc'), call.rm.parse(bitmap, row_object, 13, 'ddddddd'), call.rm.parse(bitmap, row_object, 15, 'ffffffff'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_peek_characters(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = '0123456789ABCDEF' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST CURSOR < 0 emsg = "ParseException: Illegal cursor value: -1" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.peek_characters, -1, 4 ) # TEST CURSOR > MESSAGE LENGTH emsg = "ParseException: Attempt to read past end-of-message (cursor=20 length=4): '0123456789ABCDEF' starting_here=>''" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.peek_characters, 20, 4 ) # TEST LENGTH < 0 emsg = "ParseException: Illegal length: -1" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.peek_characters, 0, -1 ) # TEST READ PAST END-OF-MESSAGE emsg = "ParseException: Attempt to read past end-of-message (cursor=8 length=9): '01234567' starting_here=>'89ABCDEF'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.peek_characters, 8, 9 ) # TEST HAPPY PATH self.assertEqual(x.peek_characters(4, 6), '456789') self.assertEqual(x._cursor, 0)
def test_execute__user_exception(self): parser = mp.FixedFormatMessageParser('3C5A3445556666aaaaaccccccdddddddffffffff') bitmap = mp.BitMap(parser, parser.get_characters(4)) row_object = {} def parse(): raise ValueError('oh-oh') x = mp.BitMapExecutor() x.add_exec(3, lambda bitmap, row: parse()) emsg = "ParseException: Received exception trying to parse bit 3: oh-oh: '3C5A' starting_here=>'3445556666aaaaaccccccdddddddffffffff'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.execute, bitmap, row_object )
def test_get_characters_to_sentinel(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg1 = 'message1' sentinel1 = '<1>' msg2 = 'message2' sentinel2 = '<2>' msg = msg1 + sentinel1 + msg2 + sentinel2 x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST HAPPY PATH result = x.get_characters_to_sentinel(sentinel1) self.assertEqual(result, msg1) self.assertEqual(x._cursor, len(msg1 + sentinel1)) expected_calls = [ call.l.info("Read '{}'", 'message1'), call.l.info("Read '{}'", '<1>'), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST SENTINEL = None emsg = "ParseException: Attempt to use None sentinel: 'message1<1>' starting_here=>'message2<2>'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.get_characters_to_sentinel, None ) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST SENTINEL NOT FOUND emsg = "ParseException: Could not find sentinel '<x>': 'message1<1>' starting_here=>'message2<2>'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.get_characters_to_sentinel, '<x>' ) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test___str__(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = 'message' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() self.assertEqual(str(x), msg) x._cursor = 4 self.assertEqual(str(x), msg[4:]) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_get_integer_from_hex_ascii_hex_to_sentinel(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') x = mp.FixedFormatMessageParser('31324142<02>43444546', True) # Clear mock calls from constructor mm.mock_calls.clear() result = x.get_integer_from_hex_ascii_hex_to_sentinel('<02>') self.assertEqual(result, 0x12AB) self.assertEqual(x._cursor, 12) expected_calls = [ call.l.info("Read '{}'", '31324142'), call.l.info("Read '{}'", '<02>'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_get_cursor(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg1 = 'message1' x = mp.FixedFormatMessageParser(msg1, True) # Clear mock calls from constructor mm.mock_calls.clear() self.assertEqual(x.get_cursor(), 0) x._cursor = 123 self.assertEqual(x.get_cursor(), 123) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_get_integer_from_ascii_decimal_to_sentinel(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') x = mp.FixedFormatMessageParser('1234<02>5678', True) # Clear mock calls from constructor mm.mock_calls.clear() result = x.get_integer_from_ascii_decimal_to_sentinel('<02>') self.assertEqual(result, 1234) self.assertEqual(x._cursor, 8) expected_calls = [ call.l.info("Read '{}'", '1234'), call.l.info("Read '{}'", '<02>'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_get_message(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = '0123456789ABCDEF' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() self.assertIs(x.get_message(), msg) self.assertIs(x.get_message(-1), msg) self.assertIs(x.get_message(0), msg) self.assertEqual(x.get_message(7), '789ABCDEF') self.assertEqual(x._cursor, 0) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_assert_equal(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = 'message' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST EQUAL - value = None emsg = "ParseException: Attempt to compare using None: '' starting_here=>'message'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.assert_equal, None ) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST NOT-EQUAL emsg = "ParseException: Expected value 'sam': '' starting_here=>'message'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.assert_equal, 'sam' ) expected_calls = [ call.l.info("Read '{}'", 'mes'), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST EQUAL x._cursor = 0 x.assert_equal(msg) self.assertEqual(x._cursor, len(msg)) expected_calls = [ call.l.info("Read '{}'", 'message'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test__parse_as_hexadecimal_integer(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = '0123456789ABCDEF' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() self.assertEqual(x._parse_as_hexadecimal_integer(0, ''), 0) self.assertEqual(x._parse_as_hexadecimal_integer(0, '4C'), 0x4C) emsg = "ParseException: Not a valid hexadecimal value 'sam': '' starting_here=>'0123456789ABCDEF'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x._parse_as_hexadecimal_integer, 0, 'sam' )
def test_assert_blank(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = ' message' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() # TEST NOT BLANK - N = None emsg = "ParseException: Expected blank field of length 10: '' starting_here=>' message'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.assert_blank ) expected_calls = [ call.l.info("Read '{}'", ' message'), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST BLANK - N = 0 x._cursor = 0 x.assert_blank(0) self.assertEqual(x._cursor, 0) expected_calls = [ ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST BLANK - N = 3 x._cursor = 0 x.assert_blank(3) self.assertEqual(x._cursor, 3) expected_calls = [ call.l.info("Read '{}'", ' '), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
def test_execute__undefined_bit(self): mm = mock.Mock() report_mock = mock.Mock() mm.attach_mock(report_mock, 'rm') parser = mp.FixedFormatMessageParser('3C5A3445556666aaaaaccccccdddddddffffffff') bitmap = mp.BitMap(parser, parser.get_characters(4)) row_object = {} def parse(bm, row, bit, expected): bitmap.get_parser().assert_equal(expected) report_mock.parse(bm, row, bit, expected) x = mp.BitMapExecutor() x.add_exec(20, lambda bitmap, row: parse(bitmap, row, 20, '')) emsg = "ParseException: Attempt to process undefined bit 20: '3C5A' starting_here=>'3445556666aaaaaccccccdddddddffffffff'" self.assertRaisesRegex( mp.ParseException, '^' + re.escape(emsg) + '$', x.execute, bitmap, row_object )
def test_get_last_parse(self, mock_logger): mm = mock.Mock() mock_logger.return_value = mock.Mock() mm.attach_mock(mock_logger.return_value, 'l') msg = '0123456789ABCDEF' x = mp.FixedFormatMessageParser(msg, True) # Clear mock calls from constructor mm.mock_calls.clear() self.assertEqual(x.get_last_parse(), '') x.assert_equal('0123') self.assertEqual(x.get_last_parse(), '0123') x.assert_equal('4567') x.assert_equal('89') x.assert_equal('A') self.assertEqual(x.get_last_parse(), '456789A') x.assert_equal('B') x.assert_equal('C') x.assert_equal('DEF') self.assertEqual(x.get_last_parse(), 'BCDEF') expected_calls = [ call.l.info("Read '{}'", '0123'), call.l.info("Read '{}'", '4567'), call.l.info("Read '{}'", '89'), call.l.info("Read '{}'", 'A'), call.l.info("Read '{}'", 'B'), call.l.info("Read '{}'", 'C'), call.l.info("Read '{}'", 'DEF'), ] verify_mock_calls(self, mm.mock_calls, expected_calls)
class TestBitMap(unittest.TestCase): parser = mp.FixedFormatMessageParser('') # ========================================================================= # METHOD - CONSTRUCTOR # ========================================================================= @mock.patch(PATCH_ADD_HEX_BYTES) def test_CONSTRUCTOR(self, mock_add_hex_bytes): mm = mock.Mock() mm.attach_mock(mock_add_hex_bytes, 'ahb') # TEST PARSER = NONE emsg = 'A FixedFormatMessageParser is required' self.assertRaisesRegex( AssertionError, '^' + re.escape(emsg) + '$', mp.BitMap, None ) # TEST NO HEX_BYTES x = mp.BitMap(self.parser) self.assertIs(x._parser, self.parser) self.assertEqual(x._bits, {}) self.assertEqual(x._next_bit, 1) self.assertEqual(x._scratchpad, {}) expected_calls = [ call.ahb(None), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # TEST WITH HEX_BYTES x = mp.BitMap(self.parser, '8C031') self.assertIs(x._parser, self.parser) self.assertEqual(x._bits, {}) self.assertEqual(x._next_bit, 1) self.assertEqual(x._scratchpad, {}) expected_calls = [ call.ahb('8C031'), ] verify_mock_calls(self, mm.mock_calls, expected_calls) # ========================================================================= # METHOD - add_hex_bytes # ========================================================================= def test_add_hex_bytes(self): x = mp.BitMap(self.parser) # TEST WITH NONE x.add_hex_bytes(None) self.assertEqual(x._bits, {}) self.assertEqual(x._next_bit, 1) # TEST WITH VALUE x.add_hex_bytes('8C031') self.assertEqual(x._bits, { 1: True, 2: False, 3: False, 4: False, 5: True, 6: True, 7: False, 8: False, 9: False, 10: False, 11: False, 12: False, 13: False, 14: False, 15: True, 16: True, 17: False, 18: False, 19: False, 20: True, }) self.assertEqual(x._next_bit, 21) # ========================================================================= # METHOD - bit_is_set # ========================================================================= def test_bit_is_set(self): x = mp.BitMap(self.parser, '8C031') set_bits = {1, 5, 6, 15, 16, 20} for bit in range(100): if bit in set_bits: self.assertTrue(x.bit_is_set(bit), bit) else: self.assertFalse(x.bit_is_set(bit), bit) # ========================================================================= # METHOD - contains_bit # ========================================================================= def test_contains_bit(self): x = mp.BitMap(self.parser, '8C031') for bit in range(100): if 0 < bit <= 20: self.assertTrue(x.contains_bit(bit), bit) else: self.assertFalse(x.contains_bit(bit), bit) # ========================================================================= # METHOD - get_scratchpad, put_scratchpad # ========================================================================= def test_get_scratchpad(self): x = mp.BitMap(self.parser) self.assertIsNone(x.get_scratchpad('key')) self.assertIsNone(x.put_scratchpad('key', 1234)) self.assertEqual(x.get_scratchpad('key'), 1234) # ========================================================================= # METHOD - get_parser # ========================================================================= def test_get_parser(self): x = mp.BitMap(self.parser) self.assertIs(x.get_parser(), self.parser)