362 lines · cpp
1//===----------------------------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9// UNSUPPORTED: c++03, c++11, c++14, c++17, c++2010 11// <flat_map>12 13#include <algorithm>14#include <array>15#include <cassert>16#include <climits>17#include <deque>18#include <initializer_list>19#include <list>20#include <flat_map>21#include <functional>22#include <ranges>23#include <tuple>24#include <type_traits>25#include <utility>26#include <vector>27 28#include "deduction_guides_sfinae_checks.h"29#include "test_allocator.h"30 31using P = std::pair<int, long>;32using PC = std::pair<const int, long>;33 34void test_copy() {35 {36 std::flat_map<long, short> source = {{1, 2}, {2, 3}};37 std::flat_map s(source);38 ASSERT_SAME_TYPE(decltype(s), decltype(source));39 assert(s == source);40 }41 {42 std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};43 std::flat_map s{source}; // braces instead of parens44 ASSERT_SAME_TYPE(decltype(s), decltype(source));45 assert(s == source);46 }47 {48 std::flat_map<long, short, std::greater<long>> source = {{1, 2}, {2, 3}};49 std::flat_map s(source, std::allocator<int>());50 ASSERT_SAME_TYPE(decltype(s), decltype(source));51 assert(s == source);52 }53}54 55void test_containers() {56 std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));57 std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));58 std::deque<int, test_allocator<int>> sorted_ks({1, 2, 3, INT_MAX}, test_allocator<int>(0, 42));59 std::deque<short, test_allocator<short>> sorted_vs({1, 2, 5, 4}, test_allocator<int>(0, 43));60 const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};61 {62 std::flat_map s(ks, vs);63 64 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);65 assert(std::ranges::equal(s, expected));66 assert(s.keys().get_allocator().get_id() == 42);67 assert(s.values().get_allocator().get_id() == 43);68 }69 {70 std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs);71 72 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);73 assert(std::ranges::equal(s, expected));74 assert(s.keys().get_allocator().get_id() == 42);75 assert(s.values().get_allocator().get_id() == 43);76 }77 {78 std::flat_map s(ks, vs, test_allocator<long>(0, 44));79 80 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);81 assert(std::ranges::equal(s, expected));82 assert(s.keys().get_allocator().get_id() == 44);83 assert(s.values().get_allocator().get_id() == 44);84 }85 {86 std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, test_allocator<long>(0, 44));87 88 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>, decltype(ks), decltype(vs)>);89 assert(std::ranges::equal(s, expected));90 assert(s.keys().get_allocator().get_id() == 44);91 assert(s.values().get_allocator().get_id() == 44);92 }93}94 95void test_containers_compare() {96 std::deque<int, test_allocator<int>> ks({1, 2, 1, INT_MAX, 3}, test_allocator<int>(0, 42));97 std::deque<short, test_allocator<short>> vs({1, 2, 1, 4, 5}, test_allocator<int>(0, 43));98 std::deque<int, test_allocator<int>> sorted_ks({INT_MAX, 3, 2, 1}, test_allocator<int>(0, 42));99 std::deque<short, test_allocator<short>> sorted_vs({4, 5, 2, 1}, test_allocator<int>(0, 43));100 const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};101 {102 std::flat_map s(ks, vs, std::greater<int>());103 104 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);105 assert(std::ranges::equal(s, expected));106 assert(s.keys().get_allocator().get_id() == 42);107 assert(s.values().get_allocator().get_id() == 43);108 }109 {110 std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, std::greater<int>());111 112 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);113 assert(std::ranges::equal(s, expected));114 assert(s.keys().get_allocator().get_id() == 42);115 assert(s.values().get_allocator().get_id() == 43);116 }117 {118 std::flat_map s(ks, vs, std::greater<int>(), test_allocator<long>(0, 44));119 120 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);121 assert(std::ranges::equal(s, expected));122 assert(s.keys().get_allocator().get_id() == 44);123 assert(s.values().get_allocator().get_id() == 44);124 }125 {126 std::flat_map s(std::sorted_unique, sorted_ks, sorted_vs, std::greater<int>(), test_allocator<long>(0, 44));127 128 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>, decltype(ks), decltype(vs)>);129 assert(std::ranges::equal(s, expected));130 assert(s.keys().get_allocator().get_id() == 44);131 assert(s.values().get_allocator().get_id() == 44);132 }133}134 135void test_iter_iter() {136 const P arr[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};137 const P sorted_arr[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};138 const PC arrc[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};139 const PC sorted_arrc[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};140 {141 std::flat_map m(std::begin(arr), std::end(arr));142 143 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);144 assert(std::ranges::equal(m, sorted_arr));145 }146 {147 std::flat_map m(std::begin(arrc), std::end(arrc));148 149 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);150 assert(std::ranges::equal(m, sorted_arr));151 }152 {153 std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr));154 155 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);156 assert(std::ranges::equal(m, sorted_arr));157 }158 {159 std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc));160 161 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);162 assert(std::ranges::equal(m, sorted_arr));163 }164 {165 std::flat_map<int, short> mo;166 std::flat_map m(mo.begin(), mo.end());167 ASSERT_SAME_TYPE(decltype(m), decltype(mo));168 }169 {170 std::flat_map<int, short> mo;171 std::flat_map m(mo.cbegin(), mo.cend());172 ASSERT_SAME_TYPE(decltype(m), decltype(mo));173 }174 {175 std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};176 std::flat_map s = {source, source + 3}; // flat_map(InputIterator, InputIterator)177 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, int>);178 assert(s.size() == 3);179 }180 {181 std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};182 std::flat_map s{source, source + 3}; // flat_map(InputIterator, InputIterator)183 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, int>);184 assert(s.size() == 3);185 }186 {187 std::pair<int, int> source[3] = {{1, 1}, {2, 2}, {3, 3}};188 std::flat_map s{std::sorted_unique, source, source + 3}; // flat_map(sorted_unique_t, InputIterator, InputIterator)189 static_assert(std::is_same_v<decltype(s), std::flat_map<int, int>>);190 assert(s.size() == 3);191 }192}193 194void test_iter_iter_compare() {195 const P arr[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};196 const P sorted_arr[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};197 const PC arrc[] = {{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};198 const PC sorted_arrc[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};199 using C = std::greater<long long>;200 {201 std::flat_map m(std::begin(arr), std::end(arr), C());202 203 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);204 assert(std::ranges::equal(m, sorted_arr));205 }206 {207 std::flat_map m(std::begin(arrc), std::end(arrc), C());208 209 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);210 assert(std::ranges::equal(m, sorted_arr));211 }212 {213 std::flat_map m(std::sorted_unique, std::begin(sorted_arr), std::end(sorted_arr), C());214 215 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);216 assert(std::ranges::equal(m, sorted_arr));217 }218 {219 std::flat_map m(std::sorted_unique, std::begin(sorted_arrc), std::end(sorted_arrc), C());220 221 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);222 assert(std::ranges::equal(m, sorted_arr));223 }224 {225 std::flat_map<int, short> mo;226 std::flat_map m(mo.begin(), mo.end(), C());227 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, short, C>);228 }229 {230 std::flat_map<int, short> mo;231 std::flat_map m(mo.cbegin(), mo.cend(), C());232 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, short, C>);233 }234}235 236void test_initializer_list() {237 const P sorted_arr[] = {{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}};238 {239 std::flat_map m{std::pair{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}};240 241 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);242 assert(std::ranges::equal(m, sorted_arr));243 }244 {245 std::flat_map m(std::sorted_unique, {std::pair{1, 1L}, {2, 2L}, {3, 1L}, {INT_MAX, 1L}});246 247 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long>);248 assert(std::ranges::equal(m, sorted_arr));249 }250 {251 std::flat_map s = {std::make_pair(1, 'a')}; // flat_map(initializer_list<pair<int, char>>)252 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, char>);253 assert(s.size() == 1);254 }255 {256 using M = std::flat_map<int, short>;257 M m;258 std::flat_map s = {std::make_pair(m, m)}; // flat_map(initializer_list<pair<M, M>>)259 ASSERT_SAME_TYPE(decltype(s), std::flat_map<M, M>);260 assert(s.size() == 1);261 assert(s[m] == m);262 }263}264 265void test_initializer_list_compare() {266 const P sorted_arr[] = {{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}};267 using C = std::greater<long long>;268 {269 std::flat_map m({std::pair{1, 1L}, {2, 2L}, {1, 1L}, {INT_MAX, 1L}, {3, 1L}}, C());270 271 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);272 assert(std::ranges::equal(m, sorted_arr));273 }274 {275 std::flat_map m(std::sorted_unique, {std::pair{INT_MAX, 1L}, {3, 1L}, {2, 2L}, {1, 1L}}, C());276 277 ASSERT_SAME_TYPE(decltype(m), std::flat_map<int, long, C>);278 assert(std::ranges::equal(m, sorted_arr));279 }280}281 282void test_from_range() {283 std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};284 const std::pair<int, short> expected[] = {{1, 1}, {2, 2}, {3, 5}, {INT_MAX, 4}};285 {286 std::flat_map s(std::from_range, r);287 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::less<int>>);288 assert(std::ranges::equal(s, expected));289 }290 {291 std::flat_map s(std::from_range, r, test_allocator<long>(0, 42));292 ASSERT_SAME_TYPE(293 decltype(s),294 std::flat_map<int,295 short,296 std::less<int>,297 std::vector<int, test_allocator<int>>,298 std::vector<short, test_allocator<short>>>);299 assert(std::ranges::equal(s, expected));300 assert(s.keys().get_allocator().get_id() == 42);301 assert(s.values().get_allocator().get_id() == 42);302 }303}304 305void test_from_range_compare() {306 std::list<std::pair<int, short>> r = {{1, 1}, {2, 2}, {1, 1}, {INT_MAX, 4}, {3, 5}};307 const std::pair<int, short> expected[] = {{INT_MAX, 4}, {3, 5}, {2, 2}, {1, 1}};308 {309 std::flat_map s(std::from_range, r, std::greater<int>());310 ASSERT_SAME_TYPE(decltype(s), std::flat_map<int, short, std::greater<int>>);311 assert(std::ranges::equal(s, expected));312 }313 {314 std::flat_map s(std::from_range, r, std::greater<int>(), test_allocator<long>(0, 42));315 ASSERT_SAME_TYPE(316 decltype(s),317 std::flat_map<int,318 short,319 std::greater<int>,320 std::vector<int, test_allocator<int>>,321 std::vector<short, test_allocator<short>>>);322 assert(std::ranges::equal(s, expected));323 assert(s.keys().get_allocator().get_id() == 42);324 assert(s.values().get_allocator().get_id() == 42);325 }326}327 328int main(int, char**) {329 // Each test function also tests the sorted_unique-prefixed and allocator-suffixed overloads.330 test_copy();331 test_containers();332 test_containers_compare();333 test_iter_iter();334 test_iter_iter_compare();335 test_initializer_list();336 test_initializer_list_compare();337 test_from_range();338 test_from_range_compare();339 340#if TEST_STD_VER >= 23341 std::vector<std::pair<const int, float>> pair_vec = {{1, 1.1f}, {2, 2.2f}, {3, 3.3f}};342 std::flat_map fm1(pair_vec.begin(), pair_vec.end());343 ASSERT_SAME_TYPE(decltype(fm1), std::flat_map<int, float>);344 345 std::vector<std::tuple<int, double>> tuple_vec = {{10, 1.1}, {20, 2.2}, {30, 3.3}};346 std::flat_map fm2(tuple_vec.begin(), tuple_vec.end());347 ASSERT_SAME_TYPE(decltype(fm2), std::flat_map<int, double>);348 349 std::vector<std::array<long, 2>> array_vec = {{100L, 101L}, {200L, 201L}, {300L, 301L}};350 std::flat_map fm3(array_vec.begin(), array_vec.end());351 ASSERT_SAME_TYPE(decltype(fm3), std::flat_map<long, long>);352 353 std::vector<std::pair<int, char>> non_const_key_pair_vec = {{5, 'a'}, {6, 'b'}};354 std::flat_map fm4(non_const_key_pair_vec.begin(), non_const_key_pair_vec.end());355 ASSERT_SAME_TYPE(decltype(fm4), std::flat_map<int, char>);356#endif357 358 AssociativeContainerDeductionGuidesSfinaeAway<std::flat_map, std::flat_map<int, short>>();359 360 return 0;361}362