[clangd] Add new helpers to make tweak tests scale better. Convert most tests. NFC

sam-mccall · sam-mccall · commit ac7864ec019c · 2019-08-02T09:12:39.000Z
Summary: TweakTests.cpp has some pretty good helpers added for the first few tweaks, but they have some limitations: - many assertion failures point at the wrong line - need lots of input/output tests, setup code is duplicated across both - local helpers make it hard to split the file as it grows The new helpers in TweakTests.h are based on old ones (same operations) but try to address these issues and generally make tests more terse while improving error messages. This patch converts everything except ExtractVariable (which is complex and has changes in flight, so will be converted later). It's LOC-neutral, despite not being able to get rid of the old helpers until ExtractVariable is done. Reviewers: ilya-biryukov Subscribers: mgorny, MaskRay, jkorous, arphaman, kadircet, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D65525 llvm-svn: 367667
diff --git a/clang-tools-extra/clangd/unittests/CMakeLists.txt b/clang-tools-extra/clangd/unittests/CMakeLists.txt
@@ -68,6 +68,7 @@ add_unittest(ClangdUnitTests ClangdTests
   TraceTests.cpp
   TypeHierarchyTests.cpp
   TweakTests.cpp
+  TweakTesting.cpp
   URITests.cpp
   XRefsTests.cpp
 
diff --git a/clang-tools-extra/clangd/unittests/TweakTesting.cpp b/clang-tools-extra/clangd/unittests/TweakTesting.cpp
@@ -0,0 +1,132 @@
+//===-- TweakTesting.cpp ------------------------------------------------*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "TweakTesting.h"
+
+#include "Annotations.h"
+#include "refactor/Tweak.h"
+#include "SourceCode.h"
+#include "clang/Tooling/Core/Replacement.h"
+#include "llvm/Support/Error.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+using Context = TweakTest::CodeContext;
+
+std::pair<llvm::StringRef, llvm::StringRef> wrapping(Context Ctx) {
+  switch (Ctx) {
+    case TweakTest::File:
+      return {"",""};
+    case TweakTest::Function:
+      return {"void wrapperFunction(){\n", "\n}"};
+    case TweakTest::Expression:
+      return {"auto expressionWrapper(){return\n", "\n;}"};
+  }
+}
+
+std::string wrap(Context Ctx, llvm::StringRef Inner) {
+  auto Wrapping = wrapping(Ctx);
+  return (Wrapping.first + Inner + Wrapping.second).str();
+}
+
+llvm::StringRef unwrap(Context Ctx, llvm::StringRef Outer) {
+  auto Wrapping = wrapping(Ctx);
+  // Unwrap only if the code matches the expected wrapping.
+  // Don't allow the begin/end wrapping to overlap!
+  if (Outer.startswith(Wrapping.first) && Outer.endswith(Wrapping.second) &&
+      Outer.size() >= Wrapping.first.size() + Wrapping.second.size())
+    return Outer.drop_front(Wrapping.first.size()).drop_back(Wrapping.second.size());
+  return Outer;
+}
+
+std::pair<unsigned, unsigned> rangeOrPoint(const Annotations &A) {
+  Range SelectionRng;
+  if (A.points().size() != 0) {
+    assert(A.ranges().size() == 0 &&
+           "both a cursor point and a selection range were specified");
+    SelectionRng = Range{A.point(), A.point()};
+  } else {
+    SelectionRng = A.range();
+  }
+  return {cantFail(positionToOffset(A.code(), SelectionRng.start)),
+          cantFail(positionToOffset(A.code(), SelectionRng.end))};
+}
+
+MATCHER_P3(TweakIsAvailable, TweakID, Ctx, Header,
+           (TweakID + (negation ? " is unavailable" : " is available")).str()) {
+  std::string WrappedCode = wrap(Ctx, arg);
+  Annotations Input(WrappedCode);
+  auto Selection = rangeOrPoint(Input);
+  TestTU TU;
+  TU.HeaderCode = Header;
+  TU.Code = Input.code();
+  ParsedAST AST = TU.build();
+  Tweak::Selection S(AST, Selection.first, Selection.second);
+  auto PrepareResult = prepareTweak(TweakID, S);
+  if (PrepareResult)
+    return true;
+  llvm::consumeError(PrepareResult.takeError());
+  return false;
+}
+
+} // namespace
+
+std::string TweakTest::apply(llvm::StringRef MarkedCode) const {
+  std::string WrappedCode = wrap(Context, MarkedCode);
+  Annotations Input(WrappedCode);
+  auto Selection = rangeOrPoint(Input);
+  TestTU TU;
+  TU.HeaderCode = Header;
+  TU.Code = Input.code();
+  ParsedAST AST = TU.build();
+  Tweak::Selection S(AST, Selection.first, Selection.second);
+
+  auto T = prepareTweak(TweakID, S);
+  if (!T)
+    return "unavailable";
+  llvm::Expected<Tweak::Effect> Result = (*T)->apply(S);
+  if (!Result)
+    return "fail: " + llvm::toString(Result.takeError());
+  if (Result->ShowMessage)
+    return "message:\n" + *Result->ShowMessage;
+  if (Result->ApplyEdit) {
+    if (auto NewText =
+            tooling::applyAllReplacements(Input.code(), *Result->ApplyEdit))
+      return unwrap(Context, *NewText);
+    else
+      return "bad edits: " + llvm::toString(NewText.takeError());
+  }
+  return "no effect";
+}
+
+::testing::Matcher<llvm::StringRef> TweakTest::isAvailable() const {
+  return TweakIsAvailable(llvm::StringRef(TweakID), Context, Header); 
+}
+
+std::vector<std::string> TweakTest::expandCases(llvm::StringRef MarkedCode) {
+  Annotations Test(MarkedCode);
+  llvm::StringRef Code = Test.code();
+  std::vector<std::string> Cases;
+  for (const auto& Point : Test.points()) {
+    size_t Offset = llvm::cantFail(positionToOffset(Code, Point));
+    Cases.push_back((Code.substr(0, Offset) + "^" + Code.substr(Offset)).str());
+  }
+  for (const auto& Range : Test.ranges()) {
+    size_t Begin = llvm::cantFail(positionToOffset(Code, Range.start));
+    size_t End = llvm::cantFail(positionToOffset(Code, Range.end));
+    Cases.push_back((Code.substr(0, Begin) + "[[" +
+                     Code.substr(Begin, End - Begin) + "]]" + Code.substr(End))
+                        .str());
+  }
+  assert(!Cases.empty() && "No markings in MarkedCode?");
+  return Cases;
+}
+
+} // namespace clangd
+} // namespace clang
diff --git a/clang-tools-extra/clangd/unittests/TweakTesting.h b/clang-tools-extra/clangd/unittests/TweakTesting.h
@@ -0,0 +1,103 @@
+//===--- TweakTesting.h - Test helpers for refactoring actions ---*- C++-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TWEAKTESTING_H
+#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANGD_TWEAKTESTING_H
+
+#include "TestTU.h"
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+namespace clang {
+namespace clangd {
+
+// Fixture base for testing tweaks. Intended to be subclassed for each tweak.
+//
+// Usage:
+// TWEAK_TEST(ExpandAutoType);
+//
+// TEST_F(ExpandAutoTypeTest, ShortensTypes) {
+//   Header = R"cpp(
+//     namespace foo { template<typename> class X{}; }
+//     using namespace foo;
+//   cpp)";
+//   Context = Block;
+//   EXPECT_THAT(apply("[[auto]] X = foo<int>();"),
+//               "foo<int> X = foo<int();");
+//   EXPECT_AVAILABLE("^a^u^t^o^ X = foo<int>();");
+//   EXPECT_UNAVAILABLE("auto ^X^ = ^foo<int>();");
+// }
+class TweakTest : public ::testing::Test {
+  const char *TweakID;
+
+public:
+  // Inputs are wrapped in file boilerplate before attempting to apply a tweak.
+  // Context describes the type of boilerplate.
+  enum CodeContext {
+    // Code snippet is placed directly into the source file. e.g. a declaration.
+    File,
+    // Snippet will appear within a function body. e.g. a statement.
+    Function,
+    // Snippet is an expression.
+    Expression,
+  };
+
+protected:
+  TweakTest(const char *TweakID) : TweakID(TweakID) {}
+
+  // Contents of a header file to be implicitly included.
+  // This typically contains declarations that will be used for a set of related
+  // testcases.
+  std::string Header;
+
+  // Context in which snippets of code should be placed to run tweaks.
+  CodeContext Context = File;
+
+  // Apply the current tweak to the range (or point) in MarkedCode.
+  // MarkedCode will be wrapped according to the Context.
+  //  - if the tweak produces edits, returns the edited code (without markings).
+  //    The context added to MarkedCode will be stripped away before returning,
+  //    unless the tweak edited it.
+  //  - if the tweak produces a message, returns "message:\n<message>"
+  //  - if prepare() returns false, returns "unavailable"
+  //  - if apply() returns an error, returns "fail: <message>"
+  std::string apply(llvm::StringRef MarkedCode) const;
+
+  // Accepts a code snippet with many ranges (or points) marked, and returns a
+  // list of snippets with one range marked each.
+  // Primarily used from EXPECT_AVAILABLE/EXPECT_UNAVAILABLE macro.
+  static std::vector<std::string> expandCases(llvm::StringRef MarkedCode);
+
+  // Returns a matcher that accepts marked code snippets where the tweak is
+  // available at the marked range.
+  ::testing::Matcher<llvm::StringRef> isAvailable() const;
+};
+
+#define TWEAK_TEST(TweakID)                                                    \
+  class TweakID##Test : public ::clang::clangd::TweakTest {                    \
+  protected:                                                                   \
+    TweakID##Test() : TweakTest(#TweakID) {}                                   \
+  }
+
+#define EXPECT_AVAILABLE(MarkedCode)                                           \
+  do {                                                                         \
+    for (const auto &Case : expandCases(MarkedCode))                           \
+      EXPECT_THAT(Case, ::clang::clangd::TweakTest::isAvailable());            \
+  } while (0)
+
+#define EXPECT_UNAVAILABLE(MarkedCode)                                         \
+  do {                                                                         \
+    for (const auto &Case : expandCases(MarkedCode))                           \
+      EXPECT_THAT(Case,                                                        \
+                  ::testing::Not(::clang::clangd::TweakTest::isAvailable()));  \
+  } while (0)
+
+} // namespace clangd
+} // namespace clang
+
+#endif
diff --git a/clang-tools-extra/clangd/unittests/TweakTests.cpp b/clang-tools-extra/clangd/unittests/TweakTests.cpp
