folly/test/MapUtilTest.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/MapUtil.h>
  18
  19 #include <map>
  20 #include <unordered_map>
  21
  22 #include <folly/Traits.h>
  23 #include <folly/portability/GTest.h>
  24
  25 using namespace folly;
  26
  27 TEST(MapUtil, get_default) {
  28   std::map<int, int> m;
  29   m[1] = 2;
  30   EXPECT_EQ(2, get_default(m, 1, 42));
  31   EXPECT_EQ(42, get_default(m, 2, 42));
  32   EXPECT_EQ(0, get_default(m, 3));
  33 }
  34
  35 TEST(MapUtil, get_default_function) {
  36   std::map<int, int> m;
  37   m[1] = 2;
  38   EXPECT_EQ(2, get_default(m, 1, [] { return 42; }));
  39   EXPECT_EQ(42, get_default(m, 2, [] { return 42; }));
  40   EXPECT_EQ(0, get_default(m, 3));
  41 }
  42
  43 TEST(MapUtil, get_or_throw) {
  44   std::map<int, int> m;
  45   m[1] = 2;
  46   EXPECT_EQ(2, get_or_throw(m, 1));
  47   EXPECT_THROW(get_or_throw(m, 2), std::out_of_range);
  48   EXPECT_EQ(&m[1], &get_or_throw(m, 1));
  49   get_or_throw(m, 1) = 3;
  50   EXPECT_EQ(3, get_or_throw(m, 1));
  51   const auto& cm = m;
  52   EXPECT_EQ(&m[1], &get_or_throw(cm, 1));
  53   EXPECT_EQ(3, get_or_throw(cm, 1));
  54   EXPECT_THROW(get_or_throw(cm, 2), std::out_of_range);
  55 }
  56
  57 TEST(MapUtil, get_or_throw_specified) {
  58   std::map<int, int> m;
  59   m[1] = 2;
  60   EXPECT_EQ(2, get_or_throw<std::runtime_error>(m, 1));
  61   EXPECT_THROW(get_or_throw<std::runtime_error>(m, 2), std::runtime_error);
  62 }
  63
  64 TEST(MapUtil, get_optional) {
  65   std::map<int, int> m;
  66   m[1] = 2;
  67   EXPECT_TRUE(get_optional(m, 1).hasValue());
  68   EXPECT_EQ(2, get_optional(m, 1).value());
  69   EXPECT_FALSE(get_optional(m, 2).hasValue());
  70 }
  71
  72 TEST(MapUtil, get_ref_default) {
  73   std::map<int, int> m;
  74   m[1] = 2;
  75   const int i = 42;
  76   EXPECT_EQ(2, get_ref_default(m, 1, i));
  77   EXPECT_EQ(42, get_ref_default(m, 2, i));
  78   EXPECT_EQ(std::addressof(i), std::addressof(get_ref_default(m, 2, i)));
  79 }
  80
  81 TEST(MapUtil, get_ref_default_function) {
  82   std::map<int, int> m;
  83   m[1] = 2;
  84   const int i = 42;
  85   EXPECT_EQ(2, get_ref_default(m, 1, [&i]() -> const int& { return i; }));
  86   EXPECT_EQ(42, get_ref_default(m, 2, [&i]() -> const int& { return i; }));
  87   EXPECT_EQ(
  88       std::addressof(i),
  89       std::addressof(
  90           get_ref_default(m, 2, [&i]() -> const int& { return i; })));
  91   // statically disallowed:
  92   // get_ref_default(m, 2, [] { return 7; });
  93 }
  94
  95 TEST(MapUtil, get_ptr) {
  96   std::map<int, int> m;
  97   m[1] = 2;
  98   EXPECT_EQ(2, *get_ptr(m, 1));
  99   EXPECT_TRUE(get_ptr(m, 2) == nullptr);
 100   *get_ptr(m, 1) = 4;
 101   EXPECT_EQ(4, m.at(1));
 102 }
 103
 104 TEST(MapUtil, get_ptr_path_simple) {
 105   using std::map;
 106   map<int, map<int, map<int, map<int, int>>>> m{{1, {{2, {{3, {{4, 5}}}}}}}};
 107   EXPECT_EQ(5, *get_ptr(m, 1, 2, 3, 4));
 108   EXPECT_TRUE(get_ptr(m, 1, 2, 3, 4));
 109   EXPECT_FALSE(get_ptr(m, 1, 2, 3, 0));
 110   EXPECT_TRUE(get_ptr(m, 1, 2, 3));
 111   EXPECT_FALSE(get_ptr(m, 1, 2, 0));
 112   EXPECT_TRUE(get_ptr(m, 1, 2));
 113   EXPECT_FALSE(get_ptr(m, 1, 0));
 114   EXPECT_TRUE(get_ptr(m, 1));
 115   EXPECT_FALSE(get_ptr(m, 0));
 116   const auto& cm = m;
 117   ++*get_ptr(m, 1, 2, 3, 4);
 118   EXPECT_EQ(6, *get_ptr(cm, 1, 2, 3, 4));
 119   EXPECT_TRUE(get_ptr(cm, 1, 2, 3, 4));
 120   EXPECT_FALSE(get_ptr(cm, 1, 2, 3, 0));
 121 }
 122
 123 TEST(MapUtil, get_ptr_path_mixed) {
 124   using std::map;
 125   using std::unordered_map;
 126   using std::string;
 127   unordered_map<string, map<int, map<string, int>>> m{{"a", {{1, {{"b", 7}}}}}};
 128   EXPECT_EQ(7, *get_ptr(m, "a", 1, "b"));
 129   EXPECT_TRUE(get_ptr(m, "a", 1, "b"));
 130   EXPECT_FALSE(get_ptr(m, "b", 1, "b"));
 131   EXPECT_FALSE(get_ptr(m, "a", 2, "b"));
 132   EXPECT_FALSE(get_ptr(m, "a", 1, "c"));
 133   EXPECT_TRUE(get_ptr(m, "a", 1, "b"));
 134   EXPECT_TRUE(get_ptr(m, "a", 1));
 135   EXPECT_TRUE(get_ptr(m, "a"));
 136   const auto& cm = m;
 137   ++*get_ptr(m, "a", 1, "b");
 138   EXPECT_EQ(8, *get_ptr(cm, "a", 1, "b"));
 139   EXPECT_TRUE(get_ptr(cm, "a", 1, "b"));
 140   EXPECT_FALSE(get_ptr(cm, "b", 1, "b"));
 141 }
 142
 143 namespace {
 144 template <typename T, typename = void>
 145 struct Compiles : std::false_type {};
 146
 147 template <typename T>
 148 struct Compiles<
 149     T,
 150     void_t<decltype(get_ref_default(
 151         std::declval<std::map<int, typename std::decay<T>::type>>(),
 152         std::declval<int>(),
 153         std::declval<T>()))>> : std::true_type {};
 154 }
 155
 156 TEST(MapUtil, get_default_temporary) {
 157   EXPECT_TRUE(Compiles<const int&>::value);
 158   EXPECT_TRUE(Compiles<int&>::value);
 159   EXPECT_FALSE(Compiles<const int&&>::value);
 160   EXPECT_FALSE(Compiles<int&&>::value);
 161 }