# pyOCD debugger # Copyright (c) 2015 Paul Osborne # Copyright (c) 2018-2020 Arm Limited # SPDX-License-Identifier: Apache-2.0 # # 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 pytest import six from pyocd.utility.conversion import ( byte_list_to_nbit_le_list, nbit_le_list_to_byte_list, byte_list_to_u32le_list, u32le_list_to_byte_list, u16le_list_to_byte_list, byte_list_to_u16le_list, u32_to_float32, float32_to_u32, uint_to_hex_le, hex_le_to_uint, u32_to_hex8le, u64_to_hex16le, hex8_to_u32be, hex16_to_u64be, hex8_to_u32le, hex16_to_u64le, byte_to_hex2, hex_to_byte_list, hex_decode, hex_encode, pairwise, ) from pyocd.utility.mask import ( align_up, align_down, ) from pyocd.gdbserver.gdbserver import ( escape, unescape, ) # pylint: disable=invalid-name class TestConversionUtilities(object): @pytest.mark.parametrize(("w",), [ (8,), (16,), (32,), (64,), (128,), (256,), ]) def test_byte_list_to_nbit_le_list_empty(self, w): assert byte_list_to_nbit_le_list([], w) == [] @pytest.mark.parametrize(("w",), [ (8,), (16,), (32,), (64,), (128,), (256,), ]) def test_nbit_le_list_to_byte_list(self, w): assert nbit_le_list_to_byte_list([], w) == [] @pytest.mark.parametrize(("w", "r"), [ (8, [0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]), (16, [0x201, 0x403, 0x605, 0x807]), (32, [0x4030201, 0x8070605]), (64, [0x807060504030201]), (128, [0x807060504030201]), (256, [0x807060504030201]), ]) def test_byte_list_to_nbit_le_list(self, w, r): assert byte_list_to_nbit_le_list([1,2,3,4,5,6,7,8], w) == r @pytest.mark.parametrize(("w", "r"), [ (8, [0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]), (16, [0x201, 0x403, 0x605, 0x807]), (32, [0x4030201, 0x8070605]), (64, [0x807060504030201]), (128, [0x55555555555555550807060504030201]), (256, [0x5555555555555555555555555555555555555555555555550807060504030201]), ]) def test_byte_list_to_nbit_le_list_nz_pad(self, w, r): assert byte_list_to_nbit_le_list([1,2,3,4,5,6,7,8], w, pad=0x55) == r @pytest.mark.parametrize(("w", "i"), [ (8, [1,2,3,4,5,6,7,8]), (16, [0x201, 0x403, 0x605, 0x807]), (32, [0x4030201, 0x8070605]), (64, [0x807060504030201]), ]) def test_nbit_le_list_to_byte_list(self, w, i): assert nbit_le_list_to_byte_list(i, w) == [1,2,3,4,5,6,7,8] @pytest.mark.parametrize(("w", "i", "r"), [ (128, [0x55555555555555550807060504030201], [1,2,3,4,5,6,7,8,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55]), (256, [0x555555555555555555555555555555550807060504030201], [1,2,3,4,5,6,7,8,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55,0,0,0,0,0,0,0,0]), ]) def test_nbit_le_list_to_byte_list_lg(self, w, i, r): assert nbit_le_list_to_byte_list(i, w) == r def test_byte_list_to_u32le_list_empty(self): assert byte_list_to_u32le_list([]) == [] def test_byteListToU32leList(self): data = range(32) assert byte_list_to_u32le_list(data) == [ 0x03020100, 0x07060504, 0x0B0A0908, 0x0F0E0D0C, 0x13121110, 0x17161514, 0x1B1A1918, 0x1F1E1D1C, ] def test_byte_list_to_u32le_list_unaligned(self): assert byte_list_to_u32le_list([1]) == [0x00000001] assert byte_list_to_u32le_list([1, 2, 3]) == [0x00030201] assert byte_list_to_u32le_list([1, 2, 3, 4, 5]) == [0x04030201, 0x00000005] assert byte_list_to_u32le_list([1], pad=0xcc) == [0xcccccc01] assert byte_list_to_u32le_list([1, 2, 3], pad=0xdd) == [0xdd030201] assert byte_list_to_u32le_list([1, 2, 3, 4, 5], pad=0xff) == [0x04030201, 0xffffff05] def test_byte_list_to_u32le_list_bytearray(self): assert byte_list_to_u32le_list(bytearray(b'abcd')) == [0x64636261] assert byte_list_to_u32le_list(bytearray(b'a')) == [0x00000061] def test_u32leListToByteList(self): data = [ 0x03020100, 0x07060504, 0x0B0A0908, 0x0F0E0D0C, 0x13121110, 0x17161514, 0x1B1A1918, 0x1F1E1D1C, ] assert u32le_list_to_byte_list(data) == list(range(32)) def test_u16leListToByteList(self): data = [0x3412, 0xFEAB] assert u16le_list_to_byte_list(data) == [ 0x12, 0x34, 0xAB, 0xFE ] def test_byteListToU16leList(self): data = [0x01, 0x00, 0xAB, 0xCD, ] assert byte_list_to_u16le_list(data) == [ 0x0001, 0xCDAB, ] def test_u32BEToFloat32BE(self): assert u32_to_float32(0x012345678) == 5.690456613903524e-28 def test_float32beToU32be(self): assert float32_to_u32(5.690456613903524e-28) == 0x012345678 def test_u32ToHex8le(self): assert u32_to_hex8le(0x0102ABCD) == "cdab0201" def test_u64ToHex16le(self): assert u64_to_hex16le(0x0102ABCD171819EF) == "ef191817cdab0201" def test_hex8ToU32be(self): assert hex8_to_u32be("0102ABCD") == 0xCDAB0201 def test_hex16ToU64be(self): assert hex16_to_u64be("0102ABCD171819EF") == 0xEF191817CDAB0201 def test_hex8ToU32le(self): assert hex8_to_u32le("0102ABCD") == 0x0102ABCD def test_hex16ToU64le(self): assert hex16_to_u64le("0102ABCD171819EF") == 0x0102ABCD171819EF def test_uint_to_hex_le_odd_width(self): assert uint_to_hex_le(0xd0102ABCD, 36) == "cdab02010d" def test_hex_le_to_uint_odd_width(self): assert hex_le_to_uint("0102ABCD0d", 36) == 0x0dCDAB0201 def test_byteToHex2(self): assert byte_to_hex2(0xC3) == "c3" def test_hexToByteList(self): assert hex_to_byte_list("ABCDEF1234") == [0xAB, 0xCD, 0xEF, 0x12, 0x34] def test_hexDecode(self): assert hex_decode('ABCDEF1234') == b'\xab\xcd\xef\x12\x34' def test_hexEncode(self): assert hex_encode(b'\xab\xcd\xef\x12\x34') == b'abcdef1234' @pytest.mark.parametrize(("args", "result"), [ ((0, 1024), 0), ((1, 1024), 1024), ((0, 3), 0), ((100, 3), 102), ((8, 4), 8), ((9, 4), 12), ((13, 16), 16), ((13, 8), 16), ]) def test_align_up(self, args, result): assert result == align_up(*args) @pytest.mark.parametrize(("args", "result"), [ ((0, 1024), 0), ((1, 1024), 0), ((0, 3), 0), ((100, 3), 99), ((8, 4), 8), ((9, 4), 8), ((13, 16), 0), ((13, 8), 8), ]) def test_align_down(self, args, result): assert result == align_down(*args) # Characters that must be escaped. ESCAPEES = (0x23, 0x24, 0x2a, 0x7d) # == ('#', '$', '}', '*') # Test the gdbserver binary data escape/unescape routines. class TestGdbEscape(object): # Verify all chars that shouldn't be escaped pass through unmodified. @pytest.mark.parametrize("data", [six.int2byte(x) for x in range(256) if (x not in ESCAPEES)]) def test_escape_passthrough(self, data): assert escape(data) == data @pytest.mark.parametrize(("data", "expected"), [ (b'#', b'}\x03'), (b'$', b'}\x04'), (b'}', b'}]'), (b'*', b'}\x0a') ]) def test_escape_1(self, data, expected): assert escape(data) == expected def test_escape_2(self): assert escape(b'1234#09*xyz') == b'1234}\x0309}\x0axyz' # Verify all chars that shouldn't be escaped pass through unmodified. @pytest.mark.parametrize("data", [six.int2byte(x) for x in range(256) if (x not in ESCAPEES)]) def test_unescape_passthrough(self, data): assert unescape(data) == [six.byte2int(data)] @pytest.mark.parametrize(("expected", "data"), [ (0x23, b'}\x03'), (0x24, b'}\x04'), (0x7d, b'}]'), (0x2a, b'}\x0a') ]) def test_unescape_1(self, data, expected): assert unescape(data) == [expected] def test_unescape_2(self): assert unescape(b'1234}\x0309}\x0axyz') == \ [0x31, 0x32, 0x33, 0x34, 0x23, 0x30, 0x39, 0x2a, 0x78, 0x79, 0x7a] class TestPairwise(object): def test_empty(self): assert list(pairwise([])) == [] def test_str(self): assert list(pairwise('abcdef')) == [('a','b'), ('c','d'), ('e','f')] def test_int(self): assert list(pairwise([1, 2, 3, 4, 5, 6])) == [(1, 2), (3, 4), (5, 6)]