TEST_F(MamaFieldCacheFieldTypesTest, testWrongType)
{
MamaFieldCacheField fieldBase;
fieldBase.create(1, MAMA_FIELD_TYPE_BOOL);
MamaFieldCacheFieldChar charField;
ASSERT_THROW(charField.set(fieldBase, 'i'), std::invalid_argument);
MamaFieldCacheFieldI8 i8Field;
ASSERT_THROW(i8Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldU8 u8Field;
ASSERT_THROW(u8Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldI16 i16Field;
ASSERT_THROW(i16Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldU16 u16Field;
ASSERT_THROW(u16Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldI32 i32Field;
ASSERT_THROW(i32Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldU32 u32Field;
ASSERT_THROW(u32Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldI64 i64Field;
ASSERT_THROW(i64Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldU64 u64Field;
ASSERT_THROW(u64Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldF32 f32Field;
ASSERT_THROW(f32Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldF64 f64Field;
ASSERT_THROW(f64Field.set(fieldBase, 3), std::invalid_argument);
MamaFieldCacheFieldString stringField;
ASSERT_THROW(stringField.set(fieldBase, "hi"), std::invalid_argument);
MamaFieldCacheFieldPrice priceField;
ASSERT_THROW(priceField.set(fieldBase, MamaPrice()), std::invalid_argument);
MamaFieldCacheFieldDateTime dateTimeField;
ASSERT_THROW(dateTimeField.set(fieldBase, MamaDateTime()), std::invalid_argument);
}
TEST_F(MamaFieldCacheFieldTypesTest, testString)
{
MamaFieldCacheField fieldBase;
fieldBase.create(1, MAMA_FIELD_TYPE_STRING, "");
MamaFieldCacheFieldString field;
const char* value;
const char* cstr = "abc";
field.set(fieldBase, cstr);
ASSERT_STREQ("abc", field.get(fieldBase));
getFieldValue(fieldBase, value);
ASSERT_STREQ("abc", value);
cstr = "cba1";
setFieldValue(fieldBase, cstr);
const char* res;
res = field.get(fieldBase);
ASSERT_STREQ(cstr, res);
getFieldValue(fieldBase, value);
ASSERT_STREQ("cba1", value);
}
TEST_F(MamaFieldCacheRecordTest, find)
{
MamaFieldCacheRecord record;
record.create();
const MamaFieldCacheField& fieldNotFound = record.find(1);
ASSERT_EQ(0, fieldNotFound.getFid());
ASSERT_EQ(MAMA_FIELD_TYPE_UNKNOWN, fieldNotFound.getType());
MamaFieldCacheField& newField =
record.add(1, MAMA_FIELD_TYPE_STRING, "MamaFieldCacheRecordTest.find");
MamaFieldCacheFieldString stringField;
stringField.set(newField, "hello");
MamaFieldCacheField& fieldFound = record.find(1);
ASSERT_EQ(1, fieldFound.getFid());
ASSERT_EQ(MAMA_FIELD_TYPE_STRING, fieldFound.getType());
ASSERT_STREQ("MamaFieldCacheRecordTest.find", fieldFound.getName());
ASSERT_EQ(std::string("hello"), stringField.get(fieldFound));
}
TEST_F(MamaFieldCacheFieldTypesTest, testFromString)
{
MamaFieldCacheField field1;
field1.create(1, MAMA_FIELD_TYPE_CHAR);
ASSERT_EQ(MAMA_FIELD_TYPE_CHAR, field1.getType());
mamaFieldCacheFieldFromString(field1, "a");
MamaFieldCacheFieldChar charField;
ASSERT_EQ('a', charField.get(field1));
MamaFieldCacheField field2;
field2.create(2, MAMA_FIELD_TYPE_I32);
mamaFieldCacheFieldFromString(field2, "321");
MamaFieldCacheFieldI32 i32Field;
ASSERT_EQ(321, i32Field.get(field2));
MamaFieldCacheField field3;
field3.create(3, MAMA_FIELD_TYPE_BOOL);
mamaFieldCacheFieldFromString(field3, "1");
MamaFieldCacheFieldBool boolField;
ASSERT_TRUE(boolField.get(field3));
MamaFieldCacheField field4;
field4.create(4, MAMA_FIELD_TYPE_STRING);
mamaFieldCacheFieldFromString(field4, "hello");
MamaFieldCacheFieldString stringField;
ASSERT_STREQ("hello", stringField.get(field4));
MamaFieldCacheField field5;
field5.create(5, MAMA_FIELD_TYPE_F32);
mamaFieldCacheFieldFromString(field5, "3.21");
MamaFieldCacheFieldF32 f32Field;
ASSERT_FLOAT_EQ(3.21, f32Field.get(field5));
}
