use super::{Composer, FEATURES};
use crate::Error;
fn composer(modules: &[(&str, &'static str)]) -> Composer {
let mut composer = Composer::new();
for (name, source) in modules {
composer.insert(name, source);
}
composer
}
#[test]
fn text_without_directives_passes_through() {
let c = composer(&[("a", "fn f() {}\n indented\n")]);
assert_eq!(
c.compose("a", &[]).as_deref(),
Ok("fn f() {}\n indented\n")
);
}
#[test]
fn an_include_pastes_the_module_in_place() {
let c = composer(&[
("dep", "DEP\n"),
("root", "before\n#include <dep>\nafter\n"),
]);
assert_eq!(
c.compose("root", &[]).as_deref(),
Ok("before\nDEP\nafter\n")
);
}
#[test]
fn a_module_included_twice_appears_once() {
let c = composer(&[
("shared", "SHARED\n"),
("left", "#include <shared>\nLEFT\n"),
("right", "#include <shared>\nRIGHT\n"),
("root", "#include <left>\n#include <right>\n"),
]);
let out = c.compose("root", &[]).expect("composes");
assert_eq!(out.matches("SHARED").count(), 1, "got:\n{out}");
assert!(out.contains("LEFT") && out.contains("RIGHT"));
}
#[test]
fn a_cycle_is_an_error_rather_than_being_absorbed() {
let c = composer(&[("a", "#include <b>\n"), ("b", "#include <a>\n")]);
assert_eq!(
c.compose("a", &[]).err(),
Some(Error::ShaderCircularInclude {
name: String::from("a")
})
);
}
#[test]
fn a_missing_module_is_named() {
let c = composer(&[("root", "#include <absent>\n")]);
assert_eq!(
c.compose("root", &[]).err(),
Some(Error::ShaderModuleMissing {
name: String::from("absent")
})
);
assert_eq!(
c.compose("also_absent", &[]).err(),
Some(Error::ShaderModuleMissing {
name: String::from("also_absent")
})
);
}
#[test]
fn ifdef_and_ifndef_select_opposite_branches() {
let c = composer(&[("root", "#ifdef X\nYES\n#else\nNO\n#endif\n")]);
assert_eq!(c.compose("root", &["X"]).as_deref(), Ok("YES\n"));
assert_eq!(c.compose("root", &[]).as_deref(), Ok("NO\n"));
let c = composer(&[("root", "#ifndef X\nABSENT\n#else\nPRESENT\n#endif\n")]);
assert_eq!(c.compose("root", &["X"]).as_deref(), Ok("PRESENT\n"));
assert_eq!(c.compose("root", &[]).as_deref(), Ok("ABSENT\n"));
}
#[test]
fn regions_nest() {
let source = "#ifdef A\nA1\n#ifdef B\nAB\n#else\nAnotB\n#endif\nA2\n#else\nnotA\n#endif\n";
let c = composer(&[("root", source)]);
assert_eq!(
c.compose("root", &["A", "B"]).as_deref(),
Ok("A1\nAB\nA2\n")
);
assert_eq!(c.compose("root", &["A"]).as_deref(), Ok("A1\nAnotB\nA2\n"));
assert_eq!(c.compose("root", &["B"]).as_deref(), Ok("notA\n"));
assert_eq!(c.compose("root", &[]).as_deref(), Ok("notA\n"));
}
#[test]
fn a_disabled_region_still_tracks_nesting() {
let source = "#ifdef ON\nkept\n#ifdef OFF\ndropped\n#endif\nstill kept\n#endif\ntail\n";
let c = composer(&[("root", source)]);
assert_eq!(
c.compose("root", &["ON"]).as_deref(),
Ok("kept\nstill kept\ntail\n")
);
assert_eq!(c.compose("root", &[]).as_deref(), Ok("tail\n"));
}
#[test]
fn an_include_in_a_dead_branch_is_neither_pasted_nor_consumed() {
let c = composer(&[
("dep", "DEP\n"),
(
"root",
"#ifdef NEVER\n#include <dep>\n#endif\n#include <dep>\n",
),
]);
assert_eq!(c.compose("root", &[]).as_deref(), Ok("DEP\n"));
}
#[test]
fn unbalanced_directives_are_refused_with_a_line_number() {
for (source, line) in [
("a\n#endif\n", 2),
("a\n#else\n", 2),
("#ifdef A\nbody\n", 3),
("#ifdef A\n#else\n#else\n#endif\n", 3),
("#ifdef\n#endif\n", 1),
("#ifdef A B\n#endif\n", 1),
] {
assert_eq!(
composer(&[("root", source)]).compose("root", &[]).err(),
Some(Error::ShaderDirective {
module: String::from("root"),
line
}),
"accepted {source:?}"
);
}
}
#[test]
fn a_malformed_include_is_refused() {
for source in ["#include dep\n", "#include <>\n", "#include <dep\n"] {
assert!(
matches!(
composer(&[("dep", "D\n"), ("root", source)])
.compose("root", &[])
.err(),
Some(Error::ShaderDirective { .. })
),
"accepted {source:?}"
);
}
}
#[test]
fn composition_is_deterministic() {
let c = Composer::with_builtins();
assert_eq!(c.compose("grid", &[]), c.compose("grid", &[]));
assert_eq!(
c.module_names(),
[
"field",
"grid",
"jump_flood",
"marching_cubes",
"mesh_render",
"scan"
]
);
assert_eq!(
c.compose("marching_cubes", &[]),
c.compose("marching_cubes", &[])
);
}
#[test]
fn the_grid_module_declares_what_the_cpu_side_packs() {
let out = Composer::with_builtins()
.compose("grid", &[])
.expect("composes");
for expected in [
"struct GridParams",
"samples: vec4<u32>",
"placement: vec4<f32>",
"fn grid_index",
"fn grid_position",
"fn grid_cells",
"fn grid_contains",
] {
assert!(out.contains(expected), "grid.wgsl is missing `{expected}`");
}
}
#[test]
fn the_grid_module_is_valid_wgsl_on_a_real_device() {
let gpu = crate::headless::shared();
let source = Composer::with_builtins()
.compose("grid", &[])
.expect("composes");
let probe = format!(
"{source}
@group(0) @binding(0) var<uniform> params: GridParams;
@group(0) @binding(1) var<storage, read_write> out: array<f32>;
@compute @workgroup_size(1)
fn main(@builtin(global_invocation_id) id: vec3<u32>) {{
if (!grid_contains(params, id)) {{ return; }}
let p = grid_position(params, id);
let cells = grid_cells(params);
out[grid_index(params, id)] = p.x + p.y + p.z + f32(cells.x + grid_sample_count(params));
}}
"
);
let scope = gpu.device().push_error_scope(wgpu::ErrorFilter::Validation);
let module = gpu
.device()
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("grid.wgsl validation probe"),
source: wgpu::ShaderSource::Wgsl(probe.into()),
});
let error = crate::block_on::block_on(scope.pop());
assert!(error.is_none(), "grid.wgsl failed validation: {error:?}");
drop(module);
}
fn validate(source: &str) -> Result<(), String> {
let module = naga::front::wgsl::parse_str(source)
.map_err(|e| format!("parse: {}", e.emit_to_string(source)))?;
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.map(|_| ())
.map_err(|e| format!("validate: {e:?}"))
}
#[test]
fn the_variant_sweep_is_the_full_cross_product() {
let c = composer(&[("a", "A\n"), ("b", "B\n")]);
assert_eq!(c.variants(&[]).len(), 2, "two modules, no features");
let variants = c.variants(&["X", "Y"]);
assert_eq!(variants.len(), 2 * 4, "two modules x 2^2 subsets");
let for_a: Vec<Vec<&str>> = variants
.iter()
.filter(|(m, _)| *m == "a")
.map(|(_, d)| d.clone())
.collect();
assert_eq!(
for_a,
vec![vec![], vec!["X"], vec!["Y"], vec!["X", "Y"]],
"subsets must be ascending bitmask order"
);
assert_eq!(c.variants(&["X", "Y"]), c.variants(&["X", "Y"]));
}
#[test]
fn every_shader_permutation_validates() {
let composer = Composer::with_builtins();
let variants = composer.variants(FEATURES);
assert_eq!(
variants.len(),
composer.module_names().len() * (1usize << FEATURES.len()),
"the sweep is not the full cross product"
);
assert!(!variants.is_empty(), "the sweep covered nothing");
let mut failures = Vec::new();
for (module, defines) in &variants {
match composer.compose(module, defines) {
Ok(source) => {
if let Err(why) = validate(&source) {
failures.push(format!("{module} {defines:?}: {why}"));
}
}
Err(why) => failures.push(format!("{module} {defines:?}: compose: {why}")),
}
}
assert!(
failures.is_empty(),
"{} of {} variants failed:\n{}",
failures.len(),
variants.len(),
failures.join("\n")
);
}
#[test]
fn the_validator_rejects_invalid_wgsl() {
assert!(validate("fn f() -> f32 { return 1.0; }\n").is_ok());
assert!(
validate("fn f() -> f32 { return no_such_thing(); }\n").is_err(),
"the validator accepted a call to an undeclared function"
);
assert!(
validate("this is not wgsl\n").is_err(),
"the validator accepted prose"
);
}