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