fop 0.1.1

FOP (Formatting Objects Processor) — Apache FOP-compatible XSL-FO processor in pure Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340

//! Visual regression tests
//!
//! These tests verify that the rendered output stays consistent across code changes.
//! They use AreaTree serialization as a structural snapshot and PDF byte-count bounds
//! as a proxy for rendering consistency.

use super::{process_fo_document, validate_pdf_bytes};

/// A simple one-page document for regression baseline
const BASELINE_FO: &str = r##"<?xml version="1.0" encoding="UTF-8"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
  <fo:layout-master-set>
    <fo:simple-page-master master-name="A4"
      page-width="210mm" page-height="297mm"
      margin-top="20mm" margin-bottom="20mm"
      margin-left="20mm" margin-right="20mm">
      <fo:region-body/>
    </fo:simple-page-master>
  </fo:layout-master-set>
  <fo:page-sequence master-reference="A4">
    <fo:flow flow-name="xsl-region-body">
      <fo:block font-size="12pt" font-family="Helvetica">
        Visual regression test baseline document.
      </fo:block>
      <fo:block font-size="10pt" margin-top="12pt">
        This document is used to detect layout regressions.
        It contains multiple blocks with different properties.
      </fo:block>
      <fo:block font-size="14pt" font-weight="bold" color="#003366" margin-top="20pt">
        Section Heading
      </fo:block>
      <fo:block font-size="10pt" margin-top="6pt">
        Lorem ipsum dolor sit amet, consectetur adipiscing elit.
        Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
      </fo:block>
    </fo:flow>
  </fo:page-sequence>
</fo:root>"##;

#[test]
fn regression_area_tree_structure() {
    use fop_core::FoTreeBuilder;
    use fop_layout::LayoutEngine;
    use std::io::Cursor;

    let fo_tree = FoTreeBuilder::new()
        .parse(Cursor::new(BASELINE_FO.as_bytes()))
        .expect("FO parsing should succeed");

    let area_tree = LayoutEngine::new()
        .layout(&fo_tree)
        .expect("Layout should succeed");

    let serialized = area_tree.serialize();

    // Structural assertions: should have a Page area at root
    assert!(
        serialized.contains("Page"),
        "Area tree must contain a Page area: {}",
        serialized
    );

    // Should have at least one Block area
    assert!(
        serialized.contains("Block"),
        "Area tree must contain Block areas: {}",
        serialized
    );

    // Should have text content
    assert!(
        serialized.contains("Visual regression"),
        "Area tree must contain the first text block"
    );

    // Page geometry: A4 = 595.28 x 841.89 pt (within 1pt tolerance)
    assert!(
        serialized.contains("595.") || serialized.contains("594."),
        "A4 page width should be ~595pt: {}",
        serialized
    );
}

#[test]
fn regression_pdf_output_size() {
    let pdf_bytes = process_fo_document(BASELINE_FO).expect("PDF generation should succeed");

    validate_pdf_bytes(&pdf_bytes);

    // PDF size should be within expected bounds (at least 1KB, less than 1MB)
    assert!(
        pdf_bytes.len() > 1024,
        "PDF should be at least 1KB, got {} bytes",
        pdf_bytes.len()
    );
    assert!(
        pdf_bytes.len() < 1_048_576,
        "PDF should be less than 1MB for this simple document, got {} bytes",
        pdf_bytes.len()
    );
}

#[test]
fn regression_page_count_stable() {
    // A document with two fo:page-sequence elements should produce exactly 2 pages.
    // Each fo:page-sequence maps to one Page area in the area tree.
    let fo_input = r##"<?xml version="1.0" encoding="UTF-8"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
  <fo:layout-master-set>
    <fo:simple-page-master master-name="A4"
      page-width="210mm" page-height="297mm"
      margin-top="20mm" margin-bottom="20mm"
      margin-left="20mm" margin-right="20mm">
      <fo:region-body/>
    </fo:simple-page-master>
  </fo:layout-master-set>
  <fo:page-sequence master-reference="A4">
    <fo:flow flow-name="xsl-region-body">
      <fo:block>Page one content.</fo:block>
    </fo:flow>
  </fo:page-sequence>
  <fo:page-sequence master-reference="A4">
    <fo:flow flow-name="xsl-region-body">
      <fo:block>Page two content.</fo:block>
    </fo:flow>
  </fo:page-sequence>
</fo:root>"##;

    use fop_core::FoTreeBuilder;
    use fop_layout::LayoutEngine;
    use std::io::Cursor;

    let fo_tree = FoTreeBuilder::new()
        .parse(Cursor::new(fo_input.as_bytes()))
        .expect("FO parsing should succeed");

    let area_tree = LayoutEngine::new()
        .layout(&fo_tree)
        .expect("Layout should succeed");

    let serialized = area_tree.serialize();

    // Count occurrences of "Page (" in the serialized output
    let page_count = serialized.matches("Page (").count();
    assert_eq!(
        page_count, 2,
        "Document with two page-sequences should have exactly 2 pages, got: {}",
        page_count
    );
}

#[test]
fn regression_benchmark_rendering_speed() {
    // Measures that a moderately complex document renders within a reasonable time.
    // This is a soft benchmark: it catches catastrophic performance regressions.
    use std::time::Instant;

    // Build a document with 50 paragraphs
    let mut fo_blocks = String::new();
    for i in 0..50 {
        fo_blocks.push_str(&format!(
            "<fo:block font-size=\"10pt\" margin-top=\"6pt\">Paragraph {}: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore.</fo:block>\n",
            i + 1
        ));
    }

    let fo_input = format!(
        r#"<?xml version="1.0" encoding="UTF-8"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
  <fo:layout-master-set>
    <fo:simple-page-master master-name="A4"
      page-width="210mm" page-height="297mm"
      margin-top="20mm" margin-bottom="20mm"
      margin-left="20mm" margin-right="20mm">
      <fo:region-body/>
    </fo:simple-page-master>
  </fo:layout-master-set>
  <fo:page-sequence master-reference="A4">
    <fo:flow flow-name="xsl-region-body">
{}
    </fo:flow>
  </fo:page-sequence>
</fo:root>"#,
        fo_blocks
    );

    let start = Instant::now();

    let pdf_bytes = process_fo_document(&fo_input).expect("PDF generation should succeed");

    let elapsed = start.elapsed();

    // Should render within 5 seconds even on slow CI machines
    assert!(
        elapsed.as_secs() < 5,
        "Rendering 50 paragraphs should complete in under 5s, took {:?}",
        elapsed
    );

    assert!(!pdf_bytes.is_empty(), "PDF output should not be empty");
}

#[test]
fn regression_single_page_count() {
    let fo = super::load_fixture("simple_single_page.fo");
    let pdf =
        super::process_fo_document(&fo).expect("simple_single_page.fo should generate a valid PDF");

    let renderer = fop_pdf_renderer::PdfRenderer::from_bytes(&pdf)
        .expect("PDF should be parseable by fop-pdf-renderer");
    assert_eq!(
        renderer.page_count(),
        1,
        "simple_single_page.fo should produce exactly 1 page"
    );

    super::validate_pdf_bytes(&pdf);
}

#[test]
fn regression_two_page_count() {
    // Two separate page-sequences = 2 pages
    let fo_input = r##"<?xml version="1.0" encoding="UTF-8"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
  <fo:layout-master-set>
    <fo:simple-page-master master-name="A4"
      page-width="210mm" page-height="297mm"
      margin-top="20mm" margin-bottom="20mm"
      margin-left="20mm" margin-right="20mm">
      <fo:region-body/>
    </fo:simple-page-master>
  </fo:layout-master-set>
  <fo:page-sequence master-reference="A4">
    <fo:flow flow-name="xsl-region-body">
      <fo:block>First page.</fo:block>
    </fo:flow>
  </fo:page-sequence>
  <fo:page-sequence master-reference="A4">
    <fo:flow flow-name="xsl-region-body">
      <fo:block>Second page.</fo:block>
    </fo:flow>
  </fo:page-sequence>
</fo:root>"##;

    let pdf =
        process_fo_document(fo_input).expect("Two-page FO document should generate a valid PDF");

    let renderer = fop_pdf_renderer::PdfRenderer::from_bytes(&pdf)
        .expect("PDF should be parseable by fop-pdf-renderer");
    assert_eq!(
        renderer.page_count(),
        2,
        "Two-page FO should produce exactly 2 pages"
    );
}

#[test]
fn regression_all_pages_rasterize() {
    let fo = super::load_fixture("simple_single_page.fo");
    let pdf =
        super::process_fo_document(&fo).expect("simple_single_page.fo should generate a valid PDF");

    let renderer = fop_pdf_renderer::PdfRenderer::from_bytes(&pdf)
        .expect("PDF should be parseable by fop-pdf-renderer");

    let pages = renderer
        .render_all_pages(72.0)
        .expect("All pages should rasterize successfully");

    assert!(
        !pages.is_empty(),
        "PDF should have at least one rasterized page"
    );
    for (i, page_bytes) in pages.iter().enumerate() {
        // Verify each page is a valid PNG (starts with PNG magic bytes)
        assert!(
            page_bytes.len() >= 8,
            "Page {} PNG should have at least 8 bytes",
            i
        );
        assert_eq!(
            &page_bytes[0..8],
            b"\x89PNG\r\n\x1a\n",
            "Page {} should start with PNG magic bytes",
            i
        );
    }

    // Additional assertion the old external tool didn't check: render dimensions
    let page = renderer
        .render_page(0, 72.0)
        .expect("First page should rasterize");
    assert!(
        page.width > 0 && page.height > 0,
        "Rasterized page should have non-zero dimensions: {}x{}",
        page.width,
        page.height
    );
}

#[test]
fn regression_extracted_text_roundtrips() {
    let fo_input = r##"<?xml version="1.0" encoding="UTF-8"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
  <fo:layout-master-set>
    <fo:simple-page-master master-name="A4"
      page-width="210mm" page-height="297mm"
      margin-top="20mm" margin-bottom="20mm"
      margin-left="20mm" margin-right="20mm">
      <fo:region-body/>
    </fo:simple-page-master>
  </fo:layout-master-set>
  <fo:page-sequence master-reference="A4">
    <fo:flow flow-name="xsl-region-body">
      <fo:block font-family="Helvetica" font-size="12pt">EXTRACTABLE TEXT CONTENT</fo:block>
    </fo:flow>
  </fo:page-sequence>
</fo:root>"##;

    let pdf = super::process_fo_document(fo_input)
        .expect("FO with Helvetica text should generate a valid PDF");

    let renderer =
        fop_pdf_renderer::PdfRenderer::from_bytes(&pdf).expect("PDF should be parseable");

    let text = renderer
        .extract_text(0)
        .expect("Text extraction should succeed");

    assert!(
        !text.is_empty(),
        "Extracted text should not be empty — got empty string. \
         Check if Helvetica text is being emitted with ToUnicode CMap."
    );
    assert!(
        text.contains("EXTRACTABLE TEXT CONTENT"),
        "Extracted text should contain 'EXTRACTABLE TEXT CONTENT' but got: {:?}",
        text
    );
}