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