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>
 145 struct element_type {
 146   using type = typename std::decay<T>::type;
 147 };
 148
 149 template <typename T>
 150 struct element_type<T()> {
 151   using type = T;
 152 };
 153
 154 template <typename T>
 155 using element_type_t = typename element_type<T>::type;
 156
 157 template <typename T, typename = void>
 158 struct Compiles : std::false_type {};
 159
 160 template <typename T>
 161 struct Compiles<
 162     T,
 163     void_t<decltype(get_ref_default(
 164         std::declval<std::map<int, element_type_t<T>>>(),
 165         std::declval<int>(),
 166         std::declval<T>()))>> : std::true_type {};
 167 } // namespace
 168
 169 TEST(MapUtil, get_default_temporary) {
 170   EXPECT_TRUE(Compiles<const int&>::value);
 171   EXPECT_TRUE(Compiles<int&>::value);
 172   EXPECT_FALSE(Compiles<const int&&>::value);
 173   EXPECT_FALSE(Compiles<int&&>::value);
 174
 175   EXPECT_TRUE(Compiles<const int&()>::value);
 176   EXPECT_TRUE(Compiles<int&()>::value);
 177   EXPECT_FALSE(Compiles<int()>::value);
 178 }
 179
 180 TEST(MapUtil, get_default_path) {
 181   using std::map;
 182   map<int, map<int, int>> m;
 183   m[4][2] = 42;
 184   EXPECT_EQ(42, get_default(m, 4, 2, 42));
 185   EXPECT_EQ(42, get_default(m, 1, 3, 42));
 186 }
 187
 188 TEST(MapUtil, get_default_path_mixed) {
 189   using std::map;
 190   using std::unordered_map;
 191   using std::string;
 192   map<int, unordered_map<string, StringPiece>> m;
 193   int key1 = 42;
 194   const string key2 = "hello";
 195   constexpr StringPiece value = "world";
 196   constexpr StringPiece dflt = "default";
 197   m[key1][key2] = value;
 198   EXPECT_EQ(value, get_default(m, 42, key2, dflt));
 199   EXPECT_EQ(value, get_default(m, key1, "hello", dflt));
 200   EXPECT_EQ(dflt, get_default(m, 0, key2, dflt));
 201   EXPECT_EQ(dflt, get_default(m, key1, "bad", "default"));
 202 }
 203
 204 TEST(MapUtil, get_ref_default_path) {
 205   using std::map;
 206   map<int, map<int, int>> m;
 207   m[4][2] = 42;
 208   const int dflt = 13;
 209   EXPECT_EQ(42, get_ref_default(m, 4, 2, dflt));
 210   EXPECT_EQ(dflt, get_ref_default(m, 1, 3, dflt));
 211 }
 212
 213 TEST(MapUtil, get_ref_default_path_mixed) {
 214   using std::map;
 215   using std::unordered_map;
 216   using std::string;
 217   map<int, unordered_map<string, StringPiece>> m;
 218   int key1 = 42;
 219   const string key2 = "hello";
 220   constexpr StringPiece value = "world";
 221   constexpr StringPiece dflt = "default";
 222   m[key1][key2] = value;
 223   EXPECT_EQ(value, get_ref_default(m, 42, key2, dflt));
 224   EXPECT_EQ(value, get_ref_default(m, key1, "hello", dflt));
 225   EXPECT_EQ(dflt, get_ref_default(m, 0, key2, dflt));
 226   EXPECT_EQ(dflt, get_ref_default(m, key1, "bad", dflt));
 227 }
 228
 229 namespace {
 230 template <typename T, typename = void>
 231 struct GetRefDefaultPathCompiles : std::false_type {};
 232
 233 template <typename T>
 234 struct GetRefDefaultPathCompiles<
 235     T,
 236     void_t<decltype(get_ref_default(
 237         std::declval<std::map<int, std::map<int, element_type_t<T>>>>(),
 238         std::declval<int>(),
 239         std::declval<int>(),
 240         std::declval<T>()))>> : std::true_type {};
 241 } // namespace
 242
 243 TEST(MapUtil, get_ref_default_path_temporary) {
 244   EXPECT_TRUE(GetRefDefaultPathCompiles<const int&>::value);
 245   EXPECT_TRUE(GetRefDefaultPathCompiles<int&>::value);
 246   EXPECT_FALSE(GetRefDefaultPathCompiles<const int&&>::value);
 247   EXPECT_FALSE(GetRefDefaultPathCompiles<int&&>::value);
 248 }