}
TEST_F(PropagateConstTest, get) {
- int a = 3;
- auto pc_a = pc<int*>(&a);
+ int data[1] = {3};
+ auto a = data + 0;
+ auto pc_a = pc<int*>(a);
- EXPECT_EQ(&a, pc_a.get());
- EXPECT_EQ(&a, as_const(pc_a).get());
+ EXPECT_EQ(a, pc_a.get());
+ EXPECT_EQ(a, as_const(pc_a).get());
EXPECT_FALSE(is_const(*pc_a.get()));
EXPECT_TRUE(is_const(*as_const(pc_a).get()));
}
TEST_F(PropagateConstTest, op_indirect) {
- int a = 3;
- auto pc_a = pc<int*>(&a);
+ int data[1] = {3};
+ auto a = data + 0;
+ auto pc_a = pc<int*>(a);
- EXPECT_EQ(&a, &*pc_a);
- EXPECT_EQ(&a, &*as_const(pc_a));
+ EXPECT_EQ(a, &*pc_a);
+ EXPECT_EQ(a, &*as_const(pc_a));
EXPECT_FALSE(is_const(*pc_a));
EXPECT_TRUE(is_const(*as_const(pc_a)));
}
TEST_F(PropagateConstTest, op_element_type_ptr) {
- int a = 3;
- auto pc_a = pc<int*>(&a);
+ int data[1] = {3};
+ auto a = data + 0;
+ auto pc_a = pc<int*>(a);
- EXPECT_EQ(&a, static_cast<int*>(pc_a));
- EXPECT_EQ(&a, static_cast<int const*>(as_const(pc_a)));
+ EXPECT_EQ(a, static_cast<int*>(pc_a));
+ EXPECT_EQ(a, static_cast<int const*>(as_const(pc_a)));
}
TEST_F(PropagateConstTest, op_bool) {
- int a = 3;
- auto pc_a = pc<int*>(&a);
+ int data[1] = {3};
+ auto a = data + 0;
+ auto pc_a = pc<int*>(a);
auto pc_0 = pc<int*>(nullptr);
EXPECT_TRUE(pc_a);
}
TEST_F(PropagateConstTest, get_underlying) {
- int a = 3;
- auto pc_a = pc<int*>(&a);
+ int data[1] = {3};
+ auto a = data + 0;
+ auto pc_a = pc<int*>(a);
- EXPECT_EQ(&a, get_underlying(pc_a));
- EXPECT_EQ(&a, get_underlying(as_const(pc_a)));
+ EXPECT_EQ(a, get_underlying(pc_a));
+ EXPECT_EQ(a, get_underlying(as_const(pc_a)));
EXPECT_FALSE(is_const(get_underlying(pc_a)));
EXPECT_TRUE(is_const(get_underlying(as_const(pc_a))));
EXPECT_TRUE(&get_underlying(pc_a) == &get_underlying(as_const(pc_a)));
}
TEST_F(PropagateConstTest, swap) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
swap(pc_a, pc_b);
EXPECT_EQ(3, *pc_b);
}
TEST_F(PropagateConstTest, op_equal_to) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x == y; };
EXPECT_TRUE(_(pc_a, pc_a));
EXPECT_FALSE(_(pc_a, pc_b));
EXPECT_FALSE(_(pc_a, nullptr));
- EXPECT_TRUE(_(pc_a, &a));
- EXPECT_FALSE(_(pc_a, &b));
- EXPECT_TRUE(_(&a, pc_a));
- EXPECT_FALSE(_(&b, pc_a));
+ EXPECT_TRUE(_(pc_a, a));
+ EXPECT_FALSE(_(pc_a, b));
+ EXPECT_TRUE(_(a, pc_a));
+ EXPECT_FALSE(_(b, pc_a));
}
TEST_F(PropagateConstTest, op_not_equal_to) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x != y; };
EXPECT_FALSE(_(pc_a, pc_a));
EXPECT_TRUE(_(pc_a, pc_b));
EXPECT_TRUE(_(pc_a, nullptr));
- EXPECT_FALSE(_(pc_a, &a));
- EXPECT_TRUE(_(pc_a, &b));
- EXPECT_FALSE(_(&a, pc_a));
- EXPECT_TRUE(_(&b, pc_a));
+ EXPECT_FALSE(_(pc_a, a));
+ EXPECT_TRUE(_(pc_a, b));
+ EXPECT_FALSE(_(a, pc_a));
+ EXPECT_TRUE(_(b, pc_a));
}
TEST_F(PropagateConstTest, op_less) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x < y; };
EXPECT_FALSE(_(pc_a, pc_a));
- EXPECT_FALSE(_(pc_a, &a));
- EXPECT_FALSE(_(&a, pc_a));
+ EXPECT_FALSE(_(pc_a, a));
+ EXPECT_FALSE(_(a, pc_a));
EXPECT_TRUE(_(pc_a, pc_b));
- EXPECT_TRUE(_(pc_a, &b));
- EXPECT_TRUE(_(&a, pc_b));
+ EXPECT_TRUE(_(pc_a, b));
+ EXPECT_TRUE(_(a, pc_b));
EXPECT_FALSE(_(pc_b, pc_a));
- EXPECT_FALSE(_(pc_b, &a));
- EXPECT_FALSE(_(&b, pc_a));
+ EXPECT_FALSE(_(pc_b, a));
+ EXPECT_FALSE(_(b, pc_a));
EXPECT_FALSE(_(pc_b, pc_b));
- EXPECT_FALSE(_(pc_b, &b));
- EXPECT_FALSE(_(&b, pc_b));
+ EXPECT_FALSE(_(pc_b, b));
+ EXPECT_FALSE(_(b, pc_b));
}
TEST_F(PropagateConstTest, op_greater) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x > y; };
EXPECT_FALSE(_(pc_a, pc_a));
- EXPECT_FALSE(_(pc_a, &a));
- EXPECT_FALSE(_(&a, pc_a));
+ EXPECT_FALSE(_(pc_a, a));
+ EXPECT_FALSE(_(a, pc_a));
EXPECT_FALSE(_(pc_a, pc_b));
- EXPECT_FALSE(_(pc_a, &b));
- EXPECT_FALSE(_(&a, pc_b));
+ EXPECT_FALSE(_(pc_a, b));
+ EXPECT_FALSE(_(a, pc_b));
EXPECT_TRUE(_(pc_b, pc_a));
- EXPECT_TRUE(_(pc_b, &a));
- EXPECT_TRUE(_(&b, pc_a));
+ EXPECT_TRUE(_(pc_b, a));
+ EXPECT_TRUE(_(b, pc_a));
EXPECT_FALSE(_(pc_b, pc_b));
- EXPECT_FALSE(_(pc_b, &b));
- EXPECT_FALSE(_(&b, pc_b));
+ EXPECT_FALSE(_(pc_b, b));
+ EXPECT_FALSE(_(b, pc_b));
}
TEST_F(PropagateConstTest, op_less_equal) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x <= y; };
EXPECT_TRUE(_(pc_a, pc_a));
- EXPECT_TRUE(_(pc_a, &a));
- EXPECT_TRUE(_(&a, pc_a));
+ EXPECT_TRUE(_(pc_a, a));
+ EXPECT_TRUE(_(a, pc_a));
EXPECT_TRUE(_(pc_a, pc_b));
- EXPECT_TRUE(_(pc_a, &b));
- EXPECT_TRUE(_(&a, pc_b));
+ EXPECT_TRUE(_(pc_a, b));
+ EXPECT_TRUE(_(a, pc_b));
EXPECT_FALSE(_(pc_b, pc_a));
- EXPECT_FALSE(_(pc_b, &a));
- EXPECT_FALSE(_(&b, pc_a));
+ EXPECT_FALSE(_(pc_b, a));
+ EXPECT_FALSE(_(b, pc_a));
EXPECT_TRUE(_(pc_b, pc_b));
- EXPECT_TRUE(_(pc_b, &b));
- EXPECT_TRUE(_(&b, pc_b));
+ EXPECT_TRUE(_(pc_b, b));
+ EXPECT_TRUE(_(b, pc_b));
}
TEST_F(PropagateConstTest, op_greater_equal) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x >= y; };
EXPECT_TRUE(_(pc_a, pc_a));
- EXPECT_TRUE(_(pc_a, &a));
- EXPECT_TRUE(_(&a, pc_a));
+ EXPECT_TRUE(_(pc_a, a));
+ EXPECT_TRUE(_(a, pc_a));
EXPECT_FALSE(_(pc_a, pc_b));
- EXPECT_FALSE(_(pc_a, &b));
- EXPECT_FALSE(_(&a, pc_b));
+ EXPECT_FALSE(_(pc_a, b));
+ EXPECT_FALSE(_(a, pc_b));
EXPECT_TRUE(_(pc_b, pc_a));
- EXPECT_TRUE(_(pc_b, &a));
- EXPECT_TRUE(_(&b, pc_a));
+ EXPECT_TRUE(_(pc_b, a));
+ EXPECT_TRUE(_(b, pc_a));
EXPECT_TRUE(_(pc_b, pc_b));
- EXPECT_TRUE(_(pc_b, &b));
- EXPECT_TRUE(_(&b, pc_b));
+ EXPECT_TRUE(_(pc_b, b));
+ EXPECT_TRUE(_(b, pc_b));
}
TEST_F(PropagateConstTest, hash) {
- int a = 3;
- auto pc_a = pc<int*>(&a);
+ int data[1] = {3};
+ auto a = data + 0;
+ auto pc_a = pc<int*>(a);
- EXPECT_EQ(std::hash<int*>()(&a), std::hash<pc<int*>>()(pc_a));
+ EXPECT_EQ(std::hash<int*>()(a), std::hash<pc<int*>>()(pc_a));
}
TEST_F(PropagateConstTest, equal_to) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = std::equal_to<pc<int*>>{};
EXPECT_TRUE(_(pc_a, pc_a));
}
TEST_F(PropagateConstTest, not_equal_to) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = std::not_equal_to<pc<int*>>{};
EXPECT_FALSE(_(pc_a, pc_a));
}
TEST_F(PropagateConstTest, less) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = std::less<pc<int*>>{};
EXPECT_FALSE(_(pc_a, pc_a));
}
TEST_F(PropagateConstTest, greater) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = std::greater<pc<int*>>{};
EXPECT_FALSE(_(pc_a, pc_a));
}
TEST_F(PropagateConstTest, less_equal) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = std::less_equal<pc<int*>>{};
EXPECT_TRUE(_(pc_a, pc_a));
}
TEST_F(PropagateConstTest, greater_equal) {
- int a = 3;
- int b = 4;
- auto pc_a = pc<int*>(&a);
- auto pc_b = pc<int*>(&b);
+ int data[2] = {3, 4};
+ auto a = data + 0;
+ auto b = data + 1;
+ auto pc_a = pc<int*>(a);
+ auto pc_b = pc<int*>(b);
auto _ = std::greater_equal<pc<int*>>{};
EXPECT_TRUE(_(pc_a, pc_a));