[analyzer] Force dependency checkers to be hidden

[Szelethus]

Summary

Since strong dependencies aren't user-facing (its hardly ever legal to disable them), lets enforce that they are hidden. Modeling checkers that aren't dependencies are of course not impacted, but there is only so much you can do against developers shooting themselves in the foot :^)

I also made some changes to the test files, reversing the "test" package for, well, testing.

[balazske]

My observation is, if there is an example checker, it should be really "example" and not "test". (The "custom" is probably good to rename to "test" but not the "example".) (The names of these files look not good too: A CheckerOptionHandling.cpp contains an example checker, should be probably CheckerOptionHandlingExample.cpp).

[Szelethus]

In D81761#2097561, @balazske wrote:

My observation is, if there is an example checker, it should be really "example" and not "test". (The "custom" is probably good to rename to "test" but not the "example".) (The names of these files look not good too: A CheckerOptionHandling.cpp contains an example checker, should be probably CheckerOptionHandlingExample.cpp).

That is indeed a very fair point. My rationale was that these examples are in fact tested in the lit files, and my intention when writing them was to test checker registration from plugins.

[baloghadamsoftware]

In D81761#2097737, @Szelethus wrote:

In D81761#2097561, @balazske wrote:

My observation is, if there is an example checker, it should be really "example" and not "test". (The "custom" is probably good to rename to "test" but not the "example".) (The names of these files look not good too: A CheckerOptionHandling.cpp contains an example checker, should be probably CheckerOptionHandlingExample.cpp).

That is indeed a very fair point. My rationale was that these examples are in fact tested in the lit files, and my intention when writing them was to test checker registration from plugins.

+1 "example" should remain "example" or can be changed to "sample", but it is not a "test". Other parts of this patch seem to be OK for me.

[Szelethus]

Revert changes to plugins and to the related tests, allow the example package to bypass the new restriction.

[baloghadamsoftware]

Now it looks good to me.

clang/include/clang/StaticAnalyzer/Checkers/Checkers.td

 
 let ParentPackage = Core in {
 
 def CallAndMessageModeling : Checker<"CallAndMessageModeling">,
   HelpText<"Responsible for essential modeling and assumptions after a "
            "function/method call. For instance, if we can't reason about the "
            "nullability of the implicit this parameter after a method call, "
            "this checker conservatively assumes it to be non-null">,
-  Documentation<HasDocumentation>;
+  Documentation<HasDocumentation>,
+  Hidden;
 
 def CallAndMessageChecker : Checker<"CallAndMessage">,
   HelpText<"Check for logical errors for function calls and Objective-C "
            "message expressions (e.g., uninitialized arguments, null function "
            "pointers)">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "FunctionPointer",

 
 def StackAddrEscapeChecker : Checker<"StackAddressEscape">,
   HelpText<"Check that addresses to stack memory do not escape the function">,
   Dependencies<[StackAddrEscapeBase]>,
   Documentation<HasDocumentation>;
 
 def DynamicTypePropagation : Checker<"DynamicTypePropagation">,
   HelpText<"Generate dynamic type information">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def NonnullGlobalConstantsChecker: Checker<"NonnilStringConstants">,
   HelpText<"Assume that const string-like globals are non-null">,
   Documentation<NotDocumented>,
   Hidden;
 
 } // end "core"
 
CmdLineOption<Boolean,
                   Hide>,
     CmdLineOption<Boolean,
                   "ModelPOSIX",
                   "If set to true, the checker models functions from the "
                   "POSIX standard.",
                   "false",
                   InAlpha>
   ]>,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def TrustNonnullChecker : Checker<"TrustNonnull">,
   HelpText<"Trust that returns from framework methods annotated with _Nonnull "
            "are not null">,
   Documentation<NotDocumented>;
 
 } // end "apiModeling"
 

clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp

assert(CheckerIt != Data.Checkers.end() &&
            "Failed to find the checker while attempting to set up its "
            "dependencies!");
 
     auto DependencyIt = binaryFind(Data.Checkers, Entry.second);
     assert(DependencyIt != Data.Checkers.end() &&
            DependencyIt->FullName == Entry.second &&
            "Failed to find the dependency of a checker!");
 
+    // We do allow diagnostics from unit test/example dependency checkers.
+    assert((DependencyIt->FullName.startswith("test") ||
+            DependencyIt->FullName.startswith("example") || IsWeak ||
+            DependencyIt->IsHidden) &&
+           "Strong dependencies are modeling checkers, and as such "
+           "non-user facing! Mark them hidden in Checkers.td!");
+
     if (IsWeak)
       CheckerIt->WeakDependencies.emplace_back(&*DependencyIt);
     else
       CheckerIt->Dependencies.emplace_back(&*DependencyIt);
   }
 }
 
 void CheckerRegistry::addDependency(StringRef FullName, StringRef Dependency) {

clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp

void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
     BR.EmitBasicReport(D, this, "Custom diagnostic", categories::LogicError,
                        "Custom diagnostic description",
                        PathDiagnosticLocation(D, Mgr.getSourceManager()), {});
   }
 };
 
 void addCustomChecker(AnalysisASTConsumer &AnalysisConsumer,
                       AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.CustomChecker", true}};
+  AnOpts.CheckersAndPackages = {{"test.CustomChecker", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
-    Registry.addChecker<CustomChecker>("custom.CustomChecker", "Description",
-                                       "");
+    Registry.addChecker<CustomChecker>("test.CustomChecker", "Description", "");
   });
 }
 
 TEST(RegisterCustomCheckers, RegisterChecker) {
   std::string Diags;
   EXPECT_TRUE(runCheckerOnCode<addCustomChecker>("void f() {;}", Diags));
-  EXPECT_EQ(Diags, "custom.CustomChecker:Custom diagnostic description\n");
+  EXPECT_EQ(Diags, "test.CustomChecker:Custom diagnostic description\n");
 }
 
 //===----------------------------------------------------------------------===//
 // Pretty much the same.
 //===----------------------------------------------------------------------===//
 
 class LocIncDecChecker : public Checker<check::Location> {
 public:

 
 bool shouldRegisterCheckerRegistrationOrderPrinter(const CheckerManager &mgr) {
   return true;
 }
 
 void addCheckerRegistrationOrderPrinter(CheckerRegistry &Registry) {
   Registry.addChecker(registerCheckerRegistrationOrderPrinter,
                       shouldRegisterCheckerRegistrationOrderPrinter,
-                      "custom.RegistrationOrder", "Description", "", false);
+                      "test.RegistrationOrder", "Description", "", false);
 }
 
 #define UNITTEST_CHECKER(CHECKER_NAME, DIAG_MSG)                               \
   class CHECKER_NAME : public Checker<check::PreStmt<DeclStmt>> {              \
     std::unique_ptr<BuiltinBug> BT =                                           \
         std::make_unique<BuiltinBug>(this, DIAG_MSG);                          \
                                                                                \
   public:                                                                      \
     void checkPreStmt(const DeclStmt *DS, CheckerContext &C) const {}          \
   };                                                                           \
                                                                                \
   void register##CHECKER_NAME(CheckerManager &mgr) {                           \
     mgr.registerChecker<CHECKER_NAME>();                                       \
   }                                                                            \
                                                                                \
   bool shouldRegister##CHECKER_NAME(const CheckerManager &mgr) {               \
     return true;                                                               \
   }                                                                            \
   void add##CHECKER_NAME(CheckerRegistry &Registry) {                          \
     Registry.addChecker(register##CHECKER_NAME, shouldRegister##CHECKER_NAME,  \
-                        "custom." #CHECKER_NAME, "Description", "", false);    \
+                        "test." #CHECKER_NAME, "Description", "", false);      \
   }
 
 UNITTEST_CHECKER(StrongDep, "Strong")
 UNITTEST_CHECKER(Dep, "Dep")
 
 bool shouldRegisterStrongFALSE(const CheckerManager &mgr) {
   return false;
 }
 
 
 void addDep(AnalysisASTConsumer &AnalysisConsumer,
                   AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
     Registry.addChecker(registerStrongDep, shouldRegisterStrongFALSE,
-                        "custom.Strong", "Description", "", false);
+                        "test.Strong", "Description", "", false);
     addStrongDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addDependency("custom.Dep", "custom.Strong");
+    Registry.addDependency("test.Dep", "test.Strong");
   });
 }
 
 TEST(RegisterDeps, UnsatisfiedDependency) {
   std::string Diags;
   EXPECT_TRUE(runCheckerOnCode<addDep>("void f() {int i;}", Diags));
-  EXPECT_EQ(Diags, "custom.RegistrationOrder:custom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.RegistrationOrder\n");
 }
 
 //===----------------------------------------------------------------------===//
 // Weak checker dependencies.
 //===----------------------------------------------------------------------===//
 
 UNITTEST_CHECKER(WeakDep, "Weak")
 
 void addWeakDepCheckerBothEnabled(AnalysisASTConsumer &AnalysisConsumer,
                                   AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.WeakDep", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.WeakDep", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 void addWeakDepCheckerBothEnabledSwitched(AnalysisASTConsumer &AnalysisConsumer,
                                           AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.WeakDep", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.WeakDep", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addWeakDependency("custom.WeakDep", "custom.Dep");
+    Registry.addWeakDependency("test.WeakDep", "test.Dep");
   });
 }
 
 void addWeakDepCheckerDepDisabled(AnalysisASTConsumer &AnalysisConsumer,
                                   AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.WeakDep", false},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.WeakDep", false},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 void addWeakDepCheckerDepUnspecified(AnalysisASTConsumer &AnalysisConsumer,
                                      AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 UNITTEST_CHECKER(WeakDep2, "Weak2")
 UNITTEST_CHECKER(Dep2, "Dep2")
 
 void addWeakDepHasWeakDep(AnalysisASTConsumer &AnalysisConsumer,
                           AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.WeakDep", true},
-                                {"custom.WeakDep2", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.WeakDep", true},
+                                {"test.WeakDep2", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addStrongDep(Registry);
     addWeakDep(Registry);
     addWeakDep2(Registry);
     addDep(Registry);
     addDep2(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
-    Registry.addWeakDependency("custom.WeakDep", "custom.WeakDep2");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
+    Registry.addWeakDependency("test.WeakDep", "test.WeakDep2");
   });
 }
 
 void addWeakDepTransitivity(AnalysisASTConsumer &AnalysisConsumer,
                             AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.WeakDep", false},
-                                {"custom.WeakDep2", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.WeakDep", false},
+                                {"test.WeakDep2", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addStrongDep(Registry);
     addWeakDep(Registry);
     addWeakDep2(Registry);
     addDep(Registry);
     addDep2(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
-    Registry.addWeakDependency("custom.WeakDep", "custom.WeakDep2");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
+    Registry.addWeakDependency("test.WeakDep", "test.WeakDep2");
   });
 }
 
 TEST(RegisterDeps, SimpleWeakDependency) {
   std::string Diags;
   EXPECT_TRUE(runCheckerOnCode<addWeakDepCheckerBothEnabled>(
       "void f() {int i;}", Diags));
-  EXPECT_EQ(Diags, "custom.RegistrationOrder:custom.WeakDep\ncustom."
-                   "Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.WeakDep\ntest."
+                   "Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 
   // Mind that AnalyzerOption listed the enabled checker list in the same order,
   // but the dependencies are switched.
   EXPECT_TRUE(runCheckerOnCode<addWeakDepCheckerBothEnabledSwitched>(
       "void f() {int i;}", Diags));
-  EXPECT_EQ(Diags, "custom.RegistrationOrder:custom.Dep\ncustom."
-                   "RegistrationOrder\ncustom.WeakDep\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.Dep\ntest."
+                   "RegistrationOrder\ntest.WeakDep\n");
   Diags.clear();
 
   // Weak dependencies dont prevent dependent checkers from being enabled.
   EXPECT_TRUE(runCheckerOnCode<addWeakDepCheckerDepDisabled>(
       "void f() {int i;}", Diags));
-  EXPECT_EQ(Diags,
-            "custom.RegistrationOrder:custom.Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 
   // Nor will they be enabled just because a dependent checker is.
   EXPECT_TRUE(runCheckerOnCode<addWeakDepCheckerDepUnspecified>(
       "void f() {int i;}", Diags));
-  EXPECT_EQ(Diags,
-            "custom.RegistrationOrder:custom.Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 
   EXPECT_TRUE(
       runCheckerOnCode<addWeakDepTransitivity>("void f() {int i;}", Diags));
-  EXPECT_EQ(Diags, "custom.RegistrationOrder:custom.WeakDep2\ncustom."
-                   "Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.WeakDep2\ntest."
+                   "Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 
   EXPECT_TRUE(
       runCheckerOnCode<addWeakDepHasWeakDep>("void f() {int i;}", Diags));
-  EXPECT_EQ(Diags, "custom.RegistrationOrder:custom.WeakDep2\ncustom."
-                   "WeakDep\ncustom.Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.WeakDep2\ntest."
+                   "WeakDep\ntest.Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 }
 
 //===----------------------------------------------------------------------===//
 // Interaction of weak and regular checker dependencies.
 //===----------------------------------------------------------------------===//
 
 void addWeakDepHasStrongDep(AnalysisASTConsumer &AnalysisConsumer,
                             AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.StrongDep", true},
-                                {"custom.WeakDep", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.StrongDep", true},
+                                {"test.WeakDep", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addStrongDep(Registry);
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addDependency("custom.WeakDep", "custom.StrongDep");
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addDependency("test.WeakDep", "test.StrongDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 void addWeakDepAndStrongDep(AnalysisASTConsumer &AnalysisConsumer,
                             AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.StrongDep", true},
-                                {"custom.WeakDep", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.StrongDep", true},
+                                {"test.WeakDep", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addStrongDep(Registry);
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addDependency("custom.Dep", "custom.StrongDep");
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addDependency("test.Dep", "test.StrongDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 void addDisabledWeakDepHasStrongDep(AnalysisASTConsumer &AnalysisConsumer,
                                     AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.StrongDep", true},
-                                {"custom.WeakDep", false},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.StrongDep", true},
+                                {"test.WeakDep", false},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addStrongDep(Registry);
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addDependency("custom.WeakDep", "custom.StrongDep");
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addDependency("test.WeakDep", "test.StrongDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 void addDisabledWeakDepHasUnspecifiedStrongDep(
     AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.WeakDep", false},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.WeakDep", false},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addStrongDep(Registry);
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addDependency("custom.WeakDep", "custom.StrongDep");
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addDependency("test.WeakDep", "test.StrongDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 void addWeakDepHasDisabledStrongDep(AnalysisASTConsumer &AnalysisConsumer,
                                     AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.StrongDep", false},
-                                {"custom.WeakDep", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.StrongDep", false},
+                                {"test.WeakDep", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addStrongDep(Registry);
     addWeakDep(Registry);
     addDep(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addDependency("custom.WeakDep", "custom.StrongDep");
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addDependency("test.WeakDep", "test.StrongDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 void addWeakDepHasUnspecifiedButLaterEnabledStrongDep(
     AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) {
-  AnOpts.CheckersAndPackages = {{"custom.Dep", true},
-                                {"custom.Dep2", true},
-                                {"custom.WeakDep", true},
-                                {"custom.RegistrationOrder", true}};
+  AnOpts.CheckersAndPackages = {{"test.Dep", true},
+                                {"test.Dep2", true},
+                                {"test.WeakDep", true},
+                                {"test.RegistrationOrder", true}};
   AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
     addStrongDep(Registry);
     addWeakDep(Registry);
     addDep(Registry);
     addDep2(Registry);
     addCheckerRegistrationOrderPrinter(Registry);
-    Registry.addDependency("custom.WeakDep", "custom.StrongDep");
-    Registry.addDependency("custom.Dep2", "custom.StrongDep");
-    Registry.addWeakDependency("custom.Dep", "custom.WeakDep");
+    Registry.addDependency("test.WeakDep", "test.StrongDep");
+    Registry.addDependency("test.Dep2", "test.StrongDep");
+    Registry.addWeakDependency("test.Dep", "test.WeakDep");
   });
 }
 
 TEST(RegisterDeps, DependencyInteraction) {
   std::string Diags;
   EXPECT_TRUE(
       runCheckerOnCode<addWeakDepHasStrongDep>("void f() {int i;}", Diags));
-  EXPECT_EQ(Diags, "custom.RegistrationOrder:custom.StrongDep\ncustom."
-                   "WeakDep\ncustom.Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.StrongDep\ntest."
+                   "WeakDep\ntest.Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 
   // Weak dependencies are registered before strong dependencies. This is most
   // important for purely diagnostic checkers that are implemented as a part of
   // purely modeling checkers, becuse the checker callback order will have to be
   // established in between the modeling portion and the weak dependency.
   EXPECT_TRUE(
       runCheckerOnCode<addWeakDepAndStrongDep>("void f() {int i;}", Diags));
-  EXPECT_EQ(Diags, "custom.RegistrationOrder:custom.WeakDep\ncustom."
-                   "StrongDep\ncustom.Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.WeakDep\ntest."
+                   "StrongDep\ntest.Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 
   // If a weak dependency is disabled, the checker itself can still be enabled.
   EXPECT_TRUE(runCheckerOnCode<addDisabledWeakDepHasStrongDep>(
       "void f() {int i;}", Diags));
-  EXPECT_EQ(Diags, "custom.RegistrationOrder:custom.Dep\ncustom."
-                   "RegistrationOrder\ncustom.StrongDep\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.Dep\ntest."
+                   "RegistrationOrder\ntest.StrongDep\n");
   Diags.clear();
 
   // If a weak dependency is disabled, the checker itself can still be enabled,
   // but it shouldn't enable a strong unspecified dependency.
   EXPECT_TRUE(runCheckerOnCode<addDisabledWeakDepHasUnspecifiedStrongDep>(
       "void f() {int i;}", Diags));
-  EXPECT_EQ(Diags,
-            "custom.RegistrationOrder:custom.Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 
   // A strong dependency of a weak dependency is disabled, so neither of them
   // should be enabled.
   EXPECT_TRUE(runCheckerOnCode<addWeakDepHasDisabledStrongDep>(
       "void f() {int i;}", Diags));
-  EXPECT_EQ(Diags,
-            "custom.RegistrationOrder:custom.Dep\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.Dep\ntest.RegistrationOrder\n");
   Diags.clear();
 
   EXPECT_TRUE(
       runCheckerOnCode<addWeakDepHasUnspecifiedButLaterEnabledStrongDep>(
           "void f() {int i;}", Diags));
-  EXPECT_EQ(Diags,
-            "custom.RegistrationOrder:custom.StrongDep\ncustom.WeakDep\ncustom."
-            "Dep\ncustom.Dep2\ncustom.RegistrationOrder\n");
+  EXPECT_EQ(Diags, "test.RegistrationOrder:test.StrongDep\ntest.WeakDep\ntest."
+                   "Dep\ntest.Dep2\ntest.RegistrationOrder\n");
   Diags.clear();
 }
 } // namespace
 } // namespace ento
 } // namespace clang