def setUpClass(cls):
cls.api = getZserioApi(__file__, "sql_databases.zs").db_with_relocation
cls._europeDbFileName = os.path.join(
getApiDir(os.path.dirname(__file__)),
"db_with_relocation_test_europe.sqlite")
cls._americaDbFileName = os.path.join(
getApiDir(os.path.dirname(__file__)),
"db_with_relocation_test_america.sqlite")
class PackedAutoArrayStructWithExternTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(__file__, "array_types.zs").packed_auto_array_struct_with_extern
def testWriteRead(self):
packedAutoArray = self._createPackedAutoArray()
bitBuffer = zserio.serialize(packedAutoArray)
self.assertEqual(bitBuffer.bitsize, packedAutoArray.bitsizeof())
self.assertEqual(bitBuffer.bitsize, packedAutoArray.initialize_offsets(0))
readPackedAutoArray = zserio.deserialize(self.api.PackedAutoArray, bitBuffer)
self.assertEqual(packedAutoArray, readPackedAutoArray)
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 _createPackedAutoArray(self):
return self.api.PackedAutoArray(
[self.api.TestStructure(uint32, zserio.BitBuffer(extern), uint8)
for uint32, extern, uint8 in zip(self.UINT32_FIELD, self.EXTERN_FIELD, self.UINT8_FIELD)]
)
UINT32_FIELD = list(range(100000, 200000, 10000))
EXTERN_FIELD = [b'\xAB\xCD\xEF', b'\x00', b'\x01', b'\x00', b'\x01',
b'\x00', b'\x01', b'\x00', b'\x01', b'\x00']
UINT8_FIELD = list(range(0, 20, 2))
BLOB_NAME = os.path.join(getApiDir(os.path.dirname(__file__)),
"packed_auto_array_struct_with_extern.blob")
class UnionWithArrayTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(__file__, "union_types.zs").union_with_array
def testArray8(self):
testUnion = self.api.TestUnion()
testUnion.array8 = [self.api.Data8(), self.api.Data8(), self.api.Data8(), self.api.Data8()]
self.assertEqual(4, len(testUnion.array8))
def testArray16(self):
testUnion = self.api.TestUnion(array16_=[1, 2, 3, 4])
self.assertEqual(4, len(testUnion.array16))
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):
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)
BLOB_NAME_BASE = os.path.join(getApiDir(os.path.dirname(__file__)), "union_with_array_")
class BitFieldUInt64LengthTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(__file__, "builtin_types.zs").bitfield_uint64_length
def testBitSizeOf(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
expectedBitSizeOfContainer = 64 + 33 + 33
self.assertEqual(expectedBitSizeOfContainer, container.bitsizeof())
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)
BLOB_NAME = os.path.join(getApiDir(os.path.dirname(__file__)), "bit_field_uint64_length.blob")
def setUpClass(cls):
cls.api = getZserioApi(
__file__,
"sql_without_rowid_tables.zs").rowid_and_without_rowid_tables
cls._fileName = os.path.join(
getApiDir(os.path.dirname(__file__)),
"rowid_and_without_rowid_tables_test.sqlite")
def setUpClass(cls):
cls.api = getZserioApi(__file__,
"allow_implicit_arrays.zs",
extraArgs=["-allowImplicitArrays"
]).table_with_implicit_array
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"table_with_implicit_array_test.sqlite")
def _runPylintOnAllSources(args, testDirs):
print("\nRunning pylint on python tests")
if not "PYLINT_ENABLED" in os.environ or os.environ["PYLINT_ENABLED"] != '1':
print("Pylint is disabled.\n")
return 0
from testutils import getApiDir, getTestSuiteName
pylintOptions = ["--persistent=n", "--score=n"]
if args.pylint_rcfile:
pylintOptions.append("--rcfile=%s" % (args.pylint_rcfile))
testDisableOption = ("missing-docstring, invalid-name, duplicate-code, too-many-public-methods, "
"too-few-public-methods, c-extension-no-member")
genDisableOption = ("missing-docstring, invalid-name, no-self-use, duplicate-code, line-too-long, "
"singleton-comparison, too-many-instance-attributes, too-many-arguments, "
"too-many-public-methods, too-few-public-methods, too-many-locals, too-many-branches, "
"too-many-statements, unneeded-not, superfluous-parens, len-as-condition, "
"import-self, misplaced-comparison-constant, invalid-unary-operand-type, "
"c-extension-no-member")
genPylintOptions = list(pylintOptions)
genPylintOptions.append("--ignore=api.py")
apiDisableOption = ("missing-docstring, unused-import, line-too-long")
apiPylintOptions = list(pylintOptions)
apiPylintOptions.append("--ignore-patterns=^.*\\.py(?<!^api\\.py)$")
for testDir in testDirs:
testSources = [os.path.join(testDir, child) for child in os.listdir(testDir) if child.endswith(".py")]
apiDir = getApiDir(testDir)
if os.path.isdir(apiDir):
apiSources = [os.path.join(apiDir, child) for child in os.listdir(apiDir)
if child.endswith(".py") or os.path.isdir(os.path.join(apiDir, child))]
testSuiteName = getTestSuiteName(testDir)
print(testSuiteName)
print(" test files...")
pylintResult = _runPylint(testSources, pylintOptions, testDisableOption)
if pylintResult != 0:
return pylintResult
sys.path.append(apiDir)
print(" generated files...") # except api.py files
pylintResult = _runPylint(apiSources, genPylintOptions, genDisableOption)
if pylintResult != 0:
return pylintResult
print(" generated api.py files...")
pylintResult = _runPylint(apiSources, apiPylintOptions, apiDisableOption)
if pylintResult != 0:
return pylintResult
sys.path.remove(apiDir)
print("Pylint done.\n")
return 0
class PackedAutoArrayStructWithUnpackedFieldTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(
__file__,
"array_types.zs").packed_auto_array_struct_with_unpacked_field
def testBitSizeOf(self):
packedAutoArray = self._createPackedAutoArray()
self.assertEqual(self.PACKED_AUTO_ARRAY_BIT_SIZE,
packedAutoArray.bitsizeof())
def testInitializeOffsets(self):
packedAutoArray = self._createPackedAutoArray()
bitPosition = 2
expectedEndBitPosition = bitPosition + self.PACKED_AUTO_ARRAY_BIT_SIZE
self.assertEqual(expectedEndBitPosition,
packedAutoArray.initialize_offsets(bitPosition))
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 _createPackedAutoArray(self):
return self.api.PackedAutoArray([
self.api.TestStructure(uint8, unpacked)
for uint8, unpacked in zip(self.UINT8_FIELD, self.UNPACKED_FIELD)
])
UINT8_FIELD = list(range(0, 20, 2))
UNPACKED_FIELD = [5000000, 0, 1, 0, 1, 0, 1, 0, 1, 0]
UINT8_MAX_BIT_NUMBER = 2
PACKED_AUTO_ARRAY_BIT_SIZE = (
8 + # auto array size: varsize
1 + # uint8Field packing descriptor: isPacked (true)
6 + # uint8Field is packed: maxBitNumber
1 + # unpackedField packing descriptor: isPacked (false)
8 + # uint8Field[0]
32 + # unpackedField[0] (4 bytes for the first value)
9 * (UINT8_MAX_BIT_NUMBER + 1) + # deltas for uint8Field values
9 * 8 # unpackedField varuint values (1 byte)
)
BLOB_NAME = os.path.join(
getApiDir(os.path.dirname(__file__)),
"packed_auto_array_struct_with_unpacked_field.blob")
def setUpClass(cls):
cls.api = getZserioApi(__file__, "explicit_parameters.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"explicit_same_as_field_test.sqlite")
test_api = cls.api.explicit_same_as_field
class SameAsFieldTableParameterProvider(
test_api.SameAsFieldTable.IParameterProvider):
@staticmethod
def getCount(_row):
return SAME_AS_FIELD_TABLE_COUNT_EXPLICIT
cls.SameAsFieldTableParameterProvider = SameAsFieldTableParameterProvider
def _runMypyOnAllSources(args, testDirs, runtimePath, testutilsPath):
print("\nRunning mypy on python tests")
if not "MYPY_ENABLED" in os.environ or os.environ["MYPY_ENABLED"] != '1':
print("Mypy is disabled.\n")
return 0
from testutils import TEST_ARGS, getApiDir, getTestSuiteName
from mypy import api
os.environ["MYPYPATH"] = runtimePath + os.pathsep + testutilsPath
mypyCacheDir = os.path.join(TEST_ARGS["build_dir"], ".mypy_cache")
mypyArgs = []
mypyArgs.append(f"--cache-dir={mypyCacheDir}")
if args.mypy_config_file:
mypyArgs.append(f"--config-file={args.mypy_config_file}")
mypyArgs.append("--no-strict-optional"
) # Item "None" of "Optional[Blob]" has no attribute "..."
for testDir in testDirs:
apiDir = getApiDir(testDir)
testSuiteName = getTestSuiteName(testDir)
print(testSuiteName + " ... ", end='', flush=True)
mypyArgsForTest = list(mypyArgs)
_loadMypyExtraArgsFile(testDir, mypyArgsForTest)
if os.path.exists(apiDir):
mypyArgsForTest.append(apiDir)
mypyArgsForTest.append(testDir)
mypyResult = api.run(mypyArgsForTest)
if mypyResult[2] != 0:
print("FAILED!")
if mypyResult[0]:
print("Type checking report:")
print(mypyResult[0])
if mypyResult[1]:
print("Error report:")
print(mypyResult[1])
return mypyResult[2]
else:
print(mypyResult[0], end='')
print("Mypy done.\n")
return 0
def setUpClass(cls):
cls.api = getZserioApi(__file__, "explicit_parameters.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)), "explicit_bitmask_param_test.sqlite")
test_api = cls.api.explicit_bitmask_param
class BitmaskParamTableParameterProvider(test_api.BitmaskParamTable.IParameterProvider):
@staticmethod
def count1(_row):
return test_api.TestBitmask.Values.TEN
@staticmethod
def count2(_row):
return test_api.TestBitmask.Values.ELEVEN
cls.BitmaskParamTableParameterProvider = BitmaskParamTableParameterProvider
class ChoiceWithArrayTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(__file__, "choice_types.zs").choice_with_array
def testArray8(self):
testChoice = self.api.TestChoice(8)
testChoice.array8 = [
self.api.Data8(),
self.api.Data8(),
self.api.Data8(),
self.api.Data8()
]
self.assertEqual(4, len(testChoice.array8))
def testArray16(self):
testChoice = self.api.TestChoice(16)
testChoice.array16 = [1, 2, 3, 4]
self.assertEqual(4, len(testChoice.array16))
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 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)
BLOB_NAME_BASE = os.path.join(getApiDir(os.path.dirname(__file__)),
"choice_with_array_")
def setUpClass(cls):
cls.api = getZserioApi(__file__, "explicit_parameters.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)), "explicit_blob_param_test.sqlite")
test_api = cls.api.explicit_blob_param
class BlobParamTableParameterProvider(test_api.BlobParamTable.IParameterProvider):
def __init__(self):
self.header = test_api.Header.fromFields(BLOB_PARAM_TABLE_HEADER_COUNT)
self.blob = test_api.Header.fromFields(BLOB_PARAM_TABLE_BLOB_COUNT)
def getHeader(self, _row):
return self.header
def getBlob(self, _row):
return self.blob
cls.BlobParamTableParameterProvider = BlobParamTableParameterProvider
def setUpClass(cls):
cls.api = getZserioApi(__file__, "explicit_parameters.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"explicit_enum_param_test.sqlite")
test_api = cls.api.explicit_enum_param
class EnumParamTableParameterProvider(
test_api.EnumParamTable.IParameterProvider):
@staticmethod
def getCount1(_row):
return test_api.TestEnum.TEN
@staticmethod
def getCount2(_row):
return test_api.TestEnum.ELEVEN
cls.EnumParamTableParameterProvider = EnumParamTableParameterProvider
def setUpClass(cls):
cls.api = getZserioApi(__file__, "explicit_parameters.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"explicit_simple_param_test.sqlite")
test_api = cls.api.explicit_simple_param
class SimpleParamTableParameterProvider(
test_api.SimpleParamTable.IParameterProvider):
@staticmethod
def count1(_row):
return SIMPLE_PARAM_TABLE_COUNT1
@staticmethod
def count2(_row):
return SIMPLE_PARAM_TABLE_COUNT2
cls.SimpleParamTableParameterProvider = SimpleParamTableParameterProvider
def setUpClass(cls):
cls.api = getZserioApi(__file__, "explicit_parameters.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"multiple_with_same_name_test.sqlite")
test_api = cls.api.multiple_with_same_name
class MultipleWithSameNameTableParameterProvider(
test_api.MultipleWithSameNameTable.IParameterProvider):
def __init__(self):
self._param1 = PARAM1
self._param2 = PARAM2
def param1(self, _row):
return self._param1
def param2(self, _row):
return self._param2
cls.MultipleWithSameNameTableParameterProvider = MultipleWithSameNameTableParameterProvider
def setUpClass(cls):
cls.api = getZserioApi(__file__, "explicit_parameters.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"multiple_explicit_params_test.sqlite")
test_api = cls.api.multiple_explicit_params
class MultipleParamsTableParameterProvider(
test_api.MultipleParamsTable.IParameterProvider):
@staticmethod
def getCount(_row):
return MULTIPLE_PARAMS_TABLE_COUNT
@staticmethod
def getCount1(_row):
return MULTIPLE_PARAMS_TABLE_COUNT1
@staticmethod
def getCount2(_row):
return MULTIPLE_PARAMS_TABLE_COUNT2
cls.MultipleParamsTableParameterProvider = MultipleParamsTableParameterProvider
class GrandChildParamTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(__file__,
"parameterized_types.zs").grand_child_param
def testWrite(self):
grandChildParam = self._createGrandChildParam()
writer = zserio.BitStreamWriter()
grandChildParam.write(writer)
reader = zserio.BitStreamReader(writer.byte_array, writer.bitposition)
self._checkGrandChildParamInStream(reader, grandChildParam)
reader.bitposition = 0
readGrandChildParam = self.api.GrandChildParam.from_reader(reader)
self.assertEqual(grandChildParam, readGrandChildParam)
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 _createItemChoiceHolder(self):
item = self.api.Item(self.ITEM_CHOICE_HOLDER_HAS_ITEM, self.ITEM_PARAM,
self.ITEM_EXTRA_PARAM)
itemChoice = self.api.ItemChoice(self.ITEM_CHOICE_HOLDER_HAS_ITEM)
itemChoice.item = item
return self.api.ItemChoiceHolder(itemChoice.has_item, itemChoice)
def _createGrandChildParam(self):
itemChoiceHolder = self._createItemChoiceHolder()
itemChoiceHolderArray = [self._createItemChoiceHolder()]
dummyArray = [0]
return self.api.GrandChildParam(itemChoiceHolder,
itemChoiceHolderArray, dummyArray)
def _checkItemChoiceHolderInStream(self, reader, itemChoiceHolder):
self.assertEqual(itemChoiceHolder.has_item, reader.read_bool())
item = itemChoiceHolder.item_choice.item
self.assertEqual(item.param, reader.read_bits(16))
self.assertEqual(item.extra_param, reader.read_bits(32))
def _checkGrandChildParamInStream(self, reader, grandChildParam):
itemChoiceHolder = grandChildParam.item_choice_holder
self._checkItemChoiceHolderInStream(reader, itemChoiceHolder)
itemChoiceHolderArray = grandChildParam.item_choice_holder_array
self.assertEqual(len(itemChoiceHolderArray), reader.read_varsize())
self._checkItemChoiceHolderInStream(reader, itemChoiceHolderArray[0])
isDummyArrayUsed = grandChildParam.is_dummy_array_used()
self.assertEqual(isDummyArrayUsed, reader.read_bool())
if isDummyArrayUsed:
dummyArray = grandChildParam.dummy_array
self.assertEqual(len(dummyArray), reader.read_varsize())
self.assertEqual(dummyArray[0], reader.read_bits(32))
BLOB_NAME = os.path.join(getApiDir(os.path.dirname(__file__)),
"grand_child_param.blob")
ITEM_CHOICE_HOLDER_HAS_ITEM = True
ITEM_PARAM = 0xAABB
ITEM_EXTRA_PARAM = 0x11223344
def setUpClass(cls):
cls.api = getZserioApi(__file__, "sql_tables.zs")
cls._fileName = os.path.join(
getApiDir(os.path.dirname(__file__)),
"dynamic_bit_field_enum_field_table_test.sqlite")
def setUpClass(cls):
cls.api = getZserioApi(__file__,
"sql_virtual_columns.zs").hidden_virtual_columns
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"hidden_virtual_columns_test.sqlite")
def setUpClass(cls):
cls.api = getZserioApi(__file__, "sql_tables.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"subtyped_bool_field_table_test.sqlite")
class VariableArrayStructCastInt8Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(
__file__, "array_types.zs").variable_array_struct_cast_int8
def testBitSizeOf(self):
numElements = 33
compoundArray = [
self.api.TestStructure(i, "Name" + str(i))
for i in range(numElements)
]
variableArray = self.api.VariableArray(numElements, compoundArray)
bitPosition = 2
numOneNumberIndexes = 10
expectedBitSize = (1 + numElements * (4 + 7) - numOneNumberIndexes) * 8
self.assertEqual(expectedBitSize, variableArray.bitsizeof(bitPosition))
def testInitializeOffsets(self):
numElements = 33
compoundArray = [
self.api.TestStructure(i, "Name" + str(i))
for i in range(numElements)
]
variableArray = self.api.VariableArray(numElements, compoundArray)
bitPosition = 2
numOneNumberIndexes = 10
expectedEndBitPosition = bitPosition + (1 + numElements * (4 + 7) -
numOneNumberIndexes) * 8
self.assertEqual(expectedEndBitPosition,
variableArray.initialize_offsets(bitPosition))
def testRead(self):
numElements = 59
writer = zserio.BitStreamWriter()
VariableArrayStructCastInt8Test._writeVariableArrayToStream(
writer, numElements)
reader = zserio.BitStreamReader(writer.byte_array, writer.bitposition)
variableArray = self.api.VariableArray.from_reader(reader)
self.assertEqual(numElements, variableArray.num_elements)
compoundArray = variableArray.compound_array
self.assertEqual(numElements, len(compoundArray))
for i in range(numElements):
testStructure = compoundArray[i]
self.assertEqual(i, testStructure.id)
self.assertTrue(testStructure.name == "Name" + str(i))
def testWriteRead(self):
numElements = 33
compoundArray = [
self.api.TestStructure(i, "Name" + str(i))
for i in range(numElements)
]
variableArray = self.api.VariableArray(numElements, compoundArray)
bitBuffer = zserio.serialize(variableArray)
self.assertEqual(variableArray.bitsizeof(), bitBuffer.bitsize)
self.assertEqual(variableArray.initialize_offsets(0),
bitBuffer.bitsize)
readVariableArray = zserio.deserialize(self.api.VariableArray,
bitBuffer)
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):
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 testWriteWrongArray(self):
numElements = 33
compoundArray = [
self.api.TestStructure(i, "Name" + str(i))
for i in range(numElements)
]
variableArray = self.api.VariableArray(numElements + 1, compoundArray)
writer = zserio.BitStreamWriter()
with self.assertRaises(zserio.PythonRuntimeException):
variableArray.write(writer)
@staticmethod
def _writeVariableArrayToStream(writer, numElements):
writer.write_bits(numElements, 8)
for i in range(numElements):
writer.write_bits(i, 32)
writer.write_string("Name" + str(i))
BLOB_NAME = os.path.join(getApiDir(os.path.dirname(__file__)),
"variable_array_struct_cast_int8.blob")
class PackedArrayElementParamTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(
__file__, "parameterized_types.zs").packed_array_element_param
def testBitSizeOfLength1(self):
self._checkBitSizeOf(self.NUM_BLOCKS1)
def testBitSizeOfLength2(self):
self._checkBitSizeOf(self.NUM_BLOCKS2)
def testBitSizeOfLength3(self):
self._checkBitSizeOf(self.NUM_BLOCKS3)
def testWriteReadLength1(self):
self._checkWriteRead(self.NUM_BLOCKS1)
def testWriteReadLength2(self):
self._checkWriteRead(self.NUM_BLOCKS2)
def testWriteReadLength3(self):
self._checkWriteRead(self.NUM_BLOCKS3)
def testWriteReadFileLength1(self):
self._checkWriteReadFile(self.NUM_BLOCKS1)
def testWriteReadFileLength2(self):
self._checkWriteReadFile(self.NUM_BLOCKS2)
def testWriteReadFileLength3(self):
self._checkWriteReadFile(self.NUM_BLOCKS3)
def _checkBitSizeOf(self, numBlocks):
database = self._createDatabase(numBlocks)
unpackedBitsizeOf = PackedArrayElementParamTest._calcUnpackedDatabaseBitSize(
numBlocks)
packedBitsizeOf = database.bitsizeof()
minCompressionRatio = 0.12
self.assertTrue(
unpackedBitsizeOf * minCompressionRatio > packedBitsizeOf,
"Unpacked array has " + str(unpackedBitsizeOf) +
" bits, packed array has " + str(packedBitsizeOf) + " bits, " +
"compression ratio is " +
str(packedBitsizeOf / unpackedBitsizeOf * 100) + "%!")
def _checkWriteRead(self, numBlocks):
database = self._createDatabase(numBlocks)
writer = zserio.BitStreamWriter()
database.write(writer)
self.assertEqual(database.bitsizeof(), writer.bitposition)
self.assertEqual(database.initialize_offsets(0), writer.bitposition)
reader = zserio.BitStreamReader(writer.byte_array, writer.bitposition)
readDatabase = self.api.Database.from_reader(reader)
self.assertEqual(database, readDatabase)
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 _createDatabase(self, numBlocks):
blockHeaderList = []
blockList = []
for i in range(numBlocks):
numItems = i + 1
blockHeader = self.api.BlockHeader(numItems, 0)
blockHeaderList.append(blockHeader)
itemList = []
for j in range(numItems):
itemList.append(j * 2)
blockList.append(self.api.Block(blockHeader, numItems, itemList))
return self.api.Database(numBlocks, blockHeaderList, blockList)
@staticmethod
def _calcUnpackedDatabaseBitSize(numBlocks):
bitSize = 16 # numBlocks
bitSize += numBlocks * (16 + 32) # headers
for i in range(numBlocks):
numItems = i + 1
bitSize += 64 + numItems * 64 # blocks[i]
return bitSize
BLOB_NAME_BASE = os.path.join(getApiDir(os.path.dirname(__file__)),
"packed_array_element_param_")
NUM_BLOCKS1 = 50
NUM_BLOCKS2 = 100
NUM_BLOCKS3 = 1000
def setUpClass(cls):
cls.api = getZserioApi(__file__, "sql_tables.zs")
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"blob_param_table_test.sqlite")
def setUpClass(cls):
cls.api = getZserioApi(__file__,
"sql_virtual_tables.zs").fts5_virtual_table
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"fts5_virtual_table_test.sqlite")
class AutoArrayStructRecursionTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(__file__,
"array_types.zs").auto_array_struct_recursion
def testBitSizeOfLength1(self):
self._checkBitSizeOf(self.AUTO_ARRAY_LENGTH1)
def testBitSizeOfLength2(self):
self._checkBitSizeOf(self.AUTO_ARRAY_LENGTH2)
def testInitializeOffsetsLength1(self):
self._checkInitializeOffsets(self.AUTO_ARRAY_LENGTH1)
def testInitializeOffsetsLength2(self):
self._checkInitializeOffsets(self.AUTO_ARRAY_LENGTH2)
def testReadLength1(self):
self._checkRead(self.AUTO_ARRAY_LENGTH1)
def testReadLength2(self):
self._checkRead(self.AUTO_ARRAY_LENGTH2)
def testWriteReadLength1(self):
self._checkWriteRead(self.AUTO_ARRAY_LENGTH1)
def testWriteReadLength2(self):
self._checkWriteRead(self.AUTO_ARRAY_LENGTH2)
def testWriteReadFileLength1(self):
self._checkWriteReadFile(self.AUTO_ARRAY_LENGTH1)
def testWriteReadFileLength2(self):
self._checkWriteReadFile(self.AUTO_ARRAY_LENGTH2)
def _checkBitSizeOf(self, numElements):
autoArrayRecursion = self._createAutoArrayRecursion(numElements)
bitPosition = 2
autoArrayRecursionBitSize = 8 + 8 + numElements * (8 + 8)
self.assertEqual(autoArrayRecursionBitSize,
autoArrayRecursion.bitsizeof(bitPosition))
def _checkInitializeOffsets(self, numElements):
autoArrayRecursion = self._createAutoArrayRecursion(numElements)
bitPosition = 2
expectedEndBitPosition = bitPosition + 8 + 8 + numElements * (8 + 8)
self.assertEqual(expectedEndBitPosition,
autoArrayRecursion.initialize_offsets(bitPosition))
def _checkRead(self, numElements):
writer = zserio.BitStreamWriter()
AutoArrayStructRecursionTest._writeAutoArrayRecursionToStream(
writer, numElements)
reader = zserio.BitStreamReader(writer.byte_array, writer.bitposition)
autoArrayRecursion = self.api.AutoArrayRecursion.from_reader(reader)
self._checkAutoArrayRecursion(autoArrayRecursion, numElements)
def _checkWriteRead(self, numElements):
autoArrayRecursion = self._createAutoArrayRecursion(numElements)
bitBuffer = zserio.serialize(autoArrayRecursion)
self.assertEqual(autoArrayRecursion.bitsizeof(), bitBuffer.bitsize)
self.assertEqual(autoArrayRecursion.initialize_offsets(0),
bitBuffer.bitsize)
readAutoArrayRecursion = zserio.deserialize(
self.api.AutoArrayRecursion, bitBuffer)
self._checkAutoArrayRecursion(readAutoArrayRecursion, 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 _createAutoArrayRecursion(self, numElements):
autoArray = []
for i in range(1, numElements + 1):
element = self.api.AutoArrayRecursion(i, [])
autoArray.append(element)
return self.api.AutoArrayRecursion(0, autoArray)
def _checkAutoArrayRecursion(self, autoArrayRecursion, numElements):
self.assertEqual(0, autoArrayRecursion.id)
autoArray = autoArrayRecursion.auto_array_recursion
self.assertEqual(numElements, len(autoArray))
for i in range(1, numElements + 1):
element = autoArray[i - 1]
self.assertEqual(i, element.id)
self.assertEqual(0, len(element.auto_array_recursion))
@staticmethod
def _writeAutoArrayRecursionToStream(writer, numElements):
writer.write_bits(0, 8)
writer.write_varsize(numElements)
for i in range(1, numElements + 1):
writer.write_bits(i, 8)
writer.write_varsize(0)
BLOB_NAME_BASE = os.path.join(getApiDir(os.path.dirname(__file__)),
"auto_array_struct_recursion_")
AUTO_ARRAY_LENGTH1 = 5
AUTO_ARRAY_LENGTH2 = 10
class FixedArrayUInt8Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(__file__, "array_types.zs").fixed_array_uint8
def testBitSizeOf(self):
uint8Array = list(range(self.FIXED_ARRAY_LENGTH))
fixedArray = self.api.FixedArray(uint8Array)
bitPosition = 2
fixedArrayBitSize = self.FIXED_ARRAY_LENGTH * 8
self.assertEqual(fixedArrayBitSize, fixedArray.bitsizeof(bitPosition))
def testInitializeOffsets(self):
uint8Array = list(range(self.FIXED_ARRAY_LENGTH))
fixedArray = self.api.FixedArray(uint8Array)
bitPosition = 2
expectedEndBitPosition = bitPosition + self.FIXED_ARRAY_LENGTH * 8
self.assertEqual(expectedEndBitPosition,
fixedArray.initialize_offsets(bitPosition))
def testRead(self):
writer = zserio.BitStreamWriter()
self._writeFixedArrayToStream(writer)
reader = zserio.BitStreamReader(writer.byte_array, writer.bitposition)
fixedArray = self.api.FixedArray.from_reader(reader)
uint8Array = fixedArray.uint8_array
self.assertEqual(self.FIXED_ARRAY_LENGTH, len(uint8Array))
for i in range(self.FIXED_ARRAY_LENGTH):
self.assertEqual(i, uint8Array[i])
def testWrite(self):
uint8Array = list(range(self.FIXED_ARRAY_LENGTH))
fixedArray = self.api.FixedArray(uint8Array)
bitBuffer = zserio.serialize(fixedArray)
self.assertEqual(fixedArray.bitsizeof(), bitBuffer.bitsize)
self.assertEqual(fixedArray.initialize_offsets(0), bitBuffer.bitsize)
readFixedArray = zserio.deserialize(self.api.FixedArray, bitBuffer)
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 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 testWriteWrongArray(self):
uint8Array = list(range(self.FIXED_ARRAY_LENGTH + 1))
fixedArray = self.api.FixedArray(uint8_array_=uint8Array)
writer = zserio.BitStreamWriter()
with self.assertRaises(zserio.PythonRuntimeException):
fixedArray.write(writer)
def _writeFixedArrayToStream(self, writer):
for i in range(self.FIXED_ARRAY_LENGTH):
writer.write_bits(i, 8)
BLOB_NAME = os.path.join(getApiDir(os.path.dirname(__file__)),
"fixed_array_uint8.blob")
FIXED_ARRAY_LENGTH = 5
class PackedAutoArrayStructRecursionTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(
__file__, "array_types.zs").packed_auto_array_struct_recursion
def testBitSizeOfLength1(self):
self._checkBitSizeOf(self.AUTO_ARRAY_LENGTH1)
def testBitSizeOfLength2(self):
self._checkBitSizeOf(self.AUTO_ARRAY_LENGTH2)
def testBitSizeOfLength3(self):
self._checkBitSizeOf(self.AUTO_ARRAY_LENGTH3)
def testInitializeOffsetsLength1(self):
self._checkInitializeOffsets(self.AUTO_ARRAY_LENGTH1)
def testInitializeOffsetsLength2(self):
self._checkInitializeOffsets(self.AUTO_ARRAY_LENGTH2)
def testInitializeOffsetsLength3(self):
self._checkInitializeOffsets(self.AUTO_ARRAY_LENGTH3)
def testReadLength1(self):
self._checkRead(self.AUTO_ARRAY_LENGTH1)
def testReadLength2(self):
self._checkRead(self.AUTO_ARRAY_LENGTH2)
def testReadLength3(self):
self._checkRead(self.AUTO_ARRAY_LENGTH3)
def testWriteReadLength1(self):
self._checkWriteRead(self.AUTO_ARRAY_LENGTH1)
def testWriteReadLength2(self):
self._checkWriteRead(self.AUTO_ARRAY_LENGTH2)
def testWriteReadLength3(self):
self._checkWriteRead(self.AUTO_ARRAY_LENGTH3)
def testWriteReadFileLength1(self):
self._checkWriteReadFile(self.AUTO_ARRAY_LENGTH1)
def testWriteReadFileLength2(self):
self._checkWriteReadFile(self.AUTO_ARRAY_LENGTH2)
def testWriteReadFileLength3(self):
self._checkWriteReadFile(self.AUTO_ARRAY_LENGTH3)
def _checkBitSizeOf(self, numElements):
packedAutoArrayRecursion = self._createPackedAutoArrayRecursion(
numElements)
bitPosition = 2
autoArrayRecursionBitSize = (
PackedAutoArrayStructRecursionTest.
_calcPackedAutoArrayRecursionBitSize(numElements))
self.assertEqual(autoArrayRecursionBitSize,
packedAutoArrayRecursion.bitsizeof(bitPosition))
def _checkInitializeOffsets(self, numElements):
packedAutoArrayRecursion = self._createPackedAutoArrayRecursion(
numElements)
bitPosition = 2
expectedEndBitPosition = bitPosition + (
PackedAutoArrayStructRecursionTest.
_calcPackedAutoArrayRecursionBitSize(numElements))
self.assertEqual(
expectedEndBitPosition,
packedAutoArrayRecursion.initialize_offsets(bitPosition))
def _checkRead(self, numElements):
writer = zserio.BitStreamWriter()
self._writePackedAutoArrayRecursionToStream(writer, numElements)
reader = zserio.BitStreamReader(writer.byte_array, writer.bitposition)
packedAutoArrayRecursion = self.api.PackedAutoArrayRecursion.from_reader(
reader)
self._checkPackedAutoArrayRecursion(packedAutoArrayRecursion,
numElements)
def _checkWriteRead(self, numElements):
packedAutoArrayRecursion = self._createPackedAutoArrayRecursion(
numElements)
bitBuffer = zserio.serialize(packedAutoArrayRecursion)
self.assertEqual(packedAutoArrayRecursion.bitsizeof(),
bitBuffer.bitsize)
self.assertEqual(packedAutoArrayRecursion.initialize_offsets(0),
bitBuffer.bitsize)
readPackedAutoArrayRecursion = zserio.deserialize(
self.api.PackedAutoArrayRecursion, bitBuffer)
self._checkPackedAutoArrayRecursion(readPackedAutoArrayRecursion,
numElements)
def _checkWriteReadFile(self, numElements):
packedAutoArrayRecursion = self._createPackedAutoArrayRecursion(
numElements)
filename = self.BLOB_NAME_BASE + str(numElements) + ".blob"
zserio.serialize_to_file(packedAutoArrayRecursion, filename)
readPackedAutoArrayRecursion = zserio.deserialize_from_file(
self.api.PackedAutoArrayRecursion, filename)
self._checkPackedAutoArrayRecursion(readPackedAutoArrayRecursion,
numElements)
def _createPackedAutoArrayRecursion(self, numElements):
autoArray = []
for i in range(1, numElements + 1):
element = self.api.PackedAutoArrayRecursion(i, [])
autoArray.append(element)
return self.api.PackedAutoArrayRecursion(0, autoArray)
def _checkPackedAutoArrayRecursion(self, packedAutoArrayRecursion,
numElements):
self.assertEqual(0, packedAutoArrayRecursion.id)
autoArray = packedAutoArrayRecursion.packed_auto_array_recursion
self.assertEqual(numElements, len(autoArray))
for i in range(1, numElements + 1):
element = autoArray[i - 1]
self.assertEqual(i, element.id)
self.assertEqual(0, len(element.packed_auto_array_recursion))
@staticmethod
def _writePackedAutoArrayRecursionToStream(writer, numElements):
writer.write_bits(0, 8)
writer.write_varsize(numElements)
writer.write_bool(True)
maxBitNumber = 1
writer.write_bits(maxBitNumber, 6)
writer.write_bits(1, 8)
writer.write_varsize(0)
for _ in range(numElements - 1):
writer.write_signed_bits(1, maxBitNumber + 1)
writer.write_varsize(0)
@staticmethod
def _calcPackedAutoArrayRecursionBitSize(numElements):
bitSize = 8 # id
bitSize += 8 # varsize (length of auto array)
bitSize += 1 # packing descriptor: is_packed
if numElements > 1:
bitSize += 6 # packing descriptor: max_bit_number
bitSize += 8 + 8 # first element
bitSize += (numElements - 1) * (8 + 2) # all deltas
return bitSize
BLOB_NAME_BASE = os.path.join(getApiDir(os.path.dirname(__file__)),
"packed_auto_array_struct_recursion_")
AUTO_ARRAY_LENGTH1 = 1
AUTO_ARRAY_LENGTH2 = 5
AUTO_ARRAY_LENGTH3 = 10
class AutoArrayUInt8Test(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.api = getZserioApi(__file__, "array_types.zs").auto_array_uint8
def testBitSizeOfLength1(self):
self._checkBitSizeOf(self.AUTO_ARRAY_LENGTH1)
def testBitSizeOfLength2(self):
self._checkBitSizeOf(self.AUTO_ARRAY_LENGTH2)
def testInitializeOffsetsLength1(self):
self._checkInitializeOffsets(self.AUTO_ARRAY_LENGTH1)
def testInitializeOffsetsLength2(self):
self._checkInitializeOffsets(self.AUTO_ARRAY_LENGTH2)
def testReadLength1(self):
self._checkRead(self.AUTO_ARRAY_LENGTH1)
def testReadLength2(self):
self._checkRead(self.AUTO_ARRAY_LENGTH2)
def testWriteReadLength1(self):
self._checkWriteRead(self.AUTO_ARRAY_LENGTH1)
def testWriteReadLength2(self):
self._checkWriteRead(self.AUTO_ARRAY_LENGTH2)
def testWriteReadFileLength1(self):
self._checkWriteReadFile(self.AUTO_ARRAY_LENGTH1)
def testWriteReadFileLength2(self):
self._checkWriteReadFile(self.AUTO_ARRAY_LENGTH2)
def _checkBitSizeOf(self, numElements):
uint8Array = list(range(numElements))
autoArray = self.api.AutoArray(uint8Array)
bitPosition = 2
autoArrayBitSize = 8 + numElements * 8
self.assertEqual(autoArrayBitSize, autoArray.bitsizeof(bitPosition))
def _checkInitializeOffsets(self, numElements):
uint8Array = list(range(numElements))
autoArray = self.api.AutoArray(uint8_array_=uint8Array)
bitPosition = 2
expectedEndBitPosition = bitPosition + 8 + numElements * 8
self.assertEqual(expectedEndBitPosition,
autoArray.initialize_offsets(bitPosition))
def _checkRead(self, numElements):
writer = zserio.BitStreamWriter()
AutoArrayUInt8Test._writeAutoArrayToStream(writer, numElements)
reader = zserio.BitStreamReader(writer.byte_array, writer.bitposition)
autoArray = self.api.AutoArray.from_reader(reader)
uint8Array = autoArray.uint8_array
self.assertEqual(numElements, len(uint8Array))
for i in range(numElements):
self.assertEqual(i, uint8Array[i])
def _checkWriteRead(self, numElements):
uint8Array = list(range(numElements))
autoArray = self.api.AutoArray(uint8Array)
bitBuffer = zserio.serialize(autoArray)
readAutoArray = zserio.deserialize(self.api.AutoArray, bitBuffer)
readUint8Array = readAutoArray.uint8_array
self.assertEqual(numElements, len(readUint8Array))
for i in range(numElements):
self.assertEqual(i, readUint8Array[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])
@staticmethod
def _writeAutoArrayToStream(writer, numElements):
writer.write_varsize(numElements)
for i in range(numElements):
writer.write_bits(i, 8)
BLOB_NAME_BASE = os.path.join(getApiDir(os.path.dirname(__file__)),
"auto_array_uint8_")
AUTO_ARRAY_LENGTH1 = 5
AUTO_ARRAY_LENGTH2 = 10
def setUpClass(cls):
cls.api = getZserioApi(__file__, "sql_tables.zs", expectedWarnings=1)
cls._fileName = os.path.join(getApiDir(os.path.dirname(__file__)),
"column_param_table_test.sqlite")
