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

diff --git a/folly/lang/test/PropagateConstTest.cpp b/folly/lang/test/PropagateConstTest.cpp
index 1a62f48d79c5bec191d72f7a890fd162a9867875..04b1058bc89bdaf41af11a8e6a045166f44184e5 100644 (file)
--- a/folly/lang/test/PropagateConstTest.cpp
+++ b/folly/lang/test/PropagateConstTest.cpp
@@ -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));