mirror of
https://github.com/llvm-mirror/libcxx.git
synced 2025-10-23 01:18:52 +08:00

As I move towards implementing std::filesystem, there is a need to make the existing tests run against both the std and experimental versions. Additionally, it's helpful to allow running the tests against other implementations of filesystem. This patch converts the test to easily target either. First, it adds a filesystem_include.hpp header which is soley responsible for selecting and including the correct implementation. Second, it converts existing tests to use this header instead of including filesystem directly. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@328475 91177308-0d34-0410-b5e6-96231b3b80d8
389 lines
10 KiB
C++
389 lines
10 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// UNSUPPORTED: c++98, c++03
|
|
|
|
// <experimental/filesystem>
|
|
|
|
// class path
|
|
|
|
// path& operator+=(const path& x);
|
|
// path& operator+=(const string_type& x);
|
|
// path& operator+=(string_view x);
|
|
// path& operator+=(const value_type* x);
|
|
// path& operator+=(value_type x);
|
|
// template <class Source>
|
|
// path& operator+=(const Source& x);
|
|
// template <class EcharT>
|
|
// path& operator+=(EcharT x);
|
|
// template <class Source>
|
|
// path& concat(const Source& x);
|
|
// template <class InputIterator>
|
|
// path& concat(InputIterator first, InputIterator last);
|
|
|
|
|
|
#include "filesystem_include.hpp"
|
|
#include <type_traits>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <cassert>
|
|
|
|
#include "test_macros.h"
|
|
#include "test_iterators.h"
|
|
#include "count_new.hpp"
|
|
#include "filesystem_test_helper.hpp"
|
|
|
|
|
|
struct ConcatOperatorTestcase {
|
|
MultiStringType lhs;
|
|
MultiStringType rhs;
|
|
MultiStringType expect;
|
|
};
|
|
|
|
#define LONGSTR "LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR_LONGSTR"
|
|
#define S(Str) MKSTR(Str)
|
|
const ConcatOperatorTestcase Cases[] =
|
|
{
|
|
{S(""), S(""), S("")}
|
|
, {S("p1"), S("p2"), S("p1p2")}
|
|
, {S("p1/"), S("/p2"), S("p1//p2")}
|
|
, {S(""), S("\\foo/bar/baz"), S("\\foo/bar/baz")}
|
|
, {S("c:\\foo"), S(""), S("c:\\foo")}
|
|
, {S(LONGSTR), S("foo"), S(LONGSTR "foo")}
|
|
, {S("abcdefghijklmnopqrstuvwxyz/\\"), S("/\\123456789"), S("abcdefghijklmnopqrstuvwxyz/\\/\\123456789")}
|
|
};
|
|
const ConcatOperatorTestcase LongLHSCases[] =
|
|
{
|
|
{S(""), S(LONGSTR), S(LONGSTR)}
|
|
, {S("p1/"), S(LONGSTR), S("p1/" LONGSTR)}
|
|
};
|
|
const ConcatOperatorTestcase CharTestCases[] =
|
|
{
|
|
{S(""), S("P"), S("P")}
|
|
, {S("/fooba"), S("r"), S("/foobar")}
|
|
};
|
|
#undef S
|
|
#undef LONGSTR
|
|
|
|
// The concat operator may need to allocate a temporary buffer before a code_cvt
|
|
// conversion. Test if this allocation occurs by:
|
|
// 1. Create a path, `LHS`, and reserve enough space to append `RHS`.
|
|
// This prevents `LHS` from allocating during the actual appending.
|
|
// 2. Create a `Source` object `RHS`, which represents a "large" string.
|
|
// (The string must not trigger the SSO)
|
|
// 3. Concat `RHS` to `LHS` and check for the expected allocation behavior.
|
|
template <class CharT>
|
|
void doConcatSourceAllocTest(ConcatOperatorTestcase const& TC)
|
|
{
|
|
using namespace fs;
|
|
using Ptr = CharT const*;
|
|
using Str = std::basic_string<CharT>;
|
|
using StrView = std::basic_string_view<CharT>;
|
|
using InputIter = input_iterator<Ptr>;
|
|
|
|
const Ptr L = TC.lhs;
|
|
const Ptr R = TC.rhs;
|
|
const Ptr E = TC.expect;
|
|
std::size_t ReserveSize = StrLen(E) + 1;
|
|
// basic_string
|
|
{
|
|
path LHS(L); PathReserve(LHS, ReserveSize);
|
|
Str RHS(R);
|
|
{
|
|
DisableAllocationGuard g;
|
|
LHS += RHS;
|
|
}
|
|
assert(LHS == E);
|
|
}
|
|
// basic_string_view
|
|
{
|
|
path LHS(L); PathReserve(LHS, ReserveSize);
|
|
StrView RHS(R);
|
|
{
|
|
DisableAllocationGuard g;
|
|
LHS += RHS;
|
|
}
|
|
assert(LHS == E);
|
|
}
|
|
// CharT*
|
|
{
|
|
path LHS(L); PathReserve(LHS, ReserveSize);
|
|
Ptr RHS(R);
|
|
{
|
|
DisableAllocationGuard g;
|
|
LHS += RHS;
|
|
}
|
|
assert(LHS == E);
|
|
}
|
|
{
|
|
path LHS(L); PathReserve(LHS, ReserveSize);
|
|
Ptr RHS(R);
|
|
{
|
|
DisableAllocationGuard g;
|
|
LHS.concat(RHS, StrEnd(RHS));
|
|
}
|
|
assert(LHS == E);
|
|
}
|
|
// input iterator - For non-native char types, appends needs to copy the
|
|
// iterator range into a contiguous block of memory before it can perform the
|
|
// code_cvt conversions.
|
|
// For "char" no allocations will be performed because no conversion is
|
|
// required.
|
|
bool DisableAllocations = std::is_same<CharT, char>::value;
|
|
{
|
|
path LHS(L); PathReserve(LHS, ReserveSize);
|
|
InputIter RHS(R);
|
|
{
|
|
RequireAllocationGuard g; // requires 1 or more allocations occur by default
|
|
if (DisableAllocations) g.requireExactly(0);
|
|
LHS += RHS;
|
|
}
|
|
assert(LHS == E);
|
|
}
|
|
{
|
|
path LHS(L); PathReserve(LHS, ReserveSize);
|
|
InputIter RHS(R);
|
|
InputIter REnd(StrEnd(R));
|
|
{
|
|
RequireAllocationGuard g;
|
|
if (DisableAllocations) g.requireExactly(0);
|
|
LHS.concat(RHS, REnd);
|
|
}
|
|
assert(LHS == E);
|
|
}
|
|
}
|
|
|
|
template <class CharT>
|
|
void doConcatSourceTest(ConcatOperatorTestcase const& TC)
|
|
{
|
|
using namespace fs;
|
|
using Ptr = CharT const*;
|
|
using Str = std::basic_string<CharT>;
|
|
using StrView = std::basic_string_view<CharT>;
|
|
using InputIter = input_iterator<Ptr>;
|
|
const Ptr L = TC.lhs;
|
|
const Ptr R = TC.rhs;
|
|
const Ptr E = TC.expect;
|
|
// basic_string
|
|
{
|
|
path LHS(L);
|
|
Str RHS(R);
|
|
path& Ref = (LHS += RHS);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
{
|
|
path LHS(L);
|
|
Str RHS(R);
|
|
path& Ref = LHS.concat(RHS);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
// basic_string_view
|
|
{
|
|
path LHS(L);
|
|
StrView RHS(R);
|
|
path& Ref = (LHS += RHS);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
{
|
|
path LHS(L);
|
|
StrView RHS(R);
|
|
path& Ref = LHS.concat(RHS);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
// Char*
|
|
{
|
|
path LHS(L);
|
|
Str RHS(R);
|
|
path& Ref = (LHS += RHS);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
{
|
|
path LHS(L);
|
|
Ptr RHS(R);
|
|
path& Ref = LHS.concat(RHS);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
{
|
|
path LHS(L);
|
|
Ptr RHS(R);
|
|
path& Ref = LHS.concat(RHS, StrEnd(RHS));
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
// iterators
|
|
{
|
|
path LHS(L);
|
|
InputIter RHS(R);
|
|
path& Ref = (LHS += RHS);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
{
|
|
path LHS(L); InputIter RHS(R);
|
|
path& Ref = LHS.concat(RHS);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
{
|
|
path LHS(L);
|
|
InputIter RHS(R);
|
|
InputIter REnd(StrEnd(R));
|
|
path& Ref = LHS.concat(RHS, REnd);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
}
|
|
|
|
template <class CharT>
|
|
void doConcatECharTest(ConcatOperatorTestcase const& TC)
|
|
{
|
|
using namespace fs;
|
|
using Ptr = CharT const*;
|
|
const Ptr RStr = TC.rhs;
|
|
assert(StrLen(RStr) == 1);
|
|
const Ptr L = TC.lhs;
|
|
const CharT R = RStr[0];
|
|
const Ptr E = TC.expect;
|
|
{
|
|
path LHS(L);
|
|
path& Ref = (LHS += R);
|
|
assert(LHS == E);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
}
|
|
|
|
|
|
template <class It, class = decltype(fs::path{}.concat(std::declval<It>()))>
|
|
constexpr bool has_concat(int) { return true; }
|
|
template <class It>
|
|
constexpr bool has_concat(long) { return false; }
|
|
|
|
template <class It, class = decltype(fs::path{}.operator+=(std::declval<It>()))>
|
|
constexpr bool has_concat_op(int) { return true; }
|
|
template <class It>
|
|
constexpr bool has_concat_op(long) { return false; }
|
|
template <class It>
|
|
constexpr bool has_concat_op() { return has_concat_op<It>(0); }
|
|
|
|
template <class It>
|
|
constexpr bool has_concat() {
|
|
static_assert(has_concat<It>(0) == has_concat_op<It>(0), "must be same");
|
|
return has_concat<It>(0) && has_concat_op<It>(0);
|
|
}
|
|
|
|
void test_sfinae() {
|
|
using namespace fs;
|
|
{
|
|
static_assert(has_concat_op<char>(), "");
|
|
static_assert(has_concat_op<const char>(), "");
|
|
static_assert(has_concat_op<char16_t>(), "");
|
|
static_assert(has_concat_op<const char16_t>(), "");
|
|
}
|
|
{
|
|
using It = const char* const;
|
|
static_assert(has_concat<It>(), "");
|
|
}
|
|
{
|
|
using It = input_iterator<const char*>;
|
|
static_assert(has_concat<It>(), "");
|
|
}
|
|
{
|
|
struct Traits {
|
|
using iterator_category = std::input_iterator_tag;
|
|
using value_type = const char;
|
|
using pointer = const char*;
|
|
using reference = const char&;
|
|
using difference_type = std::ptrdiff_t;
|
|
};
|
|
using It = input_iterator<const char*, Traits>;
|
|
static_assert(has_concat<It>(), "");
|
|
}
|
|
{
|
|
using It = output_iterator<const char*>;
|
|
static_assert(!has_concat<It>(), "");
|
|
}
|
|
{
|
|
static_assert(!has_concat<int>(0), "");
|
|
// operator+=(int) is well formed since it converts to operator+=(value_type)
|
|
// but concat(int) isn't valid because there is no concat(value_type).
|
|
// This should probably be addressed by a LWG issue.
|
|
static_assert(has_concat_op<int>(), "");
|
|
}
|
|
{
|
|
static_assert(!has_concat<int*>(), "");
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
using namespace fs;
|
|
for (auto const & TC : Cases) {
|
|
{
|
|
path LHS((const char*)TC.lhs);
|
|
path RHS((const char*)TC.rhs);
|
|
path& Ref = (LHS += RHS);
|
|
assert(LHS == (const char*)TC.expect);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
{
|
|
path LHS((const char*)TC.lhs);
|
|
std::string_view RHS((const char*)TC.rhs);
|
|
path& Ref = (LHS += RHS);
|
|
assert(LHS == (const char*)TC.expect);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
doConcatSourceTest<char> (TC);
|
|
doConcatSourceTest<wchar_t> (TC);
|
|
doConcatSourceTest<char16_t>(TC);
|
|
doConcatSourceTest<char32_t>(TC);
|
|
}
|
|
for (auto const & TC : LongLHSCases) {
|
|
// Do path test
|
|
{
|
|
path LHS((const char*)TC.lhs);
|
|
path RHS((const char*)TC.rhs);
|
|
const char* E = TC.expect;
|
|
PathReserve(LHS, StrLen(E) + 5);
|
|
{
|
|
DisableAllocationGuard g;
|
|
path& Ref = (LHS += RHS);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
assert(LHS == E);
|
|
}
|
|
{
|
|
path LHS((const char*)TC.lhs);
|
|
std::string_view RHS((const char*)TC.rhs);
|
|
const char* E = TC.expect;
|
|
PathReserve(LHS, StrLen(E) + 5);
|
|
{
|
|
DisableAllocationGuard g;
|
|
path& Ref = (LHS += RHS);
|
|
assert(&Ref == &LHS);
|
|
}
|
|
assert(LHS == E);
|
|
}
|
|
doConcatSourceAllocTest<char>(TC);
|
|
doConcatSourceAllocTest<wchar_t>(TC);
|
|
}
|
|
for (auto const& TC : CharTestCases) {
|
|
doConcatECharTest<char>(TC);
|
|
doConcatECharTest<wchar_t>(TC);
|
|
doConcatECharTest<char16_t>(TC);
|
|
doConcatECharTest<char32_t>(TC);
|
|
}
|
|
test_sfinae();
|
|
}
|