TEST_F(TestField, CreateNoCopy)
{
char s[100];
Field f = Field::create_no_copy_null_string(m_pool, "foo", 3, s);
std::string v("Hello World");
std::copy(v.begin(), v.end(), s);
EXPECT_EQ(std::string(s), f.value_as_null_string());
ByteString b = ByteString::create(m_pool, "Test2");
Field f2 = Field::create_no_copy_byte_string(m_pool, "foo", 3, b);
b.set("Test4");
EXPECT_EQ(b.to_s(), f2.value_as_byte_string().to_s());
List<int*> l = List<int*>::create(m_pool);
Field f3 = Field::create_no_copy_list(m_pool, "foo", 3, l);
EXPECT_EQ(l.ib(), f3.value_as_list<int*>().ib());
}
TEST_F(TestField, Construction)
{
Field f;
f = Field::create_number(m_pool, "test", 4, 17);
EXPECT_TRUE(f);
EXPECT_EQ(Field::NUMBER, f.type());
EXPECT_EQ(17, f.value_as_number());
EXPECT_EQ("test", f.name_as_s());
EXPECT_EQ(m_pool, f.memory_pool());
EXPECT_FALSE(f.is_dynamic());
f = Field::create_unsigned_number(m_pool, "test", 4, 17);
EXPECT_TRUE(f);
EXPECT_EQ(Field::UNSIGNED_NUMBER, f.type());
EXPECT_EQ(17UL, f.value_as_unsigned_number());
EXPECT_EQ("test", f.name_as_s());
EXPECT_EQ(m_pool, f.memory_pool());
EXPECT_FALSE(f.is_dynamic());
f = Field::create_null_string(m_pool, "test", 4, "value");
EXPECT_TRUE(f);
EXPECT_EQ(Field::NULL_STRING, f.type());
EXPECT_EQ("value", string(f.value_as_null_string()));
EXPECT_EQ("test", f.name_as_s());
EXPECT_EQ(m_pool, f.memory_pool());
EXPECT_FALSE(f.is_dynamic());
ByteString bs = ByteString::create(m_pool, "value");
f = Field::create_byte_string(m_pool, "test", 4, bs);
EXPECT_TRUE(f);
EXPECT_EQ(Field::BYTE_STRING, f.type());
EXPECT_EQ(bs.to_s(), f.value_as_byte_string().to_s());
EXPECT_EQ("test", f.name_as_s());
EXPECT_EQ(m_pool, f.memory_pool());
EXPECT_FALSE(f.is_dynamic());
// No Copy specific behavior tested in create no copy test below.
List<int*> l = List<int*>::create(m_pool);
f = Field::create_no_copy_list(m_pool, "test", 4, l);
EXPECT_TRUE(f);
EXPECT_EQ(Field::LIST, f.type());
EXPECT_EQ("test", f.name_as_s());
EXPECT_EQ(m_pool, f.memory_pool());
EXPECT_FALSE(f.is_dynamic());
}
TEST_F(TestField, Dynamic)
{
test_args args;
Field f;
{
int64_t v;
f = Field::create_dynamic_number(
m_pool, "test", 4,
test_getter<int64_t>(v, args),
test_setter<int64_t>(v, args)
);
v = 12;
EXPECT_EQ(v, f.value_as_number());
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
v = 13;
args.reset();
EXPECT_EQ(v, f.value_as_number("Hello", 5));
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
EXPECT_TRUE(f.is_dynamic());
args.reset();
v = 0;
f.set_number(23);
EXPECT_EQ(23, v);
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
args.reset();
v = 0;
f.set_number(24, "Hello", 5);
EXPECT_EQ(24, v);
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
f.make_static();
f.set_number(123);
EXPECT_FALSE(f.is_dynamic());
EXPECT_EQ(123, f.value_as_number());
}
{
uint64_t v;
f = Field::create_dynamic_unsigned_number(m_pool, "test", 4,
test_getter<uint64_t>(v, args),
test_setter<uint64_t>(v, args)
);
v = 12;
EXPECT_EQ(v, f.value_as_unsigned_number());
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
v = 13;
args.reset();
EXPECT_EQ(v, f.value_as_unsigned_number("Hello", 5));
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
EXPECT_TRUE(f.is_dynamic());
args.reset();
v = 0;
f.set_unsigned_number(23);
EXPECT_EQ(23UL, v);
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
args.reset();
v = 0;
f.set_unsigned_number(24, "Hello", 5);
EXPECT_EQ(24UL, v);
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
f.make_static();
f.set_unsigned_number(123);
EXPECT_FALSE(f.is_dynamic());
EXPECT_EQ(123UL, f.value_as_unsigned_number());
}
{
const char* v;
f = Field::create_dynamic_null_string(
m_pool, "test", 4,
test_getter<const char*>(v, args),
test_setter<const char*>(v, args)
);
v = "foo";
EXPECT_EQ(string(v), f.value_as_null_string());
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
v = "bar";
args.reset();
EXPECT_EQ(string(v), f.value_as_null_string("Hello", 5));
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
EXPECT_TRUE(f.is_dynamic());
args.reset();
v = NULL;
f.set_null_string("abc");
EXPECT_EQ(string("abc"), v);
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
args.reset();
v = NULL;
f.set_null_string("def", "Hello", 5);
EXPECT_EQ(string("def"), v);
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
f.make_static();
f.set_null_string("123");
EXPECT_FALSE(f.is_dynamic());
EXPECT_EQ(string("123"), f.value_as_null_string());
}
{
ByteString v;
f = Field::create_dynamic_byte_string(
m_pool,
"test", 4,
test_getter<ConstByteString>(v, args),
test_setter<ConstByteString>(v, args)
);
v = ByteString::create(m_pool, "foo");
EXPECT_EQ(v.to_s(), f.value_as_byte_string().to_s());
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
v = ByteString::create(m_pool, "bar");
args.reset();
EXPECT_EQ(v.to_s(), f.value_as_byte_string("Hello", 5).to_s());
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
EXPECT_TRUE(f.is_dynamic());
args.reset();
v = ByteString();
f.set_byte_string(ByteString::create(m_pool, "abc"));
EXPECT_EQ("abc", v.to_s());
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
args.reset();
v = ByteString();
f.set_byte_string(ByteString::create(m_pool, "def"), "Hello", 5);
EXPECT_EQ("def", v.to_s());
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
f.make_static();
f.set_byte_string(ByteString::create(m_pool, "123"));
EXPECT_FALSE(f.is_dynamic());
EXPECT_EQ("123", f.value_as_byte_string().to_s());
}
{
ConstList<int*> v;
List<int*> v2;
f = Field::create_dynamic_list<int*>(
m_pool,
"test", 4,
test_getter<ConstList<int*> >(v, args),
test_setter<ConstList<int*> >(v, args)
);
v = List<int*>::create(m_pool);
EXPECT_EQ(v.ib(), f.value_as_list<int*>().ib());
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
v2 = List<int*>::create(m_pool);
args.reset();
EXPECT_EQ(v.ib(), f.value_as_list<int*>("Hello", 5).ib());
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
EXPECT_TRUE(f.is_dynamic());
args.reset();
v = List<int*>();
v2 = List<int*>::create(m_pool);
f.set_no_copy_list(v2);
EXPECT_EQ(v2.ib(), v.ib());
EXPECT_EQ(f, args.field);
EXPECT_FALSE(args.arg);
EXPECT_EQ(0UL, args.arg_length);
args.reset();
v = List<int*>();
v2 = List<int*>::create(m_pool);
f.set_no_copy_list(v2, "Hello", 5);
EXPECT_EQ(v2.ib(), v.ib());
EXPECT_EQ(f, args.field);
EXPECT_EQ("Hello", string(args.arg, args.arg_length));
f.make_static();
v2 = List<int*>::create(m_pool);
f.set_no_copy_list(v2);
EXPECT_FALSE(f.is_dynamic());
EXPECT_EQ(v2.ib(), f.value_as_list<int*>().ib());
}
}
