#include "dynamictypes/DataArray.h" #include "dynamictypes/DataAssociativeArray.h" #include "dynamictypes/DataHashTable.h" #include "dynamictypes/DataSerializationContext.h" #include "unittest/TestSuite.h" #include "utilities/printfFormats.h" #include static void testInit() { DataSerializationContext context, * contextPtr; memset(&context, 0x00, sizeof(context)); stemobject_assign_vtable(context, DataSerializationContext); DataSerializationContext_init(&context); TestCase_assert(context.vtable == &DataSerializationContext_class, "Expected %p but got %p", &DataSerializationContext_class, context.vtable); DataSerializationContext_dispose(&context); memset(&context, 0xFF, sizeof(context)); stemobject_assign_vtable(context, DataSerializationContext); DataSerializationContext_init(&context); TestCase_assert(context.vtable == &DataSerializationContext_class, "Expected %p but got %p", &DataSerializationContext_class, context.vtable); DataSerializationContext_dispose(&context); contextPtr = DataSerializationContext_create(); TestCase_assert(contextPtr->vtable == &DataSerializationContext_class, "Expected %p but got %p", &DataSerializationContext_class, contextPtr->vtable); DataSerializationContext_dispose(contextPtr); } #define ENUM_TEST_0 0 #define ENUM_TEST_1 1 #define FORMAT_DATA_TYPE_BOOLEAN "%d" #define FORMAT_DATA_TYPE_INT8 "%d" #define FORMAT_DATA_TYPE_UINT8 "%u" #define FORMAT_DATA_TYPE_INT16 "%d" #define FORMAT_DATA_TYPE_UINT16 "%u" #define FORMAT_DATA_TYPE_INT32 "%d" #define FORMAT_DATA_TYPE_UINT32 "%u" #define FORMAT_DATA_TYPE_INT64 INT64_FORMAT #define FORMAT_DATA_TYPE_UINT64 UINT64_FORMAT #define FORMAT_DATA_TYPE_FLOAT "%f" #define FORMAT_DATA_TYPE_DOUBLE "%f" #define FORMAT_DATA_TYPE_FIXED_16_16 "0x%05X" #define enumKV(value) #value, value #define assertDataValueInArray(VALUE, INDEX, TYPE, EXPECTED_VALUE, FIELD) \ TestCase_assert(VALUE.array->values[INDEX].type == TYPE, "Expected %d but got %d", TYPE, VALUE.array->values[INDEX].type); \ TestCase_assert(VALUE.array->values[INDEX].value.FIELD == EXPECTED_VALUE, "Expected " #EXPECTED_VALUE " but got " FORMAT_##TYPE, VALUE.array->values[INDEX].value.FIELD) #define assertStringInArray(VALUE, INDEX, EXPECTED_VALUE) \ TestCase_assert(VALUE.array->values[INDEX].type == DATA_TYPE_STRING, "Expected %d but got %d", DATA_TYPE_STRING, VALUE.array->values[INDEX].type); \ TestCase_assert(!strcmp(VALUE.array->values[INDEX].value.string, EXPECTED_VALUE), "Expected " EXPECTED_VALUE " but got \"%s\"", VALUE.array->values[INDEX].value.string) #define assertBlobInArray(VALUE, INDEX, EXPECTED_VALUE, LENGTH) \ TestCase_assert(VALUE.array->values[INDEX].type == DATA_TYPE_BLOB, "Expected %d but got %d", DATA_TYPE_BLOB, VALUE.array->values[INDEX].type); \ TestCase_assert(VALUE.array->values[INDEX].value.blob.length == LENGTH, "Expected " #LENGTH " but got " SIZE_T_FORMAT, VALUE.array->values[INDEX].value.blob.length); \ TestCase_assert(!memcmp(VALUE.array->values[INDEX].value.blob.bytes, EXPECTED_VALUE, LENGTH), "Expected \"" EXPECTED_VALUE "\" but got \"%s\"", (char *) VALUE.array->values[INDEX].value.blob.bytes) static void testValuesInArray() { DataSerializationContext * context; DataValue * result; context = DataSerializationContext_create(); call_virtual(beginArray, context, NULL); call_virtual(writeBoolean, context, NULL, false); call_virtual(writeBoolean, context, NULL, true); call_virtual(writeInt8, context, NULL, 0); call_virtual(writeInt8, context, NULL, 1); call_virtual(writeUInt8, context, NULL, 0); call_virtual(writeUInt8, context, NULL, 1); call_virtual(writeInt16, context, NULL, 0); call_virtual(writeInt16, context, NULL, 1); call_virtual(writeUInt16, context, NULL, 0); call_virtual(writeUInt16, context, NULL, 1); call_virtual(writeInt32, context, NULL, 0); call_virtual(writeInt32, context, NULL, 1); call_virtual(writeUInt32, context, NULL, 0); call_virtual(writeUInt32, context, NULL, 1); call_virtual(writeInt64, context, NULL, 0); call_virtual(writeInt64, context, NULL, 1); call_virtual(writeUInt64, context, NULL, 0); call_virtual(writeUInt64, context, NULL, 1); call_virtual(writeFloat, context, NULL, 0.0f); call_virtual(writeFloat, context, NULL, 1.0f); call_virtual(writeDouble, context, NULL, 0.0); call_virtual(writeDouble, context, NULL, 1.0); call_virtual(writeFixed16_16, context, NULL, 0x00000); call_virtual(writeFixed16_16, context, NULL, 0x10000); Serialization_enumKeyValue testEnumValues[] = {{enumKV(ENUM_TEST_0)}, {enumKV(ENUM_TEST_1)}}; call_virtual(writeEnumeration, context, NULL, ENUM_TEST_0, 2, testEnumValues); call_virtual(writeEnumeration, context, NULL, ENUM_TEST_1, 2, testEnumValues); Serialization_bitName testBitNames1[] = {{"bit_0", 0}, {"bit_1", 1}, {"bit_2", 2}, {"bit_3", 3}, {"bit_4", 4}, {"bit_5", 5}, {"bit_6", 6}, {"bit_7", 7}}; call_virtual(writeBitfield8, context, NULL, 0xAA, 8, testBitNames1); Serialization_bitName testBitNames2[] = {{"bit0", 0}, {"bit1", 1}, {"bit2", 2}, {"bit3", 3}, {"bit4", 4}, {"bit5", 5}, {"bit6", 6}}; call_virtual(writeBitfield8, context, NULL, 0x57, 7, testBitNames2); Serialization_bitName testBitNames3[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}}; call_virtual(writeBitfield16, context, NULL, 0xF001, 16, testBitNames3); Serialization_bitName testBitNames4[] = {{"b0", 0}, {"b1", 1}, {"b2", 2}, {"b3", 3}, {"b4", 4}, {"b5", 5}}; call_virtual(writeBitfield16, context, NULL, 0x000F, 6, testBitNames4); Serialization_bitName testBitNames5[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}, {"10", 16}, {"11", 17}, {"12", 18}, {"13", 19}, {"14", 20}, {"15", 21}, {"16", 22}, {"17", 23}, {"18", 24}, {"19", 25}, {"1A", 26}, {"1B", 27}, {"1C", 28}, {"1D", 29}, {"1E", 30}, {"1F", 31}}; call_virtual(writeBitfield32, context, NULL, 0xF0000001, 32, testBitNames5); call_virtual(writeBitfield32, context, NULL, 0x0000001E, 6, testBitNames3); Serialization_bitName testBitNames6[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}, {"10", 16}, {"11", 17}, {"12", 18}, {"13", 19}, {"14", 20}, {"15", 21}, {"16", 22}, {"17", 23}, {"18", 24}, {"19", 25}, {"1A", 26}, {"1B", 27}, {"1C", 28}, {"1D", 29}, {"1E", 30}, {"1F", 31}, {"20", 32}, {"21", 33}, {"22", 34}, {"23", 35}, {"24", 36}, {"25", 37}, {"26", 38}, {"27", 39}, {"28", 40}, {"29", 41}, {"2A", 42}, {"2B", 43}, {"2C", 44}, {"2D", 45}, {"2E", 46}, {"2F", 47}, {"30", 48}, {"31", 49}, {"32", 50}, {"33", 51}, {"34", 52}, {"35", 53}, {"36", 54}, {"37", 55}, {"38", 56}, {"39", 57}, {"3A", 58}, {"3B", 59}, {"3C", 60}, {"3D", 61}, {"3E", 62}, {"3F", 63}}; call_virtual(writeBitfield64, context, NULL, 0xF000000000000001ull, 64, testBitNames6); call_virtual(writeBitfield64, context, NULL, 0x000000000000003Cull, 6, testBitNames3); call_virtual(writeString, context, NULL, "foo"); call_virtual(writeString, context, NULL, "bar"); call_virtual(writeBlob, context, NULL, "a", 1); call_virtual(writeBlob, context, NULL, "abcd", 4); call_virtual(endArray, context); result = DataSerializationContext_result(context); TestCase_assert(result != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->type == DATA_TYPE_ARRAY, "Expected %d but got %d", DATA_TYPE_ARRAY, result->type); TestCase_assert(result->value.array != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->value.array->count == 38, "Expected 38 but got " SIZE_T_FORMAT, result->value.array->count); assertDataValueInArray(result->value, 0, DATA_TYPE_BOOLEAN, false, boolean); assertDataValueInArray(result->value, 1, DATA_TYPE_BOOLEAN, true, boolean); assertDataValueInArray(result->value, 2, DATA_TYPE_INT8, 0, int8); assertDataValueInArray(result->value, 3, DATA_TYPE_INT8, 1, int8); assertDataValueInArray(result->value, 4, DATA_TYPE_UINT8, 0, uint8); assertDataValueInArray(result->value, 5, DATA_TYPE_UINT8, 1, uint8); assertDataValueInArray(result->value, 6, DATA_TYPE_INT16, 0, int16); assertDataValueInArray(result->value, 7, DATA_TYPE_INT16, 1, int16); assertDataValueInArray(result->value, 8, DATA_TYPE_UINT16, 0, uint16); assertDataValueInArray(result->value, 9, DATA_TYPE_UINT16, 1, uint16); assertDataValueInArray(result->value, 10, DATA_TYPE_INT32, 0, int32); assertDataValueInArray(result->value, 11, DATA_TYPE_INT32, 1, int32); assertDataValueInArray(result->value, 12, DATA_TYPE_UINT32, 0, uint32); assertDataValueInArray(result->value, 13, DATA_TYPE_UINT32, 1, uint32); assertDataValueInArray(result->value, 14, DATA_TYPE_INT64, 0, int64); assertDataValueInArray(result->value, 15, DATA_TYPE_INT64, 1, int64); assertDataValueInArray(result->value, 16, DATA_TYPE_UINT64, 0, uint64); assertDataValueInArray(result->value, 17, DATA_TYPE_UINT64, 1, uint64); assertDataValueInArray(result->value, 18, DATA_TYPE_FLOAT, 0.0f, float32); assertDataValueInArray(result->value, 19, DATA_TYPE_FLOAT, 1.0f, float32); assertDataValueInArray(result->value, 20, DATA_TYPE_DOUBLE, 0.0, float64); assertDataValueInArray(result->value, 21, DATA_TYPE_DOUBLE, 1.0, float64); assertDataValueInArray(result->value, 22, DATA_TYPE_FIXED_16_16, 0x00000, fixed); assertDataValueInArray(result->value, 23, DATA_TYPE_FIXED_16_16, 0x10000, fixed); assertDataValueInArray(result->value, 24, DATA_TYPE_INT32, ENUM_TEST_0, int32); assertDataValueInArray(result->value, 25, DATA_TYPE_INT32, ENUM_TEST_1, int32); assertDataValueInArray(result->value, 26, DATA_TYPE_UINT8, 0xAA, uint8); assertDataValueInArray(result->value, 27, DATA_TYPE_UINT8, 0x57, uint8); assertDataValueInArray(result->value, 28, DATA_TYPE_UINT16, 0xF001, uint16); assertDataValueInArray(result->value, 29, DATA_TYPE_UINT16, 0x000F, uint16); assertDataValueInArray(result->value, 30, DATA_TYPE_UINT32, 0xF0000001, uint32); assertDataValueInArray(result->value, 31, DATA_TYPE_UINT32, 0x0000001E, uint32); assertDataValueInArray(result->value, 32, DATA_TYPE_UINT64, 0xF000000000000001ull, uint64); assertDataValueInArray(result->value, 33, DATA_TYPE_UINT64, 0x000000000000003Cull, uint64); assertStringInArray(result->value, 34, "foo"); assertStringInArray(result->value, 35, "bar"); assertBlobInArray(result->value, 36, "a", 1); assertBlobInArray(result->value, 37, "abcd", 4); DataSerializationContext_dispose(context); } #define assertDataValueInHashTable(VALUE, KEY, TYPE, EXPECTED_VALUE, FIELD) \ value = hashGet(VALUE.hashTable, KEY); \ TestCase_assert(value != NULL, "Expected non-NULL but got NULL"); \ TestCase_assert(value->type == TYPE, "Expected %d but got %d", TYPE, value->type); \ TestCase_assert(value->value.FIELD == EXPECTED_VALUE, "Expected " #EXPECTED_VALUE " but got " FORMAT_##TYPE, value->value.FIELD) #define assertStringInHashTable(VALUE, KEY, EXPECTED_VALUE) \ value = hashGet(VALUE.hashTable, KEY); \ TestCase_assert(value != NULL, "Expected non-NULL but got NULL"); \ TestCase_assert(value->type == DATA_TYPE_STRING, "Expected %d but got %d", DATA_TYPE_STRING, value->type); \ TestCase_assert(!strcmp(value->value.string, EXPECTED_VALUE), "Expected " EXPECTED_VALUE " but got \"%s\"", value->value.string) #define assertBlobInHashTable(VALUE, KEY, EXPECTED_VALUE, LENGTH) \ value = hashGet(VALUE.hashTable, KEY); \ TestCase_assert(value != NULL, "Expected non-NULL but got NULL"); \ TestCase_assert(value->type == DATA_TYPE_BLOB, "Expected %d but got %d", DATA_TYPE_BLOB, value->type); \ TestCase_assert(value->value.blob.length == LENGTH, "Expected " #LENGTH " but got " SIZE_T_FORMAT, value->value.blob.length); \ TestCase_assert(!memcmp(value->value.blob.bytes, EXPECTED_VALUE, LENGTH), "Expected \"" EXPECTED_VALUE "\" but got \"%s\"", (char *) value->value.blob.bytes) static void testValuesInHashTable() { DataSerializationContext * context; DataValue * result, * value; context = DataSerializationContext_create(); call_virtual(beginStructure, context, NULL); call_virtual(writeBoolean, context, "bool_0", false); call_virtual(writeBoolean, context, "bool_1", true); call_virtual(writeInt8, context, "int8_0", 0); call_virtual(writeInt8, context, "int8_1", 1); call_virtual(writeUInt8, context, "uint8_0", 0); call_virtual(writeUInt8, context, "uint8_1", 1); call_virtual(writeInt16, context, "int16_0", 0); call_virtual(writeInt16, context, "int16_1", 1); call_virtual(writeUInt16, context, "uint16_0", 0); call_virtual(writeUInt16, context, "uint16_1", 1); call_virtual(writeInt32, context, "int32_0", 0); call_virtual(writeInt32, context, "int32_1", 1); call_virtual(writeUInt32, context, "uint32_0", 0); call_virtual(writeUInt32, context, "uint32_1", 1); call_virtual(writeInt64, context, "int64_0", 0); call_virtual(writeInt64, context, "int64_1", 1); call_virtual(writeUInt64, context, "uint64_0", 0); call_virtual(writeUInt64, context, "uint64_1", 1); call_virtual(writeFloat, context, "float_0", 0.0f); call_virtual(writeFloat, context, "float_1", 1.0f); call_virtual(writeDouble, context, "double_0", 0.0); call_virtual(writeDouble, context, "double_1", 1.0); call_virtual(writeFixed16_16, context, "fixed_0", 0x00000); call_virtual(writeFixed16_16, context, "fixed_1", 0x10000); Serialization_enumKeyValue testEnumValues[] = {{enumKV(ENUM_TEST_0)}, {enumKV(ENUM_TEST_1)}}; call_virtual(writeEnumeration, context, "enum_0", ENUM_TEST_0, 2, testEnumValues); call_virtual(writeEnumeration, context, "enum_1", ENUM_TEST_1, 2, testEnumValues); Serialization_bitName testBitNames1[] = {{"bit_0", 0}, {"bit_1", 1}, {"bit_2", 2}, {"bit_3", 3}, {"bit_4", 4}, {"bit_5", 5}, {"bit_6", 6}, {"bit_7", 7}}; call_virtual(writeBitfield8, context, "bitfield8_0", 0xAA, 8, testBitNames1); Serialization_bitName testBitNames2[] = {{"bit0", 0}, {"bit1", 1}, {"bit2", 2}, {"bit3", 3}, {"bit4", 4}, {"bit5", 5}, {"bit6", 6}}; call_virtual(writeBitfield8, context, "bitfield8_1", 0x57, 7, testBitNames2); Serialization_bitName testBitNames3[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}}; call_virtual(writeBitfield16, context, "bitfield16_0", 0xF001, 16, testBitNames3); Serialization_bitName testBitNames4[] = {{"b0", 0}, {"b1", 1}, {"b2", 2}, {"b3", 3}, {"b4", 4}, {"b5", 5}}; call_virtual(writeBitfield16, context, "bitfield16_1", 0x000F, 6, testBitNames4); Serialization_bitName testBitNames5[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}, {"10", 16}, {"11", 17}, {"12", 18}, {"13", 19}, {"14", 20}, {"15", 21}, {"16", 22}, {"17", 23}, {"18", 24}, {"19", 25}, {"1A", 26}, {"1B", 27}, {"1C", 28}, {"1D", 29}, {"1E", 30}, {"1F", 31}}; call_virtual(writeBitfield32, context, "bitfield32_0", 0xF0000001, 32, testBitNames5); call_virtual(writeBitfield32, context, "bitfield32_1", 0x0000001E, 6, testBitNames3); Serialization_bitName testBitNames6[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}, {"10", 16}, {"11", 17}, {"12", 18}, {"13", 19}, {"14", 20}, {"15", 21}, {"16", 22}, {"17", 23}, {"18", 24}, {"19", 25}, {"1A", 26}, {"1B", 27}, {"1C", 28}, {"1D", 29}, {"1E", 30}, {"1F", 31}, {"20", 32}, {"21", 33}, {"22", 34}, {"23", 35}, {"24", 36}, {"25", 37}, {"26", 38}, {"27", 39}, {"28", 40}, {"29", 41}, {"2A", 42}, {"2B", 43}, {"2C", 44}, {"2D", 45}, {"2E", 46}, {"2F", 47}, {"30", 48}, {"31", 49}, {"32", 50}, {"33", 51}, {"34", 52}, {"35", 53}, {"36", 54}, {"37", 55}, {"38", 56}, {"39", 57}, {"3A", 58}, {"3B", 59}, {"3C", 60}, {"3D", 61}, {"3E", 62}, {"3F", 63}}; call_virtual(writeBitfield64, context, "bitfield64_0", 0xF000000000000001ull, 64, testBitNames6); call_virtual(writeBitfield64, context, "bitfield64_1", 0x000000000000003Cull, 6, testBitNames3); call_virtual(writeString, context, "string_0", "foo"); call_virtual(writeString, context, "string_1", "bar"); call_virtual(writeBlob, context, "blob_0", "a", 1); call_virtual(writeBlob, context, "blob_1", "abcd", 4); call_virtual(endStructure, context); result = DataSerializationContext_result(context); TestCase_assert(result != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->type == DATA_TYPE_HASH_TABLE, "Expected %d but got %d", DATA_TYPE_HASH_TABLE, result->type); TestCase_assert(result->value.hashTable != NULL, "Expected non-NULL but got NULL"); TestCase_assertSizeEqual(hashGetCount(result->value.hashTable), 38); assertDataValueInHashTable(result->value, "bool_0", DATA_TYPE_BOOLEAN, false, boolean); assertDataValueInHashTable(result->value, "bool_1", DATA_TYPE_BOOLEAN, true, boolean); assertDataValueInHashTable(result->value, "int8_0", DATA_TYPE_INT8, 0, int8); assertDataValueInHashTable(result->value, "int8_1", DATA_TYPE_INT8, 1, int8); assertDataValueInHashTable(result->value, "uint8_0", DATA_TYPE_UINT8, 0, uint8); assertDataValueInHashTable(result->value, "uint8_1", DATA_TYPE_UINT8, 1, uint8); assertDataValueInHashTable(result->value, "int16_0", DATA_TYPE_INT16, 0, int16); assertDataValueInHashTable(result->value, "int16_1", DATA_TYPE_INT16, 1, int16); assertDataValueInHashTable(result->value, "uint16_0", DATA_TYPE_UINT16, 0, uint16); assertDataValueInHashTable(result->value, "uint16_1", DATA_TYPE_UINT16, 1, uint16); assertDataValueInHashTable(result->value, "int32_0", DATA_TYPE_INT32, 0, int32); assertDataValueInHashTable(result->value, "int32_1", DATA_TYPE_INT32, 1, int32); assertDataValueInHashTable(result->value, "uint32_0", DATA_TYPE_UINT32, 0, uint32); assertDataValueInHashTable(result->value, "uint32_1", DATA_TYPE_UINT32, 1, uint32); assertDataValueInHashTable(result->value, "int64_0", DATA_TYPE_INT64, 0, int64); assertDataValueInHashTable(result->value, "int64_1", DATA_TYPE_INT64, 1, int64); assertDataValueInHashTable(result->value, "uint64_0", DATA_TYPE_UINT64, 0, uint64); assertDataValueInHashTable(result->value, "uint64_1", DATA_TYPE_UINT64, 1, uint64); assertDataValueInHashTable(result->value, "float_0", DATA_TYPE_FLOAT, 0.0f, float32); assertDataValueInHashTable(result->value, "float_1", DATA_TYPE_FLOAT, 1.0f, float32); assertDataValueInHashTable(result->value, "double_0", DATA_TYPE_DOUBLE, 0.0, float64); assertDataValueInHashTable(result->value, "double_1", DATA_TYPE_DOUBLE, 1.0, float64); assertDataValueInHashTable(result->value, "fixed_0", DATA_TYPE_FIXED_16_16, 0x00000, fixed); assertDataValueInHashTable(result->value, "fixed_1", DATA_TYPE_FIXED_16_16, 0x10000, fixed); assertDataValueInHashTable(result->value, "enum_0", DATA_TYPE_INT32, ENUM_TEST_0, int32); assertDataValueInHashTable(result->value, "enum_1", DATA_TYPE_INT32, ENUM_TEST_1, int32); assertDataValueInHashTable(result->value, "bitfield8_0", DATA_TYPE_UINT8, 0xAA, uint8); assertDataValueInHashTable(result->value, "bitfield8_1", DATA_TYPE_UINT8, 0x57, uint8); assertDataValueInHashTable(result->value, "bitfield16_0", DATA_TYPE_UINT16, 0xF001, uint16); assertDataValueInHashTable(result->value, "bitfield16_1", DATA_TYPE_UINT16, 0x000F, uint16); assertDataValueInHashTable(result->value, "bitfield32_0", DATA_TYPE_UINT32, 0xF0000001, uint32); assertDataValueInHashTable(result->value, "bitfield32_1", DATA_TYPE_UINT32, 0x0000001E, uint32); assertDataValueInHashTable(result->value, "bitfield64_0", DATA_TYPE_UINT64, 0xF000000000000001ull, uint64); assertDataValueInHashTable(result->value, "bitfield64_1", DATA_TYPE_UINT64, 0x000000000000003Cull, uint64); assertStringInHashTable(result->value, "string_0", "foo"); assertStringInHashTable(result->value, "string_1", "bar"); assertBlobInHashTable(result->value, "blob_0", "a", 1); assertBlobInHashTable(result->value, "blob_1", "abcd", 4); DataSerializationContext_dispose(context); } #define assertDataValueInAssociativeArray(VALUE, INDEX, KEY, TYPE, EXPECTED_VALUE, FIELD) \ TestCase_assert(VALUE.associativeArray->values[INDEX].type == TYPE, "Expected %d but got %d", TYPE, VALUE.associativeArray->values[INDEX].type); \ TestCase_assert(VALUE.associativeArray->values[INDEX].value.FIELD == EXPECTED_VALUE, "Expected " #EXPECTED_VALUE " but got " FORMAT_##TYPE, VALUE.associativeArray->values[INDEX].value.FIELD); \ TestCase_assert(!strcmp(VALUE.associativeArray->keys[INDEX], KEY), "Expected \"%s\" but got \"%s\"", KEY, VALUE.associativeArray->keys[INDEX]) #define assertStringInAssociativeArray(VALUE, INDEX, KEY, EXPECTED_VALUE) \ TestCase_assert(VALUE.associativeArray->values[INDEX].type == DATA_TYPE_STRING, "Expected %d but got %d", DATA_TYPE_STRING, VALUE.associativeArray->values[INDEX].type); \ TestCase_assert(!strcmp(VALUE.associativeArray->values[INDEX].value.string, EXPECTED_VALUE), "Expected " EXPECTED_VALUE " but got \"%s\"", VALUE.associativeArray->values[INDEX].value.string); \ TestCase_assert(!strcmp(VALUE.associativeArray->keys[INDEX], KEY), "Expected \"%s\" but got \"%s\"", KEY, VALUE.associativeArray->keys[INDEX]) #define assertBlobInAssociativeArray(VALUE, INDEX, KEY, EXPECTED_VALUE, LENGTH) \ TestCase_assert(VALUE.associativeArray->values[INDEX].type == DATA_TYPE_BLOB, "Expected %d but got %d", DATA_TYPE_BLOB, VALUE.associativeArray->values[INDEX].type); \ TestCase_assert(VALUE.associativeArray->values[INDEX].value.blob.length == LENGTH, "Expected " #LENGTH " but got " SIZE_T_FORMAT, VALUE.associativeArray->values[INDEX].value.blob.length); \ TestCase_assert(!memcmp(VALUE.associativeArray->values[INDEX].value.blob.bytes, EXPECTED_VALUE, LENGTH), "Expected \"" EXPECTED_VALUE "\" but got \"%s\"", (char *) VALUE.associativeArray->values[INDEX].value.blob.bytes); \ TestCase_assert(!strcmp(VALUE.associativeArray->keys[INDEX], KEY), "Expected \"%s\" but got \"%s\"", KEY, VALUE.associativeArray->keys[INDEX]) static void testValuesInAssociativeArray() { DataSerializationContext * context; DataValue * result; context = DataSerializationContext_create(); call_virtual(beginDictionary, context, NULL); call_virtual(writeBoolean, context, "bool_0", false); call_virtual(writeBoolean, context, "bool_1", true); call_virtual(writeInt8, context, "int8_0", 0); call_virtual(writeInt8, context, "int8_1", 1); call_virtual(writeUInt8, context, "uint8_0", 0); call_virtual(writeUInt8, context, "uint8_1", 1); call_virtual(writeInt16, context, "int16_0", 0); call_virtual(writeInt16, context, "int16_1", 1); call_virtual(writeUInt16, context, "uint16_0", 0); call_virtual(writeUInt16, context, "uint16_1", 1); call_virtual(writeInt32, context, "int32_0", 0); call_virtual(writeInt32, context, "int32_1", 1); call_virtual(writeUInt32, context, "uint32_0", 0); call_virtual(writeUInt32, context, "uint32_1", 1); call_virtual(writeInt64, context, "int64_0", 0); call_virtual(writeInt64, context, "int64_1", 1); call_virtual(writeUInt64, context, "uint64_0", 0); call_virtual(writeUInt64, context, "uint64_1", 1); call_virtual(writeFloat, context, "float_0", 0.0f); call_virtual(writeFloat, context, "float_1", 1.0f); call_virtual(writeDouble, context, "double_0", 0.0); call_virtual(writeDouble, context, "double_1", 1.0); call_virtual(writeFixed16_16, context, "fixed_0", 0x00000); call_virtual(writeFixed16_16, context, "fixed_1", 0x10000); Serialization_enumKeyValue testEnumValues[] = {{enumKV(ENUM_TEST_0)}, {enumKV(ENUM_TEST_1)}}; call_virtual(writeEnumeration, context, "enum_0", ENUM_TEST_0, 2, testEnumValues); call_virtual(writeEnumeration, context, "enum_1", ENUM_TEST_1, 2, testEnumValues); Serialization_bitName testBitNames1[] = {{"bit_0", 0}, {"bit_1", 1}, {"bit_2", 2}, {"bit_3", 3}, {"bit_4", 4}, {"bit_5", 5}, {"bit_6", 6}, {"bit_7", 7}}; call_virtual(writeBitfield8, context, "bitfield8_0", 0xAA, 8, testBitNames1); Serialization_bitName testBitNames2[] = {{"bit0", 0}, {"bit1", 1}, {"bit2", 2}, {"bit3", 3}, {"bit4", 4}, {"bit5", 5}, {"bit6", 6}}; call_virtual(writeBitfield8, context, "bitfield8_1", 0x57, 7, testBitNames2); Serialization_bitName testBitNames3[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}}; call_virtual(writeBitfield16, context, "bitfield16_0", 0xF001, 16, testBitNames3); Serialization_bitName testBitNames4[] = {{"b0", 0}, {"b1", 1}, {"b2", 2}, {"b3", 3}, {"b4", 4}, {"b5", 5}}; call_virtual(writeBitfield16, context, "bitfield16_1", 0x000F, 6, testBitNames4); Serialization_bitName testBitNames5[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}, {"10", 16}, {"11", 17}, {"12", 18}, {"13", 19}, {"14", 20}, {"15", 21}, {"16", 22}, {"17", 23}, {"18", 24}, {"19", 25}, {"1A", 26}, {"1B", 27}, {"1C", 28}, {"1D", 29}, {"1E", 30}, {"1F", 31}}; call_virtual(writeBitfield32, context, "bitfield32_0", 0xF0000001, 32, testBitNames5); call_virtual(writeBitfield32, context, "bitfield32_1", 0x0000001E, 6, testBitNames3); Serialization_bitName testBitNames6[] = {{"0", 0}, {"1", 1}, {"2", 2}, {"3", 3}, {"4", 4}, {"5", 5}, {"6", 6}, {"7", 7}, {"8", 8}, {"9", 9}, {"A", 10}, {"B", 11}, {"C", 12}, {"D", 13}, {"E", 14}, {"F", 15}, {"10", 16}, {"11", 17}, {"12", 18}, {"13", 19}, {"14", 20}, {"15", 21}, {"16", 22}, {"17", 23}, {"18", 24}, {"19", 25}, {"1A", 26}, {"1B", 27}, {"1C", 28}, {"1D", 29}, {"1E", 30}, {"1F", 31}, {"20", 32}, {"21", 33}, {"22", 34}, {"23", 35}, {"24", 36}, {"25", 37}, {"26", 38}, {"27", 39}, {"28", 40}, {"29", 41}, {"2A", 42}, {"2B", 43}, {"2C", 44}, {"2D", 45}, {"2E", 46}, {"2F", 47}, {"30", 48}, {"31", 49}, {"32", 50}, {"33", 51}, {"34", 52}, {"35", 53}, {"36", 54}, {"37", 55}, {"38", 56}, {"39", 57}, {"3A", 58}, {"3B", 59}, {"3C", 60}, {"3D", 61}, {"3E", 62}, {"3F", 63}}; call_virtual(writeBitfield64, context, "bitfield64_0", 0xF000000000000001ull, 64, testBitNames6); call_virtual(writeBitfield64, context, "bitfield64_1", 0x000000000000003Cull, 6, testBitNames3); call_virtual(writeString, context, "string_0", "foo"); call_virtual(writeString, context, "string_1", "bar"); call_virtual(writeBlob, context, "blob_0", "a", 1); call_virtual(writeBlob, context, "blob_1", "abcd", 4); call_virtual(endDictionary, context); result = DataSerializationContext_result(context); TestCase_assert(result != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->type == DATA_TYPE_ASSOCIATIVE_ARRAY, "Expected %d but got %d", DATA_TYPE_ASSOCIATIVE_ARRAY, result->type); TestCase_assert(result->value.associativeArray != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->value.associativeArray->count == 38, "Expected 38 but got " SIZE_T_FORMAT, result->value.associativeArray->count); assertDataValueInAssociativeArray(result->value, 0, "bool_0", DATA_TYPE_BOOLEAN, false, boolean); assertDataValueInAssociativeArray(result->value, 1, "bool_1", DATA_TYPE_BOOLEAN, true, boolean); assertDataValueInAssociativeArray(result->value, 2, "int8_0", DATA_TYPE_INT8, 0, int8); assertDataValueInAssociativeArray(result->value, 3, "int8_1", DATA_TYPE_INT8, 1, int8); assertDataValueInAssociativeArray(result->value, 4, "uint8_0", DATA_TYPE_UINT8, 0, uint8); assertDataValueInAssociativeArray(result->value, 5, "uint8_1", DATA_TYPE_UINT8, 1, uint8); assertDataValueInAssociativeArray(result->value, 6, "int16_0", DATA_TYPE_INT16, 0, int16); assertDataValueInAssociativeArray(result->value, 7, "int16_1", DATA_TYPE_INT16, 1, int16); assertDataValueInAssociativeArray(result->value, 8, "uint16_0", DATA_TYPE_UINT16, 0, uint16); assertDataValueInAssociativeArray(result->value, 9, "uint16_1", DATA_TYPE_UINT16, 1, uint16); assertDataValueInAssociativeArray(result->value, 10, "int32_0", DATA_TYPE_INT32, 0, int32); assertDataValueInAssociativeArray(result->value, 11, "int32_1", DATA_TYPE_INT32, 1, int32); assertDataValueInAssociativeArray(result->value, 12, "uint32_0", DATA_TYPE_UINT32, 0, uint32); assertDataValueInAssociativeArray(result->value, 13, "uint32_1", DATA_TYPE_UINT32, 1, uint32); assertDataValueInAssociativeArray(result->value, 14, "int64_0", DATA_TYPE_INT64, 0, int64); assertDataValueInAssociativeArray(result->value, 15, "int64_1", DATA_TYPE_INT64, 1, int64); assertDataValueInAssociativeArray(result->value, 16, "uint64_0", DATA_TYPE_UINT64, 0, uint64); assertDataValueInAssociativeArray(result->value, 17, "uint64_1", DATA_TYPE_UINT64, 1, uint64); assertDataValueInAssociativeArray(result->value, 18, "float_0", DATA_TYPE_FLOAT, 0.0f, float32); assertDataValueInAssociativeArray(result->value, 19, "float_1", DATA_TYPE_FLOAT, 1.0f, float32); assertDataValueInAssociativeArray(result->value, 20, "double_0", DATA_TYPE_DOUBLE, 0.0, float64); assertDataValueInAssociativeArray(result->value, 21, "double_1", DATA_TYPE_DOUBLE, 1.0, float64); assertDataValueInAssociativeArray(result->value, 22, "fixed_0", DATA_TYPE_FIXED_16_16, 0x00000, fixed); assertDataValueInAssociativeArray(result->value, 23, "fixed_1", DATA_TYPE_FIXED_16_16, 0x10000, fixed); assertDataValueInAssociativeArray(result->value, 24, "enum_0", DATA_TYPE_INT32, ENUM_TEST_0, int32); assertDataValueInAssociativeArray(result->value, 25, "enum_1", DATA_TYPE_INT32, ENUM_TEST_1, int32); assertDataValueInAssociativeArray(result->value, 26, "bitfield8_0", DATA_TYPE_UINT8, 0xAA, uint8); assertDataValueInAssociativeArray(result->value, 27, "bitfield8_1", DATA_TYPE_UINT8, 0x57, uint8); assertDataValueInAssociativeArray(result->value, 28, "bitfield16_0", DATA_TYPE_UINT16, 0xF001, uint16); assertDataValueInAssociativeArray(result->value, 29, "bitfield16_1", DATA_TYPE_UINT16, 0x000F, uint16); assertDataValueInAssociativeArray(result->value, 30, "bitfield32_0", DATA_TYPE_UINT32, 0xF0000001, uint32); assertDataValueInAssociativeArray(result->value, 31, "bitfield32_1", DATA_TYPE_UINT32, 0x0000001E, uint32); assertDataValueInAssociativeArray(result->value, 32, "bitfield64_0", DATA_TYPE_UINT64, 0xF000000000000001ull, uint64); assertDataValueInAssociativeArray(result->value, 33, "bitfield64_1", DATA_TYPE_UINT64, 0x000000000000003Cull, uint64); assertStringInAssociativeArray(result->value, 34, "string_0", "foo"); assertStringInAssociativeArray(result->value, 35, "string_1", "bar"); assertBlobInAssociativeArray(result->value, 36, "blob_0", "a", 1); assertBlobInAssociativeArray(result->value, 37, "blob_1", "abcd", 4); DataSerializationContext_dispose(context); } static void testHierarchy() { DataSerializationContext * context; DataValue * result, * value; context = DataSerializationContext_create(); call_virtual(beginDictionary, context, NULL); call_virtual(writeBoolean, context, "bool_0", false); call_virtual(beginArray, context, "array_0"); call_virtual(writeBoolean, context, "bool_1", true); call_virtual(endArray, context); call_virtual(writeInt8, context, "int8_0", 0); call_virtual(beginStructure, context, "struct_0"); call_virtual(beginArray, context, "array_1"); call_virtual(writeInt8, context, "int8_1", 1); call_virtual(endArray, context); call_virtual(writeUInt8, context, "uint8_0", 0); call_virtual(endStructure, context); call_virtual(beginDictionary, context, "dictionary_1"); call_virtual(writeUInt8, context, "uint8_1", 1); call_virtual(endDictionary, context); call_virtual(endDictionary, context); result = DataSerializationContext_result(context); TestCase_assert(result != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->type == DATA_TYPE_ASSOCIATIVE_ARRAY, "Expected %d but got %d", DATA_TYPE_ASSOCIATIVE_ARRAY, result->type); TestCase_assert(result->value.associativeArray != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->value.associativeArray->count == 5, "Expected 5 but got " SIZE_T_FORMAT, result->value.associativeArray->count); assertDataValueInAssociativeArray(result->value, 0, "bool_0", DATA_TYPE_BOOLEAN, false, boolean); TestCase_assert(!strcmp(result->value.associativeArray->keys[1], "array_0"), "Expected \"array_0\" but got \"%s\"", result->value.associativeArray->keys[1]); TestCase_assert(result->value.associativeArray->values[1].type == DATA_TYPE_ARRAY, "Expected %d but got %d", DATA_TYPE_ARRAY, result->value.associativeArray->values[1].type); TestCase_assert(result->value.associativeArray->values[1].value.array != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->value.associativeArray->values[1].value.array->count == 1, "Expected 1 but got " SIZE_T_FORMAT, result->value.associativeArray->values[1].value.array->count); assertDataValueInAssociativeArray(result->value, 2, "int8_0", DATA_TYPE_INT8, 0, int8); TestCase_assert(!strcmp(result->value.associativeArray->keys[3], "struct_0"), "Expected \"struct_0\" but got \"%s\"", result->value.associativeArray->keys[3]); TestCase_assert(result->value.associativeArray->values[3].type == DATA_TYPE_HASH_TABLE, "Expected %d but got %d", DATA_TYPE_HASH_TABLE, result->value.associativeArray->values[3].type); TestCase_assert(result->value.associativeArray->values[3].value.hashTable != NULL, "Expected non-NULL but got NULL"); TestCase_assertSizeEqual(hashGetCount(result->value.associativeArray->values[3].value.hashTable), 2); TestCase_assert(!strcmp(result->value.associativeArray->keys[4], "dictionary_1"), "Expected \"dictionary_1\" but got \"%s\"", result->value.associativeArray->keys[4]); TestCase_assert(result->value.associativeArray->values[4].type == DATA_TYPE_ASSOCIATIVE_ARRAY, "Expected %d but got %d", DATA_TYPE_ASSOCIATIVE_ARRAY, result->value.associativeArray->values[4].type); TestCase_assert(result->value.associativeArray->values[4].value.associativeArray != NULL, "Expected non-NULL but got NULL"); TestCase_assert(result->value.associativeArray->values[4].value.associativeArray->count == 1, "Expected 1 but got " SIZE_T_FORMAT, result->value.associativeArray->values[4].value.associativeArray->count); assertDataValueInArray(result->value.associativeArray->values[1].value, 0, DATA_TYPE_BOOLEAN, true, boolean); value = hashGet(result->value.associativeArray->values[3].value.hashTable, "array_1"); TestCase_assert(value != NULL, "Expected non-NULL but got NULL"); TestCase_assert(value->type == DATA_TYPE_ARRAY, "Expected %d but got %d", DATA_TYPE_ARRAY, value->type); TestCase_assert(value->value.array != NULL, "Expected non-NULL but got NULL"); TestCase_assert(value->value.array->count == 1, "Expected 1 but got " SIZE_T_FORMAT, value->value.array->count); assertDataValueInArray(value->value, 0, DATA_TYPE_INT8, 1, int8); assertDataValueInHashTable(result->value.associativeArray->values[3].value, "uint8_0", DATA_TYPE_UINT8, 0, uint8); assertDataValueInAssociativeArray(result->value.associativeArray->values[4].value, 0, "uint8_1", DATA_TYPE_UINT8, 1, uint8); DataSerializationContext_dispose(context); } static Serialization_enumKeyValue failTestEnumValue = {enumKV(ENUM_TEST_0)}; static Serialization_bitName failTestBitName = {"a", 0}; #define testFailure(ERROR_STATUS, PREAMBLE_CODE, FAIL_CODE) \ context = DataSerializationContext_create(); \ PREAMBLE_CODE \ TestCase_assert(context->status == SERIALIZATION_ERROR_OK, "Expected %d but got %d (OK)", SERIALIZATION_ERROR_OK, context->status); \ FAIL_CODE \ TestCase_assert(context->status == ERROR_STATUS, "Expected %d but got %d (context->status)", ERROR_STATUS, context->status); \ call_virtual(dispose, context); \ \ context = DataSerializationContext_create(); \ context->jmpBuf = &jmpBuf; \ status = setjmp(jmpBuf); \ if (!status) { \ PREAMBLE_CODE \ TestCase_assert(context->status == SERIALIZATION_ERROR_OK, "Expected %d but got %d (OK setjmp)", SERIALIZATION_ERROR_OK, context->status); \ FAIL_CODE \ } \ TestCase_assert(status == ERROR_STATUS, "Expected %d but got %d (status setjmp)", ERROR_STATUS, status); \ TestCase_assert(context->status == ERROR_STATUS, "Expected %d but got %d (context->status setjmp)", ERROR_STATUS, context->status); \ call_virtual(dispose, context) #define testFailureWithAllTypes(ERROR_STATUS, PREAMBLE_CODE, KEY) \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeBoolean, context, KEY, false);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeInt8, context, KEY, 0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeUInt8, context, KEY, 0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeInt16, context, KEY, 0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeUInt16, context, KEY, 0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeInt32, context, KEY, 0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeUInt32, context, KEY, 0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeInt64, context, KEY, 0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeUInt64, context, KEY, 0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeFloat, context, KEY, 0.0f);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeDouble, context, KEY, 0.0);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeFixed16_16, context, KEY, 0x00000);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeEnumeration, context, KEY, 0, 1, &failTestEnumValue);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeBitfield8, context, KEY, 0, 1, &failTestBitName);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeBitfield16, context, KEY, 0, 1, &failTestBitName);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeBitfield32, context, KEY, 0, 1, &failTestBitName);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeBitfield64, context, KEY, 0, 1, &failTestBitName);); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeString, context, KEY, "a");); \ testFailure(ERROR_STATUS, PREAMBLE_CODE, call_virtual(writeBlob, context, KEY, "a", 1);) static void testErrors() { DataSerializationContext * context; jmp_buf jmpBuf; int status; //SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginArray, context, NULL);, call_virtual(endStructure, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginArray, context, NULL); call_virtual(beginArray, context, NULL);, call_virtual(endStructure, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginArray, context, NULL);, call_virtual(endDictionary, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginArray, context, NULL); call_virtual(beginArray, context, NULL);, call_virtual(endDictionary, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginDictionary, context, NULL);, call_virtual(endStructure, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginDictionary, context, NULL); call_virtual(beginDictionary, context, "a");, call_virtual(endStructure, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginDictionary, context, NULL);, call_virtual(endArray, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginDictionary, context, NULL); call_virtual(beginDictionary, context, "a");, call_virtual(endArray, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginStructure, context, NULL);, call_virtual(endDictionary, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginStructure, context, NULL); call_virtual(beginStructure, context, "a");, call_virtual(endDictionary, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginStructure, context, NULL);, call_virtual(endArray, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_TYPE_MISMATCH, call_virtual(beginStructure, context, NULL); call_virtual(beginStructure, context, "a");, call_virtual(endArray, context);); //SERIALIZATION_ERROR_CONTAINER_UNDERFLOW testFailure(SERIALIZATION_ERROR_CONTAINER_UNDERFLOW, , call_virtual(endArray, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_UNDERFLOW, call_virtual(beginArray, context, NULL); call_virtual(endArray, context);, call_virtual(endArray, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_UNDERFLOW, , call_virtual(endDictionary, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_UNDERFLOW, call_virtual(beginDictionary, context, NULL); call_virtual(endDictionary, context);, call_virtual(endDictionary, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_UNDERFLOW, , call_virtual(endStructure, context);); testFailure(SERIALIZATION_ERROR_CONTAINER_UNDERFLOW, call_virtual(beginStructure, context, NULL); call_virtual(endStructure, context);, call_virtual(endStructure, context);); //SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginArray, context, NULL); call_virtual(endArray, context);, call_virtual(beginArray, context, NULL);); testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginArray, context, NULL); call_virtual(endArray, context);, call_virtual(beginStructure, context, NULL);); testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginArray, context, NULL); call_virtual(endArray, context);, call_virtual(beginDictionary, context, NULL);); testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginDictionary, context, NULL); call_virtual(endDictionary, context);, call_virtual(beginDictionary, context, NULL);); testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginDictionary, context, NULL); call_virtual(endDictionary, context);, call_virtual(beginArray, context, NULL);); testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginDictionary, context, NULL); call_virtual(endDictionary, context);, call_virtual(beginStructure, context, NULL);); testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginStructure, context, NULL); call_virtual(endStructure, context);, call_virtual(beginStructure, context, NULL);); testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginStructure, context, NULL); call_virtual(endStructure, context);, call_virtual(beginArray, context, NULL);); testFailure(SERIALIZATION_ERROR_MULTIPLE_TOP_LEVEL_CONTAINERS, call_virtual(beginStructure, context, NULL); call_virtual(endStructure, context);, call_virtual(beginDictionary, context, NULL);); //SERIALIZATION_ERROR_UNNAMED_BIT testFailure(SERIALIZATION_ERROR_UNNAMED_BIT, call_virtual(beginArray, context, NULL);, call_virtual(writeBitfield8, context, NULL, 12, 1, &failTestBitName);); testFailure(SERIALIZATION_ERROR_UNNAMED_BIT, call_virtual(beginArray, context, NULL);, call_virtual(writeBitfield16, context, NULL, 12, 1, &failTestBitName);); testFailure(SERIALIZATION_ERROR_UNNAMED_BIT, call_virtual(beginArray, context, NULL);, call_virtual(writeBitfield32, context, NULL, 12, 1, &failTestBitName);); testFailure(SERIALIZATION_ERROR_UNNAMED_BIT, call_virtual(beginArray, context, NULL);, call_virtual(writeBitfield64, context, NULL, 12, 1, &failTestBitName);); //SERIALIZATION_ERROR_DUPLICATE_BIT Serialization_bitName duplicateBitNames[] = {{"a", 0}, {"a", 1}}; testFailure(SERIALIZATION_ERROR_DUPLICATE_BIT, call_virtual(beginArray, context, NULL);, call_virtual(writeBitfield8, context, NULL, 1, 2, duplicateBitNames);); testFailure(SERIALIZATION_ERROR_DUPLICATE_BIT, call_virtual(beginArray, context, NULL);, call_virtual(writeBitfield16, context, NULL, 1, 2, duplicateBitNames);); testFailure(SERIALIZATION_ERROR_DUPLICATE_BIT, call_virtual(beginArray, context, NULL);, call_virtual(writeBitfield32, context, NULL, 1, 2, duplicateBitNames);); testFailure(SERIALIZATION_ERROR_DUPLICATE_BIT, call_virtual(beginArray, context, NULL);, call_virtual(writeBitfield64, context, NULL, 1, 2, duplicateBitNames);); //SERIALIZATION_ERROR_ENUM_NOT_NAMED testFailure(SERIALIZATION_ERROR_ENUM_NOT_NAMED, call_virtual(beginArray, context, NULL);, call_virtual(writeEnumeration, context, NULL, 1, 0, NULL);); Serialization_enumKeyValue unnamedEnumValue = {"a", 0}; testFailure(SERIALIZATION_ERROR_ENUM_NOT_NAMED, call_virtual(beginArray, context, NULL);, call_virtual(writeEnumeration, context, NULL, 1, 1, &unnamedEnumValue);); //SERIALIZATION_ERROR_DUPLICATE_ENUM_NAME Serialization_enumKeyValue duplicateEnumNames[] = {{"a", 0}, {"a", 1}}; testFailure(SERIALIZATION_ERROR_DUPLICATE_ENUM_NAME, call_virtual(beginArray, context, NULL);, call_virtual(writeEnumeration, context, NULL, 0, 2, duplicateEnumNames);); //SERIALIZATION_ERROR_DUPLICATE_ENUM_VALUE Serialization_enumKeyValue duplicateEnumValues[] = {{"a", 0}, {"b", 0}}; testFailure(SERIALIZATION_ERROR_DUPLICATE_ENUM_VALUE, call_virtual(beginArray, context, NULL);, call_virtual(writeEnumeration, context, NULL, 0, 2, duplicateEnumValues);); //SERIALIZATION_ERROR_NULL_KEY testFailureWithAllTypes(SERIALIZATION_ERROR_NULL_KEY, call_virtual(beginDictionary, context, NULL);, NULL); testFailureWithAllTypes(SERIALIZATION_ERROR_NULL_KEY, call_virtual(beginStructure, context, NULL);, NULL); //SERIALIZATION_ERROR_NO_CONTAINER_STARTED testFailureWithAllTypes(SERIALIZATION_ERROR_NO_CONTAINER_STARTED, , NULL); //SERIALIZATION_ERROR_NO_TOP_LEVEL_CONTAINER testFailure(SERIALIZATION_ERROR_NO_TOP_LEVEL_CONTAINER, , DataSerializationContext_result(context);); } TEST_SUITE(DataSerializationContextTest, testInit, testValuesInArray, testValuesInHashTable, testValuesInAssociativeArray, testHierarchy, testErrors)