clang/unittests/StaticAnalyzer/BugReportInterestingnessTest.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "Reusables.h"
  10 #include "clang/Frontend/CompilerInstance.h"
  11 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
  12 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
  13 #include "clang/StaticAnalyzer/Core/Checker.h"
  14 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
  15 #include "clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h"
  16 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
  17 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  18 #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
  19 #include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
  20 #include "clang/Tooling/Tooling.h"
  21 #include "gtest/gtest.h"
  22
  23 using namespace clang;
  24 using namespace ento;
  25 using namespace llvm;
  26
  27 namespace {
  28
  29 class InterestingnessTestChecker : public Checker<check::PreCall> {
  30   BugType BT_TestBug;
  31
  32   using HandlerFn = std::function<void(const InterestingnessTestChecker *,
  33                                        const CallEvent &, CheckerContext &)>;
  34
  35   CallDescriptionMap<HandlerFn> Handlers = {
  36       {{CDM::SimpleFunc, {"setInteresting"}, 1},
  37        &InterestingnessTestChecker::handleInteresting},
  38       {{CDM::SimpleFunc, {"setNotInteresting"}, 1},
  39        &InterestingnessTestChecker::handleNotInteresting},
  40       {{CDM::SimpleFunc, {"check"}, 1},
  41        &InterestingnessTestChecker::handleCheck},
  42       {{CDM::SimpleFunc, {"bug"}, 1}, &InterestingnessTestChecker::handleBug},
  43   };
  44
  45   void handleInteresting(const CallEvent &Call, CheckerContext &C) const;
  46   void handleNotInteresting(const CallEvent &Call, CheckerContext &C) const;
  47   void handleCheck(const CallEvent &Call, CheckerContext &C) const;
  48   void handleBug(const CallEvent &Call, CheckerContext &C) const;
  49
  50 public:
  51   InterestingnessTestChecker()
  52       : BT_TestBug(this, "InterestingnessTestBug", "Test") {}
  53
  54   void checkPreCall(const CallEvent &Call, CheckerContext &C) const {
  55     const HandlerFn *Handler = Handlers.lookup(Call);
  56     if (!Handler)
  57       return;
  58
  59     (*Handler)(this, Call, C);
  60   }
  61 };
  62
  63 } // namespace
  64
  65 void InterestingnessTestChecker::handleInteresting(const CallEvent &Call,
  66                                                    CheckerContext &C) const {
  67   SymbolRef Sym = Call.getArgSVal(0).getAsSymbol();
  68   assert(Sym);
  69   C.addTransition(nullptr, C.getNoteTag([Sym](PathSensitiveBugReport &BR) {
  70     BR.markInteresting(Sym);
  71     return "";
  72   }));
  73 }
  74
  75 void InterestingnessTestChecker::handleNotInteresting(const CallEvent &Call,
  76                                                       CheckerContext &C) const {
  77   SymbolRef Sym = Call.getArgSVal(0).getAsSymbol();
  78   assert(Sym);
  79   C.addTransition(nullptr, C.getNoteTag([Sym](PathSensitiveBugReport &BR) {
  80     BR.markNotInteresting(Sym);
  81     return "";
  82   }));
  83 }
  84
  85 void InterestingnessTestChecker::handleCheck(const CallEvent &Call,
  86                                              CheckerContext &C) const {
  87   SymbolRef Sym = Call.getArgSVal(0).getAsSymbol();
  88   assert(Sym);
  89   C.addTransition(nullptr, C.getNoteTag([Sym](PathSensitiveBugReport &BR) {
  90     if (BR.isInteresting(Sym))
  91       return "Interesting";
  92     else
  93       return "NotInteresting";
  94   }));
  95 }
  96
  97 void InterestingnessTestChecker::handleBug(const CallEvent &Call,
  98                                            CheckerContext &C) const {
  99   ExplodedNode *N = C.generateErrorNode();
 100   C.emitReport(
 101       std::make_unique<PathSensitiveBugReport>(BT_TestBug, "test bug", N));
 102 }
 103
 104 namespace {
 105
 106 class TestAction : public ASTFrontendAction {
 107   ExpectedDiagsTy ExpectedDiags;
 108
 109 public:
 110   TestAction(ExpectedDiagsTy &&ExpectedDiags)
 111       : ExpectedDiags(std::move(ExpectedDiags)) {}
 112
 113   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
 114                                                  StringRef File) override {
 115     std::unique_ptr<AnalysisASTConsumer> AnalysisConsumer =
 116         CreateAnalysisConsumer(Compiler);
 117     AnalysisConsumer->AddDiagnosticConsumer(new VerifyPathDiagnosticConsumer(
 118         std::move(ExpectedDiags), Compiler.getSourceManager()));
 119     AnalysisConsumer->AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
 120       Registry.addChecker<InterestingnessTestChecker>("test.Interestingness",
 121                                                       "Description", "");
 122     });
 123     Compiler.getAnalyzerOpts().CheckersAndPackages = {
 124         {"test.Interestingness", true}};
 125     return std::move(AnalysisConsumer);
 126   }
 127 };
 128
 129 } // namespace
 130
 131 TEST(BugReportInterestingness, Symbols) {
 132   EXPECT_TRUE(tooling::runToolOnCode(
 133       std::make_unique<TestAction>(ExpectedDiagsTy{
 134           {{15, 7},
 135            "test bug",
 136            "test bug",
 137            "test.Interestingness",
 138            "InterestingnessTestBug",
 139            "Test",
 140            {
 141                {{8, 7}, "Interesting", {{{8, 7}, {8, 14}}}},
 142                {{10, 7}, "NotInteresting", {{{10, 7}, {10, 14}}}},
 143                {{12, 7}, "Interesting", {{{12, 7}, {12, 14}}}},
 144                {{14, 7}, "NotInteresting", {{{14, 7}, {14, 14}}}},
 145                {{15, 7}, "test bug", {{{15, 7}, {15, 12}}}},
 146            }}}),
 147       R"(
 148     void setInteresting(int);
 149     void setNotInteresting(int);
 150     void check(int);
 151     void bug(int);
 152
 153     void f(int A) {
 154       check(A);
 155       setInteresting(A);
 156       check(A);
 157       setNotInteresting(A);
 158       check(A);
 159       setInteresting(A);
 160       check(A);
 161       bug(A);
 162     }
 163   )",
 164       "input.cpp"));
 165 }