Coverage for /home/jenkins/workspace/NDS/Zserio/NDS_ZSERIO-linux-build/compiler/extensions/python/runtime/tests/test_serialization.py: 100%

109 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-12-13 15:12 +0000

1import unittest 

2 

3from test_object.api import SerializeEnum, SerializeNested, SerializeObject 

4 

5from zserio.serialization import (serialize, deserialize, serialize_to_bytes, deserialize_from_bytes, 

6 serialize_to_file, deserialize_from_file) 

7from zserio.bitbuffer import BitBuffer 

8from zserio.exception import PythonRuntimeException 

9 

10class SerializationTest(unittest.TestCase): 

11 

12 def test_serialize_enum(self): 

13 serialize_enum = SerializeEnum.VALUE3 

14 bitbuffer = serialize(serialize_enum) 

15 expected_bitsize = 8 

16 self.assertEqual(expected_bitsize, bitbuffer.bitsize) 

17 self.assertEqual(b'\x02', bitbuffer.buffer) 

18 

19 def test_serialize_parameterized_object(self): 

20 param = 0x12 

21 offset = 0 

22 optional_value = 0xDEADCAFE 

23 serialize_nested = SerializeNested(param, offset, optional_value) 

24 bitbuffer = serialize(serialize_nested) 

25 expected_bitsize = 40 

26 self.assertEqual(expected_bitsize, bitbuffer.bitsize) 

27 self.assertEqual(b'\x01\xDE\xAD\xCA\xFE', bitbuffer.buffer) 

28 

29 def test_serialize_object(self): 

30 param = 0x12 

31 offset = 0 

32 optional_value = 0xDEADCAFE 

33 serialize_nested = SerializeNested(param, offset, optional_value) 

34 serialize_object = SerializeObject(param, serialize_nested) 

35 bitbuffer = serialize(serialize_object) 

36 expected_bitsize = 48 

37 self.assertEqual(expected_bitsize, bitbuffer.bitsize) 

38 self.assertEqual(b'\x12\x02\xDE\xAD\xCA\xFE', bitbuffer.buffer) 

39 

40 def test_deserialize_enum(self): 

41 bitbuffer = BitBuffer(b'\x02', 8) 

42 serialize_enum = deserialize(SerializeEnum, bitbuffer) 

43 self.assertEqual(SerializeEnum.VALUE3, serialize_enum) 

44 

45 def test_deserialize_parameterized_object(self): 

46 bitbuffer = BitBuffer(b'\x01\xDE\xAD\xCA\xFE', 40) 

47 with self.assertRaises(TypeError): 

48 deserialize(SerializeNested, bitbuffer) 

49 serialize_nested = deserialize(SerializeNested, bitbuffer, 0x12) 

50 self.assertEqual(0x12, serialize_nested.param) 

51 self.assertEqual(0x01, serialize_nested.offset) 

52 self.assertEqual(0xDEADCAFE, serialize_nested.optional_value) 

53 

54 wrong_bitbuffer = BitBuffer(b'\x02\xDE\xAD\xCA\xFE', 39) 

55 with self.assertRaises(PythonRuntimeException): 

56 deserialize(SerializeNested, wrong_bitbuffer, 0x12) 

57 

58 def test_deserialize_object(self): 

59 bitbuffer = BitBuffer(b'\x12\x02\xDE\xAD\xCA\xFE', 48) 

60 serialize_object = deserialize(SerializeObject, bitbuffer) 

61 self.assertEqual(0x12, serialize_object.param) 

62 serialize_nested = serialize_object.nested 

63 self.assertEqual(0x12, serialize_nested.param) 

64 self.assertEqual(0x02, serialize_nested.offset) 

65 self.assertEqual(0xDEADCAFE, serialize_nested.optional_value) 

66 

67 def test_serialize_enum_to_bytes(self): 

68 serialize_enum = SerializeEnum.VALUE3 

69 buffer = serialize_to_bytes(serialize_enum) 

70 self.assertEqual(1, len(buffer)) 

71 self.assertEqual(b'\x02', buffer) 

72 

73 def test_serialize_parameterized_object_to_bytes(self): 

74 param = 0x12 

75 offset = 0 

76 optional_value = 0xDEADCAFE 

77 serialize_nested = SerializeNested(param, offset, optional_value) 

78 buffer = serialize_to_bytes(serialize_nested) 

79 self.assertEqual(5, len(buffer)) 

80 self.assertEqual(b'\x01\xDE\xAD\xCA\xFE', buffer) 

81 

82 def test_serialize_object_to_bytes(self): 

83 param = 0x12 

84 offset = 0 

85 optional_value = 0xDEADCAFE 

86 serialize_nested = SerializeNested(param, offset, optional_value) 

87 serialize_object = SerializeObject(param, serialize_nested) 

88 buffer = serialize_to_bytes(serialize_object) 

89 self.assertEqual(6, len(buffer)) 

90 self.assertEqual(b'\x12\x02\xDE\xAD\xCA\xFE', buffer) 

91 

92 def test_deserialize_enum_from_bytes(self): 

93 buffer = b'\x02' 

94 serialize_enum = deserialize_from_bytes(SerializeEnum, buffer) 

95 self.assertEqual(SerializeEnum.VALUE3, serialize_enum) 

96 

97 def test_deserialize_parameterized_object_from_bytes(self): 

98 buffer = b'\x01\xDE\xAD\xCA\xFE' 

99 with self.assertRaises(TypeError): 

100 deserialize_from_bytes(SerializeNested, buffer) 

101 serialize_nested = deserialize_from_bytes(SerializeNested, buffer, 0x12) 

102 self.assertEqual(0x12, serialize_nested.param) 

103 self.assertEqual(0x01, serialize_nested.offset) 

104 self.assertEqual(0xDEADCAFE, serialize_nested.optional_value) 

105 

106 wrong_buffer = b'\x00\xDE\xAD\xCA\xFE' 

107 with self.assertRaises(PythonRuntimeException): 

108 deserialize_from_bytes(SerializeNested, wrong_buffer, 0x12) 

109 

110 def test_deserialize_object_from_bytes(self): 

111 buffer = b'\x12\x02\xDE\xAD\xCA\xFE' 

112 serialize_object = deserialize_from_bytes(SerializeObject, buffer) 

113 self.assertEqual(0x12, serialize_object.param) 

114 serialize_nested = serialize_object.nested 

115 self.assertEqual(0x12, serialize_nested.param) 

116 self.assertEqual(0x02, serialize_nested.offset) 

117 self.assertEqual(0xDEADCAFE, serialize_nested.optional_value) 

118 

119 def test_to_file_from_file(self): 

120 param = 0x12 

121 offset = 0 

122 optional_value = 0xDEADCAFE 

123 serialize_nested = SerializeNested(param, offset, optional_value) 

124 serialize_object = SerializeObject(param, serialize_nested) 

125 filename = "SerializationTest.bin" 

126 serialize_to_file(serialize_object, filename) 

127 read_serialize_object = deserialize_from_file(SerializeObject, filename) 

128 self.assertEqual(serialize_object, read_serialize_object)