test/support/test_transparent_unordered.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef TEST_TRANSPARENT_UNORDERED_H
#define TEST_TRANSPARENT_UNORDERED_H

#include "test_macros.h"
#include "is_transparent.h"

#include <cassert>

// testing transparent unordered containers
#if TEST_STD_VER > 17

template <template <typename...> class UnorderedSet, typename Hash,
          typename Equal>
using unord_set_type = UnorderedSet<StoredType<int>, Hash, Equal>;

template <template <typename...> class UnorderedMap, typename Hash,
          typename Equal>
using unord_map_type = UnorderedMap<StoredType<int>, int, Hash, Equal>;

template <typename Container, typename... Args>
void test_transparent_find(Args&&... args) {
  Container c{std::forward<Args>(args)...};
  int conversions = 0;
  assert(c.find(SearchedType<int>(1, &conversions)) != c.end());
  assert(c.find(SearchedType<int>(2, &conversions)) != c.end());
  assert(conversions == 0);
  assert(c.find(SearchedType<int>(3, &conversions)) == c.end());
  assert(conversions == 0);
}

template <typename Container, typename... Args>
void test_non_transparent_find(Args&&... args) {
  Container c{std::forward<Args>(args)...};
  int conversions = 0;
  assert(c.find(SearchedType<int>(1, &conversions)) != c.end());
  assert(conversions > 0);
  conversions = 0;
  assert(c.find(SearchedType<int>(2, &conversions)) != c.end());
  assert(conversions > 0);
  conversions = 0;
  assert(c.find(SearchedType<int>(3, &conversions)) == c.end());
  assert(conversions > 0);
}

template <typename Container, typename... Args>
void test_transparent_count(Args&&... args) {
  Container c{std::forward<Args>(args)...};
  int conversions = 0;
  assert(c.count(SearchedType<int>(1, &conversions)) > 0);
  assert(c.count(SearchedType<int>(2, &conversions)) > 0);
  assert(conversions == 0);
  assert(c.count(SearchedType<int>(3, &conversions)) == 0);
  assert(conversions == 0);
}

template <typename Container, typename... Args>
void test_non_transparent_count(Args&&... args) {
  Container c{std::forward<Args>(args)...};
  int conversions = 0;
  assert(c.count(SearchedType<int>(1, &conversions)) > 0);
  assert(conversions > 0);
  conversions = 0;
  assert(c.count(SearchedType<int>(2, &conversions)) > 0);
  assert(conversions > 0);
  conversions = 0;
  assert(c.count(SearchedType<int>(3, &conversions)) == 0);
  assert(conversions > 0);
}

template <typename Container, typename... Args>
void test_transparent_contains(Args&&... args) {
  Container c{std::forward<Args>(args)...};
  int conversions = 0;
  assert(c.contains(SearchedType<int>(1, &conversions)));
  assert(c.contains(SearchedType<int>(2, &conversions)));
  assert(conversions == 0);
  assert(!c.contains(SearchedType<int>(3, &conversions)));
  assert(conversions == 0);
}

template <typename Container, typename... Args>
void test_non_transparent_contains(Args&&... args) {
  Container c{std::forward<Args>(args)...};
  int conversions = 0;
  assert(c.contains(SearchedType<int>(1, &conversions)));
  assert(conversions > 0);
  conversions = 0;
  assert(c.contains(SearchedType<int>(2, &conversions)));
  assert(conversions > 0);
  conversions = 0;
  assert(!c.contains(SearchedType<int>(3, &conversions)));
  assert(conversions > 0);
}

template <typename Container, typename... Args>
void test_transparent_equal_range(Args&&... args) {
  Container c{std::forward<Args>(args)...};
  int conversions = 0;
  auto iters = c.equal_range(SearchedType<int>(1, &conversions));
  assert(std::distance(iters.first, iters.second) > 0);
  iters = c.equal_range(SearchedType<int>(2, &conversions));
  assert(std::distance(iters.first, iters.second) > 0);
  assert(conversions == 0);
  iters = c.equal_range(SearchedType<int>(3, &conversions));
  assert(std::distance(iters.first, iters.second) == 0);
  assert(conversions == 0);
}

template <typename Container, typename... Args>
void test_non_transparent_equal_range(Args&&... args) {
  Container c{std::forward<Args>(args)...};
  int conversions = 0;
  auto iters = c.equal_range(SearchedType<int>(1, &conversions));
  assert(std::distance(iters.first, iters.second) > 0);
  assert(conversions > 0);
  conversions = 0;
  iters = c.equal_range(SearchedType<int>(2, &conversions));
  assert(std::distance(iters.first, iters.second) > 0);
  assert(conversions > 0);
  conversions = 0;
  iters = c.equal_range(SearchedType<int>(3, &conversions));
  assert(std::distance(iters.first, iters.second) == 0);
  assert(conversions > 0);
}

#endif // TEST_STD_VER > 17

#endif // TEST_TRANSPARENT_UNORDERED_H