def testWriteReadFile(self):
createWrongOffset = True
autoArrayHolder = self._createAutoArrayHolder(createWrongOffset)
zserio.serialize_to_file(autoArrayHolder, self.BLOB_NAME)
readAutoArrayHolder = zserio.deserialize_from_file(self.api.AutoArrayHolder, self.BLOB_NAME)
self.assertEqual(autoArrayHolder, readAutoArrayHolder)
def testReadFile(self):
writer = zserio.BitStreamWriter()
self._writeTile(writer)
writer.to_file(BLOB_NAME)
tile = zserio.deserialize_from_file(self.api.Tile, BLOB_NAME)
self._checkTile(tile)
def testWriteFile(self):
grandChildParam = self._createGrandChildParam()
zserio.serialize_to_file(grandChildParam, self.BLOB_NAME)
readGrandChildParam = zserio.deserialize_from_file(
self.api.GrandChildParam, self.BLOB_NAME)
self.assertEqual(grandChildParam, readGrandChildParam)
def testWriteReadFileArray16(self):
testUnion = self.api.TestUnion(array16_=[-10, -20, -30, -40, -50])
filename = self.BLOB_NAME_BASE + "array16.blob"
zserio.serialize_to_file(testUnion, filename)
readTestUnion = zserio.deserialize_from_file(self.api.TestUnion, filename)
self.assertEqual(testUnion, readTestUnion)
def testWriteReadFile(self):
packedAutoArray = self._createPackedAutoArray()
zserio.serialize_to_file(packedAutoArray, self.BLOB_NAME)
readPackedAutoArray = zserio.deserialize_from_file(
self.api.PackedAutoArray, self.BLOB_NAME)
self.assertEqual(packedAutoArray, readPackedAutoArray)
def testWriteReadFile(self):
permission = self.api.Permission.Values.READ
zserio.serialize_to_file(permission, BLOB_NAME)
readPermission = zserio.deserialize_from_file(self.api.Permission,
BLOB_NAME)
self.assertEqual(permission, readPermission)
def testWriteReadFileTeamLead(self):
teamLead = self._createTeamLead()
filename = self.BLOB_NAME_BASE + "team_lead.blob"
zserio.serialize_to_file(teamLead, filename)
readTeamLead = zserio.deserialize_from_file(self.api.Employee,
filename)
self.assertEqual(teamLead, readTeamLead)
def _checkWriteReadFile(self, numBlocks):
database = self._createDatabase(numBlocks)
filename = self.BLOB_NAME_BASE + str(numBlocks) + ".blob"
zserio.serialize_to_file(database, filename)
readDatabase = zserio.deserialize_from_file(self.api.Database,
filename)
self.assertEqual(database, readDatabase)
def testWriteReadFile(self):
uint8Array = self._createAutoArray()
packedFixedArray = self.api.PackedFixedArray(uint8Array)
zserio.serialize_to_file(packedFixedArray, self.BLOB_NAME)
readPackedFixedArray = zserio.deserialize_from_file(self.api.PackedFixedArray, self.BLOB_NAME)
readUint8Array = readPackedFixedArray.uint8_array
self._checkPackedFixedArray(readUint8Array)
def _checkWriteReadFile(self, numElements):
packedVariableArray = self._createPackedVariableArray(numElements)
filename = self.BLOB_NAME_BASE + str(numElements) + ".blob"
zserio.serialize_to_file(packedVariableArray, filename)
readPackedVariableArray = zserio.deserialize_from_file(
self.api.PackedVariableArray, filename)
self.assertEqual(packedVariableArray, readPackedVariableArray)
def testWriteReadFile(self):
oneStringStructure = self.api.OneStringStructure(self.ONE_STRING)
zserio.serialize_to_file(oneStringStructure, self.BLOB_NAME)
readOneStringStructure = zserio.deserialize_from_file(
self.api.OneStringStructure, self.BLOB_NAME)
self.assertEqual(self.ONE_STRING, readOneStringStructure.one_string)
self.assertTrue(oneStringStructure == readOneStringStructure)
def _checkWriteReadFile(self, numElements):
uint8Array = self._createAutoArray(numElements)
packedAutoArray = self.api.PackedAutoArray(uint8Array)
filename = self.BLOB_NAME_BASE + str(numElements) + ".blob"
zserio.serialize_to_file(packedAutoArray, filename)
readPackedAutoArray = zserio.deserialize_from_file(self.api.PackedAutoArray, filename)
readUint8Array = readPackedAutoArray.uint8_array
self._checkPackedAutoArray(readUint8Array, numElements)
def _checkWriteReadFile(self, numElements):
autoArrayRecursion = self._createAutoArrayRecursion(numElements)
filename = self.BLOB_NAME_BASE + str(numElements) + ".blob"
zserio.serialize_to_file(autoArrayRecursion, filename)
readAutoArrayRecursion = zserio.deserialize_from_file(
self.api.AutoArrayRecursion, filename)
self._checkAutoArrayRecursion(readAutoArrayRecursion, numElements)
def testWriteFile(self):
createWrongOffsets = True
autoIndexedOffsetArray = self._createAutoIndexedOffsetArray(
createWrongOffsets)
zserio.serialize_to_file(autoIndexedOffsetArray, BLOB_NAME)
readAutoIndexedOffsetArray = zserio.deserialize_from_file(
self.api.AutoIndexedOffsetArray, BLOB_NAME)
self.assertEqual(autoIndexedOffsetArray, readAutoIndexedOffsetArray)
def _checkWriteReadFile(self, numElements):
autoIndexedOffsetArray = self._createAutoIndexedOffsetArray(
numElements)
filename = self.BLOB_NAME_BASE + str(numElements) + ".blob"
zserio.serialize_to_file(autoIndexedOffsetArray, filename)
readAutoIndexedOffsetArray = zserio.deserialize_from_file(
self.api.AutoIndexedOffsetArray, filename)
self.assertEqual(autoIndexedOffsetArray, readAutoIndexedOffsetArray)
def testWriteReadFileArray8(self):
testUnion = self.api.TestUnion(array8_=[
self.api.Data8(-1), self.api.Data8(-2), self.api.Data8(-3), self.api.Data8(-4)
])
filename = self.BLOB_NAME_BASE + "array8.blob"
zserio.serialize_to_file(testUnion, filename)
readTestUnion = zserio.deserialize_from_file(self.api.TestUnion, filename)
self.assertEqual(testUnion, readTestUnion)
def testWriteReadFileArray16(self):
testChoice = self.api.TestChoice(16)
testChoice.array16 = [10, 20, 30, 40, 50]
filename = self.BLOB_NAME_BASE + "array16.blob"
zserio.serialize_to_file(testChoice, filename)
readTestChoice = zserio.deserialize_from_file(self.api.TestChoice,
filename, 16)
self.assertEqual(testChoice, readTestChoice)
def testWriteReadFileEmployee(self):
employee = self._createEmployee(self.EMPLOYEE_DEVELOPER1_NAME,
self.EMPLOYEE_DEVELOPER1_SALARY,
self.api.Title.DEVELOPER)
filename = self.BLOB_NAME_BASE + "employee.blob"
zserio.serialize_to_file(employee, filename)
readEmployee = zserio.deserialize_from_file(self.api.Employee,
filename)
self.assertEqual(employee, readEmployee)
def testWriteReadFile(self):
uint8Array = list(range(self.FIXED_ARRAY_LENGTH))
fixedArray = self.api.FixedArray(uint8Array)
zserio.serialize_to_file(fixedArray, self.BLOB_NAME)
readFixedArray = zserio.deserialize_from_file(self.api.FixedArray,
self.BLOB_NAME)
readUint8Array = readFixedArray.uint8_array
self.assertEqual(self.FIXED_ARRAY_LENGTH, len(readUint8Array))
for i in range(self.FIXED_ARRAY_LENGTH):
self.assertEqual(i, readUint8Array[i])
def testReadWrite(self):
container = self.api.Container()
bitFieldLength = 33
container.length = bitFieldLength
container.unsigned_bit_field = zserio.limits.UINT32_MAX + 1
container.signed_bit_field = zserio.limits.INT32_MAX + 1
zserio.serialize_to_file(container, self.BLOB_NAME)
readContainer = zserio.deserialize_from_file(self.api.Container, self.BLOB_NAME)
self.assertEqual(container, readContainer)
def testWriteReadFile(self):
numElements = 55
array = list(range(numElements))
implicitArray = self.api.ImplicitArray(array)
zserio.serialize_to_file(implicitArray, self.BLOB_NAME)
readImplicitArray = zserio.deserialize_from_file(
self.api.ImplicitArray, self.BLOB_NAME)
readArray = readImplicitArray.array
self.assertEqual(numElements, len(readArray))
for i in range(numElements):
self.assertEqual(i, readArray[i])
def _checkWriteReadFile(self, numElements):
uint8Array = list(range(numElements))
autoArray = self.api.AutoArray(uint8Array)
filename = self.BLOB_NAME_BASE + str(numElements) + ".blob"
zserio.serialize_to_file(autoArray, filename)
readAutoArray = zserio.deserialize_from_file(self.api.AutoArray,
filename)
readUint8Array = readAutoArray.uint8_array
self.assertEqual(numElements, len(readUint8Array))
for i in range(numElements):
self.assertEqual(i, readUint8Array[i])
def testWriteReadFileArray8(self):
testChoice = self.api.TestChoice(8)
testChoice.array8 = [
self.api.Data8(1),
self.api.Data8(2),
self.api.Data8(3),
self.api.Data8(4)
]
filename = self.BLOB_NAME_BASE + "array8.blob"
zserio.serialize_to_file(testChoice, filename)
readTestChoice = zserio.deserialize_from_file(self.api.TestChoice,
filename, 8)
self.assertEqual(testChoice, readTestChoice)
def testReadWrite(self):
allBuiltInTypes = self.api.AllBuiltInTypes()
allBuiltInTypes.bool_type = True
allBuiltInTypes.uint8_type = 8
allBuiltInTypes.uint16_type = zserio.limits.UINT16_MAX
allBuiltInTypes.uint32_type = zserio.limits.UINT32_MAX
allBuiltInTypes.uint64_type = zserio.limits.UINT64_MAX
allBuiltInTypes.int8_type = zserio.limits.INT8_MAX
allBuiltInTypes.int16_type = zserio.limits.INT16_MAX
allBuiltInTypes.int32_type = zserio.limits.INT32_MAX
allBuiltInTypes.int64_type = zserio.limits.INT64_MAX
allBuiltInTypes.bitfield7_type = 0x7F
allBuiltInTypes.bitfield8_type = zserio.limits.UINT8_MAX
allBuiltInTypes.bitfield15_type = 0x7FFF
allBuiltInTypes.bitfield16_type = zserio.limits.UINT16_MAX
allBuiltInTypes.bitfield31_type = 0x7FFFFFFF
allBuiltInTypes.bitfield32_type = zserio.limits.UINT32_MAX
allBuiltInTypes.bitfield63_type = 0x7FFFFFFFFFFFFFFF
allBuiltInTypes.variable_bitfield_type = zserio.limits.UINT8_MAX
allBuiltInTypes.variable_bitfield8_type = zserio.limits.UINT8_MAX
allBuiltInTypes.intfield8_type = zserio.limits.INT8_MAX
allBuiltInTypes.intfield16_type = zserio.limits.INT16_MAX
allBuiltInTypes.intfield32_type = zserio.limits.INT32_MAX
allBuiltInTypes.intfield64_type = zserio.limits.INT64_MAX
variableIntfieldTypeMax = (1 << 13) - 1
allBuiltInTypes.variable_intfield_type = variableIntfieldTypeMax
allBuiltInTypes.variable_intfield8_type = zserio.limits.INT8_MAX
allBuiltInTypes.float16_type = 1.0
allBuiltInTypes.float32_type = self.FLOAT32_MAX
allBuiltInTypes.float64_type = sys.float_info.max
allBuiltInTypes.varuint16_type = zserio.limits.VARUINT16_MAX
allBuiltInTypes.varuint32_type = zserio.limits.VARUINT32_MAX
allBuiltInTypes.varuint64_type = zserio.limits.VARUINT64_MAX
allBuiltInTypes.varuint_type = zserio.limits.VARUINT_MAX
allBuiltInTypes.varsize_type = zserio.limits.VARSIZE_MAX
allBuiltInTypes.varint16_type = zserio.limits.VARINT16_MAX
allBuiltInTypes.varint32_type = zserio.limits.VARINT32_MAX
allBuiltInTypes.varint64_type = zserio.limits.VARINT64_MAX
allBuiltInTypes.varint_type = zserio.limits.VARINT_MAX
allBuiltInTypes.string_type = "TEST"
allBuiltInTypes.extern_type = self._getExternalBitBuffer()
zserio.serialize_to_file(allBuiltInTypes, self.BLOB_NAME)
readAllBuiltInTypes = zserio.deserialize_from_file(
self.api.AllBuiltInTypes, self.BLOB_NAME)
self.assertEqual(allBuiltInTypes, readAllBuiltInTypes)
def testWriteReadFile(self):
numElements = 33
compoundArray = [
self.api.TestStructure(i, "Name" + str(i))
for i in range(numElements)
]
variableArray = self.api.VariableArray(numElements, compoundArray)
zserio.serialize_to_file(variableArray, self.BLOB_NAME)
readVariableArray = zserio.deserialize_from_file(
self.api.VariableArray, self.BLOB_NAME)
self.assertEqual(numElements, readVariableArray.num_elements)
readCompoundArray = readVariableArray.compound_array
self.assertEqual(numElements, len(readCompoundArray))
for i in range(numElements):
readTestStructure = readCompoundArray[i]
self.assertEqual(i, readTestStructure.id)
self.assertTrue(readTestStructure.name == "Name" + str(i))
def testWriteReadFile(self):
color = self.api.Color.GREEN
zserio.serialize_to_file(color, BLOB_NAME)
readColor = zserio.deserialize_from_file(self.api.Color, BLOB_NAME)
self.assertEqual(color, readColor)
