Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 97f87add50e9b435a104449372fdd08a8f8723b7 / . / clang-tools-extra / unittests / change-namespace / ChangeNamespaceTests.cpp
blob: 8ed0f9d7b8f26e6322176eac1ca6663b4c712099 [file] [log] [blame]
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]1//===-- ChangeNamespaceTests.cpp - Change namespace unit tests ---*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "ChangeNamespace.h"
11#include "unittests/Tooling/RewriterTestContext.h"
12#include "clang/ASTMatchers/ASTMatchFinder.h"
13#include "clang/Basic/FileManager.h"
14#include "clang/Basic/FileSystemOptions.h"
15#include "clang/Basic/VirtualFileSystem.h"
16#include "clang/Format/Format.h"
17#include "clang/Frontend/CompilerInstance.h"
18#include "clang/Frontend/PCHContainerOperations.h"
19#include "clang/Tooling/Refactoring.h"
20#include "clang/Tooling/Tooling.h"
21#include "llvm/ADT/IntrusiveRefCntPtr.h"
22#include "llvm/ADT/StringRef.h"
23#include "llvm/Support/MemoryBuffer.h"
24#include "gtest/gtest.h"
25#include <memory>
26#include <string>
27#include <vector>
28
29namespace clang {
30namespace change_namespace {
31namespace {
32
33class ChangeNamespaceTest : public ::testing::Test {
34public:
35 std::string runChangeNamespaceOnCode(llvm::StringRef Code) {
36 clang::RewriterTestContext Context;
37 clang::FileID ID = Context.createInMemoryFile(FileName, Code);
38
39 std::map<std::string, tooling::Replacements> FileToReplacements;
40 change_namespace::ChangeNamespaceTool NamespaceTool(
41 OldNamespace, NewNamespace, FilePattern, &FileToReplacements);
42 ast_matchers::MatchFinder Finder;
43 NamespaceTool.registerMatchers(&Finder);
44 std::unique_ptr<tooling::FrontendActionFactory> Factory =
45 tooling::newFrontendActionFactory(&Finder);
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]46 if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, {"-std=c++11"},
47 FileName))
48 return "";
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]49 formatAndApplyAllReplacements(FileToReplacements, Context.Rewrite);
50 return format(Context.getRewrittenText(ID));
51 }
52
53 std::string format(llvm::StringRef Code) {
54 tooling::Replacements Replaces = format::reformat(
55 format::getLLVMStyle(), Code, {tooling::Range(0, Code.size())});
56 auto ChangedCode = tooling::applyAllReplacements(Code, Replaces);
57 EXPECT_TRUE(static_cast<bool>(ChangedCode));
58 if (!ChangedCode) {
59 llvm::errs() << llvm::toString(ChangedCode.takeError());
60 return "";
61 }
62 return *ChangedCode;
63 }
64
65protected:
66 std::string FileName = "input.cc";
67 std::string OldNamespace = "na::nb";
68 std::string NewNamespace = "x::y";
69 std::string FilePattern = "input.cc";
70};
71
72TEST_F(ChangeNamespaceTest, NoMatchingNamespace) {
73 std::string Code = "namespace na {\n"
74 "namespace nx {\n"
75 "class A {};\n"
76 "} // namespace nx\n"
77 "} // namespace na\n";
78 std::string Expected = "namespace na {\n"
79 "namespace nx {\n"
80 "class A {};\n"
81 "} // namespace nx\n"
82 "} // namespace na\n";
83 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
84}
85
86TEST_F(ChangeNamespaceTest, SimpleMoveWithoutTypeRefs) {
87 std::string Code = "namespace na {\n"
88 "namespace nb {\n"
89 "class A {};\n"
90 "} // namespace nb\n"
91 "} // namespace na\n";
92 std::string Expected = "\n\n"
93 "namespace x {\n"
94 "namespace y {\n"
95 "class A {};\n"
96 "} // namespace y\n"
97 "} // namespace x\n";
98 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
99}
100
Eric Liu6aa94162016-11-10 18:29:01 +0000[diff] [blame]101TEST_F(ChangeNamespaceTest, NewNsNestedInOldNs) {
102 NewNamespace = "na::nb::nc";
103 std::string Code = "namespace na {\n"
104 "namespace nb {\n"
105 "class A {};\n"
106 "} // namespace nb\n"
107 "} // namespace na\n";
108 std::string Expected = "namespace na {\n"
109 "namespace nb {\n"
110 "namespace nc {\n"
111 "class A {};\n"
112 "} // namespace nc\n"
113 "\n"
114 "} // namespace nb\n"
115 "} // namespace na\n";
116 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
117}
118
119TEST_F(ChangeNamespaceTest, NewNsNestedInOldNsWithRefs) {
120 NewNamespace = "na::nb::nc";
121 std::string Code = "namespace na {\n"
122 "class A {};\n"
123 "namespace nb {\n"
124 "class B {};\n"
125 "class C {};\n"
126 "void f() { A a; B b; }\n"
127 "} // namespace nb\n"
128 "} // namespace na\n";
129 std::string Expected = "namespace na {\n"
130 "class A {};\n"
131 "namespace nb {\n"
132 "namespace nc {\n"
133 "class B {};\n"
134 "class C {};\n"
135 "void f() { A a; B b; }\n"
136 "} // namespace nc\n"
137 "\n"
138 "} // namespace nb\n"
139 "} // namespace na\n";
140 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
141}
142
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]143TEST_F(ChangeNamespaceTest, SimpleMoveIntoAnotherNestedNamespace) {
144 NewNamespace = "na::nc";
145 std::string Code = "namespace na {\n"
146 "namespace nb {\n"
147 "class A {};\n"
148 "} // namespace nb\n"
149 "} // namespace na\n";
150 std::string Expected = "namespace na {\n"
151 "\n"
152 "namespace nc {\n"
153 "class A {};\n"
154 "} // namespace nc\n"
155 "} // namespace na\n";
156 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
157}
158
Eric Liu447164d2016-10-05 15:52:39 +0000[diff] [blame]159TEST_F(ChangeNamespaceTest, MoveIntoAnotherNestedNamespaceWithRef) {
160 NewNamespace = "na::nc";
161 std::string Code = "namespace na {\n"
162 "class A {};\n"
163 "namespace nb {\n"
164 "class X { A a; };\n"
165 "} // namespace nb\n"
166 "} // namespace na\n";
167 std::string Expected = "namespace na {\n"
168 "class A {};\n"
169 "\n"
170 "namespace nc {\n"
171 "class X { A a; };\n"
172 "} // namespace nc\n"
173 "} // namespace na\n";
174 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
175}
176
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]177TEST_F(ChangeNamespaceTest, MoveIntoExistingNamespaceAndShortenRefs) {
178 std::string Code = "namespace x {\n"
179 "namespace z {\n"
180 "class Z {};\n"
181 "} // namespace z\n"
182 "namespace y {\n"
183 "class T {};\n"
184 "} // namespace y\n"
185 "} // namespace x\n"
186 "namespace na {\n"
187 "class A{};\n"
188 "namespace nb {\n"
189 "class X { A a; x::z::Z zz; x::y::T t; };\n"
190 "} // namespace nb\n"
191 "} // namespace na\n";
192 std::string Expected = "namespace x {\n"
193 "namespace z {\n"
194 "class Z {};\n"
195 "} // namespace z\n"
196 "namespace y {\n"
197 "class T {};\n"
198 "} // namespace y\n"
199 "} // namespace x\n"
200 "namespace na {\n"
201 "class A {};\n\n"
202 "} // namespace na\n"
203 "namespace x {\n"
204 "namespace y {\n"
205 "class X { ::na::A a; z::Z zz; T t; };\n"
206 "} // namespace y\n"
207 "} // namespace x\n";
208 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
209}
210
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]211TEST_F(ChangeNamespaceTest, SimpleMoveNestedNamespace) {
212 NewNamespace = "na::x::y";
213 std::string Code = "namespace na {\n"
214 "class A {};\n"
215 "namespace nb {\n"
216 "class B {};\n"
217 "} // namespace nb\n"
218 "} // namespace na\n";
219 std::string Expected = "namespace na {\n"
220 "class A {};\n"
221 "\n"
222 "namespace x {\n"
223 "namespace y {\n"
224 "class B {};\n"
225 "} // namespace y\n"
226 "} // namespace x\n"
227 "} // namespace na\n";
228 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
229}
230
231TEST_F(ChangeNamespaceTest, SimpleMoveWithTypeRefs) {
232 std::string Code = "namespace na {\n"
233 "class C_A {};\n"
234 "namespace nc {\n"
235 "class C_C {};"
236 "} // namespace nc\n"
237 "namespace nb {\n"
238 "class C_X {\n"
239 "public:\n"
240 " C_A a;\n"
241 " nc::C_C c;\n"
242 "};\n"
243 "class C_Y {\n"
244 " C_X x;\n"
245 "};\n"
246 "} // namespace nb\n"
247 "} // namespace na\n";
248 std::string Expected = "namespace na {\n"
249 "class C_A {};\n"
250 "namespace nc {\n"
251 "class C_C {};"
252 "} // namespace nc\n"
253 "\n"
254 "} // namespace na\n"
255 "namespace x {\n"
256 "namespace y {\n"
257 "class C_X {\n"
258 "public:\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]259 " ::na::C_A a;\n"
260 " ::na::nc::C_C c;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]261 "};\n"
262 "class C_Y {\n"
263 " C_X x;\n"
264 "};\n"
265 "} // namespace y\n"
266 "} // namespace x\n";
267 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
268}
269
Eric Liu8393cb02016-10-31 08:28:29 +0000[diff] [blame]270TEST_F(ChangeNamespaceTest, TypeLocInTemplateSpecialization) {
271 std::string Code = "namespace na {\n"
272 "class A {};\n"
273 "template <typename T>\n"
274 "class B {};\n"
275 "template <typename T1, typename T2>\n"
276 "class Two {};\n"
277 "namespace nc { class C {}; }\n"
278 "} // na\n"
279 "\n"
280 "namespace na {\n"
281 "namespace nb {\n"
282 "void f() {\n"
283 " B<A> b;\n"
284 " B<nc::C> b_c;\n"
285 " Two<A, nc::C> two;\n"
286 "}\n"
287 "} // nb\n"
288 "} // na\n";
289 std::string Expected = "namespace na {\n"
290 "class A {};\n"
291 "template <typename T>\n"
292 "class B {};\n"
293 "template <typename T1, typename T2>\n"
294 "class Two {};\n"
295 "namespace nc { class C {}; }\n"
296 "} // na\n"
297 "\n"
298 "\n"
299 "namespace x {\n"
300 "namespace y {\n"
301 "void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]302 " ::na::B<::na::A> b;\n"
303 " ::na::B<::na::nc::C> b_c;\n"
304 " ::na::Two<::na::A, ::na::nc::C> two;\n"
Eric Liu8393cb02016-10-31 08:28:29 +0000[diff] [blame]305 "}\n"
306 "} // namespace y\n"
307 "} // namespace x\n";
308 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
309}
310
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]311TEST_F(ChangeNamespaceTest, LeaveForwardDeclarationBehind) {
312 std::string Code = "namespace na {\n"
313 "namespace nb {\n"
314 "class FWD;\n"
Eric Liu41552d62016-12-07 14:20:52 +0000[diff] [blame]315 "class FWD2;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]316 "class A {\n"
317 " FWD *fwd;\n"
318 "};\n"
319 "} // namespace nb\n"
320 "} // namespace na\n";
321 std::string Expected = "namespace na {\n"
322 "namespace nb {\n"
323 "class FWD;\n"
Eric Liu41552d62016-12-07 14:20:52 +0000[diff] [blame]324 "class FWD2;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]325 "} // namespace nb\n"
326 "} // namespace na\n"
327 "namespace x {\n"
328 "namespace y {\n"
329 "\n"
330 "class A {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]331 " ::na::nb::FWD *fwd;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]332 "};\n"
333 "} // namespace y\n"
334 "} // namespace x\n";
335 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
336}
337
Eric Liu41552d62016-12-07 14:20:52 +0000[diff] [blame]338TEST_F(ChangeNamespaceTest, TemplateClassForwardDeclaration) {
339 std::string Code = "namespace na {\n"
340 "namespace nb {\n"
341 "class FWD;\n"
342 "template<typename T> class FWD_TEMP;\n"
343 "class A {\n"
344 " FWD *fwd;\n"
345 "};\n"
346 "template<typename T> class TEMP {};\n"
347 "} // namespace nb\n"
348 "} // namespace na\n";
349 std::string Expected = "namespace na {\n"
350 "namespace nb {\n"
351 "class FWD;\n"
352 "template<typename T> class FWD_TEMP;\n"
353 "} // namespace nb\n"
354 "} // namespace na\n"
355 "namespace x {\n"
356 "namespace y {\n"
357 "\n"
358 "class A {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]359 " ::na::nb::FWD *fwd;\n"
Eric Liu41552d62016-12-07 14:20:52 +0000[diff] [blame]360 "};\n"
361 "template<typename T> class TEMP {};\n"
362 "} // namespace y\n"
363 "} // namespace x\n";
364 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
365}
366
367TEST_F(ChangeNamespaceTest, DontMoveForwardDeclarationInClass) {
368 std::string Code = "namespace na {\n"
369 "namespace nb {\n"
370 "class A {\n"
371 " class FWD;\n"
372 " FWD *fwd;\n"
373 " template<typename T> class FWD_TEMP;\n"
374 "};\n"
375 "} // namespace nb\n"
376 "} // namespace na\n";
377 std::string Expected = "\n\n"
378 "namespace x {\n"
379 "namespace y {\n"
380 "class A {\n"
381 " class FWD;\n"
382 " FWD *fwd;\n"
383 " template<typename T> class FWD_TEMP;\n"
384 "};\n"
385 "} // namespace y\n"
386 "} // namespace x\n";
387 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
388}
389
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]390TEST_F(ChangeNamespaceTest, MoveFunctions) {
391 std::string Code = "namespace na {\n"
392 "class C_A {};\n"
393 "namespace nc {\n"
394 "class C_C {};"
395 "} // namespace nc\n"
396 "namespace nb {\n"
397 "void fwd();\n"
398 "void f(C_A ca, nc::C_C cc) {\n"
399 " C_A ca_1 = ca;\n"
400 "}\n"
401 "} // namespace nb\n"
402 "} // namespace na\n";
403
404 std::string Expected = "namespace na {\n"
405 "class C_A {};\n"
406 "namespace nc {\n"
407 "class C_C {};"
408 "} // namespace nc\n"
409 "\n"
410 "} // namespace na\n"
411 "namespace x {\n"
412 "namespace y {\n"
413 "void fwd();\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]414 "void f(::na::C_A ca, ::na::nc::C_C cc) {\n"
415 " ::na::C_A ca_1 = ca;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]416 "}\n"
417 "} // namespace y\n"
418 "} // namespace x\n";
419 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
420}
421
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]422TEST_F(ChangeNamespaceTest, FixUsingShadowDecl) {
Eric Liu912d0392016-09-27 12:54:48 +0000[diff] [blame]423 std::string Code = "class GLOB {};\n"
424 "using BLOG = GLOB;\n"
425 "namespace na {\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]426 "namespace nc {\n"
427 "class SAME {};\n"
428 "}\n"
429 "namespace nd {\n"
430 "class SAME {};\n"
431 "}\n"
432 "namespace nb {\n"
433 "using nc::SAME;\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]434 "using YO = nd::SAME;\n"
435 "typedef nd::SAME IDENTICAL;\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]436 "void f(nd::SAME Same) {}\n"
437 "} // namespace nb\n"
438 "} // namespace na\n";
439
Eric Liu912d0392016-09-27 12:54:48 +0000[diff] [blame]440 std::string Expected = "class GLOB {};\n"
441 "using BLOG = GLOB;\n"
442 "namespace na {\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]443 "namespace nc {\n"
444 "class SAME {};\n"
445 "}\n"
446 "namespace nd {\n"
447 "class SAME {};\n"
448 "}\n"
449 "\n"
450 "} // namespace na\n"
451 "namespace x {\n"
452 "namespace y {\n"
453 "using ::na::nc::SAME;\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]454 "using YO = ::na::nd::SAME;\n"
455 "typedef ::na::nd::SAME IDENTICAL;\n"
456 "void f(::na::nd::SAME Same) {}\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]457 "} // namespace y\n"
458 "} // namespace x\n";
459 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
460}
461
Eric Liu8685c762016-12-07 17:04:07 +0000[diff] [blame]462TEST_F(ChangeNamespaceTest, DontFixUsingShadowDeclInClasses) {
463 std::string Code = "namespace na {\n"
464 "class A {};\n"
465 "class Base { public: Base() {} void m() {} };\n"
466 "namespace nb {\n"
467 "class D : public Base {\n"
468 "public:\n"
469 " using AA = A; using B = Base;\n"
470 " using Base::m; using Base::Base;\n"
471 "};"
472 "} // namespace nb\n"
473 "} // namespace na\n";
474
475 std::string Expected = "namespace na {\n"
476 "class A {};\n"
477 "class Base { public: Base() {} void m() {} };\n"
478 "\n"
479 "} // namespace na\n"
480 "namespace x {\n"
481 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]482 "class D : public ::na::Base {\n"
Eric Liu8685c762016-12-07 17:04:07 +0000[diff] [blame]483 "public:\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]484 " using AA = ::na::A; using B = ::na::Base;\n"
Eric Liu8685c762016-12-07 17:04:07 +0000[diff] [blame]485 " using Base::m; using Base::Base;\n"
486 "};"
487 "} // namespace y\n"
488 "} // namespace x\n";
489 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
490}
491
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]492TEST_F(ChangeNamespaceTest, TypeInNestedNameSpecifier) {
493 std::string Code =
494 "namespace na {\n"
495 "class C_A {\n"
496 "public:\n"
497 " class Nested {\n"
498 " public:\n"
499 " static int NestedX;\n"
500 " static void nestedFunc() {}\n"
501 " };\n"
502 "};\n"
503 "namespace nb {\n"
504 "class C_X {\n"
505 " C_A na;\n"
506 " C_A::Nested nested;\n"
507 " void f() {\n"
508 " C_A::Nested::nestedFunc();\n"
509 " int X = C_A::Nested::NestedX;\n"
510 " }\n"
511 "};\n"
512 "} // namespace nb\n"
513 "} // namespace na\n";
514 std::string Expected =
515 "namespace na {\n"
516 "class C_A {\n"
517 "public:\n"
518 " class Nested {\n"
519 " public:\n"
520 " static int NestedX;\n"
521 " static void nestedFunc() {}\n"
522 " };\n"
523 "};\n"
524 "\n"
525 "} // namespace na\n"
526 "namespace x {\n"
527 "namespace y {\n"
528 "class C_X {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]529 " ::na::C_A na;\n"
530 " ::na::C_A::Nested nested;\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]531 " void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]532 " ::na::C_A::Nested::nestedFunc();\n"
533 " int X = ::na::C_A::Nested::NestedX;\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]534 " }\n"
535 "};\n"
536 "} // namespace y\n"
537 "} // namespace x\n";
538 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
539}
540
Eric Liu12068d82016-09-22 11:54:00 +0000[diff] [blame]541TEST_F(ChangeNamespaceTest, FixFunctionNameSpecifiers) {
542 std::string Code =
543 "namespace na {\n"
544 "class A {\n"
545 "public:\n"
546 " static void f() {}\n"
547 " static void g();\n"
548 "};\n"
549 "void A::g() {}"
550 "void a_f() {}\n"
551 "static void static_f() {}\n"
552 "namespace nb {\n"
553 "void f() { a_f(); static_f(); A::f(); }\n"
554 "void g() { f(); A::g(); }\n"
555 "} // namespace nb\n"
556 "} // namespace na\n";
557 std::string Expected =
558 "namespace na {\n"
559 "class A {\n"
560 "public:\n"
561 " static void f() {}\n"
562 " static void g();\n"
563 "};\n"
564 "void A::g() {}"
565 "void a_f() {}\n"
566 "static void static_f() {}\n"
567 "\n"
568 "} // namespace na\n"
569 "namespace x {\n"
570 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]571 "void f() { ::na::a_f(); ::na::static_f(); ::na::A::f(); }\n"
572 "void g() { f(); ::na::A::g(); }\n"
Eric Liu12068d82016-09-22 11:54:00 +0000[diff] [blame]573 "} // namespace y\n"
574 "} // namespace x\n";
575 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
576}
577
Eric Liuda22b3c2016-11-29 14:15:14 +0000[diff] [blame]578TEST_F(ChangeNamespaceTest, FixNonCallingFunctionReferences) {
579 std::string Code = "namespace na {\n"
580 "class A {\n"
581 "public:\n"
582 " static void f() {}\n"
583 "};\n"
584 "void a_f() {}\n"
585 "static void s_f() {}\n"
586 "namespace nb {\n"
587 "void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]588 " auto *ref1 = A::f;\n"
589 " auto *ref2 = a_f;\n"
590 " auto *ref3 = s_f;\n"
Eric Liuda22b3c2016-11-29 14:15:14 +0000[diff] [blame]591 "}\n"
592 "} // namespace nb\n"
593 "} // namespace na\n";
594 std::string Expected =
595 "namespace na {\n"
596 "class A {\n"
597 "public:\n"
598 " static void f() {}\n"
599 "};\n"
600 "void a_f() {}\n"
601 "static void s_f() {}\n"
602 "\n"
603 "} // namespace na\n"
604 "namespace x {\n"
605 "namespace y {\n"
606 "void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]607 " auto *ref1 = ::na::A::f;\n"
608 " auto *ref2 = ::na::a_f;\n"
609 " auto *ref3 = ::na::s_f;\n"
Eric Liuda22b3c2016-11-29 14:15:14 +0000[diff] [blame]610 "}\n"
611 "} // namespace y\n"
612 "} // namespace x\n";
613 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
614}
615
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]616TEST_F(ChangeNamespaceTest, MoveAndFixGlobalVariables) {
617 std::string Code = "namespace na {\n"
618 "int GlobA;\n"
619 "static int GlobAStatic = 0;\n"
620 "namespace nc { int GlobC; }\n"
621 "namespace nb {\n"
622 "int GlobB;\n"
623 "void f() {\n"
624 " int a = GlobA;\n"
625 " int b = GlobAStatic;\n"
626 " int c = nc::GlobC;\n"
627 "}\n"
628 "} // namespace nb\n"
629 "} // namespace na\n";
630
631 std::string Expected = "namespace na {\n"
632 "int GlobA;\n"
633 "static int GlobAStatic = 0;\n"
634 "namespace nc { int GlobC; }\n"
635 "\n"
636 "} // namespace na\n"
637 "namespace x {\n"
638 "namespace y {\n"
639 "int GlobB;\n"
640 "void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]641 " int a = ::na::GlobA;\n"
642 " int b = ::na::GlobAStatic;\n"
643 " int c = ::na::nc::GlobC;\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]644 "}\n"
645 "} // namespace y\n"
646 "} // namespace x\n";
647
648 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
649}
650
651TEST_F(ChangeNamespaceTest, DoNotFixStaticVariableOfClass) {
652 std::string Code = "namespace na {\n"
653 "class A {\n"
654 "public:\n"
655 "static int A1;\n"
656 "static int A2;\n"
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]657 "};\n"
658 "int A::A1 = 0;\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]659 "namespace nb {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]660 "void f() {\n"
661 " int a = A::A1; int b = A::A2;\n"
662 "}\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]663 "} // namespace nb\n"
664 "} // namespace na\n";
665
666 std::string Expected = "namespace na {\n"
667 "class A {\n"
668 "public:\n"
669 "static int A1;\n"
670 "static int A2;\n"
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]671 "};\n"
672 "int A::A1 = 0;\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]673 "\n"
674 "} // namespace na\n"
675 "namespace x {\n"
676 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]677 "void f() {\n"
678 " int a = ::na::A::A1; int b = ::na::A::A2;\n"
679 "}\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]680 "} // namespace y\n"
681 "} // namespace x\n";
682
683 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
684}
685
Haojian Wuef8a6dc2016-10-04 10:35:53 +0000[diff] [blame]686TEST_F(ChangeNamespaceTest, NoMisplaceAtEOF) {
687 std::string Code = "namespace na {\n"
688 "namespace nb {\n"
689 "class A;\n"
690 "class B {};\n"
691 "}"
692 "}";
693 std::string Expected = "namespace na {\n"
694 "namespace nb {\n"
695 "class A;\n"
696 "}\n"
697 "}\n"
698 "namespace x {\n"
699 "namespace y {\n"
700 "\n"
701 "class B {};\n"
702 "} // namespace y\n"
703 "} // namespace x\n";
704 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
705}
706
Eric Liu73f49fd2016-10-12 12:34:18 +0000[diff] [blame]707TEST_F(ChangeNamespaceTest, CommentsBeforeMovedClass) {
708 std::string Code = "namespace na {\n"
709 "namespace nb {\n"
710 "\n\n"
711 "// Wild comments.\n"
712 "\n"
713 "// Comments.\n"
714 "// More comments.\n"
715 "class B {\n"
716 " // Private comments.\n"
717 " int a;\n"
718 "};\n"
719 "}\n"
720 "}";
721 std::string Expected = "\n"
722 "\n"
723 "namespace x {\n"
724 "namespace y {\n"
725 "\n\n"
726 "// Wild comments.\n"
727 "\n"
728 "// Comments.\n"
729 "// More comments.\n"
730 "class B {\n"
731 " // Private comments.\n"
732 " int a;\n"
733 "};\n"
734 "} // namespace y\n"
735 "} // namespace x\n";
736 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
737}
738
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]739TEST_F(ChangeNamespaceTest, UsingShadowDeclInGlobal) {
740 std::string Code = "namespace glob {\n"
741 "class Glob {};\n"
742 "}\n"
743 "using glob::Glob;\n"
744 "namespace na {\n"
745 "namespace nb {\n"
746 "void f() { Glob g; }\n"
747 "} // namespace nb\n"
748 "} // namespace na\n";
749
750 std::string Expected = "namespace glob {\n"
751 "class Glob {};\n"
752 "}\n"
753 "using glob::Glob;\n"
754 "\n"
755 "namespace x {\n"
756 "namespace y {\n"
757 "void f() { Glob g; }\n"
758 "} // namespace y\n"
759 "} // namespace x\n";
760 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
761}
762
763TEST_F(ChangeNamespaceTest, UsingNamespaceInGlobal) {
764 std::string Code = "namespace glob {\n"
765 "class Glob {};\n"
766 "}\n"
767 "using namespace glob;\n"
768 "namespace na {\n"
769 "namespace nb {\n"
770 "void f() { Glob g; }\n"
771 "} // namespace nb\n"
772 "} // namespace na\n";
773
774 std::string Expected = "namespace glob {\n"
775 "class Glob {};\n"
776 "}\n"
777 "using namespace glob;\n"
778 "\n"
779 "namespace x {\n"
780 "namespace y {\n"
781 "void f() { Glob g; }\n"
782 "} // namespace y\n"
783 "} // namespace x\n";
784 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
785}
786
787TEST_F(ChangeNamespaceTest, UsingDeclAfterReference) {
788 std::string Code = "namespace glob {\n"
789 "class Glob {};\n"
790 "}\n"
791 "namespace na {\n"
792 "namespace nb {\n"
793 "void f() { glob::Glob g; }\n"
794 "} // namespace nb\n"
795 "} // namespace na\n"
796 "using glob::Glob;\n"
797 "using namespace glob;\n";
798
799 std::string Expected = "namespace glob {\n"
800 "class Glob {};\n"
801 "}\n"
802 "\n"
803 "namespace x {\n"
804 "namespace y {\n"
805 "void f() { glob::Glob g; }\n"
806 "} // namespace y\n"
807 "} // namespace x\n"
808 "using glob::Glob;\n"
809 "using namespace glob;\n";
810 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
811}
812
813TEST_F(ChangeNamespaceTest, UsingNamespaceAfterReference) {
814 NewNamespace = "na::nc";
815 std::string Code = "namespace glob {\n"
816 "class Glob {};\n"
817 "}\n"
818 "namespace na {\n"
819 "namespace nb {\n"
820 "void f() { glob::Glob g; }\n"
821 "} // namespace nb\n"
822 "using namespace glob;\n"
823 "} // namespace na\n";
824
825 std::string Expected = "namespace glob {\n"
826 "class Glob {};\n"
827 "}\n"
828 "namespace na {\n"
829 "\n"
830 "namespace nc {\n"
831 "void f() { glob::Glob g; }\n"
832 "} // namespace nc\n"
833 "using namespace glob;\n"
834 "} // namespace na\n";
835 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
836}
837
838TEST_F(ChangeNamespaceTest, UsingNamespaceAndUsingShadowInGlobal) {
839 std::string Code = "namespace glob1 {\n"
840 "namespace glob2 {\n"
841 "class Glob {};\n"
842 "}\n"
843 "}\n"
844 "using glob1::glob2::Glob;\n"
845 "using namespace glob1;\n"
846 "namespace na {\n"
847 "namespace nb {\n"
848 "void f() { Glob g; }\n"
849 "} // namespace nb\n"
850 "} // namespace na\n";
851
852 std::string Expected = "namespace glob1 {\n"
853 "namespace glob2 {\n"
854 "class Glob {};\n"
855 "}\n"
856 "}\n"
857 "using glob1::glob2::Glob;\n"
858 "using namespace glob1;\n"
859 "\n"
860 "namespace x {\n"
861 "namespace y {\n"
862 "void f() { Glob g; }\n"
863 "} // namespace y\n"
864 "} // namespace x\n";
865 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
866}
867
868TEST_F(ChangeNamespaceTest, UsingAliasInGlobal) {
869 std::string Code = "namespace glob {\n"
870 "class Glob {};\n"
871 "}\n"
872 "using GLB = glob::Glob;\n"
873 "using BLG = glob::Glob;\n"
874 "namespace na {\n"
875 "namespace nb {\n"
876 "void f() { GLB g; BLG blg; }\n"
877 "} // namespace nb\n"
878 "} // namespace na\n";
879
880 std::string Expected = "namespace glob {\n"
881 "class Glob {};\n"
882 "}\n"
883 "using GLB = glob::Glob;\n"
884 "using BLG = glob::Glob;\n"
885 "\n"
886 "namespace x {\n"
887 "namespace y {\n"
888 "void f() { GLB g; BLG blg; }\n"
889 "} // namespace y\n"
890 "} // namespace x\n";
891 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
892}
893
894TEST_F(ChangeNamespaceTest, UsingShadowDeclAndMovedNamespace) {
895 std::string Code = "namespace na { class C_A {};\n }\n"
896 "using na::C_A;\n"
897 "namespace na {\n"
898 "namespace nb {\n"
899 "class C_X {\n"
900 "public:\n"
901 " C_A a;\n"
902 "};\n"
903 "} // namespace nb\n"
904 "} // namespace na\n";
905 std::string Expected = "namespace na { class C_A {};\n }\n"
906 "using na::C_A;\n"
907 "\n"
908 "namespace x {\n"
909 "namespace y {\n"
910 "class C_X {\n"
911 "public:\n"
912 " C_A a;\n"
913 "};\n"
914 "} // namespace y\n"
915 "} // namespace x\n";
916 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
917}
918
919TEST_F(ChangeNamespaceTest, UsingNamespaceDeclAndMovedNamespace) {
920 std::string Code = "namespace na { class C_A {};\n }\n"
921 "using namespace na;\n"
922 "namespace na {\n"
923 "namespace nb {\n"
924 "class C_X {\n"
925 "public:\n"
926 " C_A ca;\n"
927 "};\n"
928 "} // namespace nb\n"
929 "} // namespace na\n";
930 std::string Expected = "namespace na { class C_A {};\n }\n"
931 "using namespace na;\n"
932 "\n"
933 "namespace x {\n"
934 "namespace y {\n"
935 "class C_X {\n"
936 "public:\n"
937 " C_A ca;\n"
938 "};\n"
939 "} // namespace y\n"
940 "} // namespace x\n";
941 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
942}
943
944TEST_F(ChangeNamespaceTest, UsingShadowDeclInFunction) {
945 std::string Code = "namespace glob {\n"
946 "class Glob {};\n"
947 "}\n"
948 "namespace na {\n"
949 "namespace nb {\n"
950 "void f() {\n"
951 " using glob::Glob;\n"
952 " Glob g;\n"
953 "}\n"
954 "} // namespace nb\n"
955 "} // namespace na\n";
956
957 std::string Expected = "namespace glob {\n"
958 "class Glob {};\n"
959 "}\n"
960 "\n"
961 "namespace x {\n"
962 "namespace y {\n"
963 "void f() {\n"
964 " using ::glob::Glob;\n"
965 " Glob g;\n"
966 "}\n"
967 "} // namespace y\n"
968 "} // namespace x\n";
969 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
970}
971
972TEST_F(ChangeNamespaceTest, UsingShadowDeclInClass) {
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]973 std::string Code = "namespace na { class C_A {}; }\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]974 "namespace na {\n"
975 "namespace nb {\n"
976 "void f() {\n"
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]977 " using ::na::C_A;\n"
978 " C_A ca;\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]979 "}\n"
980 "} // namespace nb\n"
981 "} // namespace na\n";
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]982 std::string Expected = "namespace na { class C_A {}; }\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]983 "\n"
984 "namespace x {\n"
985 "namespace y {\n"
986 "void f() {\n"
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]987 " using ::na::C_A;\n"
988 " C_A ca;\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]989 "}\n"
990 "} // namespace y\n"
991 "} // namespace x\n";
992 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
993}
994
995TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespace) {
996 std::string Code = "namespace nx { void f(); }\n"
997 "namespace na {\n"
998 "using nx::f;\n"
999 "namespace nb {\n"
1000 "void d() { f(); }\n"
1001 "} // nb\n"
1002 "} // na\n";
1003
1004 std::string Expected = "namespace nx { void f(); }\n"
1005 "namespace na {\n"
1006 "using nx::f;\n"
1007 "\n"
1008 "} // na\n"
1009 "namespace x {\n"
1010 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]1011 "void d() { ::nx::f(); }\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1012 "} // namespace y\n"
1013 "} // namespace x\n";
1014 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1015}
1016
1017TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespaceNotNested) {
1018 OldNamespace = "na";
1019 std::string Code = "namespace nx { void f(); }\n"
1020 "namespace na {\n"
1021 "using ::nx::f;\n"
1022 "void d() { f(); }\n"
1023 "} // na\n";
1024
1025 std::string Expected = "namespace nx { void f(); }\n"
1026 "\n"
1027 "namespace x {\n"
1028 "namespace y {\n"
1029 "using ::nx::f;\n"
1030 "void d() { f(); }\n"
1031 "} // namespace y\n"
1032 "} // namespace x\n";
1033 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1034}
1035
1036TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespaceMultiNested) {
1037 OldNamespace = "a::b::c::d";
1038 NewNamespace = "a::b::x::y";
1039 std::string Code = "namespace nx { void f(); void g(); }\n"
1040 "namespace a {\n"
1041 "namespace b {\n"
1042 "using ::nx::f;\n"
1043 "namespace c {\n"
1044 "using ::nx::g;\n"
1045 "namespace d {\n"
1046 "void d() { f(); g(); }\n"
1047 "} // d\n"
1048 "} // c\n"
1049 "} // b\n"
1050 "} // a\n";
1051
1052 std::string Expected = "namespace nx { void f(); void g(); }\n"
1053 "namespace a {\n"
1054 "namespace b {\n"
1055 "using ::nx::f;\n"
1056 "namespace c {\n"
1057 "using ::nx::g;\n"
1058 "\n"
1059 "} // c\n"
1060 "namespace x {\n"
1061 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]1062 "void d() { f(); ::nx::g(); }\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1063 "} // namespace y\n"
1064 "} // namespace x\n"
1065 "} // b\n"
1066 "} // a\n";
1067 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1068}
1069
1070TEST_F(ChangeNamespaceTest, UsingDeclInTheParentOfOldNamespace) {
1071 OldNamespace = "nb::nc";
1072 NewNamespace = "nb::nd";
1073 std::string Code = "namespace na { class A {}; }\n"
1074 "namespace nb {\n"
1075 "using na::A;\n"
1076 "namespace nc {\n"
1077 "void d() { A a; }\n"
1078 "} // nc\n"
1079 "} // nb\n";
1080
1081 std::string Expected = "namespace na { class A {}; }\n"
1082 "namespace nb {\n"
1083 "using na::A;\n"
1084 "\n"
1085 "namespace nd {\n"
1086 "void d() { A a; }\n"
1087 "} // namespace nd\n"
1088 "} // nb\n";
1089 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1090}
1091
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]1092TEST_F(ChangeNamespaceTest, UsingAliasDecl) {
1093 std::string Code =
1094 "namespace nx { namespace ny { class X {}; } }\n"
1095 "namespace na {\n"
1096 "namespace nb {\n"
1097 "using Y = nx::ny::X;\n"
1098 "void f() { Y y; }\n"
1099 "} // namespace nb\n"
1100 "} // namespace na\n";
1101
1102 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1103 "\n"
1104 "namespace x {\n"
1105 "namespace y {\n"
1106 "using Y = nx::ny::X;\n"
1107 "void f() { Y y; }\n"
1108 "} // namespace y\n"
1109 "} // namespace x\n";
1110 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1111}
1112
1113TEST_F(ChangeNamespaceTest, UsingAliasDeclInGlobal) {
1114 std::string Code =
1115 "namespace nx { namespace ny { class X {}; } }\n"
1116 "using Y = nx::ny::X;\n"
1117 "namespace na {\n"
1118 "namespace nb {\n"
1119 "void f() { Y y; }\n"
1120 "} // namespace nb\n"
1121 "} // namespace na\n";
1122
1123 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1124 "using Y = nx::ny::X;\n"
1125 "\n"
1126 "namespace x {\n"
1127 "namespace y {\n"
1128 "void f() { Y y; }\n"
1129 "} // namespace y\n"
1130 "} // namespace x\n";
1131 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1132}
1133
1134
1135TEST_F(ChangeNamespaceTest, TypedefAliasDecl) {
1136 std::string Code =
1137 "namespace nx { namespace ny { class X {}; } }\n"
1138 "namespace na {\n"
1139 "namespace nb {\n"
1140 "typedef nx::ny::X Y;\n"
1141 "void f() { Y y; }\n"
1142 "} // namespace nb\n"
1143 "} // namespace na\n";
1144
1145 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1146 "\n"
1147 "namespace x {\n"
1148 "namespace y {\n"
1149 "typedef nx::ny::X Y;\n"
1150 "void f() { Y y; }\n"
1151 "} // namespace y\n"
1152 "} // namespace x\n";
1153 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1154}
1155
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]1156TEST_F(ChangeNamespaceTest, DerivedClassWithConstructors) {
1157 std::string Code =
1158 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1159 "namespace na {\n"
1160 "namespace nb {\n"
1161 "class A : public nx::ny::X {\n"
1162 "public:\n"
1163 " A() : X(0) {}\n"
1164 " A(int i);\n"
1165 "};\n"
1166 "A::A(int i) : X(i) {}\n"
1167 "} // namespace nb\n"
1168 "} // namespace na\n";
1169 std::string Expected =
1170 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1171 "\n\n"
1172 "namespace x {\n"
1173 "namespace y {\n"
1174 "class A : public nx::ny::X {\n"
1175 "public:\n"
1176 " A() : X(0) {}\n"
1177 " A(int i);\n"
1178 "};\n"
1179 "A::A(int i) : X(i) {}\n"
1180 "} // namespace y\n"
1181 "} // namespace x\n";
1182 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1183}
1184
1185TEST_F(ChangeNamespaceTest, DerivedClassWithQualifiedConstructors) {
1186 std::string Code =
1187 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1188 "namespace na {\n"
1189 "namespace nb {\n"
1190 "class A : public nx::ny::X {\n"
1191 "public:\n"
1192 " A() : X::X(0) {}\n"
1193 " A(int i);\n"
1194 "};\n"
1195 "A::A(int i) : X::X(i) {}\n"
1196 "} // namespace nb\n"
1197 "} // namespace na\n";
1198 std::string Expected =
1199 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1200 "\n\n"
1201 "namespace x {\n"
1202 "namespace y {\n"
1203 "class A : public nx::ny::X {\n"
1204 "public:\n"
1205 " A() : X::X(0) {}\n"
1206 " A(int i);\n"
1207 "};\n"
1208 "A::A(int i) : X::X(i) {}\n"
1209 "} // namespace y\n"
1210 "} // namespace x\n";
1211 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1212}
1213
1214TEST_F(ChangeNamespaceTest, DerivedClassWithConstructorsAndTypeRefs) {
1215 std::string Code =
1216 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1217 "namespace na {\n"
1218 "namespace nb {\n"
1219 "class A : public nx::ny::X {\n"
1220 "public:\n"
1221 " A() : X(0) {}\n"
1222 " A(int i);\n"
1223 "};\n"
1224 "A::A(int i) : X(i) { X x(1);}\n"
1225 "} // namespace nb\n"
1226 "} // namespace na\n";
1227 std::string Expected =
1228 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1229 "\n\n"
1230 "namespace x {\n"
1231 "namespace y {\n"
1232 "class A : public nx::ny::X {\n"
1233 "public:\n"
1234 " A() : X(0) {}\n"
1235 " A(int i);\n"
1236 "};\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]1237 "A::A(int i) : X(i) { ::nx::ny::X x(1);}\n"
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]1238 "} // namespace y\n"
1239 "} // namespace x\n";
1240 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1241}
1242
Eric Liu2dd0e1b2016-12-05 11:17:04 +0000[diff] [blame]1243TEST_F(ChangeNamespaceTest, MoveToGlobalNamespace) {
1244 NewNamespace = "";
1245 std::string Code = "namespace na {\n"
1246 "class C_A {};\n"
1247 "namespace nc {\n"
1248 "class C_C {};"
1249 "} // namespace nc\n"
1250 "namespace nb {\n"
1251 "class C_X {\n"
1252 "public:\n"
1253 " C_A a;\n"
1254 " nc::C_C c;\n"
1255 "};\n"
1256 "class C_Y {\n"
1257 " C_X x;\n"
1258 "};\n"
1259 "} // namespace nb\n"
1260 "} // namespace na\n";
1261 std::string Expected = "namespace na {\n"
1262 "class C_A {};\n"
1263 "namespace nc {\n"
1264 "class C_C {};"
1265 "} // namespace nc\n"
1266 "\n"
1267 "} // namespace na\n"
1268 "class C_X {\n"
1269 "public:\n"
1270 " na::C_A a;\n"
1271 " na::nc::C_C c;\n"
1272 "};\n"
1273 "class C_Y {\n"
1274 " C_X x;\n"
1275 "};\n";
1276 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1277}
1278
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame^]1279TEST_F(ChangeNamespaceTest, KeepGlobalSpecifier) {
1280 std::string Code = "class Glob {};\n"
1281 "namespace na {\n"
1282 "class C_A {};\n"
1283 "namespace nc {\n"
1284 "class C_C {};"
1285 "} // namespace nc\n"
1286 "namespace nb {\n"
1287 "class C_X {\n"
1288 "public:\n"
1289 " ::Glob glob_1;\n"
1290 " Glob glob_2;\n"
1291 " C_A a_1;\n"
1292 " ::na::C_A a_2;\n"
1293 " nc::C_C c;\n"
1294 "};\n"
1295 "} // namespace nb\n"
1296 "} // namespace na\n";
1297 std::string Expected = "class Glob {};\n"
1298 "namespace na {\n"
1299 "class C_A {};\n"
1300 "namespace nc {\n"
1301 "class C_C {};"
1302 "} // namespace nc\n"
1303 "\n"
1304 "} // namespace na\n"
1305 "namespace x {\n"
1306 "namespace y {\n"
1307 "class C_X {\n"
1308 "public:\n"
1309 " ::Glob glob_1;\n"
1310 " Glob glob_2;\n"
1311 " ::na::C_A a_1;\n"
1312 " ::na::C_A a_2;\n"
1313 " ::na::nc::C_C c;\n"
1314 "};\n"
1315 "} // namespace y\n"
1316 "} // namespace x\n";
1317 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1318}
1319
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]1320} // anonymous namespace
1321} // namespace change_namespace
1322} // namespace clang