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);
}
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 mamaFieldCacheMapArray_clear(mamaFieldCacheMap map)
{
int i;
/* Cast the map to an array map. */
mamaFieldCacheMapArray arrayMap = (mamaFieldCacheMapArray)map;
for (i = 0; i < arrayMap->mSize; i++)
{
mamaFieldCacheField field = arrayMap->mFieldArray[i];
if (field)
{
mamaFieldCacheField_destroy(field);
arrayMap->mFieldArray[i] = NULL;
}
}
return MAMA_STATUS_OK;
}
mama_status mamaFieldCacheRecord_clear(mamaFieldCacheRecord record)
{
int i;
void* field = NULL;
if (!record)
{
return MAMA_STATUS_NULL_ARG;
}
for (i = 0; i < record->mSize; i++)
{
mamaFieldCacheVector_get(record->mFields, i, &field);
mamaFieldCacheField_destroy((mamaFieldCacheField)field);
mamaFieldCacheVector_set(record->mFields, i, NULL);
}
record->mSize = 0;
return MAMA_STATUS_OK;
}
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);
}
