8ec4999766
Instead of using `.fail.cpp` tests, use `.verify.cpp` to check for the exact reason of the failure. In the case of deduction guides, use SFINAE based tests instead since that is our preferred way of testing those. Finally, ensure that we actually run the test in `iter_alloc_deduction.pass.cpp`, since we were not running anything before. Differential Revision: https://reviews.llvm.org/D123055
116 lines
4.5 KiB
C++
116 lines
4.5 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// <string>
|
|
// UNSUPPORTED: c++03, c++11, c++14
|
|
|
|
// template<class InputIterator,
|
|
// class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
|
|
// basic_string(InputIterator, InputIterator, Allocator = Allocator())
|
|
// -> basic_string<typename iterator_traits<InputIterator>::value_type,
|
|
// char_traits<typename iterator_traits<InputIterator>::value_type>,
|
|
// Allocator>;
|
|
//
|
|
// The deduction guide shall not participate in overload resolution if InputIterator
|
|
// is a type that does not qualify as an input iterator, or if Allocator is a type
|
|
// that does not qualify as an allocator.
|
|
|
|
#include <cassert>
|
|
#include <cstddef>
|
|
#include <iterator>
|
|
#include <string>
|
|
#include <type_traits>
|
|
|
|
#include "test_macros.h"
|
|
#include "test_allocator.h"
|
|
#include "min_allocator.h"
|
|
|
|
class NotAnIterator {};
|
|
using NotAnInputIterator = std::back_insert_iterator<std::basic_string<char16_t>>;
|
|
|
|
template <typename T>
|
|
struct NotAnAllocator { typedef T value_type; };
|
|
|
|
template <class Iter, class Alloc, class = void>
|
|
struct CanDeduce : std::false_type { };
|
|
|
|
template <class Iter, class Alloc>
|
|
struct CanDeduce<Iter, Alloc, decltype((void)
|
|
std::basic_string{std::declval<Iter>(), std::declval<Iter>(), std::declval<Alloc>()}
|
|
)> : std::true_type { };
|
|
|
|
static_assert( CanDeduce<int*, std::allocator<int>>::value);
|
|
static_assert(!CanDeduce<NotAnIterator, std::allocator<char>>::value);
|
|
static_assert(!CanDeduce<NotAnInputIterator, std::allocator<char16_t>>::value);
|
|
static_assert(!CanDeduce<wchar_t const*, NotAnAllocator<wchar_t>>::value);
|
|
|
|
bool test() {
|
|
{
|
|
const char* s = "12345678901234";
|
|
std::basic_string s1(s, s+10); // Can't use {} here
|
|
using S = decltype(s1); // what type did we get?
|
|
static_assert(std::is_same_v<S::value_type, char>, "");
|
|
static_assert(std::is_same_v<S::traits_type, std::char_traits<char>>, "");
|
|
static_assert(std::is_same_v<S::allocator_type, std::allocator<char>>, "");
|
|
assert(s1.size() == 10);
|
|
assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
|
|
}
|
|
{
|
|
const char* s = "12345678901234";
|
|
std::basic_string s1{s, s+10, std::allocator<char>{}};
|
|
using S = decltype(s1); // what type did we get?
|
|
static_assert(std::is_same_v<S::value_type, char>, "");
|
|
static_assert(std::is_same_v<S::traits_type, std::char_traits<char>>, "");
|
|
static_assert(std::is_same_v<S::allocator_type, std::allocator<char>>, "");
|
|
assert(s1.size() == 10);
|
|
assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
|
|
}
|
|
{
|
|
const wchar_t* s = L"12345678901234";
|
|
std::basic_string s1{s, s+10, test_allocator<wchar_t>{}};
|
|
using S = decltype(s1); // what type did we get?
|
|
static_assert(std::is_same_v<S::value_type, wchar_t>, "");
|
|
static_assert(std::is_same_v<S::traits_type, std::char_traits<wchar_t>>, "");
|
|
static_assert(std::is_same_v<S::allocator_type, test_allocator<wchar_t>>, "");
|
|
assert(s1.size() == 10);
|
|
assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
|
|
}
|
|
{
|
|
const char16_t* s = u"12345678901234";
|
|
std::basic_string s1{s, s+10, min_allocator<char16_t>{}};
|
|
using S = decltype(s1); // what type did we get?
|
|
static_assert(std::is_same_v<S::value_type, char16_t>, "");
|
|
static_assert(std::is_same_v<S::traits_type, std::char_traits<char16_t>>, "");
|
|
static_assert(std::is_same_v<S::allocator_type, min_allocator<char16_t>>, "");
|
|
assert(s1.size() == 10);
|
|
assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
|
|
}
|
|
{
|
|
const char32_t* s = U"12345678901234";
|
|
std::basic_string s1{s, s+10, explicit_allocator<char32_t>{}};
|
|
using S = decltype(s1); // what type did we get?
|
|
static_assert(std::is_same_v<S::value_type, char32_t>, "");
|
|
static_assert(std::is_same_v<S::traits_type, std::char_traits<char32_t>>, "");
|
|
static_assert(std::is_same_v<S::allocator_type, explicit_allocator<char32_t>>, "");
|
|
assert(s1.size() == 10);
|
|
assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int main(int, char**)
|
|
{
|
|
test();
|
|
#if TEST_STD_VER > 17
|
|
// static_assert(test());
|
|
#endif
|
|
|
|
return 0;
|
|
}
|