fix: cover all error branches of validate_variant_aliases for codecov

Refactor validation into a testable `validate_aliases_inner` that accepts
mock data, so every conflict branch (empty alias, canonical-name collision,
problem-alias collision, duplicate variant alias, multi-conflict) is
exercised without depending on inventory state. Also test `variant_label`
with both empty and non-empty variant dimensions.

Patch coverage: 15 uncovered lines → ~2 (the inventory integration test
panic branch, which is inherently unreachable on a healthy codebase).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: GiggleLiu

src/registry/variant.rs

@@ -88,7 +88,6 @@ pub fn find_variant_by_alias(
 /// problem names or problem-level aliases, and empty aliases for manually
 /// constructed [`VariantEntry`] values that bypass `declare_variants!`.
 pub fn validate_variant_aliases() -> Result<(), Vec<String>> {
-    let mut conflicts = Vec::new();
     let mut problem_names: BTreeMap<String, Vec<String>> = BTreeMap::new();
 
     for problem in super::problem_type::problem_types() {
@@ -111,10 +110,26 @@ pub fn validate_variant_aliases() -> Result<(), Vec<String>> {
         }
     }
 
+    let entries: Vec<_> = inventory::iter::<VariantEntry>()
+        .map(|e| (variant_label(e), e.aliases))
+        .collect();
+
+    validate_aliases_inner(&problem_names, &entries)
+}
+
+/// Core validation logic, separated for testability with mock data.
+///
+/// - `problem_names`: lowercase key → list of human-readable sources (canonical names + problem-level aliases).
+/// - `entries`: `(variant_label, aliases_slice)` per variant entry.
+pub fn validate_aliases_inner(
+    problem_names: &BTreeMap<String, Vec<String>>,
+    entries: &[(String, &[&str])],
+) -> Result<(), Vec<String>> {
+    let mut conflicts = Vec::new();
     let mut variant_aliases: BTreeMap<String, Vec<(String, String)>> = BTreeMap::new();
-    for entry in inventory::iter::<VariantEntry> {
-        let target = variant_label(entry);
-        for alias in entry.aliases {
+
+    for (target, aliases) in entries {
+        for alias in *aliases {
             if alias.trim().is_empty() {
                 conflicts.push(format!(
                     "variant-level alias on {target} is empty or whitespace-only"
@@ -159,7 +174,7 @@ pub fn validate_variant_aliases() -> Result<(), Vec<String>> {
     }
 }
 
-fn variant_label(entry: &VariantEntry) -> String {
+pub fn variant_label(entry: &VariantEntry) -> String {
     let variant = entry.variant();
     if variant.is_empty() {
         return entry.name.to_string();

src/unit_tests/registry/variant.rs

@@ -1,8 +1,124 @@
-use crate::registry::variant::validate_variant_aliases;
+use crate::registry::variant::{validate_variant_aliases, variant_label};
+use std::collections::BTreeMap;
 
 #[test]
 fn variant_alias_inventory_is_valid() {
     if let Err(conflicts) = validate_variant_aliases() {
         panic!("variant alias validation failed:\n{}", conflicts.join("\n"));
     }
 }
+
+// --- validate_aliases_inner unit tests ---
+
+use crate::registry::variant::validate_aliases_inner;
+
+fn empty_problem_names() -> BTreeMap<String, Vec<String>> {
+    BTreeMap::new()
+}
+
+#[test]
+fn validate_inner_accepts_valid_aliases() {
+    let entries = vec![
+        ("Foo {k=K3}".to_string(), &["3FOO"][..]),
+        ("Foo {k=K2}".to_string(), &["2FOO"][..]),
+    ];
+    assert!(validate_aliases_inner(&empty_problem_names(), &entries).is_ok());
+}
+
+#[test]
+fn validate_inner_rejects_empty_alias() {
+    let entries = vec![("Foo {k=K3}".to_string(), &[""][..])];
+    let err = validate_aliases_inner(&empty_problem_names(), &entries).unwrap_err();
+    assert_eq!(err.len(), 1);
+    assert!(
+        err[0].contains("empty or whitespace-only"),
+        "expected empty alias error, got: {}",
+        err[0]
+    );
+}
+
+#[test]
+fn validate_inner_rejects_whitespace_only_alias() {
+    let entries = vec![("Foo".to_string(), &["  \t"][..])];
+    let err = validate_aliases_inner(&empty_problem_names(), &entries).unwrap_err();
+    assert!(err[0].contains("empty or whitespace-only"));
+}
+
+#[test]
+fn validate_inner_rejects_collision_with_canonical_name() {
+    let mut names = BTreeMap::new();
+    names
+        .entry("bar".to_string())
+        .or_insert_with(Vec::new)
+        .push("canonical problem name `Bar`".to_string());
+
+    let entries = vec![("Foo {k=K3}".to_string(), &["BAR"][..])];
+    let err = validate_aliases_inner(&names, &entries).unwrap_err();
+    assert_eq!(err.len(), 1);
+    assert!(err[0].contains("conflicts with canonical problem name"));
+}
+
+#[test]
+fn validate_inner_rejects_collision_with_problem_level_alias() {
+    let mut names = BTreeMap::new();
+    names
+        .entry("baz".to_string())
+        .or_insert_with(Vec::new)
+        .push("problem-level alias `BAZ` for `Bazinga`".to_string());
+
+    let entries = vec![("Foo".to_string(), &["baz"][..])];
+    let err = validate_aliases_inner(&names, &entries).unwrap_err();
+    assert_eq!(err.len(), 1);
+    assert!(err[0].contains("conflicts with problem-level alias"));
+}
+
+#[test]
+fn validate_inner_rejects_duplicate_variant_aliases() {
+    let entries = vec![
+        ("Foo {k=K3}".to_string(), &["DUP"][..]),
+        ("Bar {k=K2}".to_string(), &["dup"][..]),
+    ];
+    let err = validate_aliases_inner(&empty_problem_names(), &entries).unwrap_err();
+    assert_eq!(err.len(), 1);
+    assert!(
+        err[0].contains("duplicate variant-level alias"),
+        "expected duplicate error, got: {}",
+        err[0]
+    );
+}
+
+#[test]
+fn validate_inner_reports_multiple_conflicts() {
+    let entries = vec![
+        ("A".to_string(), &[""][..]),
+        ("B".to_string(), &["X"][..]),
+        ("C".to_string(), &["x"][..]),
+    ];
+    let err = validate_aliases_inner(&empty_problem_names(), &entries).unwrap_err();
+    assert_eq!(err.len(), 2, "expected 2 conflicts, got: {err:?}");
+}
+
+// --- variant_label unit tests ---
+
+#[test]
+fn variant_label_bare_problem() {
+    // Find a VariantEntry with no variant dimensions (empty variant list).
+    // QUBO is a standalone problem with no variants.
+    let entry = inventory::iter::<crate::registry::VariantEntry>()
+        .find(|e| e.variant().is_empty())
+        .expect("expected at least one VariantEntry with empty variant");
+    let label = variant_label(entry);
+    assert_eq!(label, entry.name);
+}
+
+#[test]
+fn variant_label_with_variant_dimensions() {
+    let entry = inventory::iter::<crate::registry::VariantEntry>()
+        .find(|e| e.name == "KSatisfiability" && e.aliases.contains(&"3SAT"))
+        .expect("expected KSatisfiability<K3> VariantEntry");
+    let label = variant_label(entry);
+    assert!(
+        label.contains("k=K3"),
+        "expected label to include k=K3, got: {label}"
+    );
+}