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
125 lines
4.7 KiB
C++
125 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// <string>
|
|
// UNSUPPORTED: c++03, c++11, c++14
|
|
|
|
// template<class charT,
|
|
// class traits,
|
|
// class Allocator = allocator<charT>
|
|
// >
|
|
// basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
|
|
// -> basic_string<charT, traits, Allocator>;
|
|
//
|
|
// The deduction guide shall not participate in overload resolution if Allocator
|
|
// is a type that does not qualify as an allocator.
|
|
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <iterator>
|
|
#include <memory>
|
|
#include <type_traits>
|
|
#include <cassert>
|
|
#include <cstddef>
|
|
|
|
#include "test_macros.h"
|
|
#include "test_allocator.h"
|
|
#include "min_allocator.h"
|
|
|
|
template <class StringView, class Allocator, class = void>
|
|
struct CanDeduce : std::false_type { };
|
|
|
|
template <class StringView, class Allocator>
|
|
struct CanDeduce<StringView, Allocator, decltype((void)
|
|
std::basic_string{std::declval<StringView>(), std::declval<Allocator>()}
|
|
)> : std::true_type { };
|
|
|
|
struct NotAnAllocator { };
|
|
static_assert( CanDeduce<std::string_view, std::allocator<char>>::value);
|
|
static_assert(!CanDeduce<std::string_view, NotAnAllocator>::value);
|
|
|
|
bool test() {
|
|
{
|
|
std::string_view sv = "12345678901234";
|
|
std::basic_string s1(sv);
|
|
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() == sv.size());
|
|
assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
|
|
}
|
|
|
|
{
|
|
std::string_view sv = "12345678901234";
|
|
std::basic_string s1{sv, 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() == sv.size());
|
|
assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
|
|
}
|
|
#ifndef TEST_HAS_NO_WIDE_CHARACTERS
|
|
{
|
|
std::wstring_view sv = L"12345678901234";
|
|
std::basic_string s1{sv, 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() == sv.size());
|
|
assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
|
|
}
|
|
#endif
|
|
#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
|
|
{
|
|
std::u8string_view sv = u8"12345678901234";
|
|
std::basic_string s1{sv, min_allocator<char8_t>{}};
|
|
using S = decltype(s1); // what type did we get?
|
|
static_assert(std::is_same_v<S::value_type, char8_t>, "");
|
|
static_assert(std::is_same_v<S::traits_type, std::char_traits<char8_t>>, "");
|
|
static_assert(std::is_same_v<S::allocator_type, min_allocator<char8_t>>, "");
|
|
assert(s1.size() == sv.size());
|
|
assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
|
|
}
|
|
#endif
|
|
{
|
|
std::u16string_view sv = u"12345678901234";
|
|
std::basic_string s1{sv, 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() == sv.size());
|
|
assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
|
|
}
|
|
{
|
|
std::u32string_view sv = U"12345678901234";
|
|
std::basic_string s1{sv, 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() == sv.size());
|
|
assert(s1.compare(0, s1.size(), sv.data(), s1.size()) == 0);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int main(int, char**)
|
|
{
|
|
test();
|
|
#if TEST_STD_VER > 17
|
|
// static_assert(test());
|
|
#endif
|
|
|
|
return 0;
|
|
}
|