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
|
//===- unittest/Format/CleanupTest.cpp - Code cleanup unit tests ----------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "clang/Format/Format.h"
#include "clang/Tooling/Core/Replacement.h"
#include "gtest/gtest.h"
namespace clang {
namespace format {
namespace {
class CleanupTest : public ::testing::Test {
protected:
std::string cleanup(llvm::StringRef Code,
const std::vector<tooling::Range> &Ranges,
const FormatStyle &Style = getLLVMStyle()) {
tooling::Replacements Replaces = format::cleanup(Style, Code, Ranges);
std::string Result = applyAllReplacements(Code, Replaces);
EXPECT_NE("", Result);
return Result;
}
};
TEST_F(CleanupTest, DeleteEmptyNamespaces) {
std::string Code = "namespace A {\n"
"namespace B {\n"
"} // namespace B\n"
"} // namespace A\n\n"
"namespace C {\n"
"namespace D { int i; }\n"
"inline namespace E { namespace { } }\n"
"}";
std::string Expected = "\n\n\n\n\nnamespace C {\n"
"namespace D { int i; }\n \n"
"}";
std::vector<tooling::Range> Ranges;
Ranges.push_back(tooling::Range(28, 0));
Ranges.push_back(tooling::Range(91, 6));
Ranges.push_back(tooling::Range(132, 0));
std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result);
}
TEST_F(CleanupTest, NamespaceWithSyntaxError) {
std::string Code = "namespace A {\n"
"namespace B {\n" // missing r_brace
"} // namespace A\n\n"
"namespace C {\n"
"namespace D int i; }\n"
"inline namespace E { namespace { } }\n"
"}";
std::string Expected = "namespace A {\n"
"\n\n\nnamespace C {\n"
"namespace D int i; }\n \n"
"}";
std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result);
}
TEST_F(CleanupTest, EmptyNamespaceNotAffected) {
std::string Code = "namespace A {\n\n"
"namespace {\n\n}}";
// Even though the namespaces are empty, but the inner most empty namespace
// block is not affected by the changed ranges.
std::string Expected = "namespace A {\n\n"
"namespace {\n\n}}";
// Set the changed range to be the second "\n".
std::vector<tooling::Range> Ranges(1, tooling::Range(14, 0));
std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result);
}
TEST_F(CleanupTest, EmptyNamespaceWithCommentsNoBreakBeforeBrace) {
std::string Code = "namespace A {\n"
"namespace B {\n"
"// Yo\n"
"} // namespace B\n"
"} // namespace A\n"
"namespace C { // Yo\n"
"}";
std::string Expected = "\n\n\n\n\n\n";
std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
std::string Result = cleanup(Code, Ranges);
EXPECT_EQ(Expected, Result);
}
TEST_F(CleanupTest, EmptyNamespaceWithCommentsBreakBeforeBrace) {
std::string Code = "namespace A\n"
"/* Yo */ {\n"
"namespace B\n"
"{\n"
"// Yo\n"
"} // namespace B\n"
"} // namespace A\n"
"namespace C\n"
"{ // Yo\n"
"}\n";
std::string Expected = "\n\n\n\n\n\n\n\n\n\n";
std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
FormatStyle Style = getLLVMStyle();
Style.BraceWrapping.AfterNamespace = true;
std::string Result = cleanup(Code, Ranges, Style);
EXPECT_EQ(Expected, Result);
}
} // end namespace
} // end namespace format
} // end namespace clang
|
