DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
use super::support::{catalog, document, nameless_fixture, painted, properties_fixture};
use designcraft_compose::Cache;
use designcraft_engine::{Session, cmd::base64_encode};
use designcraft_pdf::{PdfOptions, Standard, export_pdf, export_pdf_with_report};
use serde_json::json;
const CASES: &[&str] = &[
"/OCGs[5 0 R 6 3 R]",
"/OCGs[5 0 R 6 3 R]/D null",
"/OCGs[5 0 R 6 3 R]/D 42",
"/OCGs[5 0 R 6 3 R]/D 99 0 R",
"/OCGs[5 0 R 6 3 R]/D<</BaseState/Unchanged/OFF[6 3 R]>>",
"/OCGs[5 0 R 6 3 R]/D<</BaseState/Other/OFF[6 3 R]>>",
"/OCGs[5 0 R 6 3 R]/D<</BaseState 42/OFF[6 3 R]>>",
"/OCGs[5 0 R 6 3 R]/D<</BaseState/ON/ON 42>>",
"/OCGs[5 0 R 6 3 R]/D<</BaseState/ON/ON[null 5 0 R]>>",
];
fn incomplete_inventory(standard: &str, off: bool) {
let cases: &[&str] = if off {
&["/OCGs[5 0 R]/D<</BaseState/ON/OFF[6 3 R]>>", "/D<</ON[5 0 R]/OFF[6 3 R]>>"]
} else {
&["/OCGs[6 3 R]/D<</BaseState/OFF/ON[5 0 R]>>"]
};
for properties in cases {
let source = properties_fixture(&format!("/OCProperties<<{properties}>>"), "Hidden");
let mut session = Session::new();
session.execute("file.new", &json!({"width": 100, "height": 100, "pages": 1, "facingPages": false, "margins": 0})).unwrap();
session.execute("file.place", &json!({"base64": base64_encode(&source), "name": "incomplete.pdf", "x": 0, "y": 0, "width": 100})).unwrap();
let result = session.execute("file.exportPdf", &json!({"standard": standard})).unwrap();
let bytes = designcraft_engine::cmd::base64_decode(result["base64"].as_str().unwrap());
assert_eq!(catalog(&bytes), [("Hidden".into(), true), ("Shown".into(), false)]);
painted(&bytes, &[true, false]);
super::assert_vector(&bytes);
let warnings = result["warnings"].as_array().unwrap();
assert_eq!(warnings.len(), 1);
let warning = warnings[0].as_str().unwrap();
assert!(warning.contains("incomplete.pdf") && warning.contains("layer list incomplete"), "{warning}");
assert!(!warning.contains("layer state not readable"), "{warning}");
if standard == "x4" {
assert!(designcraft_pdf::check_pdfx4(&bytes).is_empty());
}
}
}
#[test]
fn plain_incomplete_inventory_preserves_off() {
incomplete_inventory("none", true);
}
#[test]
fn pdfx_incomplete_inventory_preserves_off() {
incomplete_inventory("x4", true);
}
#[test]
fn plain_incomplete_inventory_preserves_on() {
incomplete_inventory("none", false);
}
#[test]
fn pdfx_incomplete_inventory_preserves_on() {
incomplete_inventory("x4", false);
}
#[test]
fn incomplete_inventory_reports_both_warnings_during_fallback() {
for standard in [Standard::None, Standard::PdfX4] {
let source = properties_fixture("/OCProperties<</OCGs[5 0 R]/D<</BaseState/Unchanged/OFF[6 3 R]>>>>", "Hidden");
let doc = document(source, &[&[]]);
let report = export_pdf_with_report(&doc, &Cache::new(), &PdfOptions { standard, ..Default::default() }).unwrap();
assert_eq!(report.warnings.len(), 1);
let warning = &report.warnings[0];
assert!(
warning.contains("layers.pdf") && warning.contains("layer list incomplete") && warning.contains("layer state not readable"),
"{warning}"
);
painted(&report.bytes, &[true, true]);
if standard == Standard::PdfX4 {
assert!(designcraft_pdf::check_pdfx4(&report.bytes).is_empty());
}
}
}
fn visible_recovery(source: Vec<u8>, standard: &str) {
let mut session = Session::new();
session.execute("file.new", &json!({"width": 100, "height": 100, "pages": 1, "facingPages": false, "margins": 0})).unwrap();
session.execute("file.place", &json!({"base64": base64_encode(&source), "name": "visible-recovery.pdf", "x": 0, "y": 0, "width": 100})).unwrap();
let result = session.execute("file.exportPdf", &json!({"standard": standard})).unwrap();
let warnings = result["warnings"].as_array().unwrap();
assert_eq!(warnings.len(), 1);
assert!(warnings[0].as_str().unwrap().contains("visible-recovery.pdf"));
let bytes = designcraft_engine::cmd::base64_decode(result["base64"].as_str().unwrap());
let groups = catalog(&bytes);
assert_eq!(groups.len(), 2);
assert!(groups.iter().all(|(name, hidden)| !name.is_empty() && !hidden));
super::assert_vector(&bytes);
painted(&bytes, &[true, true]);
if standard == "x4" {
assert!(designcraft_pdf::check_pdfx4(&bytes).is_empty());
}
}
#[test]
fn plain_export_recovers_malformed_on_when_defaults_are_visible() {
visible_recovery(super::support::fixture("/BaseState/ON/ON 42", "Hidden"), "none");
}
#[test]
fn pdfx_export_recovers_malformed_on_when_defaults_are_visible() {
visible_recovery(super::support::fixture("/BaseState/ON/ON 42", "Hidden"), "x4");
}
#[test]
fn plain_export_names_visible_group_when_display_name_is_missing() {
visible_recovery(nameless_fixture("/BaseState/ON"), "none");
}
#[test]
fn pdfx_export_names_visible_group_when_display_name_is_missing() {
visible_recovery(nameless_fixture("/BaseState/ON"), "x4");
}
#[test]
fn missing_display_name_fails_when_an_override_could_match() {
for standard in [Standard::None, Standard::PdfX4] {
let doc = document(nameless_fixture("/BaseState/ON"), &[&["Shown"]]);
let result = export_pdf(&doc, &Cache::new(), &PdfOptions { standard, ..Default::default() });
assert!(result.is_err(), "a nameless group could match the explicit hidden name");
}
}
#[test]
fn malformed_on_fails_when_base_state_can_hide_groups() {
for standard in [Standard::None, Standard::PdfX4] {
let doc = document(super::support::fixture("/BaseState/OFF/ON 42", "Hidden"), &[&[]]);
let result = export_pdf(&doc, &Cache::new(), &PdfOptions { standard, ..Default::default() });
assert!(result.is_err(), "all-ON recovery would expose groups hidden by BaseState OFF");
}
}
#[test]
fn name_repair_preserves_readable_default_off_state() {
for standard in [Standard::None, Standard::PdfX4] {
let doc = document(nameless_fixture("/BaseState/ON/OFF[6 3 R]"), &[&[]]);
let report = export_pdf_with_report(&doc, &Cache::new(), &PdfOptions { standard, ..Default::default() }).unwrap();
assert_eq!(report.warnings.len(), 1);
assert!(report.warnings[0].contains("layers.pdf"));
assert_eq!(catalog(&report.bytes).iter().filter(|(_, hidden)| *hidden).count(), 1);
painted(&report.bytes, &[true, false]);
if standard == Standard::PdfX4 {
assert!(designcraft_pdf::check_pdfx4(&report.bytes).is_empty());
}
}
}
fn fallback_exports(standard: Standard) {
let mut failures = Vec::new();
for properties in CASES {
let source = properties_fixture(&format!("/OCProperties<<{properties}>>"), "Hidden");
let doc = document(source, &[&[], &["Shown"]]);
let report = match export_pdf_with_report(&doc, &Cache::new(), &PdfOptions { standard, created: Some(0), ..Default::default() }) {
Ok(report) => report,
Err(error) => {
failures.push(format!("{properties}: {error}"));
continue;
}
};
if report.warnings.len() != 1 {
failures.push(format!("{properties}: expected one fallback warning, got {:?}", report.warnings));
continue;
}
assert!(report.warnings[0].contains("layers.pdf"));
assert_eq!(catalog(&report.bytes), [("Hidden".into(), false), ("Hidden".into(), false), ("Shown".into(), false), ("Shown".into(), true)]);
super::assert_vector(&report.bytes);
painted(&report.bytes, &[true, true, false, true]);
if standard == Standard::PdfX4 {
assert!(designcraft_pdf::check_pdfx4(&report.bytes).is_empty());
}
}
assert!(failures.is_empty(), "fallback export failures: {failures:#?}");
}
#[test]
fn plain_fallback_shows_all_layers_and_preserves_frame_overrides() {
fallback_exports(Standard::None);
}
#[test]
fn pdfx_fallback_shows_all_layers_and_preserves_frame_overrides() {
fallback_exports(Standard::PdfX4);
}
#[test]
fn file_export_reports_fallback_with_filename_and_preserves_overrides() {
for properties in CASES {
for standard in ["none", "x4"] {
for hidden in [false, true] {
let source = properties_fixture(&format!("/OCProperties<<{properties}>>"), "Hidden");
let mut session = Session::new();
session.execute("file.new", &json!({"width": 100, "height": 100, "pages": 1, "facingPages": false, "margins": 0})).unwrap();
session
.execute("file.place", &json!({"base64": base64_encode(&source), "name": "fallback.pdf", "x": 0, "y": 0, "width": 100}))
.unwrap();
if hidden {
session.execute("object.layerOptions", &json!({"hidden": ["Shown"]})).unwrap();
}
let result = session.execute("file.exportPdf", &json!({"standard": standard})).unwrap();
let warnings = result["warnings"].as_array().unwrap();
assert_eq!(warnings.len(), 1, "{properties}: {result}");
assert!(warnings[0].as_str().unwrap().contains("fallback.pdf"));
let bytes = designcraft_engine::cmd::base64_decode(result["base64"].as_str().unwrap());
assert_eq!(catalog(&bytes), [("Hidden".into(), false), ("Shown".into(), hidden)]);
painted(&bytes, &[!hidden, true]);
}
}
}
}
#[test]
fn contradictory_and_unresolved_states_fail_even_with_fallback_or_overrides() {
for properties in [
"/OCGs[5 0 R 6 3 R]/D<</ON[6 3 R]/OFF[6 3 R]>>",
"/OCGs[5 0 R]/D<</BaseState/Unchanged/ON[6 3 R]/OFF[6 3 R]>>",
"/OCGs[5 0 R 6 3 R]/D<</BaseState/Unchanged/OFF[99 0 R]>>",
"/OCGs[5 0 R 6 3 R]/D<</ON[99 0 R]>>",
"/OCGs[5 0 R 6 3 R 99 0 R]",
"/OCGs[5 0 R 6 3 R]/D<</OFF[2 0 R]>>",
"/OCGs[5 0 R 6 3 R]/D<</OFF[6 0 R]>>",
"/OCGs[5 0 R 6 3 R]/D<</OFF[null]>>",
"/OCGs[5 0 R 6 3 R]/D<</OFF 42>>",
"/OCGs[5 0 R 6 3 R]/D<</OFF 99 0 R>>",
"/OCGs[5 0 R 6 3 R]/D<</BaseState/ON/ON[null 99 0 R]>>",
"/OCGs[5 0 R 6 3 R]/D<</BaseState/ON/ON 99 0 R>>",
"/OCGs[5 0 R 6 3 R]/D<</BaseState/ON/ON 42/OFF[6 3 R]>>",
] {
for standard in [Standard::None, Standard::PdfX4] {
for hidden in [&[][..], &["Shown"][..]] {
let doc = document(properties_fixture(&format!("/OCProperties<<{properties}>>"), "Hidden"), &[hidden]);
let result = export_pdf(&doc, &Cache::new(), &PdfOptions { standard, ..Default::default() });
assert!(result.is_err(), "unsafe state accepted: {properties}");
}
}
}
}