head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.2 netbsd-11-0-RC3:1.1.1.2 netbsd-11-0-RC2:1.1.1.2 netbsd-11-0-RC1:1.1.1.2 perseant-exfatfs-base-20250801:1.1.1.2 netbsd-11:1.1.1.2.0.10 netbsd-11-base:1.1.1.2 netbsd-10-1-RELEASE:1.1.1.2 perseant-exfatfs-base-20240630:1.1.1.2 perseant-exfatfs:1.1.1.2.0.8 perseant-exfatfs-base:1.1.1.2 netbsd-9-4-RELEASE:1.1.1.1 netbsd-10-0-RELEASE:1.1.1.2 netbsd-10-0-RC6:1.1.1.2 netbsd-10-0-RC5:1.1.1.2 netbsd-10-0-RC4:1.1.1.2 netbsd-10-0-RC3:1.1.1.2 netbsd-10-0-RC2:1.1.1.2 netbsd-10-0-RC1:1.1.1.2 netbsd-10:1.1.1.2.0.6 netbsd-10-base:1.1.1.2 netbsd-9-3-RELEASE:1.1.1.1 cjep_sun2x:1.1.1.2.0.4 cjep_sun2x-base:1.1.1.2 cjep_staticlib_x-base1:1.1.1.2 netbsd-9-2-RELEASE:1.1.1.1 cjep_staticlib_x:1.1.1.2.0.2 cjep_staticlib_x-base:1.1.1.2 netbsd-9-1-RELEASE:1.1.1.1 phil-wifi-20200421:1.1.1.2 phil-wifi-20200411:1.1.1.2 phil-wifi-20200406:1.1.1.2 netbsd-9-0-RELEASE:1.1.1.1 netbsd-9-0-RC2:1.1.1.1 netbsd-9-0-RC1:1.1.1.1 netbsd-9:1.1.1.1.0.6 netbsd-9-base:1.1.1.1 phil-wifi:1.1.1.1.0.4 phil-wifi-20190609:1.1.1.1 pgoyette-compat-merge-20190127:1.1.1.1.2.2 pgoyette-compat-20190127:1.1.1.1 pgoyette-compat-20190118:1.1.1.1 pgoyette-compat-1226:1.1.1.1 pgoyette-compat-1126:1.1.1.1 pgoyette-compat-1020:1.1.1.1 pgoyette-compat-0930:1.1.1.1 pgoyette-compat-0906:1.1.1.1 pgoyette-compat:1.1.1.1.0.2 pgoyette-compat-0728:1.1.1.1 clang-337282:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2018.07.17.18.32.14; author joerg; state Exp; branches 1.1.1.1; next ; commitid wDzL46ALjrCZgwKA; 1.1.1.1 date 2018.07.17.18.32.14; author joerg; state Exp; branches 1.1.1.1.2.1 1.1.1.1.4.1; next 1.1.1.2; commitid wDzL46ALjrCZgwKA; 1.1.1.2 date 2019.11.13.22.23.11; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.1.2.1 date 2018.07.17.18.32.14; author pgoyette; state dead; branches; next 1.1.1.1.2.2; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.1.2.2 date 2018.07.28.04.34.19; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.1.4.1 date 2018.07.17.18.32.14; author christos; state dead; branches; next 1.1.1.1.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.1.4.2 date 2019.06.10.21.46.47; author christos; state Exp; branches; next 1.1.1.1.4.3; commitid jtc8rnCzWiEEHGqB; 1.1.1.1.4.3 date 2020.04.13.07.50.39; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===- unittest/Tooling/RefactoringTestActionRulesTest.cpp ----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "ReplacementTest.h" #include "RewriterTestContext.h" #include "clang/Tooling/Refactoring.h" #include "clang/Tooling/Refactoring/Extract/Extract.h" #include "clang/Tooling/Refactoring/RefactoringAction.h" #include "clang/Tooling/Refactoring/RefactoringDiagnostic.h" #include "clang/Tooling/Refactoring/Rename/SymbolName.h" #include "clang/Tooling/Tooling.h" #include "llvm/Support/Errc.h" #include "gtest/gtest.h" using namespace clang; using namespace tooling; namespace { class RefactoringActionRulesTest : public ::testing::Test { protected: void SetUp() override { Context.Sources.setMainFileID( Context.createInMemoryFile("input.cpp", DefaultCode)); } RewriterTestContext Context; std::string DefaultCode = std::string(100, 'a'); }; Expected createReplacements(const std::unique_ptr &Rule, RefactoringRuleContext &Context) { class Consumer final : public RefactoringResultConsumer { void handleError(llvm::Error Err) override { Result = std::move(Err); } void handle(AtomicChanges SourceReplacements) override { Result = std::move(SourceReplacements); } void handle(SymbolOccurrences Occurrences) override { RefactoringResultConsumer::handle(std::move(Occurrences)); } public: Optional> Result; }; Consumer C; Rule->invoke(C, Context); return std::move(*C.Result); } TEST_F(RefactoringActionRulesTest, MyFirstRefactoringRule) { class ReplaceAWithB : public SourceChangeRefactoringRule { std::pair Selection; public: ReplaceAWithB(std::pair Selection) : Selection(Selection) {} static Expected initiate(RefactoringRuleContext &Cotnext, std::pair Selection) { return ReplaceAWithB(Selection); } Expected createSourceReplacements(RefactoringRuleContext &Context) { const SourceManager &SM = Context.getSources(); SourceLocation Loc = Selection.first.getBegin().getLocWithOffset(Selection.second); AtomicChange Change(SM, Loc); llvm::Error E = Change.replace(SM, Loc, 1, "b"); if (E) return std::move(E); return AtomicChanges{Change}; } }; class SelectionRequirement : public SourceRangeSelectionRequirement { public: Expected> evaluate(RefactoringRuleContext &Context) const { Expected R = SourceRangeSelectionRequirement::evaluate(Context); if (!R) return R.takeError(); return std::make_pair(*R, 20); } }; auto Rule = createRefactoringActionRule(SelectionRequirement()); // When the requirements are satisfied, the rule's function must be invoked. { RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()) .getLocWithOffset(10); RefContext.setSelectionRange({Cursor, Cursor}); Expected ErrorOrResult = createReplacements(Rule, RefContext); ASSERT_FALSE(!ErrorOrResult); AtomicChanges Result = std::move(*ErrorOrResult); ASSERT_EQ(Result.size(), 1u); std::string YAMLString = const_cast(Result[0]).toYAMLString(); ASSERT_STREQ("---\n" "Key: 'input.cpp:30'\n" "FilePath: input.cpp\n" "Error: ''\n" "InsertedHeaders: \n" "RemovedHeaders: \n" "Replacements: \n" // Extra whitespace here! " - FilePath: input.cpp\n" " Offset: 30\n" " Length: 1\n" " ReplacementText: b\n" "...\n", YAMLString.c_str()); } // When one of the requirements is not satisfied, invoke should return a // valid error. { RefactoringRuleContext RefContext(Context.Sources); Expected ErrorOrResult = createReplacements(Rule, RefContext); ASSERT_TRUE(!ErrorOrResult); unsigned DiagID; llvm::handleAllErrors(ErrorOrResult.takeError(), [&](DiagnosticError &Error) { DiagID = Error.getDiagnostic().second.getDiagID(); }); EXPECT_EQ(DiagID, diag::err_refactor_no_selection); } } TEST_F(RefactoringActionRulesTest, ReturnError) { class ErrorRule : public SourceChangeRefactoringRule { public: static Expected initiate(RefactoringRuleContext &, SourceRange R) { return ErrorRule(R); } ErrorRule(SourceRange R) {} Expected createSourceReplacements(RefactoringRuleContext &) { return llvm::make_error( "Error", llvm::make_error_code(llvm::errc::invalid_argument)); } }; auto Rule = createRefactoringActionRule(SourceRangeSelectionRequirement()); RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()); RefContext.setSelectionRange({Cursor, Cursor}); Expected Result = createReplacements(Rule, RefContext); ASSERT_TRUE(!Result); std::string Message; llvm::handleAllErrors(Result.takeError(), [&](llvm::StringError &Error) { Message = Error.getMessage(); }); EXPECT_EQ(Message, "Error"); } Optional findOccurrences(RefactoringActionRule &Rule, RefactoringRuleContext &Context) { class Consumer final : public RefactoringResultConsumer { void handleError(llvm::Error) override {} void handle(SymbolOccurrences Occurrences) override { Result = std::move(Occurrences); } void handle(AtomicChanges Changes) override { RefactoringResultConsumer::handle(std::move(Changes)); } public: Optional Result; }; Consumer C; Rule.invoke(C, Context); return std::move(C.Result); } TEST_F(RefactoringActionRulesTest, ReturnSymbolOccurrences) { class FindOccurrences : public FindSymbolOccurrencesRefactoringRule { SourceRange Selection; public: FindOccurrences(SourceRange Selection) : Selection(Selection) {} static Expected initiate(RefactoringRuleContext &, SourceRange Selection) { return FindOccurrences(Selection); } Expected findSymbolOccurrences(RefactoringRuleContext &) override { SymbolOccurrences Occurrences; Occurrences.push_back(SymbolOccurrence(SymbolName("test"), SymbolOccurrence::MatchingSymbol, Selection.getBegin())); return std::move(Occurrences); } }; auto Rule = createRefactoringActionRule( SourceRangeSelectionRequirement()); RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()); RefContext.setSelectionRange({Cursor, Cursor}); Optional Result = findOccurrences(*Rule, RefContext); ASSERT_FALSE(!Result); SymbolOccurrences Occurrences = std::move(*Result); EXPECT_EQ(Occurrences.size(), 1u); EXPECT_EQ(Occurrences[0].getKind(), SymbolOccurrence::MatchingSymbol); EXPECT_EQ(Occurrences[0].getNameRanges().size(), 1u); EXPECT_EQ(Occurrences[0].getNameRanges()[0], SourceRange(Cursor, Cursor.getLocWithOffset(strlen("test")))); } TEST_F(RefactoringActionRulesTest, EditorCommandBinding) { const RefactoringDescriptor &Descriptor = ExtractFunction::describe(); EXPECT_EQ(Descriptor.Name, "extract-function"); EXPECT_EQ( Descriptor.Description, "(WIP action; use with caution!) Extracts code into a new function"); EXPECT_EQ(Descriptor.Title, "Extract Function"); } } // end anonymous namespace @ 1.1.1.1 log @Import clang r337282 from trunk @ text @@ 1.1.1.2 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.1.4.1 log @file RefactoringActionRulesTest.cpp was added on branch phil-wifi on 2019-06-10 21:46:47 +0000 @ text @d1 248 @ 1.1.1.1.4.2 log @Sync with HEAD @ text @a0 248 //===- unittest/Tooling/RefactoringTestActionRulesTest.cpp ----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "ReplacementTest.h" #include "RewriterTestContext.h" #include "clang/Tooling/Refactoring.h" #include "clang/Tooling/Refactoring/Extract/Extract.h" #include "clang/Tooling/Refactoring/RefactoringAction.h" #include "clang/Tooling/Refactoring/RefactoringDiagnostic.h" #include "clang/Tooling/Refactoring/Rename/SymbolName.h" #include "clang/Tooling/Tooling.h" #include "llvm/Support/Errc.h" #include "gtest/gtest.h" using namespace clang; using namespace tooling; namespace { class RefactoringActionRulesTest : public ::testing::Test { protected: void SetUp() override { Context.Sources.setMainFileID( Context.createInMemoryFile("input.cpp", DefaultCode)); } RewriterTestContext Context; std::string DefaultCode = std::string(100, 'a'); }; Expected createReplacements(const std::unique_ptr &Rule, RefactoringRuleContext &Context) { class Consumer final : public RefactoringResultConsumer { void handleError(llvm::Error Err) override { Result = std::move(Err); } void handle(AtomicChanges SourceReplacements) override { Result = std::move(SourceReplacements); } void handle(SymbolOccurrences Occurrences) override { RefactoringResultConsumer::handle(std::move(Occurrences)); } public: Optional> Result; }; Consumer C; Rule->invoke(C, Context); return std::move(*C.Result); } TEST_F(RefactoringActionRulesTest, MyFirstRefactoringRule) { class ReplaceAWithB : public SourceChangeRefactoringRule { std::pair Selection; public: ReplaceAWithB(std::pair Selection) : Selection(Selection) {} static Expected initiate(RefactoringRuleContext &Cotnext, std::pair Selection) { return ReplaceAWithB(Selection); } Expected createSourceReplacements(RefactoringRuleContext &Context) { const SourceManager &SM = Context.getSources(); SourceLocation Loc = Selection.first.getBegin().getLocWithOffset(Selection.second); AtomicChange Change(SM, Loc); llvm::Error E = Change.replace(SM, Loc, 1, "b"); if (E) return std::move(E); return AtomicChanges{Change}; } }; class SelectionRequirement : public SourceRangeSelectionRequirement { public: Expected> evaluate(RefactoringRuleContext &Context) const { Expected R = SourceRangeSelectionRequirement::evaluate(Context); if (!R) return R.takeError(); return std::make_pair(*R, 20); } }; auto Rule = createRefactoringActionRule(SelectionRequirement()); // When the requirements are satisfied, the rule's function must be invoked. { RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()) .getLocWithOffset(10); RefContext.setSelectionRange({Cursor, Cursor}); Expected ErrorOrResult = createReplacements(Rule, RefContext); ASSERT_FALSE(!ErrorOrResult); AtomicChanges Result = std::move(*ErrorOrResult); ASSERT_EQ(Result.size(), 1u); std::string YAMLString = const_cast(Result[0]).toYAMLString(); ASSERT_STREQ("---\n" "Key: 'input.cpp:30'\n" "FilePath: input.cpp\n" "Error: ''\n" "InsertedHeaders: \n" "RemovedHeaders: \n" "Replacements: \n" // Extra whitespace here! " - FilePath: input.cpp\n" " Offset: 30\n" " Length: 1\n" " ReplacementText: b\n" "...\n", YAMLString.c_str()); } // When one of the requirements is not satisfied, invoke should return a // valid error. { RefactoringRuleContext RefContext(Context.Sources); Expected ErrorOrResult = createReplacements(Rule, RefContext); ASSERT_TRUE(!ErrorOrResult); unsigned DiagID; llvm::handleAllErrors(ErrorOrResult.takeError(), [&](DiagnosticError &Error) { DiagID = Error.getDiagnostic().second.getDiagID(); }); EXPECT_EQ(DiagID, diag::err_refactor_no_selection); } } TEST_F(RefactoringActionRulesTest, ReturnError) { class ErrorRule : public SourceChangeRefactoringRule { public: static Expected initiate(RefactoringRuleContext &, SourceRange R) { return ErrorRule(R); } ErrorRule(SourceRange R) {} Expected createSourceReplacements(RefactoringRuleContext &) { return llvm::make_error( "Error", llvm::make_error_code(llvm::errc::invalid_argument)); } }; auto Rule = createRefactoringActionRule(SourceRangeSelectionRequirement()); RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()); RefContext.setSelectionRange({Cursor, Cursor}); Expected Result = createReplacements(Rule, RefContext); ASSERT_TRUE(!Result); std::string Message; llvm::handleAllErrors(Result.takeError(), [&](llvm::StringError &Error) { Message = Error.getMessage(); }); EXPECT_EQ(Message, "Error"); } Optional findOccurrences(RefactoringActionRule &Rule, RefactoringRuleContext &Context) { class Consumer final : public RefactoringResultConsumer { void handleError(llvm::Error) override {} void handle(SymbolOccurrences Occurrences) override { Result = std::move(Occurrences); } void handle(AtomicChanges Changes) override { RefactoringResultConsumer::handle(std::move(Changes)); } public: Optional Result; }; Consumer C; Rule.invoke(C, Context); return std::move(C.Result); } TEST_F(RefactoringActionRulesTest, ReturnSymbolOccurrences) { class FindOccurrences : public FindSymbolOccurrencesRefactoringRule { SourceRange Selection; public: FindOccurrences(SourceRange Selection) : Selection(Selection) {} static Expected initiate(RefactoringRuleContext &, SourceRange Selection) { return FindOccurrences(Selection); } Expected findSymbolOccurrences(RefactoringRuleContext &) override { SymbolOccurrences Occurrences; Occurrences.push_back(SymbolOccurrence(SymbolName("test"), SymbolOccurrence::MatchingSymbol, Selection.getBegin())); return std::move(Occurrences); } }; auto Rule = createRefactoringActionRule( SourceRangeSelectionRequirement()); RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()); RefContext.setSelectionRange({Cursor, Cursor}); Optional Result = findOccurrences(*Rule, RefContext); ASSERT_FALSE(!Result); SymbolOccurrences Occurrences = std::move(*Result); EXPECT_EQ(Occurrences.size(), 1u); EXPECT_EQ(Occurrences[0].getKind(), SymbolOccurrence::MatchingSymbol); EXPECT_EQ(Occurrences[0].getNameRanges().size(), 1u); EXPECT_EQ(Occurrences[0].getNameRanges()[0], SourceRange(Cursor, Cursor.getLocWithOffset(strlen("test")))); } TEST_F(RefactoringActionRulesTest, EditorCommandBinding) { const RefactoringDescriptor &Descriptor = ExtractFunction::describe(); EXPECT_EQ(Descriptor.Name, "extract-function"); EXPECT_EQ( Descriptor.Description, "(WIP action; use with caution!) Extracts code into a new function"); EXPECT_EQ(Descriptor.Title, "Extract Function"); } } // end anonymous namespace @ 1.1.1.1.4.3 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.1.2.1 log @file RefactoringActionRulesTest.cpp was added on branch pgoyette-compat on 2018-07-28 04:34:19 +0000 @ text @d1 248 @ 1.1.1.1.2.2 log @Sync with HEAD @ text @a0 248 //===- unittest/Tooling/RefactoringTestActionRulesTest.cpp ----------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "ReplacementTest.h" #include "RewriterTestContext.h" #include "clang/Tooling/Refactoring.h" #include "clang/Tooling/Refactoring/Extract/Extract.h" #include "clang/Tooling/Refactoring/RefactoringAction.h" #include "clang/Tooling/Refactoring/RefactoringDiagnostic.h" #include "clang/Tooling/Refactoring/Rename/SymbolName.h" #include "clang/Tooling/Tooling.h" #include "llvm/Support/Errc.h" #include "gtest/gtest.h" using namespace clang; using namespace tooling; namespace { class RefactoringActionRulesTest : public ::testing::Test { protected: void SetUp() override { Context.Sources.setMainFileID( Context.createInMemoryFile("input.cpp", DefaultCode)); } RewriterTestContext Context; std::string DefaultCode = std::string(100, 'a'); }; Expected createReplacements(const std::unique_ptr &Rule, RefactoringRuleContext &Context) { class Consumer final : public RefactoringResultConsumer { void handleError(llvm::Error Err) override { Result = std::move(Err); } void handle(AtomicChanges SourceReplacements) override { Result = std::move(SourceReplacements); } void handle(SymbolOccurrences Occurrences) override { RefactoringResultConsumer::handle(std::move(Occurrences)); } public: Optional> Result; }; Consumer C; Rule->invoke(C, Context); return std::move(*C.Result); } TEST_F(RefactoringActionRulesTest, MyFirstRefactoringRule) { class ReplaceAWithB : public SourceChangeRefactoringRule { std::pair Selection; public: ReplaceAWithB(std::pair Selection) : Selection(Selection) {} static Expected initiate(RefactoringRuleContext &Cotnext, std::pair Selection) { return ReplaceAWithB(Selection); } Expected createSourceReplacements(RefactoringRuleContext &Context) { const SourceManager &SM = Context.getSources(); SourceLocation Loc = Selection.first.getBegin().getLocWithOffset(Selection.second); AtomicChange Change(SM, Loc); llvm::Error E = Change.replace(SM, Loc, 1, "b"); if (E) return std::move(E); return AtomicChanges{Change}; } }; class SelectionRequirement : public SourceRangeSelectionRequirement { public: Expected> evaluate(RefactoringRuleContext &Context) const { Expected R = SourceRangeSelectionRequirement::evaluate(Context); if (!R) return R.takeError(); return std::make_pair(*R, 20); } }; auto Rule = createRefactoringActionRule(SelectionRequirement()); // When the requirements are satisfied, the rule's function must be invoked. { RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()) .getLocWithOffset(10); RefContext.setSelectionRange({Cursor, Cursor}); Expected ErrorOrResult = createReplacements(Rule, RefContext); ASSERT_FALSE(!ErrorOrResult); AtomicChanges Result = std::move(*ErrorOrResult); ASSERT_EQ(Result.size(), 1u); std::string YAMLString = const_cast(Result[0]).toYAMLString(); ASSERT_STREQ("---\n" "Key: 'input.cpp:30'\n" "FilePath: input.cpp\n" "Error: ''\n" "InsertedHeaders: \n" "RemovedHeaders: \n" "Replacements: \n" // Extra whitespace here! " - FilePath: input.cpp\n" " Offset: 30\n" " Length: 1\n" " ReplacementText: b\n" "...\n", YAMLString.c_str()); } // When one of the requirements is not satisfied, invoke should return a // valid error. { RefactoringRuleContext RefContext(Context.Sources); Expected ErrorOrResult = createReplacements(Rule, RefContext); ASSERT_TRUE(!ErrorOrResult); unsigned DiagID; llvm::handleAllErrors(ErrorOrResult.takeError(), [&](DiagnosticError &Error) { DiagID = Error.getDiagnostic().second.getDiagID(); }); EXPECT_EQ(DiagID, diag::err_refactor_no_selection); } } TEST_F(RefactoringActionRulesTest, ReturnError) { class ErrorRule : public SourceChangeRefactoringRule { public: static Expected initiate(RefactoringRuleContext &, SourceRange R) { return ErrorRule(R); } ErrorRule(SourceRange R) {} Expected createSourceReplacements(RefactoringRuleContext &) { return llvm::make_error( "Error", llvm::make_error_code(llvm::errc::invalid_argument)); } }; auto Rule = createRefactoringActionRule(SourceRangeSelectionRequirement()); RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()); RefContext.setSelectionRange({Cursor, Cursor}); Expected Result = createReplacements(Rule, RefContext); ASSERT_TRUE(!Result); std::string Message; llvm::handleAllErrors(Result.takeError(), [&](llvm::StringError &Error) { Message = Error.getMessage(); }); EXPECT_EQ(Message, "Error"); } Optional findOccurrences(RefactoringActionRule &Rule, RefactoringRuleContext &Context) { class Consumer final : public RefactoringResultConsumer { void handleError(llvm::Error) override {} void handle(SymbolOccurrences Occurrences) override { Result = std::move(Occurrences); } void handle(AtomicChanges Changes) override { RefactoringResultConsumer::handle(std::move(Changes)); } public: Optional Result; }; Consumer C; Rule.invoke(C, Context); return std::move(C.Result); } TEST_F(RefactoringActionRulesTest, ReturnSymbolOccurrences) { class FindOccurrences : public FindSymbolOccurrencesRefactoringRule { SourceRange Selection; public: FindOccurrences(SourceRange Selection) : Selection(Selection) {} static Expected initiate(RefactoringRuleContext &, SourceRange Selection) { return FindOccurrences(Selection); } Expected findSymbolOccurrences(RefactoringRuleContext &) override { SymbolOccurrences Occurrences; Occurrences.push_back(SymbolOccurrence(SymbolName("test"), SymbolOccurrence::MatchingSymbol, Selection.getBegin())); return std::move(Occurrences); } }; auto Rule = createRefactoringActionRule( SourceRangeSelectionRequirement()); RefactoringRuleContext RefContext(Context.Sources); SourceLocation Cursor = Context.Sources.getLocForStartOfFile(Context.Sources.getMainFileID()); RefContext.setSelectionRange({Cursor, Cursor}); Optional Result = findOccurrences(*Rule, RefContext); ASSERT_FALSE(!Result); SymbolOccurrences Occurrences = std::move(*Result); EXPECT_EQ(Occurrences.size(), 1u); EXPECT_EQ(Occurrences[0].getKind(), SymbolOccurrence::MatchingSymbol); EXPECT_EQ(Occurrences[0].getNameRanges().size(), 1u); EXPECT_EQ(Occurrences[0].getNameRanges()[0], SourceRange(Cursor, Cursor.getLocWithOffset(strlen("test")))); } TEST_F(RefactoringActionRulesTest, EditorCommandBinding) { const RefactoringDescriptor &Descriptor = ExtractFunction::describe(); EXPECT_EQ(Descriptor.Name, "extract-function"); EXPECT_EQ( Descriptor.Description, "(WIP action; use with caution!) Extracts code into a new function"); EXPECT_EQ(Descriptor.Title, "Extract Function"); } } // end anonymous namespace @