feature: add a new ConfigDictValidationTest.cpp to be executed in bazel

Author: frankslin

data/config/BUILD.bazel

@@ -4,3 +4,19 @@ filegroup(
     name = "config",
     srcs = glob(["*.json"]),
 )
+
+cc_test(
+    name = "config_dict_validation_test",
+    srcs = ["ConfigDictValidationTest.cpp"],
+    data = [
+        ":config",
+        "//data/dictionary:binary_dictionaries",
+        "//test/testcases:testcases_json",
+    ],
+    deps = [
+        "//src:simple_converter",
+        "@bazel_tools//tools/cpp/runfiles",
+        "@googletest//:gtest_main",
+        "@rapidjson",
+    ],
+)

data/config/ConfigDictValidationTest.cpp

@@ -0,0 +1,104 @@
+/*
+ * Open Chinese Convert
+ *
+ * End-to-end validation of all configs against consolidated testcases.json.
+ */
+
+#include <fstream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+
+#include "gtest/gtest.h"
+#include "rapidjson/document.h"
+#include "src/SimpleConverter.hpp"
+
+#ifdef BAZEL
+#include "tools/cpp/runfiles/runfiles.h"
+using bazel::tools::cpp::runfiles::Runfiles;
+#endif
+
+namespace opencc {
+namespace {
+
+class ConfigDictValidationTest : public ::testing::Test {
+protected:
+  void SetUp() override {
+#ifdef BAZEL
+    runfiles_.reset(Runfiles::CreateForTest());
+    ASSERT_NE(nullptr, runfiles_);
+    testcasesPath_ = runfiles_->Rlocation("_main/test/testcases/testcases.json");
+    configDir_ = runfiles_->Rlocation("_main/data/config");
+    dictDir_ = runfiles_->Rlocation("_main/data/dictionary");
+#else
+    FAIL() << "This test expects Bazel runfiles.";
+#endif
+  }
+
+  std::string ReadFile(const std::string& path) {
+    std::ifstream ifs(path);
+    EXPECT_TRUE(ifs.is_open()) << path;
+    std::stringstream buffer;
+    buffer << ifs.rdbuf();
+    return buffer.str();
+  }
+
+  SimpleConverter& GetConverter(const std::string& config) {
+    auto it = converters_.find(config);
+    if (it != converters_.end()) {
+      return *it->second;
+    }
+    const std::string configPath = configDir_ + "/" + config + ".json";
+    auto inserted = converters_.emplace(
+        config,
+        std::make_unique<SimpleConverter>(configPath,
+                                          std::vector<std::string>{
+                                              configDir_, dictDir_}));
+    return *inserted.first->second;
+  }
+
+  std::unique_ptr<Runfiles> runfiles_;
+  std::string testcasesPath_;
+  std::string configDir_;
+  std::string dictDir_;
+  std::unordered_map<std::string, std::unique_ptr<SimpleConverter>>
+      converters_;
+};
+
+TEST_F(ConfigDictValidationTest, ConvertExpectedOutputs) {
+  const std::string json = ReadFile(testcasesPath_);
+  rapidjson::Document doc;
+  doc.Parse(json.c_str());
+  ASSERT_FALSE(doc.HasParseError());
+  ASSERT_TRUE(doc.IsObject());
+  ASSERT_TRUE(doc.HasMember("cases"));
+  const auto& cases = doc["cases"];
+  ASSERT_TRUE(cases.IsArray());
+
+  for (auto& testcase : cases.GetArray()) {
+    ASSERT_TRUE(testcase.IsObject());
+    ASSERT_TRUE(testcase.HasMember("input"));
+    ASSERT_TRUE(testcase["input"].IsString());
+    const std::string input = testcase["input"].GetString();
+    const std::string id =
+        testcase.HasMember("id") && testcase["id"].IsString()
+            ? testcase["id"].GetString()
+            : "(unknown id)";
+    ASSERT_TRUE(testcase.HasMember("expected"));
+    const auto& expectedObj = testcase["expected"];
+    ASSERT_TRUE(expectedObj.IsObject());
+    for (auto itr = expectedObj.MemberBegin(); itr != expectedObj.MemberEnd();
+         ++itr) {
+      const std::string config = itr->name.GetString();
+      ASSERT_TRUE(itr->value.IsString());
+      const std::string expected = itr->value.GetString();
+      SimpleConverter& converter = GetConverter(config);
+      EXPECT_EQ(expected, converter.Convert(input))
+          << "config=" << config << " case=" << id;
+    }
+  }
+}
+
+} // namespace
+} // namespace opencc

test/testcases/BUILD.bazel

@@ -4,3 +4,11 @@ filegroup(
     name = "testcases",
     srcs = glob(["*.in"]) + glob(["*.ans"]),
 )
+
+genrule(
+    name = "testcases_json",
+    srcs = glob(["*.in"]) + glob(["*.ans"]),
+    tools = ["gen_testcases_json.py"],
+    outs = ["testcases.json"],
+    cmd = "python3 $(location gen_testcases_json.py) $(SRCS) > $@",
+)

test/testcases/gen_testcases_json.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+Build a consolidated testcases.json from *.in/*.ans pairs.
+
+Usage (Bazel genrule):
+  python3 gen_testcases_json.py <file1> <file2> ... > testcases.json
+
+Input files should include matching *.in and *.ans files. The script will
+combine lines by input text and emit:
+{
+  "cases": [
+    {
+      "id": "case_001",
+      "input": "...",
+      "expected": {
+        "s2t": "...",
+        "t2s": "..."
+      }
+    },
+    ...
+  ]
+}
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from collections import OrderedDict, defaultdict
+from typing import Dict, List
+
+
+def collect_pairs(paths: List[str]) -> Dict[str, Dict[str, str]]:
+  """Collect matching .in/.ans files keyed by basename."""
+  pairs: Dict[str, Dict[str, str]] = defaultdict(dict)
+  for path in paths:
+    base = os.path.basename(path)
+    if base.endswith(".in"):
+      pairs[base[:-3]]["in"] = path
+    elif base.endswith(".ans"):
+      pairs[base[:-4]]["ans"] = path
+  return pairs
+
+
+def load_cases(pairs: Dict[str, Dict[str, str]]) -> OrderedDict:
+  """Load input/expected lines and merge by input string."""
+  case_map: "OrderedDict[str, Dict[str, str]]" = OrderedDict()
+  for cfg in sorted(pairs.keys()):
+    entry = pairs[cfg]
+    if "in" not in entry or "ans" not in entry:
+      continue
+    with open(entry["in"], "r", encoding="utf-8") as fin:
+      inputs = fin.read().splitlines()
+    with open(entry["ans"], "r", encoding="utf-8") as fans:
+      answers = fans.read().splitlines()
+    if len(inputs) != len(answers):
+      raise ValueError(
+          f"Line count mismatch for {entry['in']} ({len(inputs)}) vs "
+          f"{entry['ans']} ({len(answers)})")
+    for text, expected in zip(inputs, answers):
+      if text not in case_map:
+        case_map[text] = {}
+      if cfg in case_map[text] and case_map[text][cfg] != expected:
+        raise ValueError(
+            f"Conflicting expectation for '{text}' in {cfg}: "
+            f"'{case_map[text][cfg]}' vs '{expected}'")
+      case_map[text][cfg] = expected
+  return case_map
+
+
+def main(argv: List[str]) -> int:
+  if len(argv) < 2:
+    print("Usage: gen_testcases_json.py <files...>", file=sys.stderr)
+    return 1
+
+  pairs = collect_pairs(argv[1:])
+  case_map = load_cases(pairs)
+
+  cases = []
+  for idx, (text, expectations) in enumerate(case_map.items(), start=1):
+    cases.append({
+        "id": f"case_{idx:03d}",
+        "input": text,
+        "expected": expectations,
+    })
+
+  json.dump({"cases": cases}, sys.stdout, ensure_ascii=False, indent=2)
+  sys.stdout.write("\n")
+  return 0
+
+
+if __name__ == "__main__":
+  sys.exit(main(sys.argv))