int main()
{
int a1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
const std::size_t N1 = sizeof(a1)/sizeof(a1[0]);
bool b1[N1] = {true, false, false, true, true, false,
false, true, false, false, false, true};
int a2[] = {-1, -2, -3, -4, -5, -6, -7, -8};
const std::size_t N2 = sizeof(a2)/sizeof(a2[0]);
bool b2[N2] = {true, false, true, true,
false, false, true, true};
std::valarray<int> v1(a1, N1);
const std::valarray<int> v2(a2, N2);
std::valarray<bool> vb1(b1, N1);
std::valarray<bool> vb2(b2, N2);
v1[vb1] = v2[vb2];
assert(v1.size() == 16);
assert(v1[ 0] == -1);
assert(v1[ 1] == 1);
assert(v1[ 2] == 2);
assert(v1[ 3] == -3);
assert(v1[ 4] == -4);
assert(v1[ 5] == 5);
assert(v1[ 6] == 6);
assert(v1[ 7] == -7);
assert(v1[ 8] == 8);
assert(v1[ 9] == 9);
assert(v1[10] == 10);
assert(v1[11] == -8);
assert(v1[12] == 12);
assert(v1[13] == 13);
assert(v1[14] == 14);
assert(v1[15] == 15);
}
TEST(SharedValueTest, value)
{
// bool
Value vb = false;
EXPECT_EQ(vb.as<bool>(), false);
EXPECT_EQ(bool(vb), false);
EXPECT_EQ(static_cast<bool>(vb), false);
EXPECT_NO_THROW(bool b = vb);
Value vb1(false);
Value vb2(true);
EXPECT_EQ(bool(vb1), false);
EXPECT_EQ(bool(vb2), true);
bool b = vb;
EXPECT_EQ(b, false);
EXPECT_NO_THROW(vb = true);
EXPECT_EQ(vb.as<bool>(), true);
EXPECT_EQ(bool(vb), true);
EXPECT_EQ(static_cast<bool>(vb), true);
b = vb;
EXPECT_EQ(b, true);
// float
Value vf = 1 / 3.;
EXPECT_EQ(vf.as<float>(), 1 / 3.f);
EXPECT_EQ(float(vf), 1 / 3.f);
EXPECT_EQ(static_cast<float>(vf), 1 / 3.f);
EXPECT_EQ(vf.as<double>(), 1 / 3.f);
EXPECT_EQ(double(vf), 1 / 3.f);
EXPECT_EQ(static_cast<double>(vf), 1 / 3.f);
Value vf2(1.0 / 7);
Value vf3(1 / 8.f);
Value vf4(vf3);
EXPECT_EQ(float(vf2), 1.f / 7);
EXPECT_EQ(float(vf3), 1.f / 8);
EXPECT_EQ(float(vf4), 1.f / 8);
EXPECT_NO_THROW(vf = 1 / 7.f);
EXPECT_NO_THROW(float f = vf);
EXPECT_NO_THROW(double d = vf);
float f = vf;
double d = vf;
EXPECT_EQ(f, 1 / 7.f);
EXPECT_EQ(d, 1 / 7.f);
EXPECT_NO_THROW(vf = 14.245f);
EXPECT_EQ(float(vf), 14.245f);
EXPECT_EQ(double(vf), 14.245f);
EXPECT_EQ(double(vf), double(14.245f));
EXPECT_NE(double(vf), double(14.245));
EXPECT_TRUE(float(vf) == float(14.245));
// int
Value vi = -56;
EXPECT_EQ(vi.as<int>(), -56);
EXPECT_EQ(int(vi), -56);
EXPECT_EQ(static_cast<int>(vi), -56);
EXPECT_NO_THROW(int i = vi);
Value vi2(32);
Value vi3(3530454);
Value vi4(0xFF1110u);
EXPECT_EQ(int(vi2), 32);
EXPECT_EQ(int(vi3), 3530454);
EXPECT_EQ(unsigned(vi4), 0xFF1110u);
int i = vi;
EXPECT_EQ(i, -56);
EXPECT_NO_THROW(vi = 17);
EXPECT_EQ(int(vi), 17);
EXPECT_EQ(char(vi), 17);
EXPECT_EQ(short(vi), 17);
EXPECT_EQ(unsigned(vi), 17u);
// pointer
int test = 1;
int test2 = 2;
EXPECT_NO_THROW(Value vp(&test));
Value vp(static_cast<void*>(&test));
EXPECT_NO_THROW(const void* p = vp);
const void* p = vp;
EXPECT_EQ(static_cast<const void*>(vp), &test);
EXPECT_ANY_THROW(vp = &test2);
EXPECT_NO_THROW(vp = static_cast<const void *>(&test2));
EXPECT_EQ(static_cast<const void*>(vp), &test2);
}
TEST(SharedValueTest, operatorAssgn)
{
// bool
Value vb = true;
EXPECT_EQ(bool(vb), true);
EXPECT_NO_THROW(vb = false);
EXPECT_EQ(bool(vb), false);
EXPECT_ANY_THROW(vb = 1.0f);
EXPECT_ANY_THROW(vb = 17);
EXPECT_ANY_THROW(vb = static_cast<const void*>(NULL));
EXPECT_ANY_THROW(vb = static_cast<const char*>(NULL));
EXPECT_NO_THROW(vb = Value::Null);
EXPECT_EQ(bool(vb), false);
//EXPECT_ANY_THROW(vb = nullptr);
EXPECT_ANY_THROW(vb = 0x113Fu);
EXPECT_ANY_THROW(vb = EnumAOne);
Value vb2(true);
EXPECT_EQ(bool(vb2), true);
vb = false;
EXPECT_NO_THROW(vb = vb2);
EXPECT_EQ(bool(vb), bool(vb2));
EXPECT_EQ(bool(vb), true);
// float
Value vf = .0f;
EXPECT_ANY_THROW(vf = false);
EXPECT_NO_THROW(vf = 1.0f);
EXPECT_ANY_THROW(vf = 17);
EXPECT_ANY_THROW(vf = static_cast<const void*>(NULL));
EXPECT_ANY_THROW(vf = static_cast<const char*>(NULL));
EXPECT_NO_THROW(vf = Value::Null);
EXPECT_ANY_THROW(vf = nullptr);
EXPECT_ANY_THROW(vf = 0x113Fu);
EXPECT_ANY_THROW(vf = EnumAOne);
EXPECT_NO_THROW(vf = 17 / 11.f);
EXPECT_EQ(float(vf), 17 / 11.f);
Value vf2(15 / 114.f);
EXPECT_EQ(float(vf2), 15 / 114.f);
EXPECT_ANY_THROW(vf = vb);
EXPECT_NO_THROW(vf = vf2);
EXPECT_EQ(float(vf), float(vf2));
EXPECT_EQ(float(vf), 15 / 114.f);
Value vf3;
EXPECT_EQ(vf3.type(), typeid(Value::NullType));
EXPECT_NO_THROW(vf3 = 33 / 55.f);
EXPECT_NE(vf3.type(), typeid(Value::NullType));
EXPECT_EQ(vf3.type(), typeid(float));
EXPECT_NO_THROW(vf3.as<float>());
EXPECT_EQ(float(vf3), 33 / 55.f);
Value vf4;
EXPECT_NO_THROW(vf4 = vf3);
EXPECT_EQ(float(vf4), 33 / 55.f);
// int
Value vi = 0;
EXPECT_ANY_THROW(vi = false);
EXPECT_ANY_THROW(vi = 1.0f);
EXPECT_NO_THROW(vi = 17);
EXPECT_ANY_THROW(vi = static_cast<const void*>(NULL));
EXPECT_ANY_THROW(vi = static_cast<const char*>(NULL));
EXPECT_NO_THROW(vi = Value::Null);
//EXPECT_ANY_THROW(vi = nullptr);
EXPECT_NO_THROW(vi = 0x113Fu);
EXPECT_ANY_THROW(vi = EnumAOne);
// const void *
int something = 10;
Value vp = reinterpret_cast<const void*>(&something);
EXPECT_ANY_THROW(vp = false);
EXPECT_ANY_THROW(vp = 1.0f);
EXPECT_ANY_THROW(vp = 17);
EXPECT_NO_THROW(vp = static_cast<const void*>(NULL));
EXPECT_ANY_THROW(vp = static_cast<const char*>(NULL));
EXPECT_NO_THROW(vp = Value::Null);
EXPECT_ANY_THROW(vp = NULL);
EXPECT_NO_THROW(vp = nullptr);
EXPECT_ANY_THROW(vp = 0x113Fu);
EXPECT_ANY_THROW(vp = EnumAOne);
EXPECT_ANY_THROW(vp = &something);
EXPECT_NO_THROW(vp = static_cast<void *>(&something));
Value vp2(vp);
Value vp3;
Value vp4;
EXPECT_NO_THROW(vp3 = vp2);
EXPECT_NO_THROW(vp4 = vp3);
EXPECT_EQ(static_cast<const void*>(vp4), &something);
Value vp5;
Value vp6(nullptr);
const char* str1 = "test";
const void* cp = &str1;
EXPECT_ANY_THROW(cp = vp5);
vp5 = str1;
EXPECT_NO_THROW(str1 = vp5);
EXPECT_NO_THROW(vp5 = str1);
EXPECT_ANY_THROW(vp5 = vp6);
EXPECT_ANY_THROW(vp5 = cp);
EXPECT_NO_THROW(vp6 = cp);
EXPECT_ANY_THROW(vp6 = str1);
EXPECT_NO_THROW(vp6 = static_cast<const void *>(str1));
EXPECT_ANY_THROW(vp6 = vp5); // can't detect non-void ptr to void ptr value assignment
Value vp7 = cp;
EXPECT_ANY_THROW(vp7 = str1);
EXPECT_NO_THROW(vp7 = nullptr);
EXPECT_ANY_THROW(vp7 = vp5);
// const char *
Value vs = "test";
EXPECT_ANY_THROW(vs = false);
EXPECT_ANY_THROW(vs = 1.0f);
EXPECT_ANY_THROW(vs = 17);
EXPECT_ANY_THROW(vs = static_cast<const void*>(NULL));
EXPECT_NO_THROW(vs = static_cast<const char*>(NULL));
EXPECT_NO_THROW(vs = Value::Null);
EXPECT_ANY_THROW(vs = NULL);
EXPECT_ANY_THROW(vs = nullptr);
EXPECT_ANY_THROW(vs = 0x113Fu);
EXPECT_ANY_THROW(vs = EnumAOne);
// unsigned
Value vu = 10u;
EXPECT_ANY_THROW(vu = false);
EXPECT_ANY_THROW(vu = 1.0f);
EXPECT_NO_THROW(vu = 17);
EXPECT_ANY_THROW(vu = static_cast<const void*>(NULL));
EXPECT_ANY_THROW(vu = static_cast<const char*>(NULL));
EXPECT_NO_THROW(vu = Value::Null);
//EXPECT_ANY_THROW(vu = nullptr);
EXPECT_NO_THROW(vu = 0x113Fu);
EXPECT_ANY_THROW(vu = EnumAOne);
// enum
Value ve = EnumBTwo;
EXPECT_ANY_THROW(ve = false);
EXPECT_ANY_THROW(ve = 1.0f);
EXPECT_ANY_THROW(ve = 17);
EXPECT_ANY_THROW(ve = static_cast<const void*>(NULL));
EXPECT_ANY_THROW(ve = static_cast<const char*>(NULL));
EXPECT_NO_THROW(ve = Value::Null);
//EXPECT_ANY_THROW(ve = nullptr);
EXPECT_ANY_THROW(ve = 0x113Fu);
EXPECT_ANY_THROW(ve = EnumAOne);
EXPECT_NO_THROW(ve = EnumBThree);
}
