caj2pdf-core 0.8.1

Platform-neutral CAJ-family conversion core
Documentation 
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

// SPDX-License-Identifier: MIT

use super::native_document::{hnb_fixture, native_text, roles};
use super::*;
use crate::test_support::page_image;

// A parser that repeatedly reads without advancing must fail the test itself,
// rather than returning an I/O error that could masquerade as a valid rejection.
struct BudgetSource {
    source: Source,
    remaining: usize,
}

impl BudgetSource {
    fn new(bytes: Vec<u8>) -> Self {
        let mut source = Source::new(bytes);
        source.short = 3;
        Self {
            source,
            remaining: 4096,
        }
    }
}

impl RangedSource for BudgetSource {
    fn size(&self) -> u64 {
        self.source.size()
    }

    fn read_at(&mut self, offset: u64, bytes: &mut [u8]) -> crate::Result<usize> {
        assert!(
            self.remaining > 0,
            "conversion exhausted its finite read budget"
        );
        self.remaining -= 1;
        self.source.read_at(offset, bytes)
    }
}

fn paired_raw(records: &[Record]) -> Vec<u8> {
    let mut bytes = vec![3, 0x80, 100, 0, 3, 0x80, 200, 0];
    bytes.extend(image_records(records));
    bytes
}

#[test]
fn admitted_framing_rejects_late_mutations_with_bounded_read_progress() {
    // Each case has a positive control through the same public entry point,
    // limits and short-I/O adapters as its one-field negative mutations.
    for profile in 0..5 {
        for mutation in 0..5 {
            let pages = vec![vec![Record::jpeg(3, 2, 120, 20, 40)]; 2];
            let mut fixture = match profile {
                0 => fixture_with_text(Variant::HnA, &pages, paired_raw),
                1 => fixture_with_text(Variant::HnA, &pages, text),
                2 => hnb_fixture(12, 2),
                3 => hnb_fixture(20, 2),
                _ => fixture_with_text(Variant::C8, &pages, native_text),
            };
            let row = fixture.index + if profile == 2 { 12 } else { 20 };
            let length = u32::from_le_bytes(fixture.bytes[row + 4..row + 8].try_into().unwrap());
            match mutation {
                1 => fixture.bytes[row + 4..row + 8].copy_from_slice(&u32::MAX.to_le_bytes()),
                2 => fixture.bytes[row + 4..row + 8].copy_from_slice(&1_u32.to_le_bytes()),
                // Removes part of the raw end or compressed trailer from the
                // indexed span, without permitting reads into the next section.
                3 => fixture.bytes[row + 4..row + 8].copy_from_slice(&(length - 1).to_le_bytes()),
                _ => (),
            }
            let mut source = BudgetSource::new(fixture.bytes);
            if mutation == 4 {
                source.source.fault_at = Some((fixture.text_offsets[1] as u64, Fault::Zero));
            }
            let mut fonts = [C8FontSource {
                source: BudgetSource::new(crate::pdf::drawing_font()),
                face: 0,
            }];
            let mut sink = Sink {
                short: Some(7),
                ..Default::default()
            };
            let limits = Limits {
                io_chunk_bytes: 64,
                ..Default::default()
            };
            let result = if profile < 2 {
                convert_source_pages_pdf(
                    &mut source,
                    &mut sink,
                    None,
                    &mut Visitor::default(),
                    ComposeOptions::default(),
                    &limits,
                    &NeverCancel,
                )
            } else {
                convert_c8_native_pdf(
                    &mut source,
                    &mut sink,
                    C8FontSources {
                        embedding: Default::default(),
                        glyph_aliases: &[],
                        sources: &mut fonts,
                        roles: roles(),
                        symbol_glyphs: &[],
                        symbol_font: None,
                        decoration_glyphs: &[],
                        decoration_font: None,
                    },
                    None,
                    ComposeOptions::default(),
                    &limits,
                    &NeverCancel,
                )
            };
            if mutation == 0 {
                assert_eq!(result.unwrap().output_pages, 2, "profile {profile}");
                assert!(sink.bytes.ends_with(b"%%EOF\n"));
            } else {
                let error = result.unwrap_err();
                assert_eq!(
                    page_image(&error).0,
                    Some(2),
                    "profile {profile}, mutation {mutation}: {error}"
                );
                assert!(!sink.bytes.ends_with(b"%%EOF\n"));
                assert!(
                    contains(&sink.bytes, b"/Type /Page /Parent "),
                    "first page was not emitted"
                );
            }
            assert!(source.source.max_request <= 64);
            assert!(fonts[0].source.source.max_request <= 64);
            assert!(sink.max_request <= 64);
        }
    }
}