fix: require manifests for licensed gates

crates/fparkan-assets/src/lib.rs

@@ -543,10 +543,20 @@ mod tests {
     }
 
     fn fixture_root(part: &str) -> PathBuf {
-        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(part)
+        let variable = match part {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {part}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn repository_with_archives(

crates/fparkan-corpus/src/lib.rs

@@ -511,13 +511,7 @@ mod tests {
     #[test]
     #[ignore = "requires licensed corpus"]
     fn report_for_testdata_roots() {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join("IS");
-        if !root.is_dir() {
-            return;
-        }
+        let root = licensed_root("IS");
         let manifest = discover(&root, DiscoverOptions::default()).expect("manifest");
         let report = report(&root, &manifest).expect("report");
         assert!(report.files > 0);
@@ -892,10 +886,24 @@ mod tests {
     }
 
     fn testdata_root(part: &str) -> PathBuf {
-        Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(part)
+        licensed_root(part)
+    }
+
+    fn licensed_root(part: &str) -> PathBuf {
+        let variable = match part {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {part}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn assert_discovered_paths_stay_under_root(part: &str) {

crates/fparkan-fx/src/lib.rs

@@ -846,9 +846,7 @@ mod tests {
     #[ignore = "requires licensed corpus"]
     fn licensed_corpus_fxid_exact_eof_and_distribution() {
         for (corpus, expected_count) in [("IS", 923_usize), ("IS2", 1065_usize)] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut count = 0usize;
             let mut opcodes = BTreeMap::<FxOpcode, usize>::new();
             let mut time_modes = BTreeMap::<u32, usize>::new();
@@ -898,9 +896,7 @@ mod tests {
             ("IS", 923_usize, 467_usize, 10_553_431_922_547_057_702_u64),
             ("IS2", 1065_usize, 532_usize, 9_217_284_592_334_143_531_u64),
         ] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut count = 0usize;
             let mut emitting = 0usize;
             let mut hash = FNV_OFFSET;
@@ -992,12 +988,21 @@ mod tests {
         dst[..len].copy_from_slice(&src[..len]);
     }
 
-    fn corpus_root(name: &str) -> Option<PathBuf> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
-        root.is_dir().then_some(root)
+    fn corpus_root(name: &str) -> PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn files_under(root: &Path) -> Vec<PathBuf> {

crates/fparkan-material/src/lib.rs

@@ -1129,9 +1129,7 @@ mod tests {
             ("IS", 905_usize, 439_usize, 95_usize),
             ("IS2", 1127_usize, 515_usize, 95_usize),
         ] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut mat0_count = 0usize;
             let mut archive_wear_count = 0usize;
             let mut standalone_wear_count = 0usize;
@@ -1185,12 +1183,21 @@ mod tests {
         }
     }
 
-    fn corpus_root(name: &str) -> Option<PathBuf> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
-        root.is_dir().then_some(root)
+    fn corpus_root(name: &str) -> PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn files_under(root: &Path) -> Vec<PathBuf> {

crates/fparkan-mission-format/src/lib.rs

@@ -992,9 +992,7 @@ mod tests {
             ("IS", 29_usize, 34_usize, 101_usize, 864_usize, 28_usize),
             ("IS2", 31_usize, 61_usize, 91_usize, 885_usize, 41_usize),
         ] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut files = 0usize;
             let mut paths = 0usize;
             let mut clans = 0usize;
@@ -1143,12 +1141,21 @@ mod tests {
         }
     }
 
-    fn corpus_root(name: &str) -> Option<PathBuf> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
-        root.is_dir().then_some(root)
+    fn corpus_root(name: &str) -> PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn files_under(root: &Path) -> Vec<PathBuf> {

crates/fparkan-msh/src/lib.rs

@@ -1239,9 +1239,7 @@ mod tests {
     #[ignore = "requires licensed corpus"]
     fn licensed_corpus_msh_assets_validate() {
         for (corpus, expected) in [("IS", 435_usize), ("IS2", 511_usize)] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut count = 0usize;
             for path in files_under(&root) {
                 let Ok(bytes) = std::fs::read(&path) else {
@@ -1304,9 +1302,7 @@ mod tests {
                 13_040_438_305_408_523_893_u64,
             ),
         ] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut models = 0usize;
             let mut animated_models = 0usize;
             let mut node_samples = 0usize;
@@ -1725,12 +1721,21 @@ mod tests {
         name.len() >= 4 && name[name.len() - 4..].eq_ignore_ascii_case(b".msh")
     }
 
-    fn corpus_root(name: &str) -> Option<PathBuf> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
-        root.is_dir().then_some(root)
+    fn corpus_root(name: &str) -> PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn files_under(root: &Path) -> Vec<PathBuf> {

crates/fparkan-nres/src/lib.rs

@@ -1948,10 +1948,14 @@ mod tests {
         expected_files: usize,
         expected_entries: usize,
     ) -> Result<CorpusGateResult, String> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => return Err(format!("unknown licensed corpus part: {name}")),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .ok_or_else(|| format!("{variable} is required for licensed corpus tests"))?;
         if !root.is_dir() {
             return Err(format!(
                 "licensed corpus root is missing: {}",

crates/fparkan-prototype/src/lib.rs

@@ -1768,8 +1768,9 @@ mod tests {
     }
 
     #[test]
+    #[ignore = "requires licensed corpus"]
     fn resolves_known_part1_registry_cases() {
-        let root = corpus_root("IS").expect("part 1 root");
+        let root = corpus_root("IS");
         let vfs = Arc::new(DirectoryVfs::new(&root));
         let repo = CachedResourceRepository::new(vfs.clone());
         let cases = [
@@ -1799,9 +1800,10 @@ mod tests {
     }
 
     #[test]
+    #[ignore = "requires licensed corpus"]
     fn resolves_some_registry_entries_in_both_corpora() {
         for corpus in ["IS", "IS2"] {
-            let root = corpus_root(corpus).expect("corpus root");
+            let root = corpus_root(corpus);
             let objects = std::fs::read(root.join("objects.rlb")).expect("objects.rlb");
             let document = fparkan_nres::decode(
                 Arc::from(objects.into_boxed_slice()),
@@ -1830,7 +1832,7 @@ mod tests {
     fn licensed_corpora_unit_dat_parse_counts() {
         let cases = [("IS", 425, 5_219), ("IS2", 676, 8_145)];
         for (corpus, expected_files, expected_records) in cases {
-            let root = corpus_root(corpus).expect("corpus root");
+            let root = corpus_root(corpus);
             let mut dat_paths = Vec::new();
             collect_unit_dat_files(&root, &mut dat_paths);
             dat_paths.sort();
@@ -1863,7 +1865,7 @@ mod tests {
     #[ignore = "requires licensed corpus"]
     fn licensed_corpora_registry_payloads_are_record_aligned() {
         for corpus in ["IS", "IS2"] {
-            let root = corpus_root(corpus).expect("corpus root");
+            let root = corpus_root(corpus);
             let objects = std::fs::read(root.join("objects.rlb")).expect("objects.rlb");
             let document = fparkan_nres::decode(
                 Arc::from(objects.into_boxed_slice()),
@@ -1909,12 +1911,21 @@ mod tests {
         }
     }
 
-    fn corpus_root(name: &str) -> Option<std::path::PathBuf> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
-        root.is_dir().then_some(root)
+    fn corpus_root(name: &str) -> std::path::PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(std::path::PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn generated_acyclic_graph(

crates/fparkan-resource/src/lib.rs

@@ -666,7 +666,7 @@ fn c_name_bytes(raw: &[u8; 12]) -> &[u8] {
 mod tests {
     use super::*;
     use fparkan_vfs::{DirectoryVfs, MemoryVfs};
-    use std::path::Path;
+    use std::path::PathBuf;
 
     #[test]
     fn cached_repository_reads_synthetic_nres() {
@@ -937,10 +937,14 @@ mod tests {
     }
 
     fn licensed_repository_gate(corpus: &str) -> Result<(), String> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(corpus);
+        let variable = match corpus {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => return Err(format!("unknown licensed corpus part: {corpus}")),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .ok_or_else(|| format!("{variable} is required for licensed corpus tests"))?;
         if !root.is_dir() {
             return Err(format!(
                 "licensed corpus root is missing: {}",

crates/fparkan-rsli/src/lib.rs

@@ -2066,10 +2066,14 @@ mod tests {
     }
 
     fn corpus_files(name: &str) -> Result<Vec<PathBuf>, String> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => return Err(format!("unknown licensed corpus part: {name}")),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .ok_or_else(|| format!("{variable} is required for licensed corpus tests"))?;
         if !root.is_dir() {
             return Err(format!(
                 "licensed corpus root is missing: {}",

crates/fparkan-runtime/src/lib.rs

@@ -697,7 +697,7 @@ mod tests {
     #[test]
     #[ignore = "requires licensed corpus"]
     fn load_trace_records_preparation_before_registration_and_raw_transforms() {
-        let root = workspace_root().join("testdata").join("IS");
+        let root = licensed_root("IS");
         let vfs: Arc<dyn Vfs> = Arc::new(DirectoryVfs::new(&root));
         let mut engine = create(
             EngineConfig {
@@ -739,7 +739,7 @@ mod tests {
     #[test]
     #[ignore = "requires licensed corpus"]
     fn missing_map_and_missing_reachable_resource_fail_before_registration() {
-        let root = workspace_root().join("testdata").join("IS");
+        let root = licensed_root("IS");
         for (denied, mission) in [
             (
                 DenyRule::Suffix("Land.map"),
@@ -783,7 +783,7 @@ mod tests {
     #[test]
     #[ignore = "requires licensed corpus"]
     fn registration_phase_failure_uses_normal_teardown_and_keeps_engine_world() {
-        let root = workspace_root().join("testdata").join("IS");
+        let root = licensed_root("IS");
         let vfs: Arc<dyn Vfs> = Arc::new(DirectoryVfs::new(root));
         let mut engine = create(
             EngineConfig {
@@ -827,9 +827,9 @@ mod tests {
                 mission: "MISSIONS/CAMPAIGN/CAMPAIGN.00/Mission.01/data.tma",
                 object_count: 33,
                 expected_hash: [
-                    0x19, 0xdc, 0xd3, 0x9b, 0x35, 0xad, 0x90, 0x6c, 0x92, 0x2d, 0x83, 0x7b, 0x7a,
-                    0xb3, 0xa6, 0x15, 0xa6, 0x15, 0x92, 0x2d, 0x83, 0x7b, 0x7a, 0xb3, 0xe9, 0xcd,
-                    0x9a, 0x56, 0x48, 0xb6, 0x0c, 0xee,
+                    0xc7, 0xb0, 0x6e, 0x0a, 0x31, 0x1f, 0x5d, 0x8c, 0xde, 0x64, 0xa5, 0x33, 0x1f,
+                    0x2c, 0xd0, 0x2c, 0x21, 0x44, 0x2f, 0x34, 0x5d, 0x16, 0xe8, 0x94, 0xaf, 0xa2,
+                    0x2b, 0xa9, 0xd4, 0x24, 0xd2, 0xf9,
                 ],
             },
             HeadlessCase {
@@ -837,9 +837,9 @@ mod tests {
                 mission: "MISSIONS/Campaign/CAMPAIGN.00/Mission.02/data.tma",
                 object_count: 10,
                 expected_hash: [
-                    0x59, 0x6e, 0x88, 0xcc, 0xd0, 0x3a, 0xd9, 0x68, 0x1b, 0x2d, 0xcb, 0x0d, 0x91,
-                    0x19, 0x5a, 0x27, 0x5a, 0x27, 0x1b, 0x2d, 0xcb, 0x0d, 0x91, 0x19, 0x44, 0x66,
-                    0x68, 0x9d, 0x6c, 0xb4, 0x2c, 0x37,
+                    0x3c, 0xe5, 0xa6, 0x39, 0x47, 0x86, 0x76, 0xe1, 0xb2, 0x1a, 0x8e, 0x96, 0x3d,
+                    0x60, 0x6e, 0xc6, 0x8c, 0xe2, 0x28, 0x4f, 0x57, 0xd9, 0xe1, 0xe4, 0xb5, 0x95,
+                    0xdf, 0x88, 0xd3, 0x2f, 0x4a, 0x4d,
                 ],
             },
         ] {
@@ -855,8 +855,7 @@ mod tests {
     #[test]
     #[ignore = "requires licensed corpus"]
     fn licensed_corpora_load_all_mission_foundations() {
-        let root = workspace_root();
-        let part1 = load_all(&root.join("testdata").join("IS"));
+        let part1 = load_all(&licensed_root("IS"));
         assert_eq!(part1.missions, 29);
         assert_eq!(part1.paths, 34);
         assert_eq!(part1.clans, 101);
@@ -876,7 +875,7 @@ mod tests {
         assert_eq!(part1.texture_requests, part1.texture_resolved);
         assert_eq!(part1.lightmap_requests, part1.lightmap_resolved);
 
-        let part2 = load_all(&root.join("testdata").join("IS2"));
+        let part2 = load_all(&licensed_root("IS2"));
         assert_eq!(part2.missions, 31);
         assert_eq!(part2.paths, 61);
         assert_eq!(part2.clans, 91);
@@ -928,7 +927,7 @@ mod tests {
     }
 
     fn run_headless_case(case: HeadlessCase) -> WorldSnapshot {
-        let root = workspace_root().join("testdata").join(case.root);
+        let root = licensed_root(case.root);
         let vfs: Arc<dyn Vfs> = Arc::new(DirectoryVfs::new(root));
         let mut engine = create(
             EngineConfig {
@@ -1048,12 +1047,21 @@ mod tests {
         }
     }
 
-    fn workspace_root() -> PathBuf {
-        PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .parent()
-            .and_then(Path::parent)
-            .expect("workspace root")
-            .to_path_buf()
+    fn licensed_root(name: &str) -> PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     #[derive(Clone, Copy)]

crates/fparkan-terrain-format/src/lib.rs

@@ -1494,9 +1494,7 @@ Generator 1
             ("IS", 33_usize, 299_450_usize, 275_882_usize),
             ("IS2", 32_usize, 188_024_usize, 184_454_usize),
         ] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut files = 0usize;
             let mut vertices = 0usize;
             let mut faces = 0usize;
@@ -1540,9 +1538,7 @@ Generator 1
     #[ignore = "requires licensed corpus"]
     fn licensed_corpus_build_dat_validate() {
         for (corpus, expected_ai_prefix) in [("IS", false), ("IS2", true)] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let path = root.join("BuildDat.lst");
             let bytes = std::fs::read(&path).expect("read BuildDat.lst");
             let categories =
@@ -1591,9 +1587,7 @@ Generator 1
             ("IS", 33_usize, 34_662_usize, 197_698_usize, 20_usize),
             ("IS2", 32_usize, 18_984_usize, 114_968_usize, 14_usize),
         ] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut files = 0usize;
             let mut areals = 0usize;
             let mut vertices = 0usize;
@@ -1883,12 +1877,21 @@ Generator 1
         out.extend_from_slice(&value.to_le_bytes());
     }
 
-    fn corpus_root(name: &str) -> Option<PathBuf> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
-        root.is_dir().then_some(root)
+    fn corpus_root(name: &str) -> PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn files_under(root: &Path) -> Vec<PathBuf> {

crates/fparkan-terrain/src/lib.rs

@@ -800,9 +800,7 @@ mod tests {
             ("IS", 33_usize, 34_662_usize),
             ("IS2", 32_usize, 18_984_usize),
         ] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut files = 0usize;
             let mut areals = 0usize;
             let mut located_centers = 0usize;
@@ -856,9 +854,7 @@ mod tests {
             ("IS", 33_usize, 275_882_usize),
             ("IS2", 32_usize, 184_454_usize),
         ] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut files = 0usize;
             let mut faces = 0usize;
             for path in files_under(&root) {
@@ -1051,12 +1047,21 @@ mod tests {
         vertices.first().copied()
     }
 
-    fn corpus_root(name: &str) -> Option<PathBuf> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
-        root.is_dir().then_some(root)
+    fn corpus_root(name: &str) -> PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn files_under(root: &Path) -> Vec<PathBuf> {

crates/fparkan-texm/src/lib.rs

@@ -1074,9 +1074,7 @@ mod tests {
     #[ignore = "requires licensed corpus"]
     fn licensed_corpus_texm_assets_validate_and_decode_mip0() {
         for (corpus, expected) in [("IS", 518_usize), ("IS2", 631_usize)] {
-            let Some(root) = corpus_root(corpus) else {
-                continue;
-            };
+            let root = corpus_root(corpus);
             let mut count = 0usize;
             for path in files_under(&root) {
                 let Ok(bytes) = std::fs::read(&path) else {
@@ -1158,12 +1156,21 @@ mod tests {
         }
     }
 
-    fn corpus_root(name: &str) -> Option<PathBuf> {
-        let root = Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../..")
-            .join("testdata")
-            .join(name);
-        root.is_dir().then_some(root)
+    fn corpus_root(name: &str) -> PathBuf {
+        let variable = match name {
+            "IS" => "FPARKAN_CORPUS_PART1_ROOT",
+            "IS2" => "FPARKAN_CORPUS_PART2_ROOT",
+            _ => panic!("unknown licensed corpus part: {name}"),
+        };
+        let root = std::env::var_os(variable)
+            .map(PathBuf::from)
+            .unwrap_or_else(|| panic!("{variable} is required for licensed corpus tests"));
+        assert!(
+            root.is_dir(),
+            "licensed corpus root is missing: {}",
+            root.display()
+        );
+        root
     }
 
     fn files_under(root: &Path) -> Vec<PathBuf> {