[clang][dataflow] Add framework for testing analyses.

[ymandel]

Summary

Adds a general-purpose framework to support testing of dataflow analyses.

[xazax.hun]

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

48

This would also be useful for debugging. I wonder whether utilities not strictly related to testing should be closer to the actual code, so someone wanting to use this for debugging does not need to include the header that is dedicated to the tests.

77

I feel like some of our tests keep recreating lightweight versions of the LibTooling. Not really an action item for this PR, just a rant :) I hope we will have some more centralized stuff at some point.

94

Since this function is actually matching the dataflow results against expectations, I wonder if something like checkDataflow would better describe its function. But feel free to keep the current name.

137

Wouldn't users end up calling the template (not the type erased) version of this function? I wonder if we should mimic how users would interact with the framework in the tests.

[ymandel]

responding to review comments

[ymandel]

Thanks for the great comments and the fast response time!

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

48

Agreed. Added a FIXME.

77

No, I agree! I missed this -- there's no good reason for runOnCode to exist. I've removed it and like the result a lot more. :)

94

Agreed.

135

I've inlined buildAnnotationToOutputStateMapping, since it is only intended for use here anyhow and factoring it out didn't save anything because we still need to translate to typed state.

137

I see your point and tried to move in that direction. However, it makes this code a lot messier because of the need to iterate again over each block with transferBlock to recoved statement level state. Since transferBlock is part of the type-erased engine, interacting with it would require mapping all of the state to untyped before using it, which somewhat defeats the whole purpose of using the typed version.

We should consider reporting statement level information from our run...DataflowAnalysis functions, which would make this iteration unnecessary, at which point moving to the typed version would make a lot of sense.

[ymandel]

rebasing onto latest version of parent patch

[xazax.hun]

Thanks!

[ymandel]

add missing build dependency

[ymandel]

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

48–49

This SFINAE guard doesn't work on some platforms, as evidenced by the many buildbot failures after commit.

Any suggestions for

1. what's wrong
2. how to configure my local build to replicate the breakage

would be appreciated.

[ymandel]

Remove the SFINAE guard and add operator<< for NoopLattice

[thakis]

Looks like this breaks building on Windows: http://45.33.8.238/win/50614/step_4.txt

Please take a look!

[ymandel]

renames the testing namespace to test

cleans up the code the implementation of operator<< for dataflow state.

[ymandel]

rebase

clang/unittests/Analysis/FlowSensitive/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(ClangAnalysisFlowSensitiveTests
+  TestingSupport.cpp
+  TestingSupportTest.cpp
   TypeErasedDataflowAnalysisTest.cpp
   )
 
 clang_target_link_libraries(ClangAnalysisFlowSensitiveTests
   PRIVATE
   clangAnalysis
   clangAnalysisFlowSensitive
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangTesting
   clangTooling
   )
 

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

+//===--- DataflowValues.h - Data structure for dataflow values --*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a skeleton data structure for encapsulating the dataflow
+// values for a CFG.  Typically this is subclassed to provide methods for
+// computing these values from a CFG.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_ANALYSIS_FLOW_SENSITIVE_TESTING_SUPPORT_H_
+#define LLVM_CLANG_ANALYSIS_FLOW_SENSITIVE_TESTING_SUPPORT_H_
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Stmt.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchersInternal.h"
+#include "clang/Analysis/CFG.h"
+#include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
+#include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Testing/Support/Annotations.h"
+#include "gtest/gtest.h"
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace clang {
+namespace dataflow {
+
+// Requires a `<<` operator for the `Lattice` type.
+template <typename Lattice,
+          typename = decltype(std::declval<std::ostream &>()
+                              << std::declval<const Lattice &>())>
+std::ostream &operator<<(std::ostream &OS,
+                         const DataflowAnalysisState<Lattice> &S) {
+  std::string Separator = "";
+  OS << "{lattice=";
+  OS << S.Lattice;
+  // FIXME: add printing support for the environment.
+  OS << ", environment=...}";
+  return OS;
+}
+
+// Returns assertions based on annotations that are present after statements in
+// `AnnotatedCode`.
+llvm::Expected<llvm::DenseMap<const Stmt *, std::string>>
+buildStatementToAnnotationMapping(const FunctionDecl *Func,
+                                  llvm::Annotations AnnotatedCode);
+
+// Returns a map from statement annotations to the state computed for the
+// program point immediately after the annotated statement.
+std::vector<std::pair<std::string, TypeErasedDataflowAnalysisState>>
+buildAnnotationToOutputStateMapping(
+    const CFG &Cfg,
+    std::vector<llvm::Optional<TypeErasedDataflowAnalysisState>>
+        &BlockToOutputState,
+    const Environment &InitEnv, TypeErasedDataflowAnalysis &Analysis,
+    const llvm::DenseMap<const Stmt *, std::string> &StatementToAnnotationMap);
+
+// Invokes `Operation` with the ASTContext of the translation unit created from
+// `Code`, passing the additional arguments provided in `Args`, and including
+// the files provided in `VirtualMappedFiles`.
+bool runOnCode(llvm::StringRef Code,
+               const std::function<void(ASTContext &)> &Operation,
+               ArrayRef<std::string> Args,
+               const tooling::FileContentMappings &VirtualMappedFiles =
+                   tooling::FileContentMappings());
+
+namespace testing {
+
+// Creates a CFG from the body of the function that matches `func_matcher`,
+// suitable to testing a dataflow analysis.
+std::pair<const FunctionDecl *, std::unique_ptr<CFG>>
+buildCFG(ASTContext &Context,
+         ast_matchers::internal::Matcher<FunctionDecl> FuncMatcher);
+
+// Runs dataflow on the body of the function that matches `func_matcher` in code
+// snippet `code`. Requires: `Analysis` contains a type `Lattice`.
+template <typename AnalysisT>
+void runDataflow(
+    llvm::StringRef Code,
+    ast_matchers::internal::Matcher<FunctionDecl> FuncMatcher,
+    std::function<AnalysisT(ASTContext &, Environment &)> MakeAnalysis,
+    std::function<void(
+        llvm::ArrayRef<std::pair<
+            std::string, DataflowAnalysisState<typename AnalysisT::Lattice>>>,
+        ASTContext &)>
+        Expectations,
+    ArrayRef<std::string> Args,
+    const tooling::FileContentMappings &VirtualMappedFiles = {}) {
+  llvm::Annotations Annotations(Code);
+  runOnCode(
+      Annotations.code(),
+      [FuncMatcher, &Annotations, &MakeAnalysis,
+       &Expectations](ASTContext &Context) {
+        if (Context.getDiagnostics().getClient()->getNumErrors() != 0) {
+          FAIL()
+              << "Source file has syntax or type errors, they were printed to "
+                 "the test log";
+        }
+
+        std::pair<const FunctionDecl *, std::unique_ptr<CFG>> CFGResult =
+            buildCFG(Context, FuncMatcher);
+        const auto *f = CFGResult.first;
+        auto cfg = std::move(CFGResult.second);
+        ASSERT_TRUE(f != nullptr) << "Could not find target function";
+        ASSERT_TRUE(cfg != nullptr) << "Could not build control flow graph.";
+
+        Environment Env;
+        auto Analysis = MakeAnalysis(Context, Env);
+
+        llvm::Expected<llvm::DenseMap<const clang::Stmt *, std::string>>
+            StmtToAnnotations =
+                buildStatementToAnnotationMapping(f, Annotations);
+        if (auto E = StmtToAnnotations.takeError()) {
+          FAIL() << "Failed to build annotation map: "
+                 << llvm::toString(std::move(E));
+          return;
+        }
+
+        std::vector<llvm::Optional<TypeErasedDataflowAnalysisState>>
+            TypeErasedBlockStates =
+                runTypeErasedDataflowAnalysis(*cfg, Analysis, Env);
+
+        if (TypeErasedBlockStates.empty()) {
+          Expectations({}, Context);
+          return;
+        }
+
+        std::vector<std::pair<std::string, TypeErasedDataflowAnalysisState>>
+            TypeErasedResults = buildAnnotationToOutputStateMapping(
+                *cfg, TypeErasedBlockStates, Env, Analysis, *StmtToAnnotations);
+
+        std::vector<std::pair<
+            std::string, DataflowAnalysisState<typename AnalysisT::Lattice>>>
+            Results;
+        Results.reserve(TypeErasedResults.size());
+        for (auto &Entry : TypeErasedResults) {
+          auto *Lattice = llvm::any_cast<typename AnalysisT::Lattice>(
+              &Entry.second.Lattice.Value);
+          if (Lattice == nullptr) {
+            FAIL() << "Could not cast lattice element to expected type.";
+          }
+
+          Results.emplace_back(
+              std::move(Entry.first),
+              DataflowAnalysisState<typename AnalysisT::Lattice>{
+                  std::move(*Lattice), std::move(Entry.second.Env)});
+        }
+        Expectations(Results, Context);
+      },
+      Args, VirtualMappedFiles);
+}
+
+// Runs dataflow on the body of the function named `target_fun` in code snippet
+// `code`.
+template <typename AnalysisT>
+void runDataflow(
+    llvm::StringRef Code, llvm::StringRef TargetFun,
+    std::function<AnalysisT(ASTContext &, Environment &)> MakeAnalysis,
+    std::function<void(
+        llvm::ArrayRef<std::pair<
+            std::string, DataflowAnalysisState<typename AnalysisT::Lattice>>>,
+        ASTContext &)>
+        Expectations,
+    ArrayRef<std::string> Args,
+    const tooling::FileContentMappings &VirtualMappedFiles = {}) {
+  runDataflow(Code, ast_matchers::hasName(TargetFun), std::move(MakeAnalysis),
+              std::move(Expectations), Args, VirtualMappedFiles);
+}
+
+} // namespace testing
+} // namespace dataflow
+} // namespace clang
+
+#endif // LLVM_CLANG_ANALYSIS_FLOW_SENSITIVE_TESTING_SUPPORT_H_

clang/unittests/Analysis/FlowSensitive/TestingSupport.cpp

+#include "TestingSupport.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Stmt.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Analysis/CFG.h"
+#include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
+#include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Basic/TokenKinds.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/Serialization/PCHContainerOperations.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Testing/Support/Annotations.h"
+#include "gtest/gtest.h"
+#include <functional>
+#include <memory>
+#include <string>
+#include <system_error>
+#include <utility>
+#include <vector>
+
+using namespace clang;
+using namespace dataflow;
+
+namespace {
+using ast_matchers::MatchFinder;
+
+class FindTranslationUnitCallback : public MatchFinder::MatchCallback {
+public:
+  explicit FindTranslationUnitCallback(
+      std::function<void(ASTContext &)> Operation)
+      : Operation{Operation} {}
+
+  void run(const MatchFinder::MatchResult &Result) override {
+    const auto *TU = Result.Nodes.getNodeAs<TranslationUnitDecl>("tu");
+    if (TU->getASTContext().getDiagnostics().getClient()->getNumErrors() != 0) {
+      FAIL() << "Source file has syntax or type errors, they were printed to "
+                "the test log";
+    }
+    Operation(TU->getASTContext());
+  }
+
+  std::function<void(ASTContext &)> Operation;
+};
+} // namespace
+
+static bool
+isAnnotationDirectlyAfterStatement(const Stmt *Stmt, unsigned AnnotationBegin,
+                                   const SourceManager &SourceManager,
+                                   const LangOptions &LangOptions) {
+  auto NextToken =
+      Lexer::findNextToken(Stmt->getEndLoc(), SourceManager, LangOptions);
+
+  while (NextToken.hasValue() &&
+         SourceManager.getFileOffset(NextToken->getLocation()) <
+             AnnotationBegin) {
+    if (NextToken->isNot(tok::semi))
+      return false;
+
+    NextToken = Lexer::findNextToken(NextToken->getEndLoc(), SourceManager,
+                                     LangOptions);
+  }
+
+  return true;
+}
+
+llvm::Expected<llvm::DenseMap<const Stmt *, std::string>>
+buildStatementToAnnotationMapping(const FunctionDecl *Func,
+                                  llvm::Annotations AnnotatedCode) {
+  llvm::DenseMap<const Stmt *, std::string> Result;
+
+  using namespace ast_matchers; // NOLINT: Too many names
+  auto StmtMatcher =
+      findAll(stmt(unless(anyOf(hasParent(expr()), hasParent(returnStmt()))))
+                  .bind("stmt"));
+
+  // This map should stay sorted because the binding algorithm relies on the
+  // ordering of statement offsets
+  std::map<unsigned, const Stmt *> Stmts;
+  auto &Context = Func->getASTContext();
+  auto &SourceManager = Context.getSourceManager();
+
+  for (auto &Match : match(StmtMatcher, *Func->getBody(), Context)) {
+    const auto *S = Match.getNodeAs<Stmt>("stmt");
+    unsigned Offset = SourceManager.getFileOffset(S->getEndLoc());
+    Stmts[Offset] = S;
+  }
+
+  unsigned I = 0;
+  auto Annotations = AnnotatedCode.ranges();
+  std::reverse(Annotations.begin(), Annotations.end());
+  auto Code = AnnotatedCode.code();
+
+  for (auto OffsetAndStmt = Stmts.rbegin(); OffsetAndStmt != Stmts.rend();
+       OffsetAndStmt++) {
+    unsigned Offset = OffsetAndStmt->first;
+    const Stmt *Stmt = OffsetAndStmt->second;
+
+    if (I < Annotations.size() && Annotations[I].Begin >= Offset) {
+      auto Range = Annotations[I];
+
+      if (!isAnnotationDirectlyAfterStatement(Stmt, Range.Begin, SourceManager,
+                                              Context.getLangOpts())) {
+        return llvm::createStringError(
+            std::make_error_code(std::errc::invalid_argument),
+            "Annotation is not placed after a statement: %s",
+            SourceManager.getLocForStartOfFile(SourceManager.getMainFileID())
+                .getLocWithOffset(Offset)
+                .printToString(SourceManager)
+                .data());
+      }
+
+      Result[Stmt] = Code.slice(Range.Begin, Range.End).str();
+      I++;
+
+      if (I < Annotations.size() && Annotations[I].Begin >= Offset) {
+        return llvm::createStringError(
+            std::make_error_code(std::errc::invalid_argument),
+            "Multiple annotations bound to the statement at the location: %s",
+            Stmt->getBeginLoc().printToString(SourceManager).data());
+      }
+    }
+  }
+
+  if (I < Annotations.size()) {
+    return llvm::createStringError(
+        std::make_error_code(std::errc::invalid_argument),
+        "Not all annotations were bound to statements. Unbound annotation at: "
+        "%s",
+        SourceManager.getLocForStartOfFile(SourceManager.getMainFileID())
+            .getLocWithOffset(Annotations[I].Begin)
+            .printToString(SourceManager)
+            .data());
+  }
+
+  return Result;
+}
+
+std::vector<std::pair<std::string, TypeErasedDataflowAnalysisState>>
+buildAnnotationToOutputStateMapping(
+    const CFG &Cfg,
+    std::vector<llvm::Optional<TypeErasedDataflowAnalysisState>>
+        &BlockToOutputState,
+    const Environment &InitEnv, TypeErasedDataflowAnalysis &Analysis,
+    const llvm::DenseMap<const Stmt *, std::string> &StatementToAnnotationMap) {
+  std::vector<std::pair<std::string, TypeErasedDataflowAnalysisState>> Result;
+  for (const CFGBlock *Block : Cfg) {
+    // Skip blocks that were not evaluated.
+    if (!BlockToOutputState[Block->getBlockID()].hasValue())
+      continue;
+
+    transferBlock(BlockToOutputState, *Block, InitEnv, Analysis,
+                  [&Result, &StatementToAnnotationMap](
+                      const clang::CFGStmt &Stmt,
+                      const TypeErasedDataflowAnalysisState &State) {
+                    auto It = StatementToAnnotationMap.find(Stmt.getStmt());
+                    if (It == StatementToAnnotationMap.end())
+                      return;
+                    Result.emplace_back(It->second, State);
+                  });
+  }
+  return Result;
+}
+
+bool runOnCode(llvm::StringRef Code,
+               const std::function<void(ASTContext &)> &Operation,
+               ArrayRef<std::string> Args,
+               const tooling::FileContentMappings &VirtualMappedFiles) {
+  MatchFinder MatchFinder;
+  FindTranslationUnitCallback Callback(Operation);
+
+  using namespace ast_matchers; // NOLINT: Too many names
+
+  MatchFinder.addMatcher(translationUnitDecl().bind("tu"), &Callback);
+
+  std::unique_ptr<tooling::FrontendActionFactory> Factory(
+      tooling::newFrontendActionFactory(&MatchFinder));
+  return tooling::runToolOnCodeWithArgs(
+      Factory->create(), Code, Args, "input.cc", "clang-data-flow-test-tool",
+      std::make_shared<PCHContainerOperations>(), VirtualMappedFiles);
+}
+
+namespace testing {
+
+std::pair<const FunctionDecl *, std::unique_ptr<CFG>>
+buildCFG(ASTContext &Context,
+         ast_matchers::internal::Matcher<FunctionDecl> FuncMatcher) {
+  CFG::BuildOptions Options;
+  Options.PruneTriviallyFalseEdges = false;
+  Options.AddInitializers = true;
+  Options.AddImplicitDtors = true;
+  Options.AddTemporaryDtors = true;
+  Options.setAllAlwaysAdd();
+
+  const FunctionDecl *F = ast_matchers::selectFirst<FunctionDecl>(
+      "target",
+      ast_matchers::match(
+          ast_matchers::functionDecl(ast_matchers::isDefinition(), FuncMatcher)
+              .bind("target"),
+          Context));
+  if (F == nullptr)
+    return std::make_pair(nullptr, nullptr);
+
+  return std::make_pair(
+      F, clang::CFG::buildCFG(F, F->getBody(), &Context, Options));
+}
+
+} // namespace testing

clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp

+#include "TestingSupport.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using namespace clang;
+using namespace dataflow;
+
+namespace {
+
+using ::clang::ast_matchers::functionDecl;
+using ::clang::ast_matchers::hasName;
+using ::clang::ast_matchers::isDefinition;
+using ::testing::_;
+using ::testing::IsEmpty;
+using ::testing::Pair;
+using ::testing::UnorderedElementsAre;
+
+class NoopLattice {
+public:
+  bool operator==(const NoopLattice &) const { return true; }
+
+  LatticeJoinEffect join(const NoopLattice &) {
+    return LatticeJoinEffect::Unchanged;
+  }
+};
+
+class NoopAnalysis : public DataflowAnalysis<NoopAnalysis, NoopLattice> {
+public:
+  NoopAnalysis(ASTContext &Context)
+      : DataflowAnalysis<NoopAnalysis, NoopLattice>(Context) {}
+
+  static NoopLattice initialElement() { return {}; }
+
+  NoopLattice transfer(const Stmt *S, const NoopLattice &E, Environment &Env) {
+    return {};
+  }
+};
+
+template <typename T>
+const FunctionDecl *findTargetFunc(ASTContext &Context, T FunctionMatcher) {
+  auto TargetMatcher =
+      functionDecl(FunctionMatcher, isDefinition()).bind("target");
+  for (const auto &Node : ast_matchers::match(TargetMatcher, Context)) {
+    const auto *Func = Node.template getNodeAs<FunctionDecl>("target");
+    if (Func == nullptr)
+      continue;
+    if (Func->isTemplated())
+      continue;
+    return Func;
+  }
+  return nullptr;
+}
+
+class BuildStatementToAnnotationMappingTest : public ::testing::Test {
+public:
+  void
+  runTest(llvm::StringRef SourceCode, llvm::StringRef TargetName,
+          std::function<void(const llvm::DenseMap<const Stmt *, std::string> &)>
+              RunChecks) {
+    llvm::Annotations AnnotatedCode(SourceCode);
+
+    auto Test = [&AnnotatedCode, TargetName, &RunChecks](ASTContext &Context) {
+      const FunctionDecl *Func = findTargetFunc(Context, hasName(TargetName));
+      ASSERT_NE(Func, nullptr);
+
+      llvm::Expected<llvm::DenseMap<const Stmt *, std::string>> Mapping =
+          buildStatementToAnnotationMapping(Func, AnnotatedCode);
+      ASSERT_TRUE(static_cast<bool>(Mapping));
+      RunChecks(Mapping.get());
+    };
+
+    ASSERT_TRUE(
+        runOnCode(AnnotatedCode.code(), Test, {"-fsyntax-only", "-std=c++17"}));
+  }
+};
+
+TEST_F(BuildStatementToAnnotationMappingTest, ReturnStmt) {
+  runTest(R"(
+    int target() {
+      return 42;
+      /*[[ok]]*/
+    }
+  )",
+          "target",
+          [](const llvm::DenseMap<const Stmt *, std::string> &Annotations) {
+            ASSERT_EQ(Annotations.size(), 1);
+            EXPECT_TRUE(isa<ReturnStmt>(Annotations.begin()->first));
+            EXPECT_EQ(Annotations.begin()->second, "ok");
+          });
+}
+
+void runDataflow(
+    llvm::StringRef Code, llvm::StringRef Target,
+    std::function<void(llvm::ArrayRef<std::pair<
+                           std::string, DataflowAnalysisState<NoopLattice>>>,
+                       ASTContext &)>
+        Expectations) {
+  clang::dataflow::testing::runDataflow<NoopAnalysis>(
+      Code, Target,
+      [](ASTContext &Context, Environment &) { return NoopAnalysis(Context); },
+      std::move(Expectations), {"-fsyntax-only", "-std=c++17"});
+}
+
+TEST(ProgramPointAnnotations, NoAnnotations) {
+  ::testing::MockFunction<void(
+      llvm::ArrayRef<
+          std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
+      ASTContext &)>
+      Expectations;
+
+  EXPECT_CALL(Expectations, Call(IsEmpty(), _)).Times(1);
+
+  runDataflow("void target() {}", "target", Expectations.AsStdFunction());
+}
+
+TEST(ProgramPointAnnotations, NoAnnotationsDifferentTarget) {
+  ::testing::MockFunction<void(
+      llvm::ArrayRef<
+          std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
+      ASTContext &)>
+      Expectations;
+
+  EXPECT_CALL(Expectations, Call(IsEmpty(), _)).Times(1);
+
+  runDataflow("void fun() {}", "fun", Expectations.AsStdFunction());
+}
+
+TEST(ProgramPointAnnotations, WithCodepoint) {
+  ::testing::MockFunction<void(
+      llvm::ArrayRef<
+          std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
+      ASTContext &)>
+      Expectations;
+
+  EXPECT_CALL(Expectations,
+              Call(UnorderedElementsAre(Pair("program-point", _)), _))
+      .Times(1);
+
+  runDataflow(R"cc(void target() {
+                     int n;
+                     // [[program-point]]
+                   })cc",
+              "target", Expectations.AsStdFunction());
+}
+
+TEST(ProgramPointAnnotations, MultipleCodepoints) {
+  ::testing::MockFunction<void(
+      llvm::ArrayRef<
+          std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
+      ASTContext &)>
+      Expectations;
+
+  EXPECT_CALL(Expectations,
+              Call(UnorderedElementsAre(Pair("program-point-1", _),
+                                        Pair("program-point-2", _)),
+                   _))
+      .Times(1);
+
+  runDataflow(R"cc(void target(bool b) {
+                     if (b) {
+                       int n;
+                       // [[program-point-1]]
+                     } else {
+                       int m;
+                       // [[program-point-2]]
+                     }
+                   })cc",
+              "target", Expectations.AsStdFunction());
+}
+
+} // namespace