libcxx/test/support/test_transparent_unordered.h

   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-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef TEST_TRANSPARENT_UNORDERED_H
  10 #define TEST_TRANSPARENT_UNORDERED_H
  11
  12 #include "test_macros.h"
  13 #include "is_transparent.h"
  14
  15 #include <cassert>
  16
  17 // testing transparent unordered containers
  18 #if TEST_STD_VER > 17
  19
  20 template <template <typename...> class UnorderedSet, typename Hash,
  21           typename Equal>
  22 using unord_set_type = UnorderedSet<StoredType<int>, Hash, Equal>;
  23
  24 template <template <typename...> class UnorderedMap, typename Hash,
  25           typename Equal>
  26 using unord_map_type = UnorderedMap<StoredType<int>, int, Hash, Equal>;
  27
  28 template <typename Container, typename... Args>
  29 void test_transparent_find(Args&&... args) {
  30   Container c{std::forward<Args>(args)...};
  31   int conversions = 0;
  32   assert(c.find(SearchedType<int>(1, &conversions)) != c.end());
  33   assert(c.find(SearchedType<int>(2, &conversions)) != c.end());
  34   assert(conversions == 0);
  35   assert(c.find(SearchedType<int>(3, &conversions)) == c.end());
  36   assert(conversions == 0);
  37 }
  38
  39 template <typename Container, typename... Args>
  40 void test_non_transparent_find(Args&&... args) {
  41   Container c{std::forward<Args>(args)...};
  42   int conversions = 0;
  43   assert(c.find(SearchedType<int>(1, &conversions)) != c.end());
  44   assert(conversions > 0);
  45   conversions = 0;
  46   assert(c.find(SearchedType<int>(2, &conversions)) != c.end());
  47   assert(conversions > 0);
  48   conversions = 0;
  49   assert(c.find(SearchedType<int>(3, &conversions)) == c.end());
  50   assert(conversions > 0);
  51 }
  52
  53 template <typename Container, typename... Args>
  54 void test_transparent_count(Args&&... args) {
  55   Container c{std::forward<Args>(args)...};
  56   int conversions = 0;
  57   assert(c.count(SearchedType<int>(1, &conversions)) > 0);
  58   assert(c.count(SearchedType<int>(2, &conversions)) > 0);
  59   assert(conversions == 0);
  60   assert(c.count(SearchedType<int>(3, &conversions)) == 0);
  61   assert(conversions == 0);
  62 }
  63
  64 template <typename Container, typename... Args>
  65 void test_non_transparent_count(Args&&... args) {
  66   Container c{std::forward<Args>(args)...};
  67   int conversions = 0;
  68   assert(c.count(SearchedType<int>(1, &conversions)) > 0);
  69   assert(conversions > 0);
  70   conversions = 0;
  71   assert(c.count(SearchedType<int>(2, &conversions)) > 0);
  72   assert(conversions > 0);
  73   conversions = 0;
  74   assert(c.count(SearchedType<int>(3, &conversions)) == 0);
  75   assert(conversions > 0);
  76 }
  77
  78 template <typename Container, typename... Args>
  79 void test_transparent_contains(Args&&... args) {
  80   Container c{std::forward<Args>(args)...};
  81   int conversions = 0;
  82   assert(c.contains(SearchedType<int>(1, &conversions)));
  83   assert(c.contains(SearchedType<int>(2, &conversions)));
  84   assert(conversions == 0);
  85   assert(!c.contains(SearchedType<int>(3, &conversions)));
  86   assert(conversions == 0);
  87 }
  88
  89 template <typename Container, typename... Args>
  90 void test_non_transparent_contains(Args&&... args) {
  91   Container c{std::forward<Args>(args)...};
  92   int conversions = 0;
  93   assert(c.contains(SearchedType<int>(1, &conversions)));
  94   assert(conversions > 0);
  95   conversions = 0;
  96   assert(c.contains(SearchedType<int>(2, &conversions)));
  97   assert(conversions > 0);
  98   conversions = 0;
  99   assert(!c.contains(SearchedType<int>(3, &conversions)));
 100   assert(conversions > 0);
 101 }
 102
 103 template <typename Container, typename... Args>
 104 void test_transparent_equal_range(Args&&... args) {
 105   Container c{std::forward<Args>(args)...};
 106   int conversions = 0;
 107   auto iters = c.equal_range(SearchedType<int>(1, &conversions));
 108   assert(std::distance(iters.first, iters.second) > 0);
 109   iters = c.equal_range(SearchedType<int>(2, &conversions));
 110   assert(std::distance(iters.first, iters.second) > 0);
 111   assert(conversions == 0);
 112   iters = c.equal_range(SearchedType<int>(3, &conversions));
 113   assert(std::distance(iters.first, iters.second) == 0);
 114   assert(conversions == 0);
 115 }
 116
 117 template <typename Container, typename... Args>
 118 void test_non_transparent_equal_range(Args&&... args) {
 119   Container c{std::forward<Args>(args)...};
 120   int conversions = 0;
 121   auto iters = c.equal_range(SearchedType<int>(1, &conversions));
 122   assert(std::distance(iters.first, iters.second) > 0);
 123   assert(conversions > 0);
 124   conversions = 0;
 125   iters = c.equal_range(SearchedType<int>(2, &conversions));
 126   assert(std::distance(iters.first, iters.second) > 0);
 127   assert(conversions > 0);
 128   conversions = 0;
 129   iters = c.equal_range(SearchedType<int>(3, &conversions));
 130   assert(std::distance(iters.first, iters.second) == 0);
 131   assert(conversions > 0);
 132 }
 133
 134 #endif // TEST_STD_VER > 17
 135
 136 #endif // TEST_TRANSPARENT_UNORDERED_H