Skip to content

F
folly
Commit c98de6b2 authored by Yedidya Feldblum's avatar Yedidya Feldblum Committed by Facebook Github Bot
Browse files
Options

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
Hide whitespace changes
Inline Side-by-side
Showing with 132 additions and 113 deletions
folly/lang/test/PropagateConstTest.cpp
View file @ c98de6b2
...@@ -77,36 +77,40 @@ TEST_F(PropagateConstTest, op_assign_move) { ...@@ -77,36 +77,40 @@ TEST_F(PropagateConstTest, op_assign_move) {
} }
TEST_F(PropagateConstTest, get) { TEST_F(PropagateConstTest, get) {
int a = 3; int data[1] = {3};
auto pc_a = pc<int*>(&a); auto a = data + 0;
auto pc_a = pc<int*>(a);
EXPECT_EQ(&a, pc_a.get()); EXPECT_EQ(a, pc_a.get());
EXPECT_EQ(&a, as_const(pc_a).get()); EXPECT_EQ(a, as_const(pc_a).get());
EXPECT_FALSE(is_const(*pc_a.get())); EXPECT_FALSE(is_const(*pc_a.get()));
EXPECT_TRUE(is_const(*as_const(pc_a).get())); EXPECT_TRUE(is_const(*as_const(pc_a).get()));
} }
TEST_F(PropagateConstTest, op_indirect) { TEST_F(PropagateConstTest, op_indirect) {
int a = 3; int data[1] = {3};
auto pc_a = pc<int*>(&a); auto a = data + 0;
auto pc_a = pc<int*>(a);
EXPECT_EQ(&a, &*pc_a); EXPECT_EQ(a, &*pc_a);
EXPECT_EQ(&a, &*as_const(pc_a)); EXPECT_EQ(a, &*as_const(pc_a));
EXPECT_FALSE(is_const(*pc_a)); EXPECT_FALSE(is_const(*pc_a));
EXPECT_TRUE(is_const(*as_const(pc_a))); EXPECT_TRUE(is_const(*as_const(pc_a)));
} }
TEST_F(PropagateConstTest, op_element_type_ptr) { TEST_F(PropagateConstTest, op_element_type_ptr) {
int a = 3; int data[1] = {3};
auto pc_a = pc<int*>(&a); auto a = data + 0;
auto pc_a = pc<int*>(a);
EXPECT_EQ(&a, static_cast<int*>(pc_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 const*>(as_const(pc_a)));
} }
TEST_F(PropagateConstTest, op_bool) { TEST_F(PropagateConstTest, op_bool) {
int a = 3; int data[1] = {3};
auto pc_a = pc<int*>(&a); auto a = data + 0;
auto pc_a = pc<int*>(a);
auto pc_0 = pc<int*>(nullptr); auto pc_0 = pc<int*>(nullptr);
EXPECT_TRUE(pc_a); EXPECT_TRUE(pc_a);
...@@ -114,21 +118,23 @@ TEST_F(PropagateConstTest, op_bool) { ...@@ -114,21 +118,23 @@ TEST_F(PropagateConstTest, op_bool) {
} }
TEST_F(PropagateConstTest, get_underlying) { TEST_F(PropagateConstTest, get_underlying) {
int a = 3; int data[1] = {3};
auto pc_a = pc<int*>(&a); auto a = data + 0;
auto pc_a = pc<int*>(a);
EXPECT_EQ(&a, get_underlying(pc_a)); EXPECT_EQ(a, get_underlying(pc_a));
EXPECT_EQ(&a, get_underlying(as_const(pc_a))); EXPECT_EQ(a, get_underlying(as_const(pc_a)));
EXPECT_FALSE(is_const(get_underlying(pc_a))); EXPECT_FALSE(is_const(get_underlying(pc_a)));
EXPECT_TRUE(is_const(get_underlying(as_const(pc_a)))); EXPECT_TRUE(is_const(get_underlying(as_const(pc_a))));
EXPECT_TRUE(&get_underlying(pc_a) == &get_underlying(as_const(pc_a))); EXPECT_TRUE(&get_underlying(pc_a) == &get_underlying(as_const(pc_a)));
} }
TEST_F(PropagateConstTest, swap) { TEST_F(PropagateConstTest, swap) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
swap(pc_a, pc_b); swap(pc_a, pc_b);
EXPECT_EQ(3, *pc_b); EXPECT_EQ(3, *pc_b);
...@@ -140,133 +146,141 @@ TEST_F(PropagateConstTest, swap) { ...@@ -140,133 +146,141 @@ TEST_F(PropagateConstTest, swap) {
} }
TEST_F(PropagateConstTest, op_equal_to) { TEST_F(PropagateConstTest, op_equal_to) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x == y; }; auto _ = [](auto&& x, auto&& y) { return x == y; };
EXPECT_TRUE(_(pc_a, pc_a)); EXPECT_TRUE(_(pc_a, pc_a));
EXPECT_FALSE(_(pc_a, pc_b)); EXPECT_FALSE(_(pc_a, pc_b));
EXPECT_FALSE(_(pc_a, nullptr)); EXPECT_FALSE(_(pc_a, nullptr));
EXPECT_TRUE(_(pc_a, &a)); EXPECT_TRUE(_(pc_a, a));
EXPECT_FALSE(_(pc_a, &b)); EXPECT_FALSE(_(pc_a, b));
EXPECT_TRUE(_(&a, pc_a)); EXPECT_TRUE(_(a, pc_a));
EXPECT_FALSE(_(&b, pc_a)); EXPECT_FALSE(_(b, pc_a));
} }
TEST_F(PropagateConstTest, op_not_equal_to) { TEST_F(PropagateConstTest, op_not_equal_to) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x != y; }; auto _ = [](auto&& x, auto&& y) { return x != y; };
EXPECT_FALSE(_(pc_a, pc_a)); EXPECT_FALSE(_(pc_a, pc_a));
EXPECT_TRUE(_(pc_a, pc_b)); EXPECT_TRUE(_(pc_a, pc_b));
EXPECT_TRUE(_(pc_a, nullptr)); EXPECT_TRUE(_(pc_a, nullptr));
EXPECT_FALSE(_(pc_a, &a)); EXPECT_FALSE(_(pc_a, a));
EXPECT_TRUE(_(pc_a, &b)); EXPECT_TRUE(_(pc_a, b));
EXPECT_FALSE(_(&a, pc_a)); EXPECT_FALSE(_(a, pc_a));
EXPECT_TRUE(_(&b, pc_a)); EXPECT_TRUE(_(b, pc_a));
} }
TEST_F(PropagateConstTest, op_less) { TEST_F(PropagateConstTest, op_less) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x < y; }; auto _ = [](auto&& x, auto&& y) { return x < y; };
EXPECT_FALSE(_(pc_a, pc_a)); EXPECT_FALSE(_(pc_a, pc_a));
EXPECT_FALSE(_(pc_a, &a)); EXPECT_FALSE(_(pc_a, a));
EXPECT_FALSE(_(&a, pc_a)); EXPECT_FALSE(_(a, pc_a));
EXPECT_TRUE(_(pc_a, pc_b)); EXPECT_TRUE(_(pc_a, pc_b));
EXPECT_TRUE(_(pc_a, &b)); EXPECT_TRUE(_(pc_a, b));
EXPECT_TRUE(_(&a, pc_b)); EXPECT_TRUE(_(a, pc_b));
EXPECT_FALSE(_(pc_b, pc_a)); EXPECT_FALSE(_(pc_b, pc_a));
EXPECT_FALSE(_(pc_b, &a)); EXPECT_FALSE(_(pc_b, a));
EXPECT_FALSE(_(&b, pc_a)); EXPECT_FALSE(_(b, pc_a));
EXPECT_FALSE(_(pc_b, pc_b)); EXPECT_FALSE(_(pc_b, pc_b));
EXPECT_FALSE(_(pc_b, &b)); EXPECT_FALSE(_(pc_b, b));
EXPECT_FALSE(_(&b, pc_b)); EXPECT_FALSE(_(b, pc_b));
} }
TEST_F(PropagateConstTest, op_greater) { TEST_F(PropagateConstTest, op_greater) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x > y; }; auto _ = [](auto&& x, auto&& y) { return x > y; };
EXPECT_FALSE(_(pc_a, pc_a)); EXPECT_FALSE(_(pc_a, pc_a));
EXPECT_FALSE(_(pc_a, &a)); EXPECT_FALSE(_(pc_a, a));
EXPECT_FALSE(_(&a, pc_a)); EXPECT_FALSE(_(a, pc_a));
EXPECT_FALSE(_(pc_a, pc_b)); EXPECT_FALSE(_(pc_a, pc_b));
EXPECT_FALSE(_(pc_a, &b)); EXPECT_FALSE(_(pc_a, b));
EXPECT_FALSE(_(&a, pc_b)); EXPECT_FALSE(_(a, pc_b));
EXPECT_TRUE(_(pc_b, pc_a)); EXPECT_TRUE(_(pc_b, pc_a));
EXPECT_TRUE(_(pc_b, &a)); EXPECT_TRUE(_(pc_b, a));
EXPECT_TRUE(_(&b, pc_a)); EXPECT_TRUE(_(b, pc_a));
EXPECT_FALSE(_(pc_b, pc_b)); EXPECT_FALSE(_(pc_b, pc_b));
EXPECT_FALSE(_(pc_b, &b)); EXPECT_FALSE(_(pc_b, b));
EXPECT_FALSE(_(&b, pc_b)); EXPECT_FALSE(_(b, pc_b));
} }
TEST_F(PropagateConstTest, op_less_equal) { TEST_F(PropagateConstTest, op_less_equal) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x <= y; }; auto _ = [](auto&& x, auto&& y) { return x <= y; };
EXPECT_TRUE(_(pc_a, pc_a)); EXPECT_TRUE(_(pc_a, pc_a));
EXPECT_TRUE(_(pc_a, &a)); EXPECT_TRUE(_(pc_a, a));
EXPECT_TRUE(_(&a, pc_a)); EXPECT_TRUE(_(a, pc_a));
EXPECT_TRUE(_(pc_a, pc_b)); EXPECT_TRUE(_(pc_a, pc_b));
EXPECT_TRUE(_(pc_a, &b)); EXPECT_TRUE(_(pc_a, b));
EXPECT_TRUE(_(&a, pc_b)); EXPECT_TRUE(_(a, pc_b));
EXPECT_FALSE(_(pc_b, pc_a)); EXPECT_FALSE(_(pc_b, pc_a));
EXPECT_FALSE(_(pc_b, &a)); EXPECT_FALSE(_(pc_b, a));
EXPECT_FALSE(_(&b, pc_a)); EXPECT_FALSE(_(b, pc_a));
EXPECT_TRUE(_(pc_b, pc_b)); EXPECT_TRUE(_(pc_b, pc_b));
EXPECT_TRUE(_(pc_b, &b)); EXPECT_TRUE(_(pc_b, b));
EXPECT_TRUE(_(&b, pc_b)); EXPECT_TRUE(_(b, pc_b));
} }
TEST_F(PropagateConstTest, op_greater_equal) { TEST_F(PropagateConstTest, op_greater_equal) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = [](auto&& x, auto&& y) { return x >= y; }; auto _ = [](auto&& x, auto&& y) { return x >= y; };
EXPECT_TRUE(_(pc_a, pc_a)); EXPECT_TRUE(_(pc_a, pc_a));
EXPECT_TRUE(_(pc_a, &a)); EXPECT_TRUE(_(pc_a, a));
EXPECT_TRUE(_(&a, pc_a)); EXPECT_TRUE(_(a, pc_a));
EXPECT_FALSE(_(pc_a, pc_b)); EXPECT_FALSE(_(pc_a, pc_b));
EXPECT_FALSE(_(pc_a, &b)); EXPECT_FALSE(_(pc_a, b));
EXPECT_FALSE(_(&a, pc_b)); EXPECT_FALSE(_(a, pc_b));
EXPECT_TRUE(_(pc_b, pc_a)); EXPECT_TRUE(_(pc_b, pc_a));
EXPECT_TRUE(_(pc_b, &a)); EXPECT_TRUE(_(pc_b, a));
EXPECT_TRUE(_(&b, pc_a)); EXPECT_TRUE(_(b, pc_a));
EXPECT_TRUE(_(pc_b, pc_b)); EXPECT_TRUE(_(pc_b, pc_b));
EXPECT_TRUE(_(pc_b, &b)); EXPECT_TRUE(_(pc_b, b));
EXPECT_TRUE(_(&b, pc_b)); EXPECT_TRUE(_(b, pc_b));
} }
TEST_F(PropagateConstTest, hash) { TEST_F(PropagateConstTest, hash) {
int a = 3; int data[1] = {3};
auto pc_a = pc<int*>(&a); 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) { TEST_F(PropagateConstTest, equal_to) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = std::equal_to<pc<int*>>{}; auto _ = std::equal_to<pc<int*>>{};
EXPECT_TRUE(_(pc_a, pc_a)); EXPECT_TRUE(_(pc_a, pc_a));
...@@ -274,10 +288,11 @@ TEST_F(PropagateConstTest, equal_to) { ...@@ -274,10 +288,11 @@ TEST_F(PropagateConstTest, equal_to) {
} }
TEST_F(PropagateConstTest, not_equal_to) { TEST_F(PropagateConstTest, not_equal_to) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = std::not_equal_to<pc<int*>>{}; auto _ = std::not_equal_to<pc<int*>>{};
EXPECT_FALSE(_(pc_a, pc_a)); EXPECT_FALSE(_(pc_a, pc_a));
...@@ -285,10 +300,11 @@ TEST_F(PropagateConstTest, not_equal_to) { ...@@ -285,10 +300,11 @@ TEST_F(PropagateConstTest, not_equal_to) {
} }
TEST_F(PropagateConstTest, less) { TEST_F(PropagateConstTest, less) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = std::less<pc<int*>>{}; auto _ = std::less<pc<int*>>{};
EXPECT_FALSE(_(pc_a, pc_a)); EXPECT_FALSE(_(pc_a, pc_a));
...@@ -298,10 +314,11 @@ TEST_F(PropagateConstTest, less) { ...@@ -298,10 +314,11 @@ TEST_F(PropagateConstTest, less) {
} }
TEST_F(PropagateConstTest, greater) { TEST_F(PropagateConstTest, greater) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = std::greater<pc<int*>>{}; auto _ = std::greater<pc<int*>>{};
EXPECT_FALSE(_(pc_a, pc_a)); EXPECT_FALSE(_(pc_a, pc_a));
...@@ -311,10 +328,11 @@ TEST_F(PropagateConstTest, greater) { ...@@ -311,10 +328,11 @@ TEST_F(PropagateConstTest, greater) {
} }
TEST_F(PropagateConstTest, less_equal) { TEST_F(PropagateConstTest, less_equal) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = std::less_equal<pc<int*>>{}; auto _ = std::less_equal<pc<int*>>{};
EXPECT_TRUE(_(pc_a, pc_a)); EXPECT_TRUE(_(pc_a, pc_a));
...@@ -324,10 +342,11 @@ TEST_F(PropagateConstTest, less_equal) { ...@@ -324,10 +342,11 @@ TEST_F(PropagateConstTest, less_equal) {
} }
TEST_F(PropagateConstTest, greater_equal) { TEST_F(PropagateConstTest, greater_equal) {
int a = 3; int data[2] = {3, 4};
int b = 4; auto a = data + 0;
auto pc_a = pc<int*>(&a); auto b = data + 1;
auto pc_b = pc<int*>(&b); auto pc_a = pc<int*>(a);
auto pc_b = pc<int*>(b);
auto _ = std::greater_equal<pc<int*>>{}; auto _ = std::greater_equal<pc<int*>>{};
EXPECT_TRUE(_(pc_a, pc_a)); 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