Commit c98de6b2 authored by Yedidya Feldblum's avatar Yedidya Feldblum Committed by Facebook Github Bot

Fix the assumption in the propagate_const test about local layout

Summary: [Folly] Fix the assumption in the `propagate_const` test about local layout.

Reviewed By: aary

Differential Revision: D6624962

fbshipit-source-id: 6871dc20f2b5ec2d1a86f520030c7cda8a225958
parent 22df4521
......@@ -77,36 +77,40 @@ TEST_F(PropagateConstTest, op_assign_move) {
}
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);
......@@ -114,21 +118,23 @@ TEST_F(PropagateConstTest, op_bool) {
}
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);
......@@ -140,133 +146,141 @@ TEST_F(PropagateConstTest, swap) {
}
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));
......@@ -274,10 +288,11 @@ TEST_F(PropagateConstTest, equal_to) {
}
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));
......@@ -285,10 +300,11 @@ TEST_F(PropagateConstTest, not_equal_to) {
}
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));
......@@ -298,10 +314,11 @@ TEST_F(PropagateConstTest, less) {
}
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));
......@@ -311,10 +328,11 @@ TEST_F(PropagateConstTest, greater) {
}
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));
......@@ -324,10 +342,11 @@ TEST_F(PropagateConstTest, less_equal) {
}
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));
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment