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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
#include "gtest/gtest.h"
#include "Core/Transform.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/DeclGroup.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/Support/Process.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/PathV1.h"
using namespace clang;
class DummyTransform : public Transform {
public:
DummyTransform(llvm::StringRef Name, const TransformOptions &Options)
: Transform(Name, Options) {}
virtual int apply(FileOverrides &,
const tooling::CompilationDatabase &,
const std::vector<std::string> &) { return 0; }
void setAcceptedChanges(unsigned Changes) {
Transform::setAcceptedChanges(Changes);
}
void setRejectedChanges(unsigned Changes) {
Transform::setRejectedChanges(Changes);
}
void setDeferredChanges(unsigned Changes) {
Transform::setDeferredChanges(Changes);
}
void setOverrides(FileOverrides &Overrides) {
Transform::setOverrides(Overrides);
}
};
TEST(Transform, Interface) {
TransformOptions Options;
DummyTransform T("my_transform", Options);
ASSERT_EQ("my_transform", T.getName());
ASSERT_EQ(0u, T.getAcceptedChanges());
ASSERT_EQ(0u, T.getRejectedChanges());
ASSERT_EQ(0u, T.getDeferredChanges());
ASSERT_FALSE(T.getChangesMade());
ASSERT_FALSE(T.getChangesNotMade());
T.setAcceptedChanges(1);
ASSERT_TRUE(T.getChangesMade());
T.setDeferredChanges(1);
ASSERT_TRUE(T.getChangesNotMade());
T.setRejectedChanges(1);
ASSERT_TRUE(T.getChangesNotMade());
T.Reset();
ASSERT_EQ(0u, T.getAcceptedChanges());
ASSERT_EQ(0u, T.getRejectedChanges());
ASSERT_EQ(0u, T.getDeferredChanges());
T.setRejectedChanges(1);
ASSERT_TRUE(T.getChangesNotMade());
}
class TimePassingASTConsumer : public ASTConsumer {
public:
TimePassingASTConsumer(bool *Called) : Called(Called) {}
virtual bool HandleTopLevelDecl(DeclGroupRef DeclGroup) {
llvm::sys::TimeValue UserStart;
llvm::sys::TimeValue SystemStart;
llvm::sys::TimeValue UserNow;
llvm::sys::TimeValue SystemNow;
llvm::sys::TimeValue Wall;
// Busy-wait until the user/system time combined is more than 1ms
llvm::sys::TimeValue OneMS(0, 1000000);
llvm::sys::Process::GetTimeUsage(Wall, UserStart, SystemStart);
do {
llvm::sys::Process::GetTimeUsage(Wall, UserNow, SystemNow);
} while (UserNow - UserStart + SystemNow - SystemStart < OneMS);
*Called = true;
return true;
}
bool *Called;
};
struct ConsumerFactory {
ASTConsumer *newASTConsumer() {
return new TimePassingASTConsumer(&Called);
}
bool Called;
};
struct CallbackForwarder : public clang::tooling::SourceFileCallbacks {
CallbackForwarder(Transform &Callee) : Callee(Callee) {}
virtual bool handleBeginSource(CompilerInstance &CI, StringRef Filename) {
return Callee.handleBeginSource(CI, Filename);
}
virtual void handleEndSource() {
Callee.handleEndSource();
}
Transform &Callee;
};
TEST(Transform, Timings) {
TransformOptions Options;
Options.EnableTiming = true;
DummyTransform T("timing_transform", Options);
// All the path stuff is to make the test work independently of OS.
// The directory used is not important since the path gets mapped to a virtual
// file anyway. What is important is that we have an absolute path with which
// to use with mapVirtualFile().
llvm::sys::Path FileA = llvm::sys::Path::GetCurrentDirectory();
std::string CurrentDir = FileA.str();
FileA.appendComponent("a.cc");
std::string FileAName = FileA.str();
llvm::sys::Path FileB = llvm::sys::Path::GetCurrentDirectory();
FileB.appendComponent("b.cc");
std::string FileBName = FileB.str();
tooling::FixedCompilationDatabase Compilations(CurrentDir, std::vector<std::string>());
std::vector<std::string> Sources;
Sources.push_back(FileAName);
Sources.push_back(FileBName);
tooling::ClangTool Tool(Compilations, Sources);
Tool.mapVirtualFile(FileAName, "void a() {}");
Tool.mapVirtualFile(FileBName, "void b() {}");
// Factory to create TimePassingASTConsumer for each source file the tool
// runs on.
ConsumerFactory Factory;
// We don't care about any of Transform's functionality except to get it to
// record timings. For that, we need to forward handleBeginSource() and
// handleEndSource() calls to it.
CallbackForwarder Callbacks(T);
// Transform's handle* functions require FileOverrides to be set, even if
// there aren't any.
FileOverrides Overrides;
T.setOverrides(Overrides);
Tool.run(clang::tooling::newFrontendActionFactory(&Factory, &Callbacks));
EXPECT_TRUE(Factory.Called);
Transform::TimingVec::const_iterator I = T.timing_begin();
EXPECT_GT(I->second.getProcessTime(), 0.0);
// The success of the test shouldn't depend on the order of iteration through
// timers.
llvm::sys::Path FirstFile(I->first);
if (FileA == FirstFile) {
++I;
EXPECT_EQ(FileB, llvm::sys::Path(I->first));
EXPECT_GT(I->second.getProcessTime(), 0.0);
} else if (FileB == FirstFile) {
++I;
EXPECT_EQ(FileA, llvm::sys::Path(I->first));
EXPECT_GT(I->second.getProcessTime(), 0.0);
} else {
FAIL() << "Unexpected file name " << I->first << " in timing data.";
}
++I;
EXPECT_EQ(T.timing_end(), I);
}
|
