| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168 | // Copyright 2018 The Abseil Authors.//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at////      http://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.#include "absl/container/internal/compressed_tuple.h"#include <string>#include "gmock/gmock.h"#include "gtest/gtest.h"namespace absl {inline namespace lts_2018_12_18 {namespace container_internal {namespace {template <int>struct Empty {};template <typename T>struct NotEmpty {  T value;};template <typename T, typename U>struct TwoValues {  T value1;  U value2;};TEST(CompressedTupleTest, Sizeof) {  EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int>));  EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int, Empty<0>>));  EXPECT_EQ(sizeof(int), sizeof(CompressedTuple<int, Empty<0>, Empty<1>>));  EXPECT_EQ(sizeof(int),            sizeof(CompressedTuple<int, Empty<0>, Empty<1>, Empty<2>>));  EXPECT_EQ(sizeof(TwoValues<int, double>),            sizeof(CompressedTuple<int, NotEmpty<double>>));  EXPECT_EQ(sizeof(TwoValues<int, double>),            sizeof(CompressedTuple<int, Empty<0>, NotEmpty<double>>));  EXPECT_EQ(sizeof(TwoValues<int, double>),            sizeof(CompressedTuple<int, Empty<0>, NotEmpty<double>, Empty<1>>));}TEST(CompressedTupleTest, Access) {  struct S {    std::string x;  };  CompressedTuple<int, Empty<0>, S> x(7, {}, S{"ABC"});  EXPECT_EQ(sizeof(x), sizeof(TwoValues<int, S>));  EXPECT_EQ(7, x.get<0>());  EXPECT_EQ("ABC", x.get<2>().x);}TEST(CompressedTupleTest, NonClasses) {  CompressedTuple<int, const char*> x(7, "ABC");  EXPECT_EQ(7, x.get<0>());  EXPECT_STREQ("ABC", x.get<1>());}TEST(CompressedTupleTest, MixClassAndNonClass) {  CompressedTuple<int, const char*, Empty<0>, NotEmpty<double>> x(7, "ABC", {},                                                                  {1.25});  struct Mock {    int v;    const char* p;    double d;  };  EXPECT_EQ(sizeof(x), sizeof(Mock));  EXPECT_EQ(7, x.get<0>());  EXPECT_STREQ("ABC", x.get<1>());  EXPECT_EQ(1.25, x.get<3>().value);}TEST(CompressedTupleTest, Nested) {  CompressedTuple<int, CompressedTuple<int>,                  CompressedTuple<int, CompressedTuple<int>>>      x(1, CompressedTuple<int>(2),        CompressedTuple<int, CompressedTuple<int>>(3, CompressedTuple<int>(4)));  EXPECT_EQ(1, x.get<0>());  EXPECT_EQ(2, x.get<1>().get<0>());  EXPECT_EQ(3, x.get<2>().get<0>());  EXPECT_EQ(4, x.get<2>().get<1>().get<0>());  CompressedTuple<Empty<0>, Empty<0>,                  CompressedTuple<Empty<0>, CompressedTuple<Empty<0>>>>      y;  std::set<Empty<0>*> empties{&y.get<0>(), &y.get<1>(), &y.get<2>().get<0>(),                              &y.get<2>().get<1>().get<0>()};#ifdef _MSC_VER  // MSVC has a bug where many instances of the same base class are layed out in  // the same address when using __declspec(empty_bases).  // This will be fixed in a future version of MSVC.  int expected = 1;#else  int expected = 4;#endif  EXPECT_EQ(expected, sizeof(y));  EXPECT_EQ(expected, empties.size());  EXPECT_EQ(sizeof(y), sizeof(Empty<0>) * empties.size());  EXPECT_EQ(4 * sizeof(char),            sizeof(CompressedTuple<CompressedTuple<char, char>,                                   CompressedTuple<char, char>>));  EXPECT_TRUE(      (std::is_empty<CompressedTuple<CompressedTuple<Empty<0>>,                                     CompressedTuple<Empty<1>>>>::value));}TEST(CompressedTupleTest, Reference) {  int i = 7;  std::string s = "Very long std::string that goes in the heap";  CompressedTuple<int, int&, std::string, std::string&> x(i, i, s, s);  // Sanity check. We should have not moved from `s`  EXPECT_EQ(s, "Very long std::string that goes in the heap");  EXPECT_EQ(x.get<0>(), x.get<1>());  EXPECT_NE(&x.get<0>(), &x.get<1>());  EXPECT_EQ(&x.get<1>(), &i);  EXPECT_EQ(x.get<2>(), x.get<3>());  EXPECT_NE(&x.get<2>(), &x.get<3>());  EXPECT_EQ(&x.get<3>(), &s);}TEST(CompressedTupleTest, NoElements) {  CompressedTuple<> x;  static_cast<void>(x);  // Silence -Wunused-variable.  EXPECT_TRUE(std::is_empty<CompressedTuple<>>::value);}TEST(CompressedTupleTest, Constexpr) {  constexpr CompressedTuple<int, double, CompressedTuple<int>> x(      7, 1.25, CompressedTuple<int>(5));  constexpr int x0 = x.get<0>();  constexpr double x1 = x.get<1>();  constexpr int x2 = x.get<2>().get<0>();  EXPECT_EQ(x0, 7);  EXPECT_EQ(x1, 1.25);  EXPECT_EQ(x2, 5);}#if defined(__clang__) || defined(__GNUC__)TEST(CompressedTupleTest, EmptyFinalClass) {  struct S final {    int f() const { return 5; }  };  CompressedTuple<S> x;  EXPECT_EQ(x.get<0>().f(), 5);}#endif}  // namespace}  // namespace container_internal}  // inline namespace lts_2018_12_18}  // namespace absl
 |