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); }