TEST_F(MamaFieldCacheTestC, getFullMsg1) { mamaFieldCache fieldCache = NULL; mama_status ret = mamaFieldCache_create(&fieldCache); mamaFieldCacheField field = NULL; mamaFieldCacheField_create(&field, 10, MAMA_FIELD_TYPE_BOOL, NULL); mamaFieldCacheField_setBool(field, 1); mamaFieldCache_applyField(fieldCache, field); /* This field must never be published */ mamaFieldCacheField_create(&field, 25, MAMA_FIELD_TYPE_F64, NULL); mamaFieldCacheField_setF64(field, 3.1); mamaFieldCacheField_setPublish(field, 0); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_create(&field, 66, MAMA_FIELD_TYPE_I32, NULL); mamaFieldCacheField_setI32(field, -100); mamaFieldCache_applyField(fieldCache, field); // Creating a string field without a value. Even if this field is added to the // cache, it will not be added to the message because we cannot add a NULL // string to a mama message mamaFieldCacheField_create(&field, 110, MAMA_FIELD_TYPE_STRING, NULL); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_create(&field, 90, MAMA_FIELD_TYPE_STRING, NULL); mamaFieldCacheField_setString(field, "hello world", 0); mamaFieldCache_applyField(fieldCache, field); mamaMsg message; mamaMsg_create(&message); // should use add* methods to populate the message because the message is empty mamaFieldCache_getFullMessage(fieldCache, message); mama_bool_t resultBool = 0; ret = mamaMsg_getBool(message, "test_bool", 10, &resultBool); ASSERT_EQ(MAMA_STATUS_OK, ret); mama_f64_t resultF64; ret = mamaMsg_getF64(message, "test_f32", 25, &resultF64); ASSERT_EQ(MAMA_STATUS_NOT_FOUND, ret); mama_i32_t resultI32; ret = mamaMsg_getI32(message, "test_i32", 66, &resultI32); ASSERT_EQ(MAMA_STATUS_OK, ret); const char* resultString; ret = mamaMsg_getString(message, "test_string", 90, &resultString); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_EQ(1, resultBool); ASSERT_DOUBLE_EQ(-100, resultI32); ASSERT_STREQ("hello world", resultString); mamaMsg_destroy (message); ret = mamaFieldCache_destroy(fieldCache); }
TEST_F(MamaFieldCacheTestC, getDeltaMsgTrackingModif) { mama_size_t size = 0; mama_bool_t modified = 0; mamaFieldCache fieldCache = NULL; mama_status ret = mamaFieldCache_create(&fieldCache); // tracking modification state globally at cache level mamaFieldCache_setTrackModified(fieldCache, 1); mamaFieldCacheField field = NULL; // This field must be always published mamaFieldCacheField_create(&field, 66, MAMA_FIELD_TYPE_I32, NULL); mamaFieldCacheField_setI32(field, -100); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Don't check if modified before publishing -> always publish mamaFieldCacheField_setCheckModified(field, 0); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); size = 0; mamaFieldCacheList_getSize(fieldCache->mAlwaysPublishFields, &size); ASSERT_EQ(1, size); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(0, size); mamaMsg message; mamaMsg_create(&message); // reset the modified field and remove from list for field 66 mamaFieldCache_getDeltaMessage(fieldCache, message); mamaMsg_destroy(message); message = NULL; size = 0; mamaFieldCacheList_getSize(fieldCache->mAlwaysPublishFields, &size); ASSERT_EQ(1, size); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(0, size); // This field will be published mamaFieldCacheField_create(&field, 10, MAMA_FIELD_TYPE_BOOL, NULL); mamaFieldCacheField_setBool(field, 1); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Check if modified before publishing mamaFieldCacheField_setCheckModified(field, 1); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(1, size); // This field must never be published because publish is false mamaFieldCacheField_create(&field, 25, MAMA_FIELD_TYPE_F64, NULL); mamaFieldCacheField_setF64(field, 3.1); // Disable publishing mamaFieldCacheField_setPublish(field, 0); // Check modified can be anything - no publishing anyway... see above mamaFieldCacheField_setCheckModified(field, 1); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(1, size); // This field will always be published mamaFieldCacheField_create(&field, 90, MAMA_FIELD_TYPE_STRING, NULL); mamaFieldCacheField_setString(field, "hello world", 0); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Don't check if modified mamaFieldCacheField_setCheckModified(field, 0); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(1, size); // This field will always be published mamaFieldCacheField_create(&field, 91, MAMA_FIELD_TYPE_STRING, NULL); mamaFieldCacheField_setString(field, "hello world again", 0); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Don't check if modified mamaFieldCacheField_setCheckModified(field, 0); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(1, size); mamaMsg_create(&message); mamaFieldCache_getDeltaMessage(fieldCache, message); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(0, size); ASSERT_EQ(MAMA_STATUS_OK, mamaFieldCache_find(fieldCache, 10, "", &field)); mamaFieldCacheField_isModified(field, &modified); ASSERT_FALSE(modified); mama_bool_t resultBool; ret = mamaMsg_getBool(message, "test_bool", 10, &resultBool); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_EQ(1, resultBool); mama_f64_t resultF64; ret = mamaMsg_getF64(message, "test_f32", 25, &resultF64); ASSERT_EQ(MAMA_STATUS_NOT_FOUND, ret); mama_i32_t resultI32; ret = mamaMsg_getI32(message, "test_i32", 66, &resultI32); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_EQ(-100, resultI32); const char* resultString; ret = mamaMsg_getString(message, "test_string", 90, &resultString); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_STREQ("hello world", resultString); ret = mamaMsg_getString(message, "test_string", 91, &resultString); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_STREQ("hello world again", resultString); mamaMsg_destroy (message); ret = mamaFieldCache_destroy(fieldCache); }
mama_status mamaFieldCache_updateCacheFromField(mamaFieldCache fieldCache, const mamaFieldCacheField field) { mama_status ret; mama_fid_t fid; mamaFieldType type; mama_bool_t alreadyModified = 0; const char* name = NULL; mamaFieldCacheField cachedField = NULL; ret = mamaFieldCacheField_getFid(field, &fid); if (ret != MAMA_STATUS_OK) { return ret; } ret = mamaFieldCacheField_getType(field, &type); if (ret != MAMA_STATUS_OK) { return ret; } mamaFieldCacheField_getName(field, &name); if (MAMA_STATUS_OK != mamaFieldCacheMap_find(fieldCache->mMap, fid, type, name, &cachedField)) { ret = mamaFieldCacheField_create(&cachedField, fid, type, NULL); if (ret != MAMA_STATUS_OK) { return ret; } ret = mamaFieldCacheMap_add(fieldCache->mMap, cachedField); if (ret != MAMA_STATUS_OK) { return ret; } fieldCache->mSize++; if (field->mPublish && !field->mCheckModified) { /* Always publish */ mamaFieldCacheList_add(fieldCache->mAlwaysPublishFields, (void*)cachedField); } alreadyModified = 0; } else { alreadyModified = cachedField->mIsModified; } mamaFieldCacheField_copy(field, cachedField); if (cachedField->mPublish && cachedField->mCheckModified && !alreadyModified && fieldCache->mTrackModified) { cachedField->mIsModified = 1; mamaFieldCacheList_add(fieldCache->mModifiedFields, (void*)cachedField); } return ret; }
TEST_F(MamaFieldCacheTestC, getDeltaMsgAlwaysPublishFields) { mama_bool_t modified = 0; mama_size_t numFields = 0; mamaFieldCache fieldCache = NULL; mama_status ret = mamaFieldCache_create(&fieldCache); // tracking modification state globally at cache level mamaFieldCache_setTrackModified(fieldCache, 1); mamaFieldCacheField field = NULL; // This field must be always published mamaFieldCacheField_create(&field, 66, MAMA_FIELD_TYPE_I32, NULL); mamaFieldCacheField_setI32(field, -100); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Don't check if modified before publishing -> always publish mamaFieldCacheField_setCheckModified(field, 0); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); mama_size_t size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(0, size); mamaFieldCacheList_getSize(fieldCache->mAlwaysPublishFields, &size); ASSERT_EQ(1, size); mamaMsg message; mamaMsg_create(&message); mamaFieldCache_getDeltaMessage(fieldCache, message); mamaMsg_getNumFields(message, &numFields); ASSERT_EQ(1, numFields); mamaMsg_destroy(message); message = NULL; mamaMsg_create(&message); ASSERT_EQ(MAMA_STATUS_OK, mamaFieldCache_find(fieldCache, 66, "", &field)); mamaFieldCacheField_isModified(field, &modified); ASSERT_FALSE(modified); mamaFieldCache_getDeltaMessage(fieldCache, message); ASSERT_EQ(MAMA_STATUS_OK, mamaFieldCache_find(fieldCache, 66, "", &field)); mamaFieldCacheField_isModified(field, &modified); ASSERT_FALSE(modified); mama_i32_t resultI32 = 0; ret = mamaMsg_getI32(message, "test_i32", 66, &resultI32); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_EQ(-100, resultI32); mamaMsg_destroy (message); ret = mamaFieldCache_destroy(fieldCache); }
mama_status mamaFieldCacheRecord_add(mamaFieldCacheRecord record, mama_fid_t fid, mamaFieldType type, const char* name, mamaFieldCacheField* field) { if (!record || !field) { return MAMA_STATUS_NULL_ARG; } *field = NULL; mamaFieldCacheVector_grow(record->mFields, record->mSize + 10); mamaFieldCacheField_create(field, fid, type, name); mamaFieldCacheVector_set(record->mFields, record->mSize, *field); record->mSize++; return MAMA_STATUS_OK; }
mama_status mamaFieldCache_updateCacheFromMsgField(mamaFieldCache fieldCache, const mamaMsgField messageField) { mama_status ret; mama_fid_t fid; mamaFieldType type = MAMA_FIELD_TYPE_UNKNOWN; const char* name = NULL; mamaFieldDescriptor descriptor = NULL; mamaFieldCacheField field = NULL; ret = mamaMsgField_getFid(messageField, &fid); if (ret != MAMA_STATUS_OK) { return ret; } if (MAMA_STATUS_OK != mamaFieldCacheMap_find(fieldCache->mMap, fid, type, name, &field)) { ret = mamaMsgField_getType(messageField, &type); if (ret != MAMA_STATUS_OK) { return ret; } if (fieldCache->mUseFieldNames) { mamaMsgField_getName(messageField, &name); } mamaFieldCacheField_create(&field, fid, type, name); ret = mamaFieldCacheMap_add(fieldCache->mMap, field); if (ret != MAMA_STATUS_OK) { return ret; } fieldCache->mSize++; mamaMsgField_getDescriptor(messageField, &descriptor); if (descriptor) { mamaFieldCacheField_setDescriptor(field, descriptor); } } else { type = field->mType; } if (fieldCache->mTrackModified && field->mPublish && !field->mIsModified) { field->mIsModified = 1; mamaFieldCacheList_add(fieldCache->mModifiedFields, (void*)field); } switch (type) { case MAMA_FIELD_TYPE_BOOL: { mama_bool_t result; mamaMsgField_getBool(messageField, &result); mamaFieldCacheField_setBool(field, result); break; } case MAMA_FIELD_TYPE_CHAR: { char value; mamaMsgField_getChar(messageField, &value); mamaFieldCacheField_setChar(field, value); break; } case MAMA_FIELD_TYPE_I8: { mama_i8_t value; mamaMsgField_getI8(messageField, &value); mamaFieldCacheField_setI8(field, value); break; } case MAMA_FIELD_TYPE_U8: { mama_u8_t value; mamaMsgField_getU8(messageField, &value); mamaFieldCacheField_setU8(field, value); break; } case MAMA_FIELD_TYPE_I16: { mama_i16_t value; mamaMsgField_getI16(messageField, &value); mamaFieldCacheField_setI16(field, value); break; } case MAMA_FIELD_TYPE_U16: { mama_u16_t value; mamaMsgField_getU16(messageField, &value); mamaFieldCacheField_setU16(field, value); break; } case MAMA_FIELD_TYPE_I32: { mama_i32_t value; mamaMsgField_getI32(messageField, &value); mamaFieldCacheField_setI32(field, value); break; } case MAMA_FIELD_TYPE_U32: { mama_u32_t value; mamaMsgField_getU32(messageField, &value); mamaFieldCacheField_setU32(field, value); break; } case MAMA_FIELD_TYPE_I64: { mama_i64_t value; mamaMsgField_getI64(messageField, &value); mamaFieldCacheField_setI64(field, value); break; } case MAMA_FIELD_TYPE_U64: { mama_u64_t value; mamaMsgField_getU64(messageField, &value); mamaFieldCacheField_setU64(field, value); break; } case MAMA_FIELD_TYPE_F32: { mama_f32_t value; mamaMsgField_getF32(messageField, &value); mamaFieldCacheField_setF32(field, value); break; } case MAMA_FIELD_TYPE_QUANTITY: case MAMA_FIELD_TYPE_F64: { mama_f64_t value; mamaMsgField_getF64(messageField, &value); mamaFieldCacheField_setF64(field, value); break; } case MAMA_FIELD_TYPE_STRING: { const char* value = NULL; mamaMsgField_getString(messageField, &value); mamaFieldCacheField_setString(field, value, 0); break; } case MAMA_FIELD_TYPE_PRICE: { mamaMsgField_getPrice(messageField, fieldCache->mReusablePrice); mamaFieldCacheField_setPrice(field, fieldCache->mReusablePrice); break; } case MAMA_FIELD_TYPE_TIME: { mamaMsgField_getDateTime(messageField, fieldCache->mReusableDateTime); mamaFieldCacheField_setDateTime(field, fieldCache->mReusableDateTime); break; } case MAMA_FIELD_TYPE_VECTOR_I8: { const mama_i8_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorI8(messageField, &values, &size); mamaFieldCacheField_setI8Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_U8: { const mama_u8_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorU8(messageField, &values, &size); mamaFieldCacheField_setU8Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_I16: { const mama_i16_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorI16(messageField, &values, &size); mamaFieldCacheField_setI16Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_U16: { const mama_u16_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorU16(messageField, &values, &size); mamaFieldCacheField_setU16Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_I32: { const mama_i32_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorI32(messageField, &values, &size); mamaFieldCacheField_setI32Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_U32: { const mama_u32_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorU32(messageField, &values, &size); mamaFieldCacheField_setU32Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_I64: { const mama_i64_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorI64(messageField, &values, &size); mamaFieldCacheField_setI64Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_U64: { const mama_u64_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorU64(messageField, &values, &size); mamaFieldCacheField_setU64Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_F32: { const mama_f32_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorF32(messageField, &values, &size); mamaFieldCacheField_setF32Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_F64: { const mama_f64_t* values = NULL; mama_size_t size = 0; mamaMsgField_getVectorF64(messageField, &values, &size); mamaFieldCacheField_setF64Vector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_STRING: { const char** values = NULL; mama_size_t size = 0; mamaMsgField_getVectorString(messageField, &values, &size); mamaFieldCacheField_setStringVector(field, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_PRICE: { /* TODO: mamaMsgField does not provide methods to get price vector const mamaPrice* values = NULL; mama_size_t size; mamaMsgField_getVectorPrice(messageField, &values, &size); mamaFieldCacheField_setPriceVector(field, values, size); */ break; } case MAMA_FIELD_TYPE_VECTOR_TIME: { /* TODO: mamaMsgField does not provide methods to get time vector const mamaDateTime* values = NULL; mama_size_t size; mamaMsgField_getVectorDateTime(messageField, &values, &size); mamaFieldCacheField_setDateTimeVector(field, values, size); */ break; } default: break; } return ret; }
TEST_F(MamaFieldCacheTestC, getDeltaMsgMultipleUpdates) { mama_size_t size = 0; mama_bool_t modified = 0; mamaFieldCache fieldCache = NULL; mama_status ret = mamaFieldCache_create(&fieldCache); // tracking modification state globally at cache level // mamaFieldCache_setTrackModified(fieldCache, 1); mamaFieldCacheField field = NULL; mamaFieldCacheField_create(&field, 66, MAMA_FIELD_TYPE_I32, NULL); mamaFieldCacheField_setI32(field, -100); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Check if modified before publishing mamaFieldCacheField_setCheckModified(field, 1); mamaFieldCache_applyField(fieldCache, field); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(1, size); // apply a second time before getDeltaMsg is called mamaFieldCacheField_setI32(field, 80); mamaFieldCache_applyField(fieldCache, field); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(1, size); mamaFieldCacheField_destroy(field); // This field must never be published because publish is false mamaFieldCacheField_create(&field, 25, MAMA_FIELD_TYPE_F64, NULL); mamaFieldCacheField_setF64(field, 3.1); // Disable publishing mamaFieldCacheField_setPublish(field, 0); // Check modified can be anything - no publishing anyway... see above mamaFieldCacheField_setCheckModified(field, 1); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(1, size); size = 0; mamaFieldCacheList_getSize(fieldCache->mModifiedFields, &size); ASSERT_EQ(1, size); mamaMsg message = NULL; mamaMsg_create(&message); mamaFieldCache_getDeltaMessage(fieldCache, message); ASSERT_EQ(MAMA_STATUS_OK, mamaFieldCache_find(fieldCache, 66, "", &field)); mamaFieldCacheField_isModified(field, &modified); ASSERT_FALSE(modified); mama_i32_t resultI32 = 0; ret = mamaMsg_getI32(message, "test_i32", 66, &resultI32); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_EQ(80, resultI32); mama_f64_t resultF64; ret = mamaMsg_getF64(message, "test_f32", 25, &resultF64); ASSERT_EQ(MAMA_STATUS_NOT_FOUND, ret); mamaMsg_destroy (message); ret = mamaFieldCache_destroy(fieldCache); }
TEST_F(MamaFieldCacheTestC, getDeltaMsgNotTrackingModif) { mama_bool_t modified = 0; mamaFieldCache fieldCache = NULL; mama_status ret = mamaFieldCache_create(&fieldCache); // setting explicitely to non-tracking mode mamaFieldCache_setTrackModified(fieldCache, 0); // This field will be published mamaFieldCacheField field = NULL; mamaFieldCacheField_create(&field, 10, MAMA_FIELD_TYPE_BOOL, NULL); mamaFieldCacheField_setBool(field, 1); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Check if modified before publishing - who cares... global check modified is disabled mamaFieldCacheField_setCheckModified(field, 1); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); // This field will not be published mamaFieldCacheField_create(&field, 25, MAMA_FIELD_TYPE_F64, NULL); mamaFieldCacheField_setF64(field, 3.1); // Disable publishing mamaFieldCacheField_setPublish(field, 0); // Check modified can be anything - no publishing anyway... see above mamaFieldCacheField_setCheckModified(field, 1); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); // This field will be published mamaFieldCacheField_create(&field, 66, MAMA_FIELD_TYPE_I32, NULL); mamaFieldCacheField_setI32(field, -100); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Check if modified - who cares... global check modified is disabled mamaFieldCacheField_setCheckModified(field, 1); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); // This field will be published mamaFieldCacheField_create(&field, 90, MAMA_FIELD_TYPE_STRING, NULL); mamaFieldCacheField_setString(field, "hello world", 0); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Don't check if modified - who cares... global check modified is disabled mamaFieldCacheField_setCheckModified(field, 0); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); // This field will be published mamaFieldCacheField_create(&field, 91, MAMA_FIELD_TYPE_STRING, NULL); mamaFieldCacheField_setString(field, "hello world again", 0); // Enable publishing mamaFieldCacheField_setPublish(field, 1); // Don't check if modified - who cares... global check modified is disabled mamaFieldCacheField_setCheckModified(field, 1); mamaFieldCache_applyField(fieldCache, field); mamaFieldCacheField_destroy(field); mamaMsg message; mamaMsg_create(&message); // This results in a Full message because track modified is false mamaFieldCache_getDeltaMessage(fieldCache, message); ASSERT_EQ(MAMA_STATUS_OK, mamaFieldCache_find(fieldCache, 10, "", &field)); mamaFieldCacheField_isModified(field, &modified); // The modified flag is not modified if the cache is not tracking modifications ASSERT_FALSE(modified); mama_bool_t resultBool; ret = mamaMsg_getBool(message, "test_bool", 10, &resultBool); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_EQ(1, resultBool); mama_f64_t resultF64; ret = mamaMsg_getF64(message, "test_f32", 25, &resultF64); ASSERT_EQ(MAMA_STATUS_NOT_FOUND, ret); mama_i32_t resultI32; ret = mamaMsg_getI32(message, "test_i32", 66, &resultI32); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_EQ(-100, resultI32); const char* resultString; ret = mamaMsg_getString(message, "test_string", 90, &resultString); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_STREQ("hello world", resultString); ret = mamaMsg_getString(message, "test_string", 91, &resultString); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_STREQ("hello world again", resultString); mamaMsg_destroy (message); ret = mamaFieldCache_destroy(fieldCache); }
TEST_F(MamaFieldCacheTestC, applyFieldNew) { mama_status ret = MAMA_STATUS_OK; mamaFieldCache fieldCache = NULL; mamaFieldCacheField cachedField = NULL; mama_size_t size = 0; mama_bool_t boolValue = 0; mamaFieldCache_create(&fieldCache); mamaFieldCacheField field1 = NULL; mamaFieldCacheField_create(&field1, 2, MAMA_FIELD_TYPE_F32, NULL); mamaFieldCacheField_setF32(field1, 13.13); mamaFieldCacheField_setPublish(field1, 1); mamaFieldCacheField_setCheckModified(field1, 1); mamaFieldCache_getSize(fieldCache, &size); ASSERT_EQ(0, size); mamaFieldCache_applyField(fieldCache, field1); mamaFieldCache_getSize(fieldCache, &size); ASSERT_EQ(1, size); ret = mamaFieldCache_find(fieldCache, 2, NULL, &cachedField); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_TRUE(cachedField != NULL); mamaFieldCacheField_getPublish(cachedField, &boolValue); ASSERT_EQ(1, boolValue); boolValue = 0; mamaFieldCacheField_getCheckModified(cachedField, &boolValue); ASSERT_EQ(1, boolValue); boolValue = 0; mamaFieldCacheField_isModified(cachedField, &boolValue); ASSERT_EQ(1, boolValue); mamaFieldCacheField field2 = NULL; mamaFieldCacheField_create(&field2, 4, MAMA_FIELD_TYPE_I32, "name4"); mamaFieldCacheField_setI32(field2, 321); mamaFieldCacheField_setPublish(field2, 0); mamaFieldCacheField_setCheckModified(field2, 0); mamaFieldCache_applyField(fieldCache, field2); mamaFieldCache_getSize(fieldCache, &size); ASSERT_EQ(2, size); cachedField = NULL; ret = mamaFieldCache_find(fieldCache, 4, "", &cachedField); ASSERT_TRUE(cachedField != NULL); ASSERT_EQ(MAMA_STATUS_OK, ret); boolValue = 0; mamaFieldCacheField_getPublish(cachedField, &boolValue); ASSERT_EQ(0, boolValue); boolValue = 0; mamaFieldCacheField_getCheckModified(cachedField, &boolValue); ASSERT_EQ(0, boolValue); boolValue = 0; mamaFieldCacheField_isModified(cachedField, &boolValue); ASSERT_EQ(0, boolValue); const char* cachedName = NULL; ret = mamaFieldCacheField_getName(cachedField, &cachedName); ASSERT_EQ(MAMA_STATUS_OK, ret); ASSERT_TRUE(cachedName != NULL); ASSERT_STREQ("name4", cachedName); mamaFieldCacheField_destroy(field1); mamaFieldCacheField_destroy(field2); mamaFieldCache_destroy(fieldCache); }