mirror of
https://github.com/darlinghq/darling-libcxx.git
synced 2024-11-26 21:30:42 +00:00
a574ade231
It turns out that llvmorg-14.0.6 might be too new for dyld (the vector base class no longer exist in that release).
137 lines
4.7 KiB
C++
137 lines
4.7 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// 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
|