test_transport.py
Go to the documentation of this file.
1 #
2 # Copyright (C) 2014-2015 UAVCAN Development Team <uavcan.org>
3 #
4 # This software is distributed under the terms of the MIT License.
5 #
6 # Author: Ben Dyer <ben_dyer@mac.com>
7 # Pavel Kirienko <pavel.kirienko@zubax.com>
8 #
9 
10 import unittest
11 from pyuavcan_v0 import transport
12 from pyuavcan_v0.dsdl import parser
13 
14 
15 class TestBitsFromBytes(unittest.TestCase):
16  def test_empty(self):
17  bits = transport.bits_from_bytes(bytearray(b""))
18  self.assertEqual(bits, "")
19 
20  def test_single_byte(self):
21  bits = transport.bits_from_bytes(bytearray(b"\x00"))
22  self.assertEqual(bits, "00000000")
23 
24  bits = transport.bits_from_bytes(bytearray(b"\xA5"))
25  self.assertEqual(bits, "10100101")
26 
27  bits = transport.bits_from_bytes(bytearray(b"\xFF"))
28  self.assertEqual(bits, "11111111")
29 
30  bits = transport.bits_from_bytes(bytearray(b"\x0F"))
31  self.assertEqual(bits, "00001111")
32 
33  bits = transport.bits_from_bytes(bytearray(b"\xF0"))
34  self.assertEqual(bits, "11110000")
35 
36  def test_multiple_bytes(self):
37  bits = transport.bits_from_bytes(bytearray(b"\x00\xFF"))
38  self.assertEqual(bits, "0000000011111111")
39 
40  bits = transport.bits_from_bytes(bytearray(b"\xFF\x00"))
41  self.assertEqual(bits, "1111111100000000")
42 
43  bits = transport.bits_from_bytes(bytearray(b"\x00\x00\xAA\x55\xFF\xFF"))
44  self.assertEqual(
45  bits, "000000000000000010101010010101011111111111111111")
46 
47 
48 class TestBytesFromBits(unittest.TestCase):
49  def test_empty(self):
50  result_bytes = transport.bytes_from_bits("")
51  self.assertEqual(result_bytes, b"")
52 
53  def test_partial_byte(self):
54  result_bytes = transport.bytes_from_bits("0")
55  self.assertEqual(result_bytes, b"\x00")
56 
57  result_bytes = transport.bytes_from_bits("1")
58  self.assertEqual(result_bytes, b"\x01")
59 
60  result_bytes = transport.bytes_from_bits("100")
61  self.assertEqual(result_bytes, b"\x04")
62 
63  result_bytes = transport.bytes_from_bits("001")
64  self.assertEqual(result_bytes, b"\x01")
65 
66  result_bytes = transport.bytes_from_bits("1001")
67  self.assertEqual(result_bytes, b"\x09")
68 
69  result_bytes = transport.bytes_from_bits("01001")
70  self.assertEqual(result_bytes, b"\x09")
71 
72  result_bytes = transport.bytes_from_bits("0001001")
73  self.assertEqual(result_bytes, b"\x09")
74 
75  result_bytes = transport.bytes_from_bits("1001001")
76  self.assertEqual(result_bytes, b"\x49")
77 
78  def test_single_byte(self):
79  result_bytes = transport.bytes_from_bits("10010110")
80  self.assertEqual(result_bytes, b"\x96")
81 
82  result_bytes = transport.bytes_from_bits("10100101")
83  self.assertEqual(result_bytes, b"\xA5")
84 
85  result_bytes = transport.bytes_from_bits("00000000")
86  self.assertEqual(result_bytes, b"\x00")
87 
88  def test_multiple_bytes(self):
89  result_bytes = transport.bytes_from_bits("1010010110010110")
90  self.assertEqual(result_bytes, b"\xA5\x96")
91 
92  result_bytes = transport.bytes_from_bits("11010010110010110")
93  self.assertEqual(result_bytes, b"\xD2\xCB\x00")
94 
95  result_bytes = transport.bytes_from_bits("10100101100101101")
96  self.assertEqual(result_bytes, b"\xA5\x96\x01")
97 
98 
99 class TestBEFromLEBits(unittest.TestCase):
100  def test_partial_byte(self):
101  for bits in ("0", "1", "100", "001", "1001", "01001", "001001",
102  "1001001"):
103  out_bits = transport.be_from_le_bits(bits, len(bits))
104  self.assertEqual(out_bits, bits)
105 
106  def test_single_byte(self):
107  for bits in ("10010110", "10100101", "00000000"):
108  out_bits = transport.be_from_le_bits(bits, 8)
109  self.assertEqual(out_bits, bits)
110 
111  def test_multiple_bytes(self):
112  # llllllllmmmm
113  out_bits = transport.be_from_le_bits("110110101110", 12)
114  # mmmmllllllll
115  self.assertEqual(out_bits, "111011011010")
116 
117  # llllllllmmmmmmmm
118  out_bits = transport.be_from_le_bits("1010010110010110", 16)
119  # mmmmmmmmllllllll
120  self.assertEqual(out_bits, "1001011010100101")
121 
122  # llllllll........m
123  out_bits = transport.be_from_le_bits("11010010110010110", 17)
124  # m........llllllll
125  self.assertEqual(out_bits, "01100101111010010")
126 
127  # llllllll........m
128  out_bits = transport.be_from_le_bits("10100101100101101", 17)
129  # m........llllllll
130  self.assertEqual(out_bits, "11001011010100101")
131 
132 
133 class TestLEFromBEBits(unittest.TestCase):
134  def test_partial_byte(self):
135  for bits in ("0", "1", "100", "001", "1001", "01001", "001001",
136  "1001001"):
137  out_bits = transport.le_from_be_bits(bits, len(bits))
138  self.assertEqual(out_bits, bits)
139 
140  def test_single_byte(self):
141  for bits in ("10010110", "10100101", "00000000"):
142  out_bits = transport.le_from_be_bits(bits, 8)
143  self.assertEqual(out_bits, bits)
144 
145  def test_multiple_bytes(self):
146  # mmmmllllllll
147  out_bits = transport.le_from_be_bits("111011011010", 12)
148  # llllllllmmmm
149  self.assertEqual(out_bits, "110110101110")
150 
151  # mmmmmmmmllllllll
152  out_bits = transport.le_from_be_bits("1001011010100101", 16)
153  # llllllllmmmmmmmm
154  self.assertEqual(out_bits, "1010010110010110")
155 
156  # m........llllllll
157  out_bits = transport.le_from_be_bits("01100101111010010", 17)
158  # llllllll........m
159  self.assertEqual(out_bits, "11010010110010110")
160 
161  # m........llllllll
162  out_bits = transport.le_from_be_bits("11001011010100101", 17)
163  # llllllll........m
164  self.assertEqual(out_bits, "10100101100101101")
165 
166 
167 class TestCast(unittest.TestCase):
168  def test_truncated_1bit(self):
169  dtype = parser.PrimitiveType(
170  parser.PrimitiveType.KIND_UNSIGNED_INT,
171  1,
172  parser.PrimitiveType.CAST_MODE_TRUNCATED)
173  value = transport.cast(0, dtype)
174  self.assertEqual(value, 0)
175  value = transport.cast(1, dtype)
176  self.assertEqual(value, 1)
177  value = transport.cast(2, dtype)
178  self.assertEqual(value, 0)
179  value = transport.cast(-1, dtype)
180  self.assertEqual(value, 1)
181  value = transport.cast(5, dtype)
182  self.assertEqual(value, 1)
183  value = transport.cast(-10, dtype)
184  self.assertEqual(value, 0)
185 
186  def test_truncated_4bit(self):
187  dtype = parser.PrimitiveType(
188  parser.PrimitiveType.KIND_UNSIGNED_INT,
189  4,
190  parser.PrimitiveType.CAST_MODE_TRUNCATED)
191  value = transport.cast(0, dtype)
192  self.assertEqual(value, 0)
193  value = transport.cast(15, dtype)
194  self.assertEqual(value, 15)
195  value = transport.cast(16, dtype)
196  self.assertEqual(value, 0)
197  value = transport.cast(-1, dtype)
198  self.assertEqual(value, 15)
199  value = transport.cast(30, dtype)
200  self.assertEqual(value, 14)
201 
202  def test_truncated_33bit(self):
203  dtype = parser.PrimitiveType(
204  parser.PrimitiveType.KIND_UNSIGNED_INT,
205  33,
206  parser.PrimitiveType.CAST_MODE_TRUNCATED)
207  value = transport.cast(0, dtype)
208  self.assertEqual(value, 0)
209  value = transport.cast(8589934591, dtype)
210  self.assertEqual(value, 8589934591)
211  value = transport.cast(8589934592, dtype)
212  self.assertEqual(value, 0)
213  value = transport.cast(-1, dtype)
214  self.assertEqual(value, 8589934591)
215 
216  def test_truncated_64bit(self):
217  dtype = parser.PrimitiveType(
218  parser.PrimitiveType.KIND_UNSIGNED_INT,
219  64,
220  parser.PrimitiveType.CAST_MODE_TRUNCATED)
221  value = transport.cast(0, dtype)
222  self.assertEqual(value, 0)
223  value = transport.cast(18446744073709551615, dtype)
224  self.assertEqual(value, 18446744073709551615)
225  value = transport.cast(-1, dtype)
226  self.assertEqual(value, 18446744073709551615)
227  value = transport.cast(18446744073709551617, dtype)
228  self.assertEqual(value, 1)
229  value = transport.cast(-18446744073709551615, dtype)
230  self.assertEqual(value, 1)
231 
232  def test_unsigned_saturated_1bit(self):
233  dtype = parser.PrimitiveType(
234  parser.PrimitiveType.KIND_UNSIGNED_INT,
235  1,
236  parser.PrimitiveType.CAST_MODE_SATURATED)
237  value = transport.cast(0, dtype)
238  self.assertEqual(value, 0)
239  value = transport.cast(1, dtype)
240  self.assertEqual(value, 1)
241  value = transport.cast(2, dtype)
242  self.assertEqual(value, 1)
243  value = transport.cast(-1, dtype)
244  self.assertEqual(value, 0)
245  value = transport.cast(5, dtype)
246  self.assertEqual(value, 1)
247  value = transport.cast(-10, dtype)
248  self.assertEqual(value, 0)
249 
250  def test_unsigned_saturated_4bit(self):
251  dtype = parser.PrimitiveType(
252  parser.PrimitiveType.KIND_UNSIGNED_INT,
253  4,
254  parser.PrimitiveType.CAST_MODE_SATURATED)
255  value = transport.cast(0, dtype)
256  self.assertEqual(value, 0)
257  value = transport.cast(15, dtype)
258  self.assertEqual(value, 15)
259  value = transport.cast(16, dtype)
260  self.assertEqual(value, 15)
261  value = transport.cast(-1, dtype)
262  self.assertEqual(value, 0)
263  value = transport.cast(30, dtype)
264  self.assertEqual(value, 15)
265 
266  def test_unsigned_saturated_33bit(self):
267  dtype = parser.PrimitiveType(
268  parser.PrimitiveType.KIND_UNSIGNED_INT,
269  33,
270  parser.PrimitiveType.CAST_MODE_SATURATED)
271  value = transport.cast(0, dtype)
272  self.assertEqual(value, 0)
273  value = transport.cast(8589934591, dtype)
274  self.assertEqual(value, 8589934591)
275  value = transport.cast(8589934592, dtype)
276  self.assertEqual(value, 8589934591)
277  value = transport.cast(-1, dtype)
278  self.assertEqual(value, 0)
279 
280  def test_unsigned_saturated_64bit(self):
281  dtype = parser.PrimitiveType(
282  parser.PrimitiveType.KIND_UNSIGNED_INT,
283  64,
284  parser.PrimitiveType.CAST_MODE_SATURATED)
285  value = transport.cast(0, dtype)
286  self.assertEqual(value, 0)
287  value = transport.cast(18446744073709551615, dtype)
288  self.assertEqual(value, 18446744073709551615)
289  value = transport.cast(-1, dtype)
290  self.assertEqual(value, 0)
291  value = transport.cast(18446744073709551617, dtype)
292  self.assertEqual(value, 18446744073709551615)
293  value = transport.cast(-18446744073709551615, dtype)
294  self.assertEqual(value, 0)
295 
296  def test_signed_saturated_4bit(self):
297  dtype = parser.PrimitiveType(
298  parser.PrimitiveType.KIND_SIGNED_INT,
299  4,
300  parser.PrimitiveType.CAST_MODE_SATURATED)
301  value = transport.cast(0, dtype)
302  self.assertEqual(value, 0)
303  value = transport.cast(15, dtype)
304  self.assertEqual(value, 7)
305  value = transport.cast(16, dtype)
306  self.assertEqual(value, 7)
307  value = transport.cast(-1, dtype)
308  self.assertEqual(value, -1)
309  value = transport.cast(-30, dtype)
310  self.assertEqual(value, -8)
311 
312  def test_signed_saturated_33bit(self):
313  dtype = parser.PrimitiveType(
314  parser.PrimitiveType.KIND_SIGNED_INT,
315  33,
316  parser.PrimitiveType.CAST_MODE_SATURATED)
317  value = transport.cast(0, dtype)
318  self.assertEqual(value, 0)
319  value = transport.cast(8589934591, dtype)
320  self.assertEqual(value, 4294967295)
321  value = transport.cast(-8589934592, dtype)
322  self.assertEqual(value, -4294967296)
323  value = transport.cast(-1, dtype)
324  self.assertEqual(value, -1)
325 
326  def test_signed_saturated_64bit(self):
327  dtype = parser.PrimitiveType(
328  parser.PrimitiveType.KIND_SIGNED_INT,
329  64,
330  parser.PrimitiveType.CAST_MODE_SATURATED)
331  value = transport.cast(0, dtype)
332  self.assertEqual(value, 0)
333  value = transport.cast(18446744073709551615, dtype)
334  self.assertEqual(value, 9223372036854775808)
335  value = transport.cast(-1, dtype)
336  self.assertEqual(value, -1)
337  value = transport.cast(-18446744073709551617, dtype)
338  self.assertEqual(value, -9223372036854775809)
339  value = transport.cast(-9223372036854775808, dtype)
340  self.assertEqual(value, -9223372036854775808)
341 
342  def test_float16_truncated(self):
343  pass
344 
345  def test_float16_saturated(self):
346  pass
347 
348  def test_float32_truncated(self):
349  pass
350 
351  def test_float32_saturated(self):
352  pass
353 
354 
355 class TestArrayBasic(unittest.TestCase):
356  def setUp(self):
357  custom_type = parser.CompoundType(
358  "CustomType",
359  parser.CompoundType.KIND_MESSAGE,
360  "source.uavcan",
361  0,
362  (0,0),
363  ""
364  )
365  custom_type.fields = [
366  parser.Field(
367  parser.PrimitiveType(
368  parser.PrimitiveType.KIND_SIGNED_INT,
369  8,
370  parser.PrimitiveType.CAST_MODE_TRUNCATED
371  ),
372  "a"
373  ),
374  parser.Field(
375  parser.PrimitiveType(
376  parser.PrimitiveType.KIND_FLOAT,
377  16,
378  parser.PrimitiveType.CAST_MODE_SATURATED
379  ),
380  "b"
381  ),
382  parser.Field(
383  parser.ArrayType(
384  parser.PrimitiveType(
385  parser.PrimitiveType.KIND_UNSIGNED_INT,
386  1,
387  parser.PrimitiveType.CAST_MODE_SATURATED
388  ),
389  parser.ArrayType.MODE_DYNAMIC,
390  5
391  ),
392  "c"
393  )
394  ]
395 
396  def custom_type_factory(*args, **kwargs):
397  return transport.CompoundValue(custom_type, *args, **kwargs)
398  custom_type._instantiate = custom_type_factory
399 
400  self.a1_type = parser.ArrayType(
401  parser.PrimitiveType(
402  parser.PrimitiveType.KIND_SIGNED_INT,
403  8,
404  parser.PrimitiveType.CAST_MODE_TRUNCATED
405  ),
406  parser.ArrayType.MODE_STATIC,
407  4
408  )
409  self.a2_type = parser.ArrayType(
410  parser.PrimitiveType(
411  parser.PrimitiveType.KIND_FLOAT,
412  16,
413  parser.PrimitiveType.CAST_MODE_SATURATED
414  ),
415  parser.ArrayType.MODE_STATIC,
416  2
417  )
418  self.a3_type = parser.ArrayType(
419  custom_type,
420  parser.ArrayType.MODE_STATIC,
421  2
422  )
423 
424  def test_size(self):
425  self.assertEqual(self.a3_type.value_type.fields[2].type.value_type.bitlen, 1)
426  self.assertEqual(self.a1_type.get_max_bitlen(), 8 * 4)
427  self.assertEqual(self.a2_type.get_max_bitlen(), 16 * 2)
428  self.assertEqual(self.a3_type.get_max_bitlen(), (8 + 16 + 5 + 3) * 2)
429 
430  def test_representation(self):
431  a1 = transport.ArrayValue(self.a1_type)
432  a2 = transport.ArrayValue(self.a2_type)
433  a3 = transport.ArrayValue(self.a3_type)
434  for i in range(4):
435  a1[i] = i
436  for i in range(2):
437  a2[i] = i
438  for i in range(2):
439  a3[i].a = i
440  a3[i].b = i
441  for i2 in range(5):
442  a3[i].c.append(i2 & 1)
443  self.assertEqual(len(a3[i].c), 5)
444 
445  self.assertEqual(
446  transport.format_bits(a1._pack(False)),
447  "00000000 00000001 00000010 00000011"
448  )
449  self.assertEqual(
450  transport.format_bits(a2._pack(False)),
451  "00000000 00000000 00000000 00111100"
452  )
453  self.assertEqual(
454  transport.format_bits(a3._pack(True)),
455  "00000000 00000000 00000000 10101010 " +
456  "00000001 00000000 00111100 10101010"
457  )
458 
459 
460 class TestVoid(unittest.TestCase):
461  def setUp(self):
462  self.custom_type = parser.CompoundType(
463  "CustomType",
464  parser.CompoundType.KIND_MESSAGE,
465  "source.uavcan",
466  0,
467  (0,0),
468  ""
469  )
470  self.custom_type.fields = [
471  parser.Field(
472  parser.PrimitiveType(
473  parser.PrimitiveType.KIND_FLOAT,
474  16,
475  parser.PrimitiveType.CAST_MODE_SATURATED
476  ),
477  "a"
478  ),
479  parser.Field(parser.VoidType(3), None),
480  parser.Field(
481  parser.PrimitiveType(
482  parser.PrimitiveType.KIND_UNSIGNED_INT,
483  1,
484  parser.PrimitiveType.CAST_MODE_SATURATED
485  ),
486  "b"
487  )
488  ]
489 
490  def custom_type_factory(*args, **kwargs):
491  return transport.CompoundValue(self.custom_type, *args,
492  **kwargs)
493  self.custom_type._instantiate = custom_type_factory
494 
495  def test_size(self):
496  self.assertEqual(self.custom_type.fields[1].type.bitlen, 3)
497  self.assertEqual(self.custom_type.get_max_bitlen(), 20)
498 
499  def test_representation(self):
500  c1 = self.custom_type()
501  self.assertEqual(
502  transport.format_bits(c1._pack(False)),
503  "00000000 00000000 0000"
504  )
505 
506  c1.a = 1
507  c1.b = 1
508  self.assertEqual(
509  transport.format_bits(c1._pack(False)),
510  "00000000 00111100 0001"
511  )
512 
513 
514 class TestMessageUnion(unittest.TestCase):
515  def setUp(self):
516  self.custom_type = parser.CompoundType(
517  "CustomType",
518  parser.CompoundType.KIND_MESSAGE,
519  "source.uavcan",
520  0,
521  (0,0),
522  ""
523  )
524  self.custom_type.union = True
525  self.custom_type.fields = [
526  parser.Field(
527  parser.PrimitiveType(
528  parser.PrimitiveType.KIND_FLOAT,
529  16,
530  parser.PrimitiveType.CAST_MODE_SATURATED
531  ),
532  "a"
533  ),
534  parser.Field(
535  parser.ArrayType(
536  parser.PrimitiveType(
537  parser.PrimitiveType.KIND_UNSIGNED_INT,
538  8,
539  parser.PrimitiveType.CAST_MODE_SATURATED
540  ),
541  parser.ArrayType.MODE_STATIC,
542  2
543  ),
544  "b"
545  )
546  ]
547 
548  def custom_type_factory(*args, **kwargs):
549  return transport.CompoundValue(self.custom_type, *args,
550  **kwargs)
551  self.custom_type._instantiate = custom_type_factory
552 
553  def test_size(self):
554  self.assertEqual(self.custom_type.fields[0].type.bitlen, 16)
555  self.assertEqual(self.custom_type.fields[1].type.get_max_bitlen(), 16)
556  self.assertEqual(self.custom_type.get_max_bitlen(), 17)
557 
558  def test_representation(self):
559  c1 = self.custom_type()
560  self.assertEqual(
561  transport.format_bits(c1._pack(True)),
562  "00000000 00000000 0"
563  )
564 
565  c2 = self.custom_type()
566  c2.a = 1
567  self.assertEqual(transport.get_active_union_field(c2), "a")
568  self.assertEqual(
569  transport.format_bits(c2._pack(True)),
570  "00000000 00011110 0"
571  )
572 
573  c3 = self.custom_type()
574  c3.b[0] = 1
575  c3.b[1] = 3
576  self.assertEqual(transport.get_active_union_field(c3), "b")
577  self.assertEqual(
578  transport.format_bits(c3._pack(False)),
579  "10000000 10000001 1"
580  )
581 
582 
583 class TestAssignment(unittest.TestCase):
584  def setUp(self):
585  import pyuavcan_v0
586  self.a = pyuavcan_v0.protocol.GetNodeInfo.Response()
587 
588  def test_compound_assignment(self):
589  import pyuavcan_v0
590 
591  orig_status = self.a.status
592  print(orig_status)
593  self.assertEqual(orig_status.mode, 0)
594  self.assertEqual(orig_status.uptime_sec, 0)
595 
596  self.a.status = pyuavcan_v0.protocol.NodeStatus(mode=3, uptime_sec=12345)
597 
598  new_status = self.a.status
599  print(new_status)
600  self.assertEqual(new_status.mode, 3)
601  self.assertEqual(new_status.uptime_sec, 12345)
602 
603  def test_array_assignment(self):
604  print(repr(self.a.name))
605  print(str(self.a.name))
606  self.assertEqual(self.a.name, [])
607  self.assertEqual(self.a.name, '')
608  self.a.name = '123'
609  self.assertEqual(self.a.name, [49, 50, 51])
610  self.assertEqual(self.a.name, '123')
611  self.a.name = [52, 53, 54]
612  self.assertEqual(self.a.name, [52, 53, 54])
613  self.assertEqual(self.a.name, '456')
614  print(repr(self.a.name))
615  print(str(self.a.name))
616 
617 
618 class TestFloats(unittest.TestCase):
619  def test_basic(self):
620  def make_float(bitlen):
621  return parser.PrimitiveType(parser.PrimitiveType.KIND_FLOAT, bitlen,
622  parser.PrimitiveType.CAST_MODE_TRUNCATED)
623 
624  # 64 bit
625  a = transport.PrimitiveValue(make_float(64))
626  print(a.value)
627  self.assertEqual(a.value, 0)
628  a.value = 123.456
629  print(a.value)
630  self.assertEqual(a.value, 123.456)
631 
632  # 16 bit
633  a = transport.PrimitiveValue(make_float(16))
634  print(a.value)
635  self.assertEqual(a.value, 0)
636  # nan
637  a.value = float('nan')
638  print(a.value)
639  self.assertEqual(str(a.value), 'nan')
640  # positive infinity
641  a.value = float('inf')
642  print(a.value)
643  self.assertEqual(str(a.value), 'inf')
644  # negative infinity
645  a.value = float('-inf')
646  print(a.value)
647  self.assertEqual(str(a.value), '-inf')
648 
649 
650 if __name__ == '__main__':
651  unittest.main()
test_transport.TestMessageUnion
Definition: test_transport.py:514
test_transport.TestAssignment.a
a
Definition: test_transport.py:586
test_transport.TestBEFromLEBits.test_single_byte
def test_single_byte(self)
Definition: test_transport.py:106
test_transport.TestBEFromLEBits.test_partial_byte
def test_partial_byte(self)
Definition: test_transport.py:100
test_transport.TestCast.test_truncated_33bit
def test_truncated_33bit(self)
Definition: test_transport.py:202
test_transport.TestCast.test_float32_saturated
def test_float32_saturated(self)
Definition: test_transport.py:351
test_transport.TestBitsFromBytes.test_single_byte
def test_single_byte(self)
Definition: test_transport.py:20
test_transport.TestLEFromBEBits.test_multiple_bytes
def test_multiple_bytes(self)
Definition: test_transport.py:145
test_transport.TestBytesFromBits
Definition: test_transport.py:48
test_transport.TestCast.test_float16_truncated
def test_float16_truncated(self)
Definition: test_transport.py:342
test_transport.TestVoid.setUp
def setUp(self)
Definition: test_transport.py:461
test_transport.TestBytesFromBits.test_empty
def test_empty(self)
Definition: test_transport.py:49
test_transport.TestVoid.test_representation
def test_representation(self)
Definition: test_transport.py:499
test_transport.TestAssignment.test_compound_assignment
def test_compound_assignment(self)
Definition: test_transport.py:588
test_transport.TestLEFromBEBits.test_partial_byte
def test_partial_byte(self)
Definition: test_transport.py:134
test_transport.TestCast.test_signed_saturated_4bit
def test_signed_saturated_4bit(self)
Definition: test_transport.py:296
test_transport.TestLEFromBEBits
Definition: test_transport.py:133
test_transport.TestCast.test_signed_saturated_64bit
def test_signed_saturated_64bit(self)
Definition: test_transport.py:326
test_transport.TestBEFromLEBits.test_multiple_bytes
def test_multiple_bytes(self)
Definition: test_transport.py:111
test_transport.TestAssignment.setUp
def setUp(self)
Definition: test_transport.py:584
test_transport.TestArrayBasic.a2_type
a2_type
Definition: test_transport.py:409
libuavcan_dsdl_compiler.str
str
Definition: libuavcan_dsdl_compiler/__init__.py:22
test_transport.TestMessageUnion.test_representation
def test_representation(self)
Definition: test_transport.py:558
test_transport.TestArrayBasic.test_representation
def test_representation(self)
Definition: test_transport.py:430
test_transport.TestCast.test_float16_saturated
def test_float16_saturated(self)
Definition: test_transport.py:345
test_transport.TestCast.test_signed_saturated_33bit
def test_signed_saturated_33bit(self)
Definition: test_transport.py:312
test_transport.TestVoid.custom_type
custom_type
Definition: test_transport.py:462
test_transport.TestCast.test_unsigned_saturated_64bit
def test_unsigned_saturated_64bit(self)
Definition: test_transport.py:280
test_transport.TestAssignment.test_array_assignment
def test_array_assignment(self)
Definition: test_transport.py:603
test_transport.TestCast.test_truncated_4bit
def test_truncated_4bit(self)
Definition: test_transport.py:186
test_transport.TestFloats.test_basic
def test_basic(self)
Definition: test_transport.py:619
test_transport.TestCast.test_unsigned_saturated_4bit
def test_unsigned_saturated_4bit(self)
Definition: test_transport.py:250
test_transport.TestCast.test_unsigned_saturated_1bit
def test_unsigned_saturated_1bit(self)
Definition: test_transport.py:232
test_transport.TestBitsFromBytes.test_empty
def test_empty(self)
Definition: test_transport.py:16
test_transport.TestArrayBasic.test_size
def test_size(self)
Definition: test_transport.py:424
test_transport.TestBytesFromBits.test_partial_byte
def test_partial_byte(self)
Definition: test_transport.py:53
test_transport.TestVoid.test_size
def test_size(self)
Definition: test_transport.py:495
test_transport.TestCast.test_truncated_1bit
def test_truncated_1bit(self)
Definition: test_transport.py:168
pyuavcan_v0.dsdl
Definition: pyuavcan/pyuavcan_v0/dsdl/__init__.py:1
test_transport.TestBytesFromBits.test_multiple_bytes
def test_multiple_bytes(self)
Definition: test_transport.py:88
test_transport.TestBEFromLEBits
Definition: test_transport.py:99
test_transport.TestCast.test_float32_truncated
def test_float32_truncated(self)
Definition: test_transport.py:348
test_transport.TestBitsFromBytes
Definition: test_transport.py:15
test_transport.TestArrayBasic.a3_type
a3_type
Definition: test_transport.py:418
test_transport.TestMessageUnion.custom_type
custom_type
Definition: test_transport.py:516
test_transport.TestBytesFromBits.test_single_byte
def test_single_byte(self)
Definition: test_transport.py:78
test_transport.TestFloats
Definition: test_transport.py:618
test_transport.TestVoid
Definition: test_transport.py:460
test_transport.TestMessageUnion.test_size
def test_size(self)
Definition: test_transport.py:553
test_transport.TestCast
Definition: test_transport.py:167
test_transport.TestLEFromBEBits.test_single_byte
def test_single_byte(self)
Definition: test_transport.py:140
test_transport.TestCast.test_unsigned_saturated_33bit
def test_unsigned_saturated_33bit(self)
Definition: test_transport.py:266
test_transport.TestBitsFromBytes.test_multiple_bytes
def test_multiple_bytes(self)
Definition: test_transport.py:36
test_transport.TestAssignment
Definition: test_transport.py:583
test_transport.TestArrayBasic.setUp
def setUp(self)
Definition: test_transport.py:356
test_transport.TestMessageUnion.setUp
def setUp(self)
Definition: test_transport.py:515
test_transport.TestArrayBasic.a1_type
a1_type
Definition: test_transport.py:400
test_transport.TestCast.test_truncated_64bit
def test_truncated_64bit(self)
Definition: test_transport.py:216

uavcan_communicator
Author(s):
autogenerated on Fri Dec 13 2024 03:10:03