forked from project-chip/connectedhomeip
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathtest_tlv.py
165 lines (148 loc) · 7.34 KB
/
test_tlv.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
#
# Copyright (c) 2021 Project CHIP Authors
# All rights reserved.
#
# 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.
#
from chip.tlv import TLVWriter, TLVReader
from chip.tlv import uint as tlvUint
import unittest
class TestTLVWriter(unittest.TestCase):
def _getEncoded(self, val, tag=None):
writer = TLVWriter()
writer.put(tag, val)
return writer.encoding
def test_int(self):
encodedVal = self._getEncoded(0x00deadbeefca00fe)
self.assertEqual(encodedVal,
bytearray([0b00000011,
0xfe, 0x00, 0xca, 0xef, 0xbe, 0xad, 0xde, 0x00]))
encodedVal = self._getEncoded(0x7cadbeef)
self.assertEqual(encodedVal,
bytearray([0b00000010, 0xef, 0xbe, 0xad, 0x7c]))
encodedVal = self._getEncoded(0x7cad)
self.assertEqual(encodedVal,
bytearray([0b00000001, 0xad, 0x7c]))
encodedVal = self._getEncoded(0x7c)
self.assertEqual(encodedVal,
bytearray([0b00000000, 0x7c]))
# Negative numbers
encodedVal = self._getEncoded(-(0x5555555555555555))
self.assertEqual(encodedVal,
bytearray([0b00000011,
0xab, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]))
encodedVal = self._getEncoded(-(0x55555555))
self.assertEqual(encodedVal,
bytearray([0b00000010, 0xab, 0xaa, 0xaa, 0xaa]))
encodedVal = self._getEncoded(-(0x5555))
self.assertEqual(encodedVal,
bytearray([0b00000001, 0xab, 0xaa]))
encodedVal = self._getEncoded(-(0x55))
self.assertEqual(encodedVal,
bytearray([0b00000000, 0xab]))
# The following numbers are positive values but exceeds the upper bounds of the type they seems to be.
encodedVal = self._getEncoded(0xdeadbeef)
self.assertEqual(encodedVal,
bytearray([0b00000011, 0xef, 0xbe, 0xad, 0xde, 0x00, 0x00, 0x00, 0x00]))
encodedVal = self._getEncoded(0xdead)
self.assertEqual(encodedVal,
bytearray([0b00000010, 0xad, 0xde, 0x00, 0x00]))
encodedVal = self._getEncoded(0xad)
self.assertEqual(encodedVal,
bytearray([0b00000001, 0xad, 0x00]))
# Similar, these negative numbers also exceedes the width of the type they seems to be.
encodedVal = self._getEncoded(-(0xaaaaaaaa))
self.assertEqual(encodedVal,
bytearray([0b00000011, 0x56, 0x55, 0x55, 0x55, 0xff, 0xff, 0xff, 0xff]))
encodedVal = self._getEncoded(-(0xaaaa))
self.assertEqual(encodedVal,
bytearray([0b00000010, 0x56, 0x55, 0xff, 0xff]))
encodedVal = self._getEncoded(-(0xaa))
self.assertEqual(encodedVal,
bytearray([0b00000001, 0x56, 0xff]))
try:
encodedVal = self._getEncoded(0xf000f000f000f000)
self.fail("Signed number exceeds INT64_MAX but no exception received")
except Exception:
pass
try:
encodedVal = self._getEncoded(-(0xf000f000f000f000))
self.fail("Signed number exceeds INT64_MIN but no exception received")
except Exception:
pass
def test_uint(self):
encodedVal = self._getEncoded(tlvUint(0xdeadbeefca0000fe))
self.assertEqual(encodedVal,
bytearray([0b00000111,
0xfe, 0x00, 0x00, 0xca, 0xef, 0xbe, 0xad, 0xde]))
encodedVal = self._getEncoded(tlvUint(0xdeadbeef))
self.assertEqual(encodedVal,
bytearray([0b00000110, 0xef, 0xbe, 0xad, 0xde]))
encodedVal = self._getEncoded(tlvUint(0xdead))
self.assertEqual(encodedVal,
bytearray([0b00000101, 0xad, 0xde]))
encodedVal = self._getEncoded(tlvUint(0xde))
self.assertEqual(encodedVal,
bytearray([0b00000100, 0xde]))
try:
encodedVal = self._getEncoded(tlvUint(-1))
self.fail("Negative unsigned int but no exception raised.")
except Exception:
pass
try:
encodedVal = self._getEncoded(tlvUint(0x10000000000000000))
self.fail("Overflowed uint but no exception raised.")
except Exception:
pass
class TestTLVReader(unittest.TestCase):
def _read_case(self, input, answer):
decoded = TLVReader(bytearray(input)).get()["Any"]
self.assertEqual(type(decoded), type(answer))
self.assertEqual(decoded, answer)
def test_int(self):
self._read_case([0b00000011,
0xfe, 0x00, 0xca, 0xef, 0xbe, 0xad, 0xde, 0x00], 0x00deadbeefca00fe)
self._read_case([0b00000010, 0xef, 0xbe, 0xad, 0x7c], 0x7cadbeef)
self._read_case([0b00000001, 0xad, 0x7c], 0x7cad)
self._read_case([0b00000000, 0x7c], 0x7c)
self._read_case([0b00000011,
0xab, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa], -(0x5555555555555555))
self._read_case([0b00000010, 0xab, 0xaa, 0xaa, 0xaa], -(0x55555555))
self._read_case([0b00000001, 0xab, 0xaa], -(0x5555))
self._read_case([0b00000000, 0xab], -(0x55))
def test_uint(self):
self._read_case([0b00000111,
0xfe, 0x00, 0xca, 0xef, 0xbe, 0xad, 0xde, 0x00], tlvUint(0x00deadbeefca00fe))
self._read_case([0b00000110, 0xef, 0xbe, 0xad, 0x7c],
tlvUint(0x7cadbeef))
self._read_case([0b00000101, 0xad, 0x7c], tlvUint(0x7cad))
self._read_case([0b00000100, 0x7c], tlvUint(0x7c))
self._read_case([0b00000111,
0xab, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa], tlvUint(0xaaaaaaaaaaaaaaab))
self._read_case([0b00000110, 0xab, 0xaa, 0xaa, 0xaa],
tlvUint(0xaaaaaaab))
self._read_case([0b00000101, 0xab, 0xaa], tlvUint(0xaaab))
self._read_case([0b00000100, 0xab], tlvUint(0xab))
def test_structure(self):
test_cases = [
(b'\x15\x36\x01\x15\x35\x01\x26\x00\xBF\xA2\x55\x16\x37\x01\x24\x02\x00\x24\x03\x28\x24\x04\x00\x18\x24\x02\x01\x18\x18\x18\x18',
{1: [{1: {0: 374710975, 1: [0, 40, 0], 2: 1}}]}),
(b'\x156\x01\x155\x01&\x00\xBF\xA2U\x167\x01$\x02\x00$\x03($\x04\x01\x18,\x02\x18Nordic Semiconductor ASA\x18\x18\x18\x18',
{1: [{1: {0: 374710975, 1: [0, 40, 1], 2: 'Nordic Semiconductor ASA'}}]}),
(b"\0256\001\0255\001&\000\031\346x\2077\001$\002\001$\003\006$\004\000\030(\002\030\030\030\030",
{1: [{1: {0: 2272847385, 1: [1, 6, 0], 2: False}}]})
]
for tlv_bytes, answer in test_cases:
self._read_case(tlv_bytes, answer)
if __name__ == '__main__':
unittest.main()