1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// REQUIRES: can-create-symlinks
// UNSUPPORTED: c++03, c++11, c++14
// UNSUPPORTED: no-filesystem
// UNSUPPORTED: availability-filesystem-missing
// <filesystem>
// path proximate(const path& p, error_code &ec)
// path proximate(const path& p, const path& base = current_path())
// path proximate(const path& p, const path& base, error_code& ec);
#include <filesystem>
#include <string>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
#include "test_iterators.h"
#include "count_new.h"
#include "filesystem_test_helper.h"
namespace fs = std::filesystem;
static void test_signature_0() {
fs::path p("");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(fs::current_path()));
}
static void test_signature_1() {
fs::path p(".");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(fs::current_path()));
}
static void test_signature_2() {
static_test_env static_env;
fs::path p(static_env.File);
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.File));
}
static void test_signature_3() {
static_test_env static_env;
fs::path p(static_env.Dir);
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir));
}
static void test_signature_4() {
static_test_env static_env;
fs::path p(static_env.SymlinkToDir);
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir));
}
static void test_signature_5() {
static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2/.");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir / "dir2"));
}
static void test_signature_6() {
static_test_env static_env;
// FIXME? If the trailing separator occurs in a part of the path that exists,
// it is omitted. Otherwise it is added to the end of the result.
fs::path p(static_env.SymlinkToDir / "dir2/./");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir / "dir2"));
}
static void test_signature_7() {
static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2/DNE/./");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir / "dir2/DNE/"));
}
static void test_signature_8() {
static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir2));
}
static void test_signature_9() {
static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2/../dir2/DNE/..");
const fs::path output = fs::weakly_canonical(p);
// weakly_canonical has a quirk - if the path is considered to exist,
// it's returned without a trailing slash, otherwise it's returned with
// one (see a note in fs.op.weakly_canonical/weakly_canonical.pass.cpp).
// On Windows, a path like existent/nonexistentsubdir/.. is considered
// to exist, on posix it's considered to not exist. Therefore, the
// result here differs in the trailing slash.
#ifdef _WIN32
assert(output == fs::path::string_type(static_env.Dir2));
#else
assert(output == fs::path::string_type(static_env.Dir2 / ""));
#endif
}
static void test_signature_10() {
static_test_env static_env;
fs::path p(static_env.SymlinkToDir / "dir2/dir3/../DNE/DNE2");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir2 / "DNE/DNE2"));
}
static void test_signature_11() {
static_test_env static_env;
fs::path p(static_env.Dir / "../dir1");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir));
}
static void test_signature_12() {
static_test_env static_env;
fs::path p(static_env.Dir / "./.");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir));
}
static void test_signature_13() {
static_test_env static_env;
fs::path p(static_env.Dir / "DNE/../foo");
const fs::path output = fs::weakly_canonical(p);
assert(output == fs::path::string_type(static_env.Dir / "foo"));
}
int main(int, char**) {
test_signature_0();
test_signature_1();
test_signature_2();
test_signature_3();
test_signature_4();
test_signature_5();
test_signature_6();
test_signature_7();
test_signature_8();
test_signature_9();
test_signature_10();
test_signature_11();
test_signature_12();
test_signature_13();
return 0;
}
|
