feat: add testname execution

Author: bekard

src/Builder/Builder.cc

@@ -68,7 +68,7 @@ Result<void> Builder::build() {
   return Ok();
 }
 
-Result<void> Builder::test() {
+Result<void> Builder::test(std::optional<std::string> testName) {
   Try(ensurePlanned());
 
   const Manifest& mf = graphState->manifest();
@@ -109,6 +109,7 @@ Result<void> Builder::test() {
 
   std::size_t numPassed = 0;
   std::size_t numFailed = 0;
+  std::size_t numFilteredOut = 0;
   ExitStatus summaryStatus(EXIT_SUCCESS);
 
   const auto labelFor = [](BuildGraph::TestKind kind) {
@@ -121,29 +122,35 @@ Result<void> Builder::test() {
     std::unreachable();
   };
 
-  for (const auto& target : targets) {
-    const fs::path absoluteBinary = outDir / target.ninjaTarget;
-    const std::string testBinPath =
-        fs::relative(absoluteBinary, mf.path.parent_path()).string();
-    Diag::info("Running", "{} test {} ({})", labelFor(target.kind),
-               target.sourcePath, testBinPath);
-
-    const ExitStatus curExitStatus =
-        Try(execCmd(Command(absoluteBinary.string())));
-    if (curExitStatus.success()) {
-      ++numPassed;
+  for (const auto& testTarget : targets) {
+    if (!testName.has_value()
+        || testTarget.ninjaTarget.find(*testName) != std::string::npos) {
+
+      const fs::path absoluteBinary = outDir / testTarget.ninjaTarget;
+      const std::string testBinPath =
+          fs::relative(absoluteBinary, mf.path.parent_path()).string();
+      Diag::info("Running", "{} test {} ({})", labelFor(testTarget.kind),
+                 testTarget.sourcePath, testBinPath);
+
+      const ExitStatus curExitStatus =
+          Try(execCmd(Command(absoluteBinary.string())));
+      if (curExitStatus.success()) {
+        ++numPassed;
+      } else {
+        ++numFailed;
+        summaryStatus = curExitStatus;
+      }
     } else {
-      ++numFailed;
-      summaryStatus = curExitStatus;
+      ++numFilteredOut;
     }
   }
 
   const auto runEnd = std::chrono::steady_clock::now();
   const std::chrono::duration<double> runElapsed = runEnd - runStart;
 
   const std::string summary =
-      fmt::format("{} passed; {} failed; finished in {:.2f}s", numPassed,
-                  numFailed, runElapsed.count());
+      fmt::format("{} passed; {} failed; {} filtered out; finished in {:.2f}s",
+                  numPassed, numFailed, numFilteredOut, runElapsed.count());
   if (!summaryStatus.success()) {
     return Err(anyhow::anyhow(summary));
   }

src/Builder/Builder.hpp

@@ -26,7 +26,7 @@ class Builder {
 
   Result<void> schedule(const ScheduleOptions& options = {});
   Result<void> build();
-  Result<void> test();
+  Result<void> test(std::optional<std::string> testName);
   Result<void> run(const std::vector<std::string>& args);
 
   const BuildGraph& graph() const;

src/Cmd/Test.cc

@@ -26,10 +26,13 @@ const Subcmd TEST_CMD = //
         .setDesc("Run the tests of a local package")
         .addOpt(OPT_JOBS)
         .addOpt(Opt{ "--coverage" }.setDesc("Enable code coverage analysis"))
+        .setArg(
+            Arg{ "TESTNAME" }.setRequired(false).setDesc("Test name to launch"))
         .setMainFn(testMain);
 
 static Result<void> testMain(const CliArgsView args) {
   bool enableCoverage = false;
+  std::optional<std::string> testName;
 
   for (auto itr = args.begin(); itr != args.end(); ++itr) {
     const std::string_view arg = *itr;
@@ -54,6 +57,8 @@ static Result<void> testMain(const CliArgsView args) {
       setParallelism(numThreads);
     } else if (arg == "--coverage") {
       enableCoverage = true;
+    } else if (!testName) {
+      testName = arg;
     } else {
       return TEST_CMD.noSuchArg(arg);
     }
@@ -63,7 +68,7 @@ static Result<void> testMain(const CliArgsView args) {
   Builder builder(manifest.path.parent_path(), BuildProfile::Test);
   Try(builder.schedule(ScheduleOptions{ .includeDevDeps = true,
                                         .enableCoverage = enableCoverage }));
-  return builder.test();
+  return builder.test(testName);
 }
 
 } // namespace cabin

tests/test.cc

@@ -5,6 +5,7 @@
 #include <fmt/format.h>
 #include <string>
 #include <utility>
+#include <vector>
 
 static std::size_t countFiles(const tests::fs::path& root,
                               std::string_view extension) {
@@ -20,6 +21,42 @@ static std::size_t countFiles(const tests::fs::path& root,
   return count;
 }
 
+struct TestInfo {
+  std::string projectName;
+  std::vector<std::string> testTargets;
+  bool hasLib = false;
+
+  std::size_t numPassed = 0;
+  std::size_t numFailed = 0;
+  std::size_t numFiltered = 0;
+};
+
+static std::string expectedTestSummary(const TestInfo& testInfo) {
+  std::string summary = "   Analyzing project dependencies...\n";
+  if (testInfo.hasLib) {
+    summary += fmt::format("   Compiling {}(lib) v0.1.0 (<PROJECT>)\n",
+                           testInfo.projectName);
+  }
+  summary += fmt::format(
+      "   Compiling {}(test) v0.1.0 (<PROJECT>)\n"
+      "    Finished `test` profile [unoptimized + debuginfo] target(s) in "
+      "<DURATION>s\n",
+      testInfo.projectName);
+
+  for (std::string_view testTarget : testInfo.testTargets) {
+    summary += fmt::format("     Running unit test src/{0}.cc "
+                           "(cabin-out/test/unit/src/{0}.cc.test)\n",
+                           testTarget);
+  }
+
+  summary += fmt::format(
+      "          Ok {} passed; {} failed; {} filtered out; finished in "
+      "<DURATION>s\n",
+      testInfo.numPassed, testInfo.numFailed, testInfo.numFiltered);
+
+  return summary;
+}
+
 static std::string expectedTestSummary(std::string_view projectName,
                                        bool hasLib) {
   std::string summary = "   Analyzing project dependencies...\n";
@@ -34,7 +71,8 @@ static std::string expectedTestSummary(std::string_view projectName,
       "<DURATION>s\n"
       "     Running unit test src/main.cc "
       "(cabin-out/test/unit/src/main.cc.test)\n"
-      "          Ok 1 passed; 0 failed; finished in <DURATION>s\n";
+      "          Ok 1 passed; 0 failed; 0 filtered out; finished in "
+      "<DURATION>s\n";
   return summary;
 }
 
@@ -55,8 +93,8 @@ int main() {
 void test_addition() {
   int result = 2 + 2;
   if (result != 4) {
-    std::cerr << "Test failed: 2 + 2 = " << result << ", expected 4" << std::endl;
-    std::exit(1);
+    std::cerr << "Test failed: 2 + 2 = " << result << ", expected 4" <<
+    std::endl; std::exit(1);
   }
   std::cout << "test test addition ... ok" << std::endl;
 }
@@ -260,4 +298,139 @@ int main() {
     const auto outDir = project / "cabin-out" / "test" / "unit" / "lib";
     expect(tests::fs::is_regular_file(outDir / "lib_only.cc.test"));
   };
+
+  "cabin test testname filters single test"_test = [] {
+    const tests::TempDir tmp;
+    tests::runCabin({ "new", "testname_project" }, tmp.path).unwrap();
+    const auto project = tmp.path / "testname_project";
+    const auto projectPath = tests::fs::weakly_canonical(project).string();
+
+    tests::writeFile(project / "src/main.cc",
+                     R"(#include <iostream>
+
+#ifdef CABIN_TEST
+void test_function() {
+  std::cout << "main test function ... ok" << std::endl;
+}
+
+int main() {
+  test_function();
+  return 0;
+}
+#else
+int main() {
+  std::cout << "Hello, world!" << std::endl;
+  return 0;
+}
+#endif
+)");
+
+    tests::writeFile(project / "src/Testname.cc",
+                     R"(#include <iostream>
+
+#ifdef CABIN_TEST
+void test_function() {
+  std::cout << "testname test function ... ok" << std::endl;
+}
+
+int main() {
+  test_function();
+  return 0;
+}
+#endif
+)");
+
+    const auto result =
+        tests::runCabin({ "test", "Testname" }, project).unwrap();
+    expect(result.status.success());
+    auto sanitizedOut = tests::sanitizeOutput(
+        result.out, { { projectPath, "<PROJECT>" } }); // NOLINT
+    expect(sanitizedOut == "testname test function ... ok\n");
+    auto sanitizedErr = tests::sanitizeOutput(
+        result.err, { { projectPath, "<PROJECT>" } }); // NOLINT
+
+    expect(sanitizedErr
+           == expectedTestSummary(TestInfo{ .projectName = "testname_project",
+                                            .testTargets = { "Testname" },
+                                            .numPassed = 1,
+                                            .numFailed = 0,
+                                            .numFiltered = 1 }));
+  };
+
+  "cabin test testname filters multiple tests"_test = [] {
+    const tests::TempDir tmp;
+    tests::runCabin({ "new", "testname_project" }, tmp.path).unwrap();
+    const auto project = tmp.path / "testname_project";
+    const auto projectPath = tests::fs::weakly_canonical(project).string();
+
+    tests::writeFile(project / "src/main.cc",
+                     R"(#include <iostream>
+
+#ifdef CABIN_TEST
+void test_function() {
+  std::cout << "main test function ... ok" << std::endl;
+}
+
+int main() {
+  test_function();
+  return 0;
+}
+#else
+int main() {
+  std::cout << "Hello, world!" << std::endl;
+  return 0;
+}
+#endif
+)");
+
+    tests::writeFile(project / "src/TestnameFirst.cc",
+                     R"(#include <iostream>
+
+#ifdef CABIN_TEST
+void test_function() {
+  std::cout << "testname first function ... ok" << std::endl;
+}
+
+int main() {
+  test_function();
+  return 0;
+}
+#endif
+)");
+
+    tests::writeFile(project / "src/TestnameSecond.cc",
+                     R"(#include <iostream>
+
+#ifdef CABIN_TEST
+void test_function() {
+std::cout << "testname second function ... ok" << std::endl;
+}
+
+int main() {
+test_function();
+return 0;
+}
+#endif
+)");
+
+    const auto result =
+        tests::runCabin({ "test", "Testname" }, project).unwrap();
+    expect(result.status.success());
+
+    auto sanitizedOut = tests::sanitizeOutput(
+        result.out, { { projectPath, "<PROJECT>" } }); // NOLINT
+    expect(sanitizedOut
+           == "testname first function ... ok\n"
+              "testname second function ... ok\n");
+
+    auto sanitizedErr = tests::sanitizeOutput(
+        result.err, { { projectPath, "<PROJECT>" } }); // NOLINT
+    expect(sanitizedErr
+           == expectedTestSummary(
+               TestInfo{ .projectName = "testname_project",
+                         .testTargets = { "TestnameFirst", "TestnameSecond" },
+                         .numPassed = 2,
+                         .numFailed = 0,
+                         .numFiltered = 1 }));
+  };
 }