/* Description: Use the price API to copy a mama price object to a second mama price object.
* Both objects must have different values and precision hints before the copy
* Both objects must have identical values and precision hints after the copy
* Test for all combinations of valid and invalid input parameters
*
* Expected Failures : NULL Price to NULL Price - MAMA STATUS INVALID ARGUMENT
* : NULL Price to Valid Price - MAMA STATUS INVALID ARGUMENT
* : Valid Price to NULL Price - MAMA STATUS INVALID ARGUMENT
*
* Expected Passes : Valid Price to Valid Price - MAMA STATUS OK && value & hints are equal
*
*/
TEST_F (MamaPriceTestC, testCopyMamaPrice)
{
double x = 100,
y = 200;
mama_price_hints_t hint1 = MAMA_PRICE_IMPL_HINT_PREC_10,
hint2 = MAMA_PRICE_IMPL_HINT_PREC_2;
mamaPrice price1 = CreateTestPrice(x, hint1),
price2 = CreateTestPrice(y, hint2),
nullPrice = NULL;
EXPECT_FALSE ( ArePricesEqual(price1,price2) );
EXPECT_FALSE ( ArePricesEqual(price2,price1) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_copy(nullPrice,nullPrice) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_copy(nullPrice,price2) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_copy(price1,nullPrice) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_copy(price2,price1) );
EXPECT_TRUE ( ArePricesEqual(price1,price2) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price2) );
}
/* Description: Use the price API to add a subtract a price object from a second mama price object
* Both objects must have different values before the subtraction
* Both objects must have identical precision hints before the subtraction
* Test for all combinations of valid and invalid input parameters
*
* Expected Failures : NULL Price to NULL Price - MAMA STATUS INVALID ARGUMENT
* : NULL Price to Valid Price - MAMA STATUS INVALID ARGUMENT
* : Valid Price to NULL Price - MAMA STATUS INVALID ARGUMENT
*
* Expected Passes : Valid Price to Valid Price - MAMA STATUS OK &&
* value & hints are equal to the expected result
*
*/
TEST_F (MamaPriceTestC, testSubtractMamaPrice)
{
double x = 100,
y = 200,
z = x - y;
mama_price_hints_t hint = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPrice price1 = CreateTestPrice(x,hint),
price2 = CreateTestPrice(y,hint),
expectedPrice = CreateTestPrice(z,hint),
nullPrice = NULL;
EXPECT_FALSE ( ArePricesEqual(price1,price2) );
EXPECT_FALSE ( ArePricesEqual(price1,expectedPrice) );
EXPECT_FALSE ( ArePricesEqual(price2,expectedPrice) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_subtract(nullPrice,nullPrice) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_subtract(price1,nullPrice) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_subtract(nullPrice,price2) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_subtract(price1,price2) );
EXPECT_TRUE ( ArePricesEqual(price1,expectedPrice) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price2) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(expectedPrice) );
}
/* Description: Use the price API to test for equality between 2 different price objects
* Test for all combinations of valid and invalid input parameters
* Note that comparing 2 NULL prices is a pass
*
* Expected Failures :
* : NULL Price to Valid Price - MAMA STATUS INVALID ARGUMENT
* : Valid Price to NULL Price - MAMA STATUS INVALID ARGUMENT
*
* Expected Passes : true - value & hints are identical
* : false - value & hints are not identical
*
*/
TEST_F (MamaPriceTestC, testEqualMamaPrice)
{
double x = 100,
y = 100,
z = 300;
double eq = 1,
neq = 0;
mama_price_hints_t hints = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPrice price1 = CreateTestPrice(x,hints),
price2 = CreateTestPrice(y,hints),
price3 = CreateTestPrice(z,hints),
nullPrice = NULL;
EXPECT_EQ ( neq, mamaPrice_equal(price1,nullPrice) );
EXPECT_EQ ( neq, mamaPrice_equal(nullPrice,price1) );
EXPECT_EQ ( eq, mamaPrice_equal(nullPrice,nullPrice) );
EXPECT_EQ ( eq, mamaPrice_equal(price1,price1) );
EXPECT_EQ ( eq, mamaPrice_equal(price1,price2) );
EXPECT_EQ ( neq, mamaPrice_equal(price1,price3) );
EXPECT_EQ ( neq, mamaPrice_equal(price3,price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price2) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price3) );
}
/* Description: Use the price API to compare 2 different price objects
* Upon successful completion, the fuction will return the difference between
* the values of both objects.
* The test will include scenarios wehre the difference is positive and negative.
* Both objects must have identical values before the comparison
*
* Known Issues : NULL PRice to NULL PRice - Core
* : NULL Price to Valid Price - Core
* : Valid Price to NULL Price - Core
*
* Expected Passes : return the difference between both
* : false - value & hints are not identical
*
*/
TEST_F (MamaPriceTestC, testCompareMamaPrice)
{
double x = 100,
y = 200;
double r0 = 0,
r1 = x - y,
r2 = y - x;
mama_price_hints_t hints = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPrice price1 = CreateTestPrice(x,hints),
price2 = CreateTestPrice(y,hints);
// TOTO -= Bug in compare method. App crashes when NULL Prices are passed in
// EXPECT_EQ ( r0, mamaPrice_compare(nullPrice, nullPrice) );
// EXPECT_EQ ( r1, mamaPrice_compare(nullPrice, price2) );
// EXPECT_EQ ( r2, mamaPrice_compare(price2, nullPrice) );
EXPECT_EQ ( r0, mamaPrice_compare(price1, price1) );
EXPECT_EQ ( r1, mamaPrice_compare(price1, price2) );
EXPECT_EQ ( r2, mamaPrice_compare(price2, price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price2) );
}
/* Description: Use the price API to create and destroy a simple price object.
* Use the price API to destroy a NULL price Object
*
* Expected Result: create a valid price - MAMA STATUS OK
* Expected Result: destroy a valid price - MAMA STATUS OK
* Expected Result: destroy a NULL price - MAMA STATUS INVALID ARGUMENT
*/
TEST_F (MamaPriceTestC, testCreateAndDestroyMamaPrice)
{
mamaPrice price,
nullPrice = NULL;
// Test Create and Destroy with a good price object
ASSERT_EQ ( MAMA_STATUS_OK, mamaPrice_create(&price) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
// Test Destroy with NULL price objects
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_destroy(nullPrice) );
}
TEST_F (MamaPriceTestC, testSetIsValidPriceMamaPrice)
{
double x = 100.1;
mama_price_hints_t hints = MAMA_PRICE_IMPL_HINT_PREC_10;
mama_bool_t t = true,
f = false,
expected;
mamaPrice price = CreateTestPrice(x,hints),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_setIsValidPrice(nullPrice, t) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_setIsValidPrice(nullPrice, f) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_setIsValidPrice(price, t) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getIsValidPrice(price, &expected) );
EXPECT_NE ( f, expected );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_setIsValidPrice(price, f) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getIsValidPrice(price, &expected) );
EXPECT_EQ ( f, expected );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
TEST_F (MamaPriceTestC, testGetWithHintsMamaPrice)
{
double x = 100;
mamaPricePrecision precision = MAMA_PRICE_PREC_DIV_8;
mama_price_hints_t hint = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPrice price = CreateTestPrice(x,hint),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getWithHints(nullPrice, NULL, NULL) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getWithHints(nullPrice, NULL, &precision) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getWithHints(nullPrice, &x, NULL) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getWithHints(nullPrice, &x, &precision) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getWithHints(price, NULL, NULL) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getWithHints(price, NULL, &precision) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getWithHints(price, &x, NULL) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getWithHints(price, &x, &precision) );
EXPECT_EQ ( MAMA_PRICE_PREC_10, precision) ;
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
void MamaPriceTestC::TearDown(void)
{
/* Delete the price */
if(m_price != NULL)
{
ASSERT_EQ (mamaPrice_destroy (m_price), MAMA_STATUS_OK);
}
}
mama_status mamaFieldCacheField_destroy(mamaFieldCacheField field)
{
if (!field)
{
return MAMA_STATUS_NULL_ARG;
}
if (field->mName)
{
free((void*)field->mName);
}
if (field->mDataSize)
{
free(field->mData.data);
}
else
{
switch (field->mType)
{
case MAMA_FIELD_TYPE_PRICE:
mamaPrice_destroy((mamaPrice)field->mData.data);
break;
case MAMA_FIELD_TYPE_TIME:
mamaDateTime_destroy((mamaDateTime)field->mData.data);
break;
case MAMA_FIELD_TYPE_VECTOR_STRING:
if (field->mData.data)
{
mamaFieldCacheVector_free((mamaFieldCacheVector)field->mData.data);
mamaFieldCacheVector_destroy((mamaFieldCacheVector)field->mData.data);
}
break;
case MAMA_FIELD_TYPE_VECTOR_PRICE:
if (field->mData.data)
{
mamaFieldCacheField_destroyPriceVector(
(mamaFieldCacheVector)field->mData.data);
}
break;
case MAMA_FIELD_TYPE_VECTOR_TIME:
if (field->mData.data)
{
mamaFieldCacheField_destroyDateTimeVector(
(mamaFieldCacheVector)field->mData.data);
}
break;
default:
break;
}
}
free(field);
return MAMA_STATUS_OK;
}
TEST_F (MamaPriceTestC, testNegateMamaPrice)
{
double x = 100;
mama_price_hints_t hint = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPrice price1 = CreateTestPrice(x,hint),
price2 = CreateTestPrice(x * -1,hint),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_negate(nullPrice) );
EXPECT_FALSE ( ArePricesEqual(price2,price1) );
EXPECT_FALSE ( ArePricesEqual(price1,price2) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_negate(price1) );
EXPECT_TRUE ( ArePricesEqual(price1,price2) );
EXPECT_TRUE ( ArePricesEqual(price2,price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price2) );
}
TEST_F (MamaPriceTestC, testIsZeroMamaPrice)
{
double x = 100,
y = 0;
mama_price_hints_t hint = MAMA_PRICE_IMPL_HINT_PREC_10;
mama_bool_t b;
mamaPrice price1 = CreateTestPrice(x,hint),
price2 = CreateTestPrice(y,hint),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_isZero(nullPrice, &b) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_isZero(price1, &b) );
EXPECT_FALSE (b);
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_isZero(price2, &b) );
EXPECT_TRUE (b);
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price1) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price2) );
}
/* Description: Create a price
* Clear the price
* Destroy the price.
*
* Expected Result: valid price.- MAMA STATUS OK
* Expected Result: NULL price - MAMA STATUS INVALID ARGUMENT
*/
TEST_F (MamaPriceTestC, testClearMamaPrice)
{
double x = 100;
mama_price_hints_t hint = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPrice price = CreateTestPrice(x, hint),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_clear(nullPrice) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_clear(price) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
mama_status
mamaFieldCacheField_destroyPriceVector(mamaFieldCacheVector priceVector)
{
mama_size_t i;
mama_size_t size = 0;
void* price = NULL;
mamaFieldCacheVector_getSize(priceVector, &size);
for (i = 0; i < size; i++)
{
mamaFieldCacheVector_get(priceVector, i, &price);
mamaPrice_destroy((mamaPrice)price);
}
mamaFieldCacheVector_destroy(priceVector);
return MAMA_STATUS_OK;
}
TEST_F (MamaPriceTestC, testSetWithHintsMamaPrice)
{
double x = 100;
mama_price_hints_t hint1 = MAMA_PRICE_IMPL_HINT_PREC_10,
hint2 = MAMA_PRICE_IMPL_HINT_PREC_2;
mamaPrice price = CreateTestPrice(x,hint1),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_setWithHints(nullPrice, x, hint2) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_setWithHints(price, x, hint2) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
TEST_F (MamaPriceTestC, testGetValueMamaPrice)
{
double x = 100,
val;
mama_price_hints_t hint = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPrice price = CreateTestPrice(x,hint),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getValue(nullPrice, &val) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getValue(price, NULL) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getValue(price, &val) );
EXPECT_EQ ( val, x);
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
/* Description: Use the price API to set the value of a price object
* Upon successful completion, the fuction will set the value attribute of the price
* object to the input value.
*
* Expected Failures : NULL Price - MAMA STATUS INVALID ARG
*
* Expected Passes : With a valid price and value, the function retuns MAMA STATUS OK and updates
* : the value attribute of the price to the new value
*
*/
TEST_F (MamaPriceTestC, testSetValueMamaPrice)
{
double x = 100,
y = 200;
mama_price_hints_t hints = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPrice price = CreateTestPrice(x,hints),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_setValue(nullPrice, x) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_setValue(price, y) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getValue(price, &x) );
EXPECT_EQ ( x, y );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
TEST_F (MamaPriceTestC, testGetAsStringMamaPrice)
{
double x = 1.1234567890;
mama_size_t size = 20;
char buff[20];
mama_price_hints_t hint = MAMA_PRICE_IMPL_HINT_PREC_10000000000;
mamaPrice price = CreateTestPrice(x,hint),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getAsString(nullPrice, NULL, size) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getAsString(nullPrice, buff, size) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getAsString(price, NULL, size) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getAsString(price, buff, size) );
EXPECT_STREQ ( "1.1234567890", buff );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
TEST_F (MamaPriceTestC, testGetIsValidPriceMamaPrice)
{
double x = 100;
mama_price_hints_t hints = MAMA_PRICE_IMPL_HINT_PREC_10;
mama_bool_t b;
mamaPrice price = CreateTestPrice(x,hints),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getIsValidPrice(nullPrice, NULL) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getIsValidPrice(nullPrice, &b) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getIsValidPrice(price, NULL) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getIsValidPrice(price, &b) );
EXPECT_FALSE ( b );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
TEST_F (MamaPriceTestC, testGetPrecisionMamaPrice)
{
double x = 100;
mama_price_hints_t hints = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPricePrecision precision2;
mamaPrice price = CreateTestPrice(x,hints),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getPrecision(nullPrice, NULL) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getPrecision(nullPrice, &precision2) );
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_getPrecision(price, NULL) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getPrecision(price, &precision2) );
EXPECT_EQ ( MAMA_PRICE_PREC_10, precision2 );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
/* Description: Use the price API to set the precision of a price object
* Upon successful completion, the fuction will set the hintw attribute of the price
* object to the input value.
*
* Expected Failures : NULL Price - MAMA STATUS INVALID ARG
*
* Expected Passes : With a valid price and precision, the function retuns MAMA STATUS OK and updates
* : the value attribute of the price to the new value
*
*/
TEST_F (MamaPriceTestC, testSetPrecisionMamaPrice)
{
double x = 100;
mama_price_hints_t hints = MAMA_PRICE_IMPL_HINT_PREC_10;
mamaPricePrecision precision = MAMA_PRICE_PREC_DIV_8,
expectedPrecision;
mamaPrice price = CreateTestPrice(x,hints),
nullPrice = NULL;
EXPECT_EQ ( MAMA_STATUS_INVALID_ARG, mamaPrice_setPrecision(nullPrice, precision) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_setPrecision(price, precision) );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_getPrecision(price, &expectedPrecision) );
EXPECT_EQ ( precision, expectedPrecision );
EXPECT_EQ ( MAMA_STATUS_OK, mamaPrice_destroy(price) );
}
void populateMessageFromDictionary (mamaDictionaryImpl* impl,
mamaMsg msg)
{
int i = 0;
mama_status status = MAMA_STATUS_OK;
const mama_bool_t bool_vector[] = {0};
const char char_vector[] = {' '};
const mama_i8_t i8_vector[] = {1};
const mama_u8_t u8_vector[] = {1};
const mama_i16_t i16_vector[] = {1};
const mama_u16_t u16_vector[] = {1};
const mama_i32_t i32_vector[] = {1};
const mama_u32_t u32_vector[] = {1};
const mama_i64_t i64_vector[] = {1};
const mama_u64_t u64_vector[] = {1};
const mama_f32_t f32_vector[] = {1.0f};
const mama_f64_t f64_vector[] = {1.0};
const char* string_vector[] = {" "};
mamaMsg msgArray[1];
mamaMsg tempMsg = NULL;
mamaPrice price_vector[1];
mamaPrice price = NULL;
mamaDateTime dateTime_vector[1];
mamaDateTime dateTime = NULL;
mamaMsg_create (&tempMsg);
mamaMsg_addI32 (tempMsg, NULL, 1, 0);
msgArray[0] = tempMsg;
mamaPrice_create (&price);
mamaPrice_setValue (price,123.45);
price_vector[0] = price;
mamaDateTime_create (&dateTime);
mamaDateTime_setToNow (dateTime);
dateTime_vector[0] = dateTime;
for (i=0;i<impl->mDictSize;i++)
{
if (impl->mDict[i])
{
mamaFieldDescriptor fd = impl->mDict[i];
mama_fid_t fid = mamaFieldDescriptor_getFid (fd);
const char* name = mamaFieldDescriptor_getName (fd);
mamaFieldType type = mamaFieldDescriptor_getType (fd);
switch (type)
{
case MAMA_FIELD_TYPE_MSG:
ADD_TO_DICT (Msg, tempMsg);
break;
case MAMA_FIELD_TYPE_OPAQUE:
mamaMsg_addOpaque (msg, name, fid, (void*)" ", 2);
break;
case MAMA_FIELD_TYPE_STRING:
ADD_TO_DICT (String, "");
break;
case MAMA_FIELD_TYPE_BOOL:
ADD_TO_DICT (Bool, 0);
break;
case MAMA_FIELD_TYPE_CHAR:
ADD_TO_DICT (Char, ' ');
break;
case MAMA_FIELD_TYPE_I8:
ADD_TO_DICT (I8, 0);
break;
case MAMA_FIELD_TYPE_U8:
ADD_TO_DICT (U8, 0);
break;
case MAMA_FIELD_TYPE_I16:
ADD_TO_DICT (I16, 0);
break;
case MAMA_FIELD_TYPE_U16:
ADD_TO_DICT (U16, 0);
break;
case MAMA_FIELD_TYPE_I32:
ADD_TO_DICT (I32, 0);
break;
case MAMA_FIELD_TYPE_U32:
ADD_TO_DICT (U32, 0);
break;
case MAMA_FIELD_TYPE_I64:
ADD_TO_DICT (I64, 0);
break;
case MAMA_FIELD_TYPE_U64:
ADD_TO_DICT (U64, 0);
break;
case MAMA_FIELD_TYPE_F32:
ADD_TO_DICT (F32, 0.0f);
break;
case MAMA_FIELD_TYPE_F64:
ADD_TO_DICT (F64, 0.0);
break;
case MAMA_FIELD_TYPE_TIME:
ADD_TO_DICT (DateTime, dateTime);
break;
case MAMA_FIELD_TYPE_PRICE:
ADD_TO_DICT (Price, price);
break;
case MAMA_FIELD_TYPE_VECTOR_BOOL:
ADD_VECTOR_TO_DICT (Bool, bool_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_CHAR:
ADD_VECTOR_TO_DICT (Char, char_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_I8:
ADD_VECTOR_TO_DICT (I8, i8_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_U8:
ADD_VECTOR_TO_DICT (U8, u8_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_I16:
ADD_VECTOR_TO_DICT (I16, i16_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_U16:
ADD_VECTOR_TO_DICT (U16, u16_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_I32:
ADD_VECTOR_TO_DICT (I32, i32_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_U32:
ADD_VECTOR_TO_DICT (U32, u32_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_I64:
ADD_VECTOR_TO_DICT (I64, i64_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_U64:
ADD_VECTOR_TO_DICT (U64, u64_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_F32:
ADD_VECTOR_TO_DICT (F32, f32_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_F64:
ADD_VECTOR_TO_DICT (F64, f64_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_STRING:
ADD_VECTOR_TO_DICT (String, string_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_MSG:
ADD_VECTOR_TO_DICT (Msg, msgArray);
break;
case MAMA_FIELD_TYPE_VECTOR_TIME:
ADD_VECTOR_TO_DICT (DateTime, dateTime_vector);
break;
case MAMA_FIELD_TYPE_VECTOR_PRICE:
ADD_VECTOR_TO_DICT (Price, price_vector);
break;
default:
/* error with unknown type */
mama_log (MAMA_LOG_LEVEL_NORMAL, "Could not add type to "
"dict message - not supported. [%s] fid=%d name=%s",
mamaFieldTypeToString (type), fid, name);
break;
}
}
}
mamaPrice_destroy (price);
mamaDateTime_destroy (dateTime);
mamaMsg_destroy (tempMsg);
}
