Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 0325a77c5b59c1d5b9508dfc49625d7f5e9051ee / . / clang-tools-extra / unittests / change-namespace / ChangeNamespaceTests.cpp
blob: 526878b3c9b71d65fd47422e09f4f5805a40a7ad [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"
Eric Liu6aa94162016-11-10 18:29:01 +0000[diff] [blame]113 "} // namespace nb\n"
114 "} // namespace na\n";
115 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
116}
117
Eric Liuee5104b2017-01-04 14:49:08 +0000[diff] [blame]118TEST_F(ChangeNamespaceTest, NewNsNestedInOldNsWithSurroundingNewLines) {
119 NewNamespace = "na::nb::nc";
120 std::string Code = "namespace na {\n"
121 "namespace nb {\n"
122 "\n"
123 "class A {};\n"
124 "\n"
125 "} // namespace nb\n"
126 "} // namespace na\n";
127 std::string Expected = "namespace na {\n"
128 "namespace nb {\n"
129 "namespace nc {\n"
130 "\n"
131 "class A {};\n"
132 "\n"
133 "} // namespace nc\n"
134 "} // namespace nb\n"
135 "} // namespace na\n";
136 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
137}
138
139TEST_F(ChangeNamespaceTest, MoveOldNsWithSurroundingNewLines) {
140 NewNamespace = "nx::ny";
141 std::string Code = "namespace na {\n"
142 "namespace nb {\n"
143 "\n"
144 "class A {};\n"
145 "\n"
146 "} // namespace nb\n"
147 "} // namespace na\n";
148 std::string Expected = "\n\n"
149 "namespace nx {\n"
150 "namespace ny {\n"
151 "\n"
152 "class A {};\n"
153 "\n"
154 "} // namespace ny\n"
155 "} // namespace nx\n";
156 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
157}
158
Eric Liu6aa94162016-11-10 18:29:01 +0000[diff] [blame]159TEST_F(ChangeNamespaceTest, NewNsNestedInOldNsWithRefs) {
160 NewNamespace = "na::nb::nc";
161 std::string Code = "namespace na {\n"
162 "class A {};\n"
163 "namespace nb {\n"
164 "class B {};\n"
165 "class C {};\n"
166 "void f() { A a; B b; }\n"
167 "} // namespace nb\n"
168 "} // namespace na\n";
169 std::string Expected = "namespace na {\n"
170 "class A {};\n"
171 "namespace nb {\n"
172 "namespace nc {\n"
173 "class B {};\n"
174 "class C {};\n"
175 "void f() { A a; B b; }\n"
176 "} // namespace nc\n"
Eric Liu6aa94162016-11-10 18:29:01 +0000[diff] [blame]177 "} // namespace nb\n"
178 "} // namespace na\n";
179 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
180}
181
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]182TEST_F(ChangeNamespaceTest, SimpleMoveIntoAnotherNestedNamespace) {
183 NewNamespace = "na::nc";
184 std::string Code = "namespace na {\n"
185 "namespace nb {\n"
186 "class A {};\n"
187 "} // namespace nb\n"
188 "} // namespace na\n";
189 std::string Expected = "namespace na {\n"
190 "\n"
191 "namespace nc {\n"
192 "class A {};\n"
193 "} // namespace nc\n"
194 "} // namespace na\n";
195 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
196}
197
Eric Liu447164d2016-10-05 15:52:39 +0000[diff] [blame]198TEST_F(ChangeNamespaceTest, MoveIntoAnotherNestedNamespaceWithRef) {
199 NewNamespace = "na::nc";
200 std::string Code = "namespace na {\n"
201 "class A {};\n"
202 "namespace nb {\n"
203 "class X { A a; };\n"
204 "} // namespace nb\n"
205 "} // namespace na\n";
206 std::string Expected = "namespace na {\n"
207 "class A {};\n"
208 "\n"
209 "namespace nc {\n"
210 "class X { A a; };\n"
211 "} // namespace nc\n"
212 "} // namespace na\n";
213 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
214}
215
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]216TEST_F(ChangeNamespaceTest, MoveIntoExistingNamespaceAndShortenRefs) {
217 std::string Code = "namespace x {\n"
218 "namespace z {\n"
219 "class Z {};\n"
220 "} // namespace z\n"
221 "namespace y {\n"
222 "class T {};\n"
223 "} // namespace y\n"
224 "} // namespace x\n"
225 "namespace na {\n"
226 "class A{};\n"
227 "namespace nb {\n"
228 "class X { A a; x::z::Z zz; x::y::T t; };\n"
229 "} // namespace nb\n"
230 "} // namespace na\n";
231 std::string Expected = "namespace x {\n"
232 "namespace z {\n"
233 "class Z {};\n"
234 "} // namespace z\n"
235 "namespace y {\n"
236 "class T {};\n"
237 "} // namespace y\n"
238 "} // namespace x\n"
239 "namespace na {\n"
240 "class A {};\n\n"
241 "} // namespace na\n"
242 "namespace x {\n"
243 "namespace y {\n"
244 "class X { ::na::A a; z::Z zz; T t; };\n"
245 "} // namespace y\n"
246 "} // namespace x\n";
247 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
248}
249
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]250TEST_F(ChangeNamespaceTest, SimpleMoveNestedNamespace) {
251 NewNamespace = "na::x::y";
252 std::string Code = "namespace na {\n"
253 "class A {};\n"
254 "namespace nb {\n"
255 "class B {};\n"
256 "} // namespace nb\n"
257 "} // namespace na\n";
258 std::string Expected = "namespace na {\n"
259 "class A {};\n"
260 "\n"
261 "namespace x {\n"
262 "namespace y {\n"
263 "class B {};\n"
264 "} // namespace y\n"
265 "} // namespace x\n"
266 "} // namespace na\n";
267 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
268}
269
270TEST_F(ChangeNamespaceTest, SimpleMoveWithTypeRefs) {
271 std::string Code = "namespace na {\n"
272 "class C_A {};\n"
273 "namespace nc {\n"
274 "class C_C {};"
275 "} // namespace nc\n"
276 "namespace nb {\n"
277 "class C_X {\n"
278 "public:\n"
279 " C_A a;\n"
280 " nc::C_C c;\n"
281 "};\n"
282 "class C_Y {\n"
283 " C_X x;\n"
284 "};\n"
285 "} // namespace nb\n"
286 "} // namespace na\n";
287 std::string Expected = "namespace na {\n"
288 "class C_A {};\n"
289 "namespace nc {\n"
290 "class C_C {};"
291 "} // namespace nc\n"
292 "\n"
293 "} // namespace na\n"
294 "namespace x {\n"
295 "namespace y {\n"
296 "class C_X {\n"
297 "public:\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]298 " ::na::C_A a;\n"
299 " ::na::nc::C_C c;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]300 "};\n"
301 "class C_Y {\n"
302 " C_X x;\n"
303 "};\n"
304 "} // namespace y\n"
305 "} // namespace x\n";
306 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
307}
308
Eric Liu8393cb02016-10-31 08:28:29 +0000[diff] [blame]309TEST_F(ChangeNamespaceTest, TypeLocInTemplateSpecialization) {
310 std::string Code = "namespace na {\n"
311 "class A {};\n"
312 "template <typename T>\n"
313 "class B {};\n"
314 "template <typename T1, typename T2>\n"
315 "class Two {};\n"
316 "namespace nc { class C {}; }\n"
317 "} // na\n"
318 "\n"
319 "namespace na {\n"
320 "namespace nb {\n"
321 "void f() {\n"
322 " B<A> b;\n"
323 " B<nc::C> b_c;\n"
324 " Two<A, nc::C> two;\n"
325 "}\n"
326 "} // nb\n"
327 "} // na\n";
328 std::string Expected = "namespace na {\n"
329 "class A {};\n"
330 "template <typename T>\n"
331 "class B {};\n"
332 "template <typename T1, typename T2>\n"
333 "class Two {};\n"
334 "namespace nc { class C {}; }\n"
335 "} // na\n"
336 "\n"
337 "\n"
338 "namespace x {\n"
339 "namespace y {\n"
340 "void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]341 " ::na::B<::na::A> b;\n"
342 " ::na::B<::na::nc::C> b_c;\n"
343 " ::na::Two<::na::A, ::na::nc::C> two;\n"
Eric Liu8393cb02016-10-31 08:28:29 +0000[diff] [blame]344 "}\n"
345 "} // namespace y\n"
346 "} // namespace x\n";
347 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
348}
349
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]350TEST_F(ChangeNamespaceTest, LeaveForwardDeclarationBehind) {
351 std::string Code = "namespace na {\n"
352 "namespace nb {\n"
353 "class FWD;\n"
Eric Liu41552d62016-12-07 14:20:52 +0000[diff] [blame]354 "class FWD2;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]355 "class A {\n"
356 " FWD *fwd;\n"
357 "};\n"
358 "} // namespace nb\n"
359 "} // namespace na\n";
360 std::string Expected = "namespace na {\n"
361 "namespace nb {\n"
362 "class FWD;\n"
Eric Liu41552d62016-12-07 14:20:52 +0000[diff] [blame]363 "class FWD2;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]364 "} // namespace nb\n"
365 "} // namespace na\n"
366 "namespace x {\n"
367 "namespace y {\n"
368 "\n"
369 "class A {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]370 " ::na::nb::FWD *fwd;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]371 "};\n"
372 "} // namespace y\n"
373 "} // namespace x\n";
374 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
375}
376
Eric Liu41552d62016-12-07 14:20:52 +0000[diff] [blame]377TEST_F(ChangeNamespaceTest, TemplateClassForwardDeclaration) {
378 std::string Code = "namespace na {\n"
379 "namespace nb {\n"
380 "class FWD;\n"
381 "template<typename T> class FWD_TEMP;\n"
382 "class A {\n"
383 " FWD *fwd;\n"
384 "};\n"
385 "template<typename T> class TEMP {};\n"
386 "} // namespace nb\n"
387 "} // namespace na\n";
388 std::string Expected = "namespace na {\n"
389 "namespace nb {\n"
390 "class FWD;\n"
391 "template<typename T> class FWD_TEMP;\n"
392 "} // namespace nb\n"
393 "} // namespace na\n"
394 "namespace x {\n"
395 "namespace y {\n"
396 "\n"
397 "class A {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]398 " ::na::nb::FWD *fwd;\n"
Eric Liu41552d62016-12-07 14:20:52 +0000[diff] [blame]399 "};\n"
400 "template<typename T> class TEMP {};\n"
401 "} // namespace y\n"
402 "} // namespace x\n";
403 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
404}
405
406TEST_F(ChangeNamespaceTest, DontMoveForwardDeclarationInClass) {
407 std::string Code = "namespace na {\n"
408 "namespace nb {\n"
409 "class A {\n"
410 " class FWD;\n"
411 " FWD *fwd;\n"
412 " template<typename T> class FWD_TEMP;\n"
413 "};\n"
414 "} // namespace nb\n"
415 "} // namespace na\n";
416 std::string Expected = "\n\n"
417 "namespace x {\n"
418 "namespace y {\n"
419 "class A {\n"
420 " class FWD;\n"
421 " FWD *fwd;\n"
422 " template<typename T> class FWD_TEMP;\n"
423 "};\n"
424 "} // namespace y\n"
425 "} // namespace x\n";
426 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
427}
428
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]429TEST_F(ChangeNamespaceTest, MoveFunctions) {
430 std::string Code = "namespace na {\n"
431 "class C_A {};\n"
432 "namespace nc {\n"
433 "class C_C {};"
434 "} // namespace nc\n"
435 "namespace nb {\n"
436 "void fwd();\n"
437 "void f(C_A ca, nc::C_C cc) {\n"
438 " C_A ca_1 = ca;\n"
439 "}\n"
440 "} // namespace nb\n"
441 "} // namespace na\n";
442
443 std::string Expected = "namespace na {\n"
444 "class C_A {};\n"
445 "namespace nc {\n"
446 "class C_C {};"
447 "} // namespace nc\n"
448 "\n"
449 "} // namespace na\n"
450 "namespace x {\n"
451 "namespace y {\n"
452 "void fwd();\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]453 "void f(::na::C_A ca, ::na::nc::C_C cc) {\n"
454 " ::na::C_A ca_1 = ca;\n"
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]455 "}\n"
456 "} // namespace y\n"
457 "} // namespace x\n";
458 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
459}
460
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]461TEST_F(ChangeNamespaceTest, FixUsingShadowDecl) {
Eric Liu912d0392016-09-27 12:54:48 +0000[diff] [blame]462 std::string Code = "class GLOB {};\n"
463 "using BLOG = GLOB;\n"
464 "namespace na {\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]465 "namespace nc {\n"
466 "class SAME {};\n"
467 "}\n"
468 "namespace nd {\n"
469 "class SAME {};\n"
470 "}\n"
471 "namespace nb {\n"
472 "using nc::SAME;\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]473 "using YO = nd::SAME;\n"
474 "typedef nd::SAME IDENTICAL;\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]475 "void f(nd::SAME Same) {}\n"
476 "} // namespace nb\n"
477 "} // namespace na\n";
478
Eric Liu912d0392016-09-27 12:54:48 +0000[diff] [blame]479 std::string Expected = "class GLOB {};\n"
480 "using BLOG = GLOB;\n"
481 "namespace na {\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]482 "namespace nc {\n"
483 "class SAME {};\n"
484 "}\n"
485 "namespace nd {\n"
486 "class SAME {};\n"
487 "}\n"
488 "\n"
489 "} // namespace na\n"
490 "namespace x {\n"
491 "namespace y {\n"
492 "using ::na::nc::SAME;\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]493 "using YO = ::na::nd::SAME;\n"
494 "typedef ::na::nd::SAME IDENTICAL;\n"
495 "void f(::na::nd::SAME Same) {}\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]496 "} // namespace y\n"
497 "} // namespace x\n";
498 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
499}
500
Eric Liu8685c762016-12-07 17:04:07 +0000[diff] [blame]501TEST_F(ChangeNamespaceTest, DontFixUsingShadowDeclInClasses) {
502 std::string Code = "namespace na {\n"
503 "class A {};\n"
504 "class Base { public: Base() {} void m() {} };\n"
505 "namespace nb {\n"
506 "class D : public Base {\n"
507 "public:\n"
508 " using AA = A; using B = Base;\n"
509 " using Base::m; using Base::Base;\n"
510 "};"
511 "} // namespace nb\n"
512 "} // namespace na\n";
513
514 std::string Expected = "namespace na {\n"
515 "class A {};\n"
516 "class Base { public: Base() {} void m() {} };\n"
517 "\n"
518 "} // namespace na\n"
519 "namespace x {\n"
520 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]521 "class D : public ::na::Base {\n"
Eric Liu8685c762016-12-07 17:04:07 +0000[diff] [blame]522 "public:\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]523 " using AA = ::na::A; using B = ::na::Base;\n"
Eric Liu8685c762016-12-07 17:04:07 +0000[diff] [blame]524 " using Base::m; using Base::Base;\n"
525 "};"
526 "} // namespace y\n"
527 "} // namespace x\n";
528 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
529}
530
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]531TEST_F(ChangeNamespaceTest, TypeInNestedNameSpecifier) {
532 std::string Code =
533 "namespace na {\n"
534 "class C_A {\n"
535 "public:\n"
536 " class Nested {\n"
537 " public:\n"
538 " static int NestedX;\n"
539 " static void nestedFunc() {}\n"
540 " };\n"
541 "};\n"
542 "namespace nb {\n"
543 "class C_X {\n"
544 " C_A na;\n"
545 " C_A::Nested nested;\n"
546 " void f() {\n"
547 " C_A::Nested::nestedFunc();\n"
548 " int X = C_A::Nested::NestedX;\n"
549 " }\n"
550 "};\n"
551 "} // namespace nb\n"
552 "} // namespace na\n";
553 std::string Expected =
554 "namespace na {\n"
555 "class C_A {\n"
556 "public:\n"
557 " class Nested {\n"
558 " public:\n"
559 " static int NestedX;\n"
560 " static void nestedFunc() {}\n"
561 " };\n"
562 "};\n"
563 "\n"
564 "} // namespace na\n"
565 "namespace x {\n"
566 "namespace y {\n"
567 "class C_X {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]568 " ::na::C_A na;\n"
569 " ::na::C_A::Nested nested;\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]570 " void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]571 " ::na::C_A::Nested::nestedFunc();\n"
572 " int X = ::na::C_A::Nested::NestedX;\n"
Eric Liu68765a82016-09-21 15:06:12 +0000[diff] [blame]573 " }\n"
574 "};\n"
575 "} // namespace y\n"
576 "} // namespace x\n";
577 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
578}
579
Eric Liu12068d82016-09-22 11:54:00 +0000[diff] [blame]580TEST_F(ChangeNamespaceTest, FixFunctionNameSpecifiers) {
581 std::string Code =
582 "namespace na {\n"
583 "class A {\n"
584 "public:\n"
585 " static void f() {}\n"
586 " static void g();\n"
587 "};\n"
588 "void A::g() {}"
589 "void a_f() {}\n"
590 "static void static_f() {}\n"
591 "namespace nb {\n"
592 "void f() { a_f(); static_f(); A::f(); }\n"
593 "void g() { f(); A::g(); }\n"
594 "} // namespace nb\n"
595 "} // namespace na\n";
596 std::string Expected =
597 "namespace na {\n"
598 "class A {\n"
599 "public:\n"
600 " static void f() {}\n"
601 " static void g();\n"
602 "};\n"
603 "void A::g() {}"
604 "void a_f() {}\n"
605 "static void static_f() {}\n"
606 "\n"
607 "} // namespace na\n"
608 "namespace x {\n"
609 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]610 "void f() { ::na::a_f(); ::na::static_f(); ::na::A::f(); }\n"
611 "void g() { f(); ::na::A::g(); }\n"
Eric Liu12068d82016-09-22 11:54:00 +0000[diff] [blame]612 "} // namespace y\n"
613 "} // namespace x\n";
614 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
615}
616
Eric Liue3f35e42016-12-20 14:39:04 +0000[diff] [blame]617TEST_F(ChangeNamespaceTest, FixOverloadedOperatorFunctionNameSpecifiers) {
618 std::string Code =
619 "namespace na {\n"
620 "class A {\n"
621 "public:\n"
622 " int x;\n"
623 " bool operator==(const A &RHS) const { return x == RHS.x; }\n"
624 "};\n"
625 "bool operator<(const A &LHS, const A &RHS) { return LHS.x == RHS.x; }\n"
626 "namespace nb {\n"
627 "bool f() {\n"
628 " A x, y;\n"
629 " auto f = operator<;\n"
630 " return (x == y) && (x < y) && (operator<(x, y));\n"
631 "}\n"
632 "} // namespace nb\n"
633 "} // namespace na\n";
634 std::string Expected =
635 "namespace na {\n"
636 "class A {\n"
637 "public:\n"
638 " int x;\n"
639 " bool operator==(const A &RHS) const { return x == RHS.x; }\n"
640 "};\n"
641 "bool operator<(const A &LHS, const A &RHS) { return LHS.x == RHS.x; }\n"
642 "\n"
643 "} // namespace na\n"
644 "namespace x {\n"
645 "namespace y {\n"
646 "bool f() {\n"
647 " ::na::A x, y;\n"
648 " auto f = ::na::operator<;\n"
649 // FIXME: function calls to overloaded operators are not fixed now even if
650 // they are referenced by qualified names.
651 " return (x == y) && (x < y) && (operator<(x,y));\n"
652 "}\n"
653 "} // namespace y\n"
654 "} // namespace x\n";
655 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
656}
657
Eric Liuda22b3c2016-11-29 14:15:14 +0000[diff] [blame]658TEST_F(ChangeNamespaceTest, FixNonCallingFunctionReferences) {
659 std::string Code = "namespace na {\n"
660 "class A {\n"
661 "public:\n"
662 " static void f() {}\n"
663 "};\n"
664 "void a_f() {}\n"
665 "static void s_f() {}\n"
666 "namespace nb {\n"
667 "void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]668 " auto *ref1 = A::f;\n"
669 " auto *ref2 = a_f;\n"
670 " auto *ref3 = s_f;\n"
Eric Liuda22b3c2016-11-29 14:15:14 +0000[diff] [blame]671 "}\n"
672 "} // namespace nb\n"
673 "} // namespace na\n";
674 std::string Expected =
675 "namespace na {\n"
676 "class A {\n"
677 "public:\n"
678 " static void f() {}\n"
679 "};\n"
680 "void a_f() {}\n"
681 "static void s_f() {}\n"
682 "\n"
683 "} // namespace na\n"
684 "namespace x {\n"
685 "namespace y {\n"
686 "void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]687 " auto *ref1 = ::na::A::f;\n"
688 " auto *ref2 = ::na::a_f;\n"
689 " auto *ref3 = ::na::s_f;\n"
Eric Liuda22b3c2016-11-29 14:15:14 +0000[diff] [blame]690 "}\n"
691 "} // namespace y\n"
692 "} // namespace x\n";
693 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
694}
695
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]696TEST_F(ChangeNamespaceTest, MoveAndFixGlobalVariables) {
697 std::string Code = "namespace na {\n"
698 "int GlobA;\n"
699 "static int GlobAStatic = 0;\n"
700 "namespace nc { int GlobC; }\n"
701 "namespace nb {\n"
702 "int GlobB;\n"
703 "void f() {\n"
704 " int a = GlobA;\n"
705 " int b = GlobAStatic;\n"
706 " int c = nc::GlobC;\n"
707 "}\n"
708 "} // namespace nb\n"
709 "} // namespace na\n";
710
711 std::string Expected = "namespace na {\n"
712 "int GlobA;\n"
713 "static int GlobAStatic = 0;\n"
714 "namespace nc { int GlobC; }\n"
715 "\n"
716 "} // namespace na\n"
717 "namespace x {\n"
718 "namespace y {\n"
719 "int GlobB;\n"
720 "void f() {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]721 " int a = ::na::GlobA;\n"
722 " int b = ::na::GlobAStatic;\n"
723 " int c = ::na::nc::GlobC;\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]724 "}\n"
725 "} // namespace y\n"
726 "} // namespace x\n";
727
728 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
729}
730
731TEST_F(ChangeNamespaceTest, DoNotFixStaticVariableOfClass) {
732 std::string Code = "namespace na {\n"
733 "class A {\n"
734 "public:\n"
735 "static int A1;\n"
736 "static int A2;\n"
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]737 "};\n"
738 "int A::A1 = 0;\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]739 "namespace nb {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]740 "void f() {\n"
741 " int a = A::A1; int b = A::A2;\n"
742 "}\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]743 "} // namespace nb\n"
744 "} // namespace na\n";
745
746 std::string Expected = "namespace na {\n"
747 "class A {\n"
748 "public:\n"
749 "static int A1;\n"
750 "static int A2;\n"
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]751 "};\n"
752 "int A::A1 = 0;\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]753 "\n"
754 "} // namespace na\n"
755 "namespace x {\n"
756 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]757 "void f() {\n"
758 " int a = ::na::A::A1; int b = ::na::A::A2;\n"
759 "}\n"
Eric Liu159f0132016-09-30 04:32:39 +0000[diff] [blame]760 "} // namespace y\n"
761 "} // namespace x\n";
762
763 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
764}
765
Haojian Wuef8a6dc2016-10-04 10:35:53 +0000[diff] [blame]766TEST_F(ChangeNamespaceTest, NoMisplaceAtEOF) {
767 std::string Code = "namespace na {\n"
768 "namespace nb {\n"
769 "class A;\n"
770 "class B {};\n"
771 "}"
772 "}";
773 std::string Expected = "namespace na {\n"
774 "namespace nb {\n"
775 "class A;\n"
776 "}\n"
777 "}\n"
778 "namespace x {\n"
779 "namespace y {\n"
780 "\n"
781 "class B {};\n"
782 "} // namespace y\n"
783 "} // namespace x\n";
784 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
785}
786
Eric Liu73f49fd2016-10-12 12:34:18 +0000[diff] [blame]787TEST_F(ChangeNamespaceTest, CommentsBeforeMovedClass) {
788 std::string Code = "namespace na {\n"
789 "namespace nb {\n"
790 "\n\n"
791 "// Wild comments.\n"
792 "\n"
793 "// Comments.\n"
794 "// More comments.\n"
795 "class B {\n"
796 " // Private comments.\n"
797 " int a;\n"
798 "};\n"
799 "}\n"
800 "}";
801 std::string Expected = "\n"
802 "\n"
803 "namespace x {\n"
804 "namespace y {\n"
805 "\n\n"
806 "// Wild comments.\n"
807 "\n"
808 "// Comments.\n"
809 "// More comments.\n"
810 "class B {\n"
811 " // Private comments.\n"
812 " int a;\n"
813 "};\n"
814 "} // namespace y\n"
815 "} // namespace x\n";
816 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
817}
818
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]819TEST_F(ChangeNamespaceTest, UsingShadowDeclInGlobal) {
820 std::string Code = "namespace glob {\n"
821 "class Glob {};\n"
822 "}\n"
823 "using glob::Glob;\n"
824 "namespace na {\n"
825 "namespace nb {\n"
826 "void f() { Glob g; }\n"
827 "} // namespace nb\n"
828 "} // namespace na\n";
829
830 std::string Expected = "namespace glob {\n"
831 "class Glob {};\n"
832 "}\n"
833 "using glob::Glob;\n"
834 "\n"
835 "namespace x {\n"
836 "namespace y {\n"
837 "void f() { Glob g; }\n"
838 "} // namespace y\n"
839 "} // namespace x\n";
840 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
841}
842
843TEST_F(ChangeNamespaceTest, UsingNamespaceInGlobal) {
844 std::string Code = "namespace glob {\n"
845 "class Glob {};\n"
846 "}\n"
847 "using namespace glob;\n"
848 "namespace na {\n"
849 "namespace nb {\n"
850 "void f() { Glob g; }\n"
851 "} // namespace nb\n"
852 "} // namespace na\n";
853
854 std::string Expected = "namespace glob {\n"
855 "class Glob {};\n"
856 "}\n"
857 "using namespace glob;\n"
858 "\n"
859 "namespace x {\n"
860 "namespace y {\n"
861 "void f() { Glob g; }\n"
862 "} // namespace y\n"
863 "} // namespace x\n";
864 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
865}
866
Eric Liu180dac62016-12-23 10:47:09 +0000[diff] [blame]867TEST_F(ChangeNamespaceTest, NamespaceAliasInGlobal) {
868 std::string Code = "namespace glob {\n"
869 "class Glob {};\n"
870 "}\n"
871 "namespace glob2 { class Glob2 {}; }\n"
872 "namespace gl = glob;\n"
873 "namespace gl2 = ::glob2;\n"
874 "namespace na {\n"
875 "namespace nb {\n"
876 "void f() { gl::Glob g; gl2::Glob2 g2; }\n"
877 "} // namespace nb\n"
878 "} // namespace na\n";
879
880 std::string Expected =
881 "namespace glob {\n"
882 "class Glob {};\n"
883 "}\n"
884 "namespace glob2 { class Glob2 {}; }\n"
885 "namespace gl = glob;\n"
886 "namespace gl2 = ::glob2;\n"
887 "\n"
888 "namespace x {\n"
889 "namespace y {\n"
890 "void f() { gl::Glob g; gl2::Glob2 g2; }\n"
891 "} // namespace y\n"
892 "} // namespace x\n";
893 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
894}
895
896TEST_F(ChangeNamespaceTest, NamespaceAliasInNamespace) {
897 std::string Code = "namespace glob {\n"
898 "class Glob {};\n"
899 "}\n"
900 "namespace na {\n"
901 "namespace nb {\n"
902 "namespace gl = glob;\n"
903 "void f() { gl::Glob g; }\n"
904 "} // namespace nb\n"
905 "} // namespace na\n";
906
907 std::string Expected = "namespace glob {\n"
908 "class Glob {};\n"
909 "}\n"
910 "\n"
911 "namespace x {\n"
912 "namespace y {\n"
913 "namespace gl = glob;\n"
914 "void f() { gl::Glob g; }\n"
915 "} // namespace y\n"
916 "} // namespace x\n";
917 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
918}
919
920TEST_F(ChangeNamespaceTest, NamespaceAliasInAncestorNamespace) {
921 NewNamespace = "na::nx";
922 std::string Code = "namespace glob {\n"
923 "class Glob {};\n"
924 "}\n"
925 "namespace other { namespace gl = glob; }\n"
926 "namespace na {\n"
927 "namespace ga = glob;\n"
928 "namespace nb {\n"
929 "void f() { ga::Glob g; }\n"
930 "} // namespace nb\n"
931 "} // namespace na\n";
932
933 std::string Expected = "namespace glob {\n"
934 "class Glob {};\n"
935 "}\n"
936 "namespace other { namespace gl = glob; }\n"
937 "namespace na {\n"
938 "namespace ga = glob;\n"
939 "\n"
940 "namespace nx {\n"
941 "void f() { ga::Glob g; }\n"
942 "} // namespace nx\n"
943 "} // namespace na\n";
944 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
945}
946
947TEST_F(ChangeNamespaceTest, NamespaceAliasInOtherNamespace) {
948 std::string Code = "namespace glob {\n"
949 "class Glob {};\n"
950 "}\n"
951 "namespace other { namespace gl = glob; }\n"
952 "namespace na {\n"
953 "namespace ga = glob;\n"
954 "namespace nb {\n"
955 "void f() { glob::Glob g; }\n"
956 "} // namespace nb\n"
957 "} // namespace na\n";
958
959 std::string Expected = "namespace glob {\n"
960 "class Glob {};\n"
961 "}\n"
962 "namespace other { namespace gl = glob; }\n"
963 "namespace na {\n"
964 "namespace ga = glob;\n"
965 "\n"
966 "} // namespace na\n"
967 "namespace x {\n"
968 "namespace y {\n"
969 "void f() { glob::Glob g; }\n"
970 "} // namespace y\n"
971 "} // namespace x\n";
972 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
973}
974
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]975TEST_F(ChangeNamespaceTest, UsingDeclAfterReference) {
976 std::string Code = "namespace glob {\n"
977 "class Glob {};\n"
978 "}\n"
979 "namespace na {\n"
980 "namespace nb {\n"
981 "void f() { glob::Glob g; }\n"
982 "} // namespace nb\n"
983 "} // namespace na\n"
984 "using glob::Glob;\n"
985 "using namespace glob;\n";
986
987 std::string Expected = "namespace glob {\n"
988 "class Glob {};\n"
989 "}\n"
990 "\n"
991 "namespace x {\n"
992 "namespace y {\n"
993 "void f() { glob::Glob g; }\n"
994 "} // namespace y\n"
995 "} // namespace x\n"
996 "using glob::Glob;\n"
997 "using namespace glob;\n";
998 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
999}
1000
1001TEST_F(ChangeNamespaceTest, UsingNamespaceAfterReference) {
1002 NewNamespace = "na::nc";
1003 std::string Code = "namespace glob {\n"
1004 "class Glob {};\n"
1005 "}\n"
1006 "namespace na {\n"
1007 "namespace nb {\n"
1008 "void f() { glob::Glob g; }\n"
1009 "} // namespace nb\n"
1010 "using namespace glob;\n"
1011 "} // namespace na\n";
1012
1013 std::string Expected = "namespace glob {\n"
1014 "class Glob {};\n"
1015 "}\n"
1016 "namespace na {\n"
1017 "\n"
1018 "namespace nc {\n"
1019 "void f() { glob::Glob g; }\n"
1020 "} // namespace nc\n"
1021 "using namespace glob;\n"
1022 "} // namespace na\n";
1023 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1024}
1025
1026TEST_F(ChangeNamespaceTest, UsingNamespaceAndUsingShadowInGlobal) {
1027 std::string Code = "namespace glob1 {\n"
1028 "namespace glob2 {\n"
1029 "class Glob {};\n"
1030 "}\n"
1031 "}\n"
1032 "using glob1::glob2::Glob;\n"
1033 "using namespace glob1;\n"
1034 "namespace na {\n"
1035 "namespace nb {\n"
1036 "void f() { Glob g; }\n"
1037 "} // namespace nb\n"
1038 "} // namespace na\n";
1039
1040 std::string Expected = "namespace glob1 {\n"
1041 "namespace glob2 {\n"
1042 "class Glob {};\n"
1043 "}\n"
1044 "}\n"
1045 "using glob1::glob2::Glob;\n"
1046 "using namespace glob1;\n"
1047 "\n"
1048 "namespace x {\n"
1049 "namespace y {\n"
1050 "void f() { Glob g; }\n"
1051 "} // namespace y\n"
1052 "} // namespace x\n";
1053 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1054}
1055
1056TEST_F(ChangeNamespaceTest, UsingAliasInGlobal) {
1057 std::string Code = "namespace glob {\n"
1058 "class Glob {};\n"
1059 "}\n"
1060 "using GLB = glob::Glob;\n"
1061 "using BLG = glob::Glob;\n"
1062 "namespace na {\n"
1063 "namespace nb {\n"
1064 "void f() { GLB g; BLG blg; }\n"
1065 "} // namespace nb\n"
1066 "} // namespace na\n";
1067
1068 std::string Expected = "namespace glob {\n"
1069 "class Glob {};\n"
1070 "}\n"
1071 "using GLB = glob::Glob;\n"
1072 "using BLG = glob::Glob;\n"
1073 "\n"
1074 "namespace x {\n"
1075 "namespace y {\n"
1076 "void f() { GLB g; BLG blg; }\n"
1077 "} // namespace y\n"
1078 "} // namespace x\n";
1079 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1080}
1081
1082TEST_F(ChangeNamespaceTest, UsingShadowDeclAndMovedNamespace) {
1083 std::string Code = "namespace na { class C_A {};\n }\n"
1084 "using na::C_A;\n"
1085 "namespace na {\n"
1086 "namespace nb {\n"
1087 "class C_X {\n"
1088 "public:\n"
1089 " C_A a;\n"
1090 "};\n"
1091 "} // namespace nb\n"
1092 "} // namespace na\n";
1093 std::string Expected = "namespace na { class C_A {};\n }\n"
1094 "using na::C_A;\n"
1095 "\n"
1096 "namespace x {\n"
1097 "namespace y {\n"
1098 "class C_X {\n"
1099 "public:\n"
1100 " C_A a;\n"
1101 "};\n"
1102 "} // namespace y\n"
1103 "} // namespace x\n";
1104 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1105}
1106
1107TEST_F(ChangeNamespaceTest, UsingNamespaceDeclAndMovedNamespace) {
1108 std::string Code = "namespace na { class C_A {};\n }\n"
1109 "using namespace na;\n"
1110 "namespace na {\n"
1111 "namespace nb {\n"
1112 "class C_X {\n"
1113 "public:\n"
1114 " C_A ca;\n"
1115 "};\n"
1116 "} // namespace nb\n"
1117 "} // namespace na\n";
1118 std::string Expected = "namespace na { class C_A {};\n }\n"
1119 "using namespace na;\n"
1120 "\n"
1121 "namespace x {\n"
1122 "namespace y {\n"
1123 "class C_X {\n"
1124 "public:\n"
1125 " C_A ca;\n"
1126 "};\n"
1127 "} // namespace y\n"
1128 "} // namespace x\n";
1129 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1130}
1131
1132TEST_F(ChangeNamespaceTest, UsingShadowDeclInFunction) {
1133 std::string Code = "namespace glob {\n"
1134 "class Glob {};\n"
1135 "}\n"
1136 "namespace na {\n"
1137 "namespace nb {\n"
1138 "void f() {\n"
1139 " using glob::Glob;\n"
1140 " Glob g;\n"
1141 "}\n"
1142 "} // namespace nb\n"
1143 "} // namespace na\n";
1144
1145 std::string Expected = "namespace glob {\n"
1146 "class Glob {};\n"
1147 "}\n"
1148 "\n"
1149 "namespace x {\n"
1150 "namespace y {\n"
1151 "void f() {\n"
1152 " using ::glob::Glob;\n"
1153 " Glob g;\n"
1154 "}\n"
1155 "} // namespace y\n"
1156 "} // namespace x\n";
1157 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1158}
1159
1160TEST_F(ChangeNamespaceTest, UsingShadowDeclInClass) {
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]1161 std::string Code = "namespace na { class C_A {}; }\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1162 "namespace na {\n"
1163 "namespace nb {\n"
1164 "void f() {\n"
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]1165 " using ::na::C_A;\n"
1166 " C_A ca;\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1167 "}\n"
1168 "} // namespace nb\n"
1169 "} // namespace na\n";
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]1170 std::string Expected = "namespace na { class C_A {}; }\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1171 "\n"
1172 "namespace x {\n"
1173 "namespace y {\n"
1174 "void f() {\n"
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]1175 " using ::na::C_A;\n"
1176 " C_A ca;\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1177 "}\n"
1178 "} // namespace y\n"
1179 "} // namespace x\n";
1180 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1181}
1182
1183TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespace) {
1184 std::string Code = "namespace nx { void f(); }\n"
1185 "namespace na {\n"
1186 "using nx::f;\n"
1187 "namespace nb {\n"
1188 "void d() { f(); }\n"
1189 "} // nb\n"
1190 "} // na\n";
1191
1192 std::string Expected = "namespace nx { void f(); }\n"
1193 "namespace na {\n"
1194 "using nx::f;\n"
1195 "\n"
1196 "} // na\n"
1197 "namespace x {\n"
1198 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]1199 "void d() { ::nx::f(); }\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1200 "} // namespace y\n"
1201 "} // namespace x\n";
1202 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1203}
1204
1205TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespaceNotNested) {
1206 OldNamespace = "na";
1207 std::string Code = "namespace nx { void f(); }\n"
1208 "namespace na {\n"
1209 "using ::nx::f;\n"
1210 "void d() { f(); }\n"
1211 "} // na\n";
1212
1213 std::string Expected = "namespace nx { void f(); }\n"
1214 "\n"
1215 "namespace x {\n"
1216 "namespace y {\n"
1217 "using ::nx::f;\n"
1218 "void d() { f(); }\n"
1219 "} // namespace y\n"
1220 "} // namespace x\n";
1221 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1222}
1223
1224TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespaceMultiNested) {
1225 OldNamespace = "a::b::c::d";
1226 NewNamespace = "a::b::x::y";
1227 std::string Code = "namespace nx { void f(); void g(); }\n"
1228 "namespace a {\n"
1229 "namespace b {\n"
1230 "using ::nx::f;\n"
1231 "namespace c {\n"
1232 "using ::nx::g;\n"
1233 "namespace d {\n"
1234 "void d() { f(); g(); }\n"
1235 "} // d\n"
1236 "} // c\n"
1237 "} // b\n"
1238 "} // a\n";
1239
1240 std::string Expected = "namespace nx { void f(); void g(); }\n"
1241 "namespace a {\n"
1242 "namespace b {\n"
1243 "using ::nx::f;\n"
1244 "namespace c {\n"
1245 "using ::nx::g;\n"
1246 "\n"
1247 "} // c\n"
1248 "namespace x {\n"
1249 "namespace y {\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]1250 "void d() { f(); ::nx::g(); }\n"
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1251 "} // namespace y\n"
1252 "} // namespace x\n"
1253 "} // b\n"
1254 "} // a\n";
1255 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1256}
1257
Eric Liuae7de712017-02-02 15:29:54 +0000[diff] [blame]1258TEST_F(ChangeNamespaceTest, UsingShadowDeclInTheParentOfOldNamespace) {
Eric Liub9bf1b52016-11-08 22:44:17 +0000[diff] [blame]1259 OldNamespace = "nb::nc";
1260 NewNamespace = "nb::nd";
1261 std::string Code = "namespace na { class A {}; }\n"
1262 "namespace nb {\n"
1263 "using na::A;\n"
1264 "namespace nc {\n"
1265 "void d() { A a; }\n"
1266 "} // nc\n"
1267 "} // nb\n";
1268
1269 std::string Expected = "namespace na { class A {}; }\n"
1270 "namespace nb {\n"
1271 "using na::A;\n"
1272 "\n"
1273 "namespace nd {\n"
1274 "void d() { A a; }\n"
1275 "} // namespace nd\n"
1276 "} // nb\n";
1277 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1278}
1279
Eric Liuae7de712017-02-02 15:29:54 +0000[diff] [blame]1280TEST_F(ChangeNamespaceTest, UsingShadowDeclInOldNamespace) {
1281 OldNamespace = "nb";
1282 NewNamespace = "nc";
1283 std::string Code = "namespace na { class A {}; }\n"
1284 "namespace nb {\n"
1285 "using na::A;\n"
1286 "void d() { A a; }\n"
1287 "struct X { A a; };\n"
1288 "} // nb\n";
1289
1290 std::string Expected = "namespace na { class A {}; }\n"
1291 "\n"
1292 "namespace nc {\n"
1293 "using ::na::A;\n"
1294 "void d() { A a; }\n"
1295 "struct X { A a; };\n"
1296 "} // namespace nc\n";
1297 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1298}
1299
1300TEST_F(ChangeNamespaceTest, UsingShadowDeclOfTemplateClass) {
1301 OldNamespace = "nb";
1302 NewNamespace = "nc";
1303 std::string Code = "namespace na {\n"
1304 "template <typename T>\n"
1305 "class A { T t; };\n"
1306 "} // namespace na\n"
1307 "namespace nb {\n"
1308 "using na::A;\n"
1309 "void d() { A<int> a; }\n"
1310 "} // nb\n";
1311
1312 std::string Expected = "namespace na {\n"
1313 "template <typename T>\n"
1314 "class A { T t; };\n"
1315 "} // namespace na\n"
1316 "\n"
1317 "namespace nc {\n"
1318 "using ::na::A;\n"
1319 "void d() { A<int> a; }\n"
1320 "} // namespace nc\n";
1321 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1322}
1323
1324TEST_F(ChangeNamespaceTest, UsingShadowDeclOfTemplateFunction) {
1325 OldNamespace = "nb";
1326 NewNamespace = "nc";
1327 std::string Code = "namespace na {\n"
1328 "template <typename T>\n"
1329 "void f() { T t; };\n"
1330 "} // namespace na\n"
1331 "namespace nb {\n"
1332 "using na::f;\n"
1333 "void d() { f<int>(); }\n"
1334 "} // nb\n";
1335
1336 std::string Expected = "namespace na {\n"
1337 "template <typename T>\n"
1338 "void f() { T t; };\n"
1339 "} // namespace na\n"
1340 "\n"
1341 "namespace nc {\n"
1342 "using ::na::f;\n"
1343 "void d() { f<int>(); }\n"
1344 "} // namespace nc\n";
1345 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1346}
1347
Eric Liu32158862016-11-14 19:37:55 +0000[diff] [blame]1348TEST_F(ChangeNamespaceTest, UsingAliasDecl) {
1349 std::string Code =
1350 "namespace nx { namespace ny { class X {}; } }\n"
1351 "namespace na {\n"
1352 "namespace nb {\n"
1353 "using Y = nx::ny::X;\n"
1354 "void f() { Y y; }\n"
1355 "} // namespace nb\n"
1356 "} // namespace na\n";
1357
1358 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1359 "\n"
1360 "namespace x {\n"
1361 "namespace y {\n"
1362 "using Y = nx::ny::X;\n"
1363 "void f() { Y y; }\n"
1364 "} // namespace y\n"
1365 "} // namespace x\n";
1366 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1367}
1368
1369TEST_F(ChangeNamespaceTest, UsingAliasDeclInGlobal) {
1370 std::string Code =
1371 "namespace nx { namespace ny { class X {}; } }\n"
1372 "using Y = nx::ny::X;\n"
1373 "namespace na {\n"
1374 "namespace nb {\n"
1375 "void f() { Y y; }\n"
1376 "} // namespace nb\n"
1377 "} // namespace na\n";
1378
1379 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1380 "using Y = nx::ny::X;\n"
1381 "\n"
1382 "namespace x {\n"
1383 "namespace y {\n"
1384 "void f() { Y y; }\n"
1385 "} // namespace y\n"
1386 "} // namespace x\n";
1387 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1388}
1389
1390
1391TEST_F(ChangeNamespaceTest, TypedefAliasDecl) {
1392 std::string Code =
1393 "namespace nx { namespace ny { class X {}; } }\n"
1394 "namespace na {\n"
1395 "namespace nb {\n"
1396 "typedef nx::ny::X Y;\n"
1397 "void f() { Y y; }\n"
1398 "} // namespace nb\n"
1399 "} // namespace na\n";
1400
1401 std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
1402 "\n"
1403 "namespace x {\n"
1404 "namespace y {\n"
1405 "typedef nx::ny::X Y;\n"
1406 "void f() { Y y; }\n"
1407 "} // namespace y\n"
1408 "} // namespace x\n";
1409 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1410}
1411
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]1412TEST_F(ChangeNamespaceTest, DerivedClassWithConstructors) {
1413 std::string Code =
1414 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1415 "namespace na {\n"
1416 "namespace nb {\n"
1417 "class A : public nx::ny::X {\n"
1418 "public:\n"
1419 " A() : X(0) {}\n"
1420 " A(int i);\n"
1421 "};\n"
1422 "A::A(int i) : X(i) {}\n"
1423 "} // namespace nb\n"
1424 "} // namespace na\n";
1425 std::string Expected =
1426 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1427 "\n\n"
1428 "namespace x {\n"
1429 "namespace y {\n"
1430 "class A : public nx::ny::X {\n"
1431 "public:\n"
1432 " A() : X(0) {}\n"
1433 " A(int i);\n"
1434 "};\n"
1435 "A::A(int i) : X(i) {}\n"
1436 "} // namespace y\n"
1437 "} // namespace x\n";
1438 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1439}
1440
1441TEST_F(ChangeNamespaceTest, DerivedClassWithQualifiedConstructors) {
1442 std::string Code =
1443 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1444 "namespace na {\n"
1445 "namespace nb {\n"
1446 "class A : public nx::ny::X {\n"
1447 "public:\n"
1448 " A() : X::X(0) {}\n"
1449 " A(int i);\n"
1450 "};\n"
1451 "A::A(int i) : X::X(i) {}\n"
1452 "} // namespace nb\n"
1453 "} // namespace na\n";
1454 std::string Expected =
1455 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1456 "\n\n"
1457 "namespace x {\n"
1458 "namespace y {\n"
1459 "class A : public nx::ny::X {\n"
1460 "public:\n"
1461 " A() : X::X(0) {}\n"
1462 " A(int i);\n"
1463 "};\n"
1464 "A::A(int i) : X::X(i) {}\n"
1465 "} // namespace y\n"
1466 "} // namespace x\n";
1467 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1468}
1469
1470TEST_F(ChangeNamespaceTest, DerivedClassWithConstructorsAndTypeRefs) {
1471 std::string Code =
1472 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1473 "namespace na {\n"
1474 "namespace nb {\n"
1475 "class A : public nx::ny::X {\n"
1476 "public:\n"
1477 " A() : X(0) {}\n"
1478 " A(int i);\n"
1479 "};\n"
1480 "A::A(int i) : X(i) { X x(1);}\n"
1481 "} // namespace nb\n"
1482 "} // namespace na\n";
1483 std::string Expected =
1484 "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
1485 "\n\n"
1486 "namespace x {\n"
1487 "namespace y {\n"
1488 "class A : public nx::ny::X {\n"
1489 "public:\n"
1490 " A() : X(0) {}\n"
1491 " A(int i);\n"
1492 "};\n"
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]1493 "A::A(int i) : X(i) { ::nx::ny::X x(1);}\n"
Eric Liuff51f012016-11-16 16:54:53 +0000[diff] [blame]1494 "} // namespace y\n"
1495 "} // namespace x\n";
1496 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1497}
1498
Eric Liu2dd0e1b2016-12-05 11:17:04 +0000[diff] [blame]1499TEST_F(ChangeNamespaceTest, MoveToGlobalNamespace) {
1500 NewNamespace = "";
1501 std::string Code = "namespace na {\n"
1502 "class C_A {};\n"
1503 "namespace nc {\n"
1504 "class C_C {};"
1505 "} // namespace nc\n"
1506 "namespace nb {\n"
1507 "class C_X {\n"
1508 "public:\n"
1509 " C_A a;\n"
1510 " nc::C_C c;\n"
1511 "};\n"
1512 "class C_Y {\n"
1513 " C_X x;\n"
1514 "};\n"
1515 "} // namespace nb\n"
1516 "} // namespace na\n";
1517 std::string Expected = "namespace na {\n"
1518 "class C_A {};\n"
1519 "namespace nc {\n"
1520 "class C_C {};"
1521 "} // namespace nc\n"
1522 "\n"
1523 "} // namespace na\n"
1524 "class C_X {\n"
1525 "public:\n"
1526 " na::C_A a;\n"
1527 " na::nc::C_C c;\n"
1528 "};\n"
1529 "class C_Y {\n"
1530 " C_X x;\n"
1531 "};\n";
1532 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1533}
1534
Eric Liu97f87ad2016-12-07 20:08:02 +0000[diff] [blame]1535TEST_F(ChangeNamespaceTest, KeepGlobalSpecifier) {
1536 std::string Code = "class Glob {};\n"
1537 "namespace na {\n"
1538 "class C_A {};\n"
1539 "namespace nc {\n"
1540 "class C_C {};"
1541 "} // namespace nc\n"
1542 "namespace nb {\n"
1543 "class C_X {\n"
1544 "public:\n"
1545 " ::Glob glob_1;\n"
1546 " Glob glob_2;\n"
1547 " C_A a_1;\n"
1548 " ::na::C_A a_2;\n"
1549 " nc::C_C c;\n"
1550 "};\n"
1551 "} // namespace nb\n"
1552 "} // namespace na\n";
1553 std::string Expected = "class Glob {};\n"
1554 "namespace na {\n"
1555 "class C_A {};\n"
1556 "namespace nc {\n"
1557 "class C_C {};"
1558 "} // namespace nc\n"
1559 "\n"
1560 "} // namespace na\n"
1561 "namespace x {\n"
1562 "namespace y {\n"
1563 "class C_X {\n"
1564 "public:\n"
1565 " ::Glob glob_1;\n"
1566 " Glob glob_2;\n"
1567 " ::na::C_A a_1;\n"
1568 " ::na::C_A a_2;\n"
1569 " ::na::nc::C_C c;\n"
1570 "};\n"
1571 "} // namespace y\n"
1572 "} // namespace x\n";
1573 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1574}
1575
Eric Liu26cf68a2016-12-15 10:42:35 +0000[diff] [blame]1576TEST_F(ChangeNamespaceTest, UsingAliasInTemplate) {
1577 NewNamespace = "na::nb::nc";
1578 std::string Code = "namespace some_ns {\n"
1579 "template <typename T, typename S>\n"
1580 "class G {};\n"
1581 "} // namespace some_ns\n"
1582 "namespace na {\n"
1583 "template<typename P>\n"
1584 "using GG = some_ns::G<int, P>;\n"
1585 "} // namespace na\n"
1586 "namespace na {\n"
1587 "namespace nb {\n"
1588 "void f() {\n"
1589 " GG<float> g;\n"
1590 "}\n"
1591 "} // namespace nb\n"
1592 "} // namespace na\n";
1593 std::string Expected = "namespace some_ns {\n"
1594 "template <typename T, typename S>\n"
1595 "class G {};\n"
1596 "} // namespace some_ns\n"
1597 "namespace na {\n"
1598 "template<typename P>\n"
1599 "using GG = some_ns::G<int, P>;\n"
1600 "} // namespace na\n"
1601 "namespace na {\n"
1602 "namespace nb {\n"
1603 "namespace nc {\n"
1604 "void f() {\n"
1605 " GG<float> g;\n"
1606 "}\n"
Eric Liuee5104b2017-01-04 14:49:08 +0000[diff] [blame]1607 "} // namespace nc\n"
Eric Liu26cf68a2016-12-15 10:42:35 +0000[diff] [blame]1608 "} // namespace nb\n"
1609 "} // namespace na\n";
1610 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1611}
1612
1613TEST_F(ChangeNamespaceTest, TemplateUsingAliasInBaseClass) {
1614 NewNamespace = "na::nb::nc";
1615 std::string Code = "namespace some_ns {\n"
1616 "template <typename T, typename S>\n"
1617 "class G {};\n"
1618 "} // namespace some_ns\n"
1619 "namespace na {\n"
1620 "class Base {\n"
1621 "public:\n"
1622 " template<typename P>\n"
1623 " using GG = some_ns::G<int, P>;\n"
Eric Liu0c0aea02016-12-15 13:02:41 +0000[diff] [blame]1624 "\n"
1625 " struct Nested {};\n"
Eric Liu26cf68a2016-12-15 10:42:35 +0000[diff] [blame]1626 "};\n"
1627 "class Derived : public Base {};\n"
1628 "} // namespace na\n"
1629 "namespace na {\n"
1630 "namespace nb {\n"
1631 "void f() {\n"
1632 " Derived::GG<float> g;\n"
Eric Liu0c0aea02016-12-15 13:02:41 +0000[diff] [blame]1633 " const Derived::GG<int> gg;\n"
1634 " const Derived::GG<int>* gg_ptr;\n"
1635 " struct Derived::Nested nested;\n"
1636 " const struct Derived::Nested *nested_ptr;\n"
Eric Liu26cf68a2016-12-15 10:42:35 +0000[diff] [blame]1637 "}\n"
1638 "} // namespace nb\n"
1639 "} // namespace na\n";
1640 std::string Expected = "namespace some_ns {\n"
1641 "template <typename T, typename S>\n"
1642 "class G {};\n"
1643 "} // namespace some_ns\n"
1644 "namespace na {\n"
1645 "class Base {\n"
1646 "public:\n"
1647 " template<typename P>\n"
1648 " using GG = some_ns::G<int, P>;\n"
Eric Liu0c0aea02016-12-15 13:02:41 +0000[diff] [blame]1649 "\n"
1650 " struct Nested {};\n"
Eric Liu26cf68a2016-12-15 10:42:35 +0000[diff] [blame]1651 "};\n"
1652 "class Derived : public Base {};\n"
1653 "} // namespace na\n"
1654 "namespace na {\n"
1655 "namespace nb {\n"
1656 "namespace nc {\n"
1657 "void f() {\n"
1658 " Derived::GG<float> g;\n"
Eric Liu0c0aea02016-12-15 13:02:41 +0000[diff] [blame]1659 " const Derived::GG<int> gg;\n"
1660 " const Derived::GG<int>* gg_ptr;\n"
1661 " struct Derived::Nested nested;\n"
1662 " const struct Derived::Nested *nested_ptr;\n"
Eric Liu26cf68a2016-12-15 10:42:35 +0000[diff] [blame]1663 "}\n"
Eric Liuee5104b2017-01-04 14:49:08 +0000[diff] [blame]1664 "} // namespace nc\n"
Eric Liu26cf68a2016-12-15 10:42:35 +0000[diff] [blame]1665 "} // namespace nb\n"
1666 "} // namespace na\n";
1667 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1668}
1669
Eric Liubc715502017-01-26 15:08:44 +0000[diff] [blame]1670TEST_F(ChangeNamespaceTest, ExistingNamespaceConflictWithNewNamespace) {
1671 OldNamespace = "nx";
1672 NewNamespace = "ny::na::nc";
1673 std::string Code = "namespace na {\n"
1674 "class A {};\n"
1675 "} // namespace na\n"
1676 "namespace nb {\n"
1677 "class B {};\n"
1678 "} // namespace nb\n"
1679 "namespace nx {\n"
1680 "class X {\n"
1681 " na::A a; nb::B b;\n"
1682 "};\n"
1683 "} // namespace nx\n";
1684 std::string Expected = "namespace na {\n"
1685 "class A {};\n"
1686 "} // namespace na\n"
1687 "namespace nb {\n"
1688 "class B {};\n"
1689 "} // namespace nb\n"
1690 "\n"
1691 "namespace ny {\n"
1692 "namespace na {\n"
1693 "namespace nc {\n"
1694 "class X {\n"
1695 " ::na::A a; nb::B b;\n"
1696 "};\n"
1697 "} // namespace nc\n"
1698 "} // namespace na\n"
1699 "} // namespace ny\n";
1700 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1701}
1702
1703TEST_F(ChangeNamespaceTest, ShortenNamespaceSpecifier) {
1704 OldNamespace = "nx";
1705 NewNamespace = "ny::na";
1706 std::string Code = "class G {};\n"
1707 "namespace ny {\n"
1708 "class Y {};\n"
1709 "namespace na {\n"
1710 "class A {};\n"
1711 "namespace nc { class C {}; } // namespace nc\n"
1712 "}\n // namespace na\n"
1713 "}\n // namespace ny\n"
1714 "namespace nx {\n"
1715 "class X {\n"
1716 " G g; ny::Y y; ny::na::A a; ny::na::nc::C c;\n"
1717 "};\n"
1718 "} // namespace nx\n";
1719 std::string Expected = "class G {};\n"
1720 "namespace ny {\n"
1721 "class Y {};\n"
1722 "namespace na {\n"
1723 "class A {};\n"
1724 "namespace nc { class C {}; } // namespace nc\n"
1725 "}\n // namespace na\n"
1726 "}\n // namespace ny\n"
1727 "\n"
1728 "namespace ny {\n"
1729 "namespace na {\n"
1730 "class X {\n"
1731 " G g; Y y; A a; nc::C c;\n"
1732 "};\n"
1733 "} // namespace na\n"
1734 "} // namespace ny\n";
1735 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1736}
1737
Eric Liu91229162017-01-26 16:31:32 +0000[diff] [blame]1738TEST_F(ChangeNamespaceTest, ShortenNamespaceSpecifierInAnonymousNamespace) {
1739 OldNamespace = "nx";
1740 NewNamespace = "ny::na";
1741 std::string Code = "class G {};\n"
1742 "namespace ny {\n"
1743 "class Y {};\n"
1744 "namespace na {\n"
1745 "class A {};\n"
1746 "namespace nc { class C {}; } // namespace nc\n"
1747 "}\n // namespace na\n"
1748 "}\n // namespace ny\n"
1749 "namespace nx {\n"
1750 "namespace {\n"
1751 "class X {\n"
1752 " G g; ::ny::Y y; ::ny::na::A a; ::ny::na::nc::C c;\n"
1753 "};\n"
1754 "} // namespace\n"
1755 "} // namespace nx\n";
1756 std::string Expected = "class G {};\n"
1757 "namespace ny {\n"
1758 "class Y {};\n"
1759 "namespace na {\n"
1760 "class A {};\n"
1761 "namespace nc { class C {}; } // namespace nc\n"
1762 "}\n // namespace na\n"
1763 "}\n // namespace ny\n"
1764 "\n"
1765 "namespace ny {\n"
1766 "namespace na {\n"
1767 "namespace {\n"
1768 "class X {\n"
1769 " G g; Y y; A a; nc::C c;\n"
1770 "};\n"
1771 "} // namespace\n"
1772 "} // namespace na\n"
1773 "} // namespace ny\n";
1774 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1775}
1776
Eric Liu0325a772017-02-02 17:40:38 +0000[diff] [blame^]1777TEST_F(ChangeNamespaceTest, SimpleMoveEnum) {
1778 std::string Code = "namespace na {\n"
1779 "namespace nb {\n"
1780 "enum class X { X1, X2 };\n"
1781 "enum Y { Y1, Y2 };\n"
1782 "} // namespace nb\n"
1783 "} // namespace na\n";
1784 std::string Expected = "\n\nnamespace x {\n"
1785 "namespace y {\n"
1786 "enum class X { X1, X2 };\n"
1787 "enum Y { Y1, Y2 };\n"
1788 "} // namespace y\n"
1789 "} // namespace x\n";
1790
1791 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1792}
1793
1794TEST_F(ChangeNamespaceTest, ReferencesToEnums) {
1795 std::string Code = "enum Glob { G1, G2 };\n"
1796 "namespace na {\n"
1797 "enum class X { X1 };\n"
1798 "enum Y { Y1, Y2 };\n"
1799 "namespace nb {\n"
1800 "void f() {\n"
1801 " Glob g1 = Glob::G1;\n"
1802 " Glob g2 = G2;\n"
1803 " X x1 = X::X1;\n"
1804 " Y y1 = Y::Y1;\n"
1805 " Y y2 = Y2;\n"
1806 "}\n"
1807 "} // namespace nb\n"
1808 "} // namespace na\n";
1809 std::string Expected = "enum Glob { G1, G2 };\n"
1810 "namespace na {\n"
1811 "enum class X { X1 };\n"
1812 "enum Y { Y1, Y2 };\n"
1813 "\n"
1814 "} // namespace na\n"
1815 "namespace x {\n"
1816 "namespace y {\n"
1817 "void f() {\n"
1818 " Glob g1 = Glob::G1;\n"
1819 " Glob g2 = G2;\n"
1820 " ::na::X x1 = ::na::X::X1;\n"
1821 " ::na::Y y1 = ::na::Y::Y1;\n"
1822 " ::na::Y y2 = ::na::Y::Y2;\n"
1823 "}\n"
1824 "} // namespace y\n"
1825 "} // namespace x\n";
1826
1827 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1828}
1829
1830TEST_F(ChangeNamespaceTest, NoRedundantEnumUpdate) {
1831 std::string Code = "namespace ns {\n"
1832 "enum class X { X1 };\n"
1833 "enum Y { Y1, Y2 };\n"
1834 "} // namespace ns\n"
1835 "namespace na {\n"
1836 "namespace nb {\n"
1837 "void f() {\n"
1838 " ns::X x1 = ns::X::X1;\n"
1839 " ns::Y y1 = ns::Y::Y1;\n"
1840 " ns::Y y2 = ns::Y2;\n"
1841 "}\n"
1842 "} // namespace nb\n"
1843 "} // namespace na\n";
1844 std::string Expected = "namespace ns {\n"
1845 "enum class X { X1 };\n"
1846 "enum Y { Y1, Y2 };\n"
1847 "} // namespace ns\n"
1848 "\n"
1849 "namespace x {\n"
1850 "namespace y {\n"
1851 "void f() {\n"
1852 " ns::X x1 = ns::X::X1;\n"
1853 " ns::Y y1 = ns::Y::Y1;\n"
1854 // FIXME: this is redundant
1855 " ns::Y y2 = ::ns::Y::Y2;\n"
1856 "}\n"
1857 "} // namespace y\n"
1858 "} // namespace x\n";
1859 ;
1860
1861 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1862}
1863
1864TEST_F(ChangeNamespaceTest, EnumsAndUsingShadows) {
1865 std::string Code = "namespace ns {\n"
1866 "enum class X { X1 };\n"
1867 "enum Y { Y1, Y2, Y3 };\n"
1868 "} // namespace ns\n"
1869 "using ns::X;\n"
1870 "using ns::Y;\n"
1871 "using ns::Y::Y2;\n"
1872 "using ns::Y::Y3;\n"
1873 "namespace na {\n"
1874 "namespace nb {\n"
1875 "void f() {\n"
1876 " X x1 = X::X1;\n"
1877 " Y y1 = Y::Y1;\n"
1878 " Y y2 = Y2;\n"
1879 " Y y3 = Y3;\n"
1880 "}\n"
1881 "} // namespace nb\n"
1882 "} // namespace na\n";
1883 std::string Expected = "namespace ns {\n"
1884 "enum class X { X1 };\n"
1885 "enum Y { Y1, Y2, Y3 };\n"
1886 "} // namespace ns\n"
1887 "using ns::X;\n"
1888 "using ns::Y;\n"
1889 "using ns::Y::Y2;\n"
1890 "using ns::Y::Y3;\n"
1891 "\n"
1892 "namespace x {\n"
1893 "namespace y {\n"
1894 "void f() {\n"
1895 " X x1 = X::X1;\n"
1896 " Y y1 = Y::Y1;\n"
1897 " Y y2 = Y2;\n"
1898 " Y y3 = Y3;\n"
1899 "}\n"
1900 "} // namespace y\n"
1901 "} // namespace x\n";
1902
1903 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1904}
1905
1906TEST_F(ChangeNamespaceTest, EnumsAndAliases) {
1907 std::string Code = "namespace ns {\n"
1908 "enum class X { X1 };\n"
1909 "enum Y { Y1, Y2, Y3 };\n"
1910 "} // namespace ns\n"
1911 "typedef ns::X TX;\n"
1912 "typedef ns::Y TY;\n"
1913 "using UX = ns::X;\n"
1914 "using UY = ns::Y;\n"
1915 "namespace na {\n"
1916 "namespace nb {\n"
1917 "void f() {\n"
1918 " ns::X x1 = ns::X::X1;\n"
1919 " TX tx1 = TX::X1;\n"
1920 " UX ux1 = UX::X1;\n"
1921 " ns::Y y1 = ns::Y::Y1;\n"
1922 " TY ty1 = TY::Y1;\n"
1923 " UY uy1 = UY::Y1;\n"
1924 "}\n"
1925 "} // namespace nb\n"
1926 "} // namespace na\n";
1927 std::string Expected = "namespace ns {\n"
1928 "enum class X { X1 };\n"
1929 "enum Y { Y1, Y2, Y3 };\n"
1930 "} // namespace ns\n"
1931 "typedef ns::X TX;\n"
1932 "typedef ns::Y TY;\n"
1933 "using UX = ns::X;\n"
1934 "using UY = ns::Y;\n"
1935 "\n"
1936 "namespace x {\n"
1937 "namespace y {\n"
1938 "void f() {\n"
1939 " ns::X x1 = ns::X::X1;\n"
1940 " TX tx1 = TX::X1;\n"
1941 " UX ux1 = UX::X1;\n"
1942 " ns::Y y1 = ns::Y::Y1;\n"
1943 " TY ty1 = TY::Y1;\n"
1944 " UY uy1 = UY::Y1;\n"
1945 "}\n"
1946 "} // namespace y\n"
1947 "} // namespace x\n";
1948
1949 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1950}
1951
1952TEST_F(ChangeNamespaceTest, EnumInClass) {
1953 std::string Code = "namespace na {\n"
1954 "struct X { enum E { E1 }; };\n"
1955 "namespace nb {\n"
1956 "void f() {\n"
1957 " X::E e = X::E1;\n"
1958 " X::E ee = X::E::E1;\n"
1959 "}\n"
1960 "} // namespace nb\n"
1961 "} // namespace na\n";
1962 std::string Expected = "namespace na {\n"
1963 "struct X { enum E { E1 }; };\n"
1964 "\n"
1965 "} // namespace na\n"
1966 "namespace x {\n"
1967 "namespace y {\n"
1968 "void f() {\n"
1969 " ::na::X::E e = ::na::X::E1;\n"
1970 " ::na::X::E ee = ::na::X::E::E1;\n"
1971 "}\n"
1972 "} // namespace y\n"
1973 "} // namespace x\n";
1974
1975 EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
1976}
1977
Eric Liu495b2112016-09-19 17:40:32 +0000[diff] [blame]1978} // anonymous namespace
1979} // namespace change_namespace
1980} // namespace clang