refactor: rename test-error -> test-diag-code

Author: strager

test/CMakeLists.txt

@@ -39,13 +39,13 @@ quick_lint_js_add_executable(
   test-configuration.cpp
   test-crash.cpp
   test-diag-code-list.cpp
+  test-diag-code.cpp
   test-diag-matcher.cpp
   test-diagnostic-formatter.cpp
   test-diagnostic.cpp
   test-document.cpp
   test-emacs-lisp-diag-reporter.cpp
   test-emacs-location.cpp
-  test-error.cpp
   test-event-loop.cpp
   test-file-canonical.cpp
   test-file-path.cpp

test/test-error.cpp renamed to test/test-diag-code.cpp

@@ -9,59 +9,59 @@
 
 namespace quick_lint_js {
 namespace {
-struct error_name_and_code {
+struct diag_name_and_code {
   const char* name;
   const char* code;
 };
-static constexpr error_name_and_code all_errors[] = {
-#define QLJS_DIAG_TYPE(error_name, error_code, severity, struct_body, format) \
-  {.name = #error_name, .code = error_code},
+static constexpr diag_name_and_code all_diags[] = {
+#define QLJS_DIAG_TYPE(diag_name, diag_code, severity, struct_body, format) \
+  {.name = #diag_name, .code = diag_code},
     QLJS_X_DIAG_TYPES
 #undef QLJS_DIAG_TYPE
 };
 
-std::string next_unused_error_code() {
+std::string next_unused_diag_code() {
   for (int i = 1; i <= 9999; ++i) {
     char code[7];
     std::snprintf(code, sizeof(code), "E%04d", i);
     auto existing_it =
-        std::find_if(std::begin(all_errors), std::end(all_errors),
-                     [&](const error_name_and_code& error) {
-                       return std::string_view(error.code) == code;
+        std::find_if(std::begin(all_diags), std::end(all_diags),
+                     [&](const diag_name_and_code& diag) {
+                       return std::string_view(diag.code) == code;
                      });
-    if (existing_it == std::end(all_errors)) {
+    if (existing_it == std::end(all_diags)) {
       return std::string(code);
     }
   }
   QLJS_UNIMPLEMENTED();
 }
 
-TEST(test_error, error_codes_are_unique) {
-  std::unordered_map<std::string, const char*> code_to_error_name;
-  for (const error_name_and_code& error : all_errors) {
-    auto existing_it = code_to_error_name.find(error.code);
-    if (existing_it == code_to_error_name.end()) {
-      code_to_error_name.emplace(error.code, error.name);
+TEST(test_diag_code, diag_codes_are_unique) {
+  std::unordered_map<std::string, const char*> code_to_diag_name;
+  for (const diag_name_and_code& diag : all_diags) {
+    auto existing_it = code_to_diag_name.find(diag.code);
+    if (existing_it == code_to_diag_name.end()) {
+      code_to_diag_name.emplace(diag.code, diag.name);
     } else {
-      ADD_FAILURE() << "error code " << error.code
-                    << " used for multiple errors: " << error.name << ", "
-                    << existing_it->second << "\ntry this unused error code: "
-                    << next_unused_error_code();
+      ADD_FAILURE() << "diag code " << diag.code
+                    << " used for multiple diags: " << diag.name << ", "
+                    << existing_it->second << "\ntry this unused diag code: "
+                    << next_unused_diag_code();
     }
   }
 }
 
-TEST(test_error, error_codes_are_well_formed) {
-  for (const error_name_and_code& error : all_errors) {
+TEST(test_diag_code, diag_codes_are_well_formed) {
+  for (const diag_name_and_code& diag : all_diags) {
 #if defined(_WIN32)
-    constexpr const char* error_pattern = R"(^E\d\d\d\d$)";
+    constexpr const char* code_pattern = R"(^E\d\d\d\d$)";
 #else
-    constexpr const char* error_pattern = R"(^E[0-9][0-9][0-9][0-9]$)";
+    constexpr const char* code_pattern = R"(^E[0-9][0-9][0-9][0-9]$)";
 #endif
     // Wrapping the code in std::string improves gtest diagnostics.
-    EXPECT_THAT(std::string(error.code), ::testing::MatchesRegex(error_pattern))
-        << "error " << error.name << " should have a code like E1234"
-        << "\ntry this unused error code: " << next_unused_error_code();
+    EXPECT_THAT(std::string(diag.code), ::testing::MatchesRegex(code_pattern))
+        << "diag " << diag.name << " should have a code like E1234"
+        << "\ntry this unused diag code: " << next_unused_diag_code();
   }
 }
 }