use super::hint_page::PageOffsetHintTable;
use super::hint_shared::SharedObjectHintTable;
use crate::bit_writer::BitWriter;
use crate::pipeline::buffer::Buffer;
use crate::pipeline::count::Count;
use crate::pipeline::flate::{Flate, FlateAction, DEFAULT_OUT_BUFFER_SIZE};
use crate::pipeline::{Pipeline, PipelineResult};
pub struct HintStreamBytes {
pub uncompressed: Vec<u8>,
pub compressed: Vec<u8>,
pub shared_section_offset_in_uncompressed: usize,
pub outline_section_offset_in_uncompressed: Option<usize>,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct OutlineHintTable {
pub first_object: u32,
pub first_object_offset: u32,
pub nobjects: u32,
pub group_length: u32,
}
fn write_bits_checked(
writer: &mut BitWriter<'_>,
value: u64,
slot_bits: usize,
field_name: &str,
) -> crate::Result<()> {
let max = if slot_bits >= 64 {
u64::MAX
} else {
(1u64 << slot_bits) - 1
};
if value > max {
return Err(crate::Error::Unsupported(format!(
"hint stream: {field_name} value {value} does not fit in {slot_bits}-bit Annex F slot \
(max {max}) — file likely exceeds 4 GiB or has a malformed plan"
)));
}
writer.write_bits(value, slot_bits)?;
Ok(())
}
fn encode_page_offset_header(
writer: &mut BitWriter<'_>,
t: &PageOffsetHintTable,
) -> crate::Result<()> {
let h = &t.header;
write_bits_checked(
writer,
h.least_object_count as u64,
32,
"least_object_count",
)?;
write_bits_checked(
writer,
h.location_of_first_page,
32,
"location_of_first_page",
)?;
write_bits_checked(
writer,
h.bits_object_count_delta as u64,
16,
"bits_object_count_delta",
)?;
write_bits_checked(writer, h.least_page_length, 32, "least_page_length")?;
write_bits_checked(
writer,
h.bits_page_length_delta as u64,
16,
"bits_page_length_delta",
)?;
write_bits_checked(writer, h.least_content_offset, 32, "least_content_offset")?;
write_bits_checked(
writer,
h.bits_content_offset_delta as u64,
16,
"bits_content_offset_delta",
)?;
write_bits_checked(writer, h.least_content_length, 32, "least_content_length")?;
write_bits_checked(
writer,
h.bits_content_length_delta as u64,
16,
"bits_content_length_delta",
)?;
write_bits_checked(
writer,
h.bits_shared_object_count as u64,
16,
"bits_shared_object_count",
)?;
write_bits_checked(
writer,
h.bits_shared_object_id as u64,
16,
"bits_shared_object_id",
)?;
write_bits_checked(writer, h.bits_numerator as u64, 16, "bits_numerator")?;
write_bits_checked(writer, h.denominator as u64, 16, "denominator")?;
Ok(())
}
fn encode_page_offset_entries(
writer: &mut BitWriter<'_>,
t: &PageOffsetHintTable,
) -> PipelineResult<()> {
let h = &t.header;
for entry in &t.entries {
writer.write_bits(
entry.object_count_minus_least as u64,
h.bits_object_count_delta as usize,
)?;
}
writer.flush()?;
for entry in &t.entries {
writer.write_bits(
entry.page_length_minus_least,
h.bits_page_length_delta as usize,
)?;
}
writer.flush()?;
for entry in &t.entries {
writer.write_bits(
entry.shared_object_count as u64,
h.bits_shared_object_count as usize,
)?;
}
writer.flush()?;
for entry in &t.entries {
for &id in &entry.shared_object_ids {
writer.write_bits(id as u64, h.bits_shared_object_id as usize)?;
}
}
writer.flush()?;
for entry in &t.entries {
for &num in &entry.shared_object_numerators {
writer.write_bits(num as u64, h.bits_numerator as usize)?;
}
}
writer.flush()?;
for entry in &t.entries {
writer.write_bits(
entry.content_stream_offset,
h.bits_content_offset_delta as usize,
)?;
}
writer.flush()?;
for entry in &t.entries {
writer.write_bits(
entry.content_stream_length,
h.bits_content_length_delta as usize,
)?;
}
writer.flush()?;
Ok(())
}
fn encode_shared_object_header(
writer: &mut BitWriter<'_>,
t: &SharedObjectHintTable,
) -> crate::Result<()> {
let h = &t.header;
write_bits_checked(
writer,
h.first_object_number as u64,
32,
"shared.first_object_number",
)?;
write_bits_checked(writer, h.location, 32, "shared.location")?;
write_bits_checked(
writer,
h.first_page_entries as u64,
32,
"shared.first_page_entries",
)?;
write_bits_checked(
writer,
h.section_entries as u64,
32,
"shared.section_entries",
)?;
write_bits_checked(
writer,
h.bits_group_object_count as u64,
16,
"shared.bits_group_object_count",
)?;
write_bits_checked(writer, h.least_length, 32, "shared.least_length")?;
write_bits_checked(
writer,
h.bits_length_delta as u64,
16,
"shared.bits_length_delta",
)?;
Ok(())
}
fn encode_shared_object_entries(
writer: &mut BitWriter<'_>,
t: &SharedObjectHintTable,
) -> PipelineResult<()> {
let h = &t.header;
for entry in &t.objects {
writer.write_bits(
entry.length_minus_least as u64,
h.bits_length_delta as usize,
)?;
}
writer.flush()?;
for entry in &t.objects {
writer.write_bits(if entry.signature_present { 1 } else { 0 }, 1)?;
if entry.signature_present {
if let Some(sig) = &entry.signature {
for &byte in sig {
writer.write_bits(byte as u64, 8)?;
}
}
}
}
writer.flush()?;
for entry in &t.objects {
writer.write_bits(
entry.nobjects_minus_one as u64,
h.bits_group_object_count as usize,
)?;
}
writer.flush()?;
Ok(())
}
fn encode_page_section(
writer: &mut BitWriter<'_>,
page_offset: &PageOffsetHintTable,
) -> crate::Result<()> {
encode_page_offset_header(writer, page_offset)?;
writer.flush()?;
encode_page_offset_entries(writer, page_offset)?;
writer.flush()?;
Ok(())
}
fn encode_shared_section(
writer: &mut BitWriter<'_>,
shared_object: &SharedObjectHintTable,
) -> crate::Result<()> {
encode_shared_object_header(writer, shared_object)?;
writer.flush()?;
encode_shared_object_entries(writer, shared_object)?;
writer.flush()?;
Ok(())
}
fn encode_outline_section(
writer: &mut BitWriter<'_>,
outline: &OutlineHintTable,
) -> PipelineResult<()> {
writer.write_bits(outline.first_object as u64, 32)?;
writer.write_bits(outline.first_object_offset as u64, 32)?;
writer.write_bits(outline.nobjects as u64, 32)?;
writer.write_bits(outline.group_length as u64, 32)?;
writer.flush()
}
fn checked_hint_offset<T>(count: u64, key: &str) -> crate::Result<T>
where
T: TryFrom<u64>,
{
T::try_from(count).map_err(|_| {
crate::Error::Unsupported(format!(
"hint {key} offset does not fit {}",
std::any::type_name::<T>()
))
})
}
#[cfg(test)]
fn encode_hint_sections_for_test(
tables: &(PageOffsetHintTable, SharedObjectHintTable),
mut terminal: impl Pipeline,
) -> crate::Result<()> {
let mut count = Count::new("count hint stream", &mut terminal);
{
let mut writer = BitWriter::new(&mut count);
encode_page_section(&mut writer, &tables.0)?;
writer.flush()?;
}
{
let mut writer = BitWriter::new(&mut count);
encode_shared_section(&mut writer, &tables.1)?;
writer.flush()?;
}
count.finish()?;
Ok(())
}
pub fn encode_hint_stream(
page_offset: &PageOffsetHintTable,
shared_object: &SharedObjectHintTable,
outline: Option<&OutlineHintTable>,
) -> crate::Result<HintStreamBytes> {
encode_hint_stream_with_out_buffer_size(
page_offset,
shared_object,
outline,
DEFAULT_OUT_BUFFER_SIZE,
)
}
fn encode_hint_stream_with_out_buffer_size(
page_offset: &PageOffsetHintTable,
shared_object: &SharedObjectHintTable,
outline: Option<&OutlineHintTable>,
out_buffer_size: usize,
) -> crate::Result<HintStreamBytes> {
let mut compressed_sink = Buffer::new("compressed hint stream", None);
let uncompressed;
let shared_section_offset;
let outline_section_offset;
{
let mut flate = Flate::new(
"compress hint stream",
&mut compressed_sink,
FlateAction::Deflate,
out_buffer_size,
)?;
let mut raw = Buffer::new("raw hint stream", Some(&mut flate));
{
let mut count = Count::new("count hint stream", &mut raw);
{
let mut writer = BitWriter::new(&mut count);
encode_page_section(&mut writer, page_offset)?;
writer.flush()?;
}
shared_section_offset = checked_hint_offset(count.count(), "/S")?;
{
let mut writer = BitWriter::new(&mut count);
encode_shared_section(&mut writer, shared_object)?;
writer.flush()?;
}
outline_section_offset = if let Some(outline) = outline {
let offset = checked_hint_offset(count.count(), "/O")?;
let mut writer = BitWriter::new(&mut count);
encode_outline_section(&mut writer, outline)?;
writer.flush()?;
Some(offset)
} else {
None
};
count.finish()?;
}
uncompressed = raw.take_buffer()?;
}
let compressed = compressed_sink.take_buffer()?;
Ok(HintStreamBytes {
uncompressed,
compressed,
shared_section_offset_in_uncompressed: shared_section_offset,
outline_section_offset_in_uncompressed: outline_section_offset,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::hint_page::PageOffsetHintTable;
use crate::linearization::hint_shared::{SharedObjectEntry, SharedObjectHintTable};
use crate::linearization::plan::{LinearizationPlan, PageHintEntry, SharedObjectHintEntry};
use crate::linearization::renumber::RenumberMap;
use crate::pipeline::{Pipeline, PipelineError, PipelineResult};
use crate::ObjectRef;
struct FailingSink {
identifier: &'static str,
fail_at_write: Option<usize>,
writes: usize,
fail_finish: bool,
}
impl FailingSink {
fn new(identifier: &'static str) -> Self {
Self {
identifier,
fail_at_write: Some(0),
writes: 0,
fail_finish: false,
}
}
fn at_write(identifier: &'static str, fail_at_write: usize) -> Self {
Self {
identifier,
fail_at_write: Some(fail_at_write),
writes: 0,
fail_finish: false,
}
}
fn at_finish(identifier: &'static str) -> Self {
Self {
identifier,
fail_at_write: None,
writes: 0,
fail_finish: true,
}
}
}
impl Pipeline for FailingSink {
fn identifier(&self) -> &str {
self.identifier
}
fn write(&mut self, _data: &[u8]) -> PipelineResult<()> {
if self.fail_at_write == Some(self.writes) {
return Err(PipelineError::logic(format!(
"{}: write failed",
self.identifier()
)));
}
self.writes += 1;
Ok(())
}
fn finish(&mut self) -> PipelineResult<()> {
if self.fail_finish {
Err(PipelineError::logic(format!(
"{}: finish failed",
self.identifier()
)))
} else {
Ok(())
}
}
}
fn single_page_plan() -> LinearizationPlan {
LinearizationPlan {
part2_objects: vec![
ObjectRef::new(3, 0),
ObjectRef::new(2, 0),
ObjectRef::new(1, 0),
],
total_object_count: 3,
page_hints: vec![PageHintEntry {
page_ref: ObjectRef::new(3, 0),
first_object_index: 0,
object_count: 3,
byte_length: 0,
}],
..Default::default()
}
}
fn minimal_tables() -> (PageOffsetHintTable, SharedObjectHintTable) {
let plan = single_page_plan();
let renumber = RenumberMap::from_plan(&plan);
let page_offset = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let shared_object = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
(page_offset, shared_object)
}
fn nonzero_tables() -> (PageOffsetHintTable, SharedObjectHintTable) {
let (mut page_offset, mut shared_object) = minimal_tables();
page_offset.header.bits_object_count_delta = 8;
page_offset.header.bits_page_length_delta = 8;
page_offset.header.bits_shared_object_count = 8;
page_offset.header.bits_shared_object_id = 8;
page_offset.header.bits_numerator = 8;
page_offset.header.bits_content_offset_delta = 8;
page_offset.header.bits_content_length_delta = 8;
let page = &mut page_offset.entries[0];
page.object_count_minus_least = 1;
page.page_length_minus_least = 1;
page.shared_object_count = 1;
page.shared_object_ids = vec![1];
page.shared_object_numerators = vec![1];
page.content_stream_offset = 1;
page.content_stream_length = 1;
shared_object.header.first_page_entries = 1;
shared_object.header.section_entries = 1;
shared_object.header.bits_group_object_count = 8;
shared_object.header.bits_length_delta = 8;
shared_object.objects = vec![SharedObjectEntry {
length_minus_least: 1,
signature_present: true,
signature: Some([0xA5; 16]),
nobjects_minus_one: 1,
}];
(page_offset, shared_object)
}
#[test]
fn shared_section_emits_qpdf_columns_without_group_preamble() {
let (page_offset, mut shared_object) = minimal_tables();
shared_object.header.first_page_entries = 1;
shared_object.header.section_entries = 1;
shared_object.header.bits_group_object_count = 8;
shared_object.header.bits_length_delta = 8;
shared_object.objects = vec![SharedObjectEntry {
length_minus_least: 0x2a,
signature_present: false,
signature: None,
nobjects_minus_one: 0x3c,
}];
let encoded = encode_hint_stream(&page_offset, &shared_object, None).expect("encode");
let decoded = crate::linearization::show::read_h_shared_object(
&encoded.uncompressed[encoded.shared_section_offset_in_uncompressed..],
)
.expect("decode qpdf-shaped shared section");
let entry = &decoded.entries[0];
assert_eq!(entry.delta_group_length, 0x2a);
assert!(!entry.signature_present);
assert_eq!(entry.nobjects_minus_one, 0x3c);
}
#[test]
fn hint_encoding_maps_pipeline_logic_error_to_qpdf_internal_category() {
let err = encode_hint_sections_for_test(&minimal_tables(), FailingSink::new("hint sink"))
.unwrap_err();
assert!(matches!(
err,
crate::Error::Internal(ref message) if message == "hint sink: write failed"
));
}
#[test]
fn checked_hint_offset_maps_conversion_failure_to_the_target_type() {
let err = checked_hint_offset::<u8>(u64::from(u8::MAX) + 1, "/S").unwrap_err();
assert!(matches!(
err,
crate::Error::Unsupported(ref message)
if message == "hint /S offset does not fit u8"
));
}
#[test]
fn hint_encoding_maps_flate_runtime_error_to_qpdf_system_category() {
let tables = minimal_tables();
let err = encode_hint_stream_with_out_buffer_size(&tables.0, &tables.1, None, 0)
.err()
.expect("zero output buffer must fail");
assert!(matches!(
err,
crate::Error::System(ref message)
if message == "Pl_Flate: output buffer size must be greater than zero"
));
}
#[test]
fn hint_encoding_propagates_page_and_shared_section_write_and_finish_errors() {
let tables = nonzero_tables();
let encoded = encode_hint_stream(&tables.0, &tables.1, None).unwrap();
for fail_at_write in 0..encoded.uncompressed.len() {
let err = encode_hint_sections_for_test(
&tables,
FailingSink::at_write("hint sink", fail_at_write),
)
.unwrap_err();
assert!(matches!(
err,
crate::Error::Internal(ref message) if message == "hint sink: write failed"
));
}
encode_hint_sections_for_test(
&tables,
FailingSink::at_write("hint sink", encoded.uncompressed.len()),
)
.unwrap();
let err = encode_hint_sections_for_test(&tables, FailingSink::at_finish("hint sink"))
.unwrap_err();
assert!(matches!(
err,
crate::Error::Internal(ref message) if message == "hint sink: finish failed"
));
}
fn two_page_plan_with_shared() -> LinearizationPlan {
LinearizationPlan {
part2_objects: vec![ObjectRef::new(3, 0), ObjectRef::new(6, 0)],
part3_objects: vec![ObjectRef::new(5, 0), ObjectRef::new(8, 0)],
part4_other_pages_private: vec![ObjectRef::new(4, 0), ObjectRef::new(7, 0)],
total_object_count: 8,
page_hints: vec![
PageHintEntry {
page_ref: ObjectRef::new(3, 0),
first_object_index: 0,
object_count: 3,
byte_length: 0,
},
PageHintEntry {
page_ref: ObjectRef::new(4, 0),
first_object_index: 0,
object_count: 5,
byte_length: 0,
},
],
shared_hints: vec![
SharedObjectHintEntry {
object_ref: ObjectRef::new(5, 0),
referencing_pages: vec![0, 1],
},
SharedObjectHintEntry {
object_ref: ObjectRef::new(8, 0),
referencing_pages: vec![0, 1],
},
],
..Default::default()
}
}
#[test]
fn single_page_encode_does_not_panic() {
let plan = single_page_plan();
let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let _ = encode_hint_stream(&po, &so, None).expect("encode"); }
#[test]
fn single_page_shared_section_offset_is_positive() {
let plan = single_page_plan();
let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let result = encode_hint_stream(&po, &so, None).expect("encode");
assert!(
result.shared_section_offset_in_uncompressed > 0,
"shared section must start after the page offset section"
);
}
#[test]
fn single_page_compressed_starts_with_zlib_header() {
let plan = single_page_plan();
let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let result = encode_hint_stream(&po, &so, None).expect("encode");
assert!(
result.compressed.len() >= 2,
"compressed output must have at least 2 bytes (zlib header)"
);
assert_eq!(
result.compressed[0], 0x78,
"first byte must be 0x78 (zlib CMF)"
);
assert!(
result.compressed[1] == 0x9C
|| result.compressed[1] == 0xDA
|| result.compressed[1] == 0x01,
"second byte must be a valid zlib FLG (0x9C, 0xDA, or 0x01), got 0x{:02X}",
result.compressed[1]
);
}
#[test]
fn single_page_shared_section_within_uncompressed() {
let plan = single_page_plan();
let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let result = encode_hint_stream(&po, &so, None).expect("encode");
assert!(
result.shared_section_offset_in_uncompressed <= result.uncompressed.len(),
"shared section offset must be within the uncompressed stream"
);
}
#[test]
fn two_page_encode_does_not_panic() {
let plan = two_page_plan_with_shared();
let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let _ = encode_hint_stream(&po, &so, None).expect("encode");
}
#[test]
fn two_page_shared_section_offset_is_positive() {
let plan = two_page_plan_with_shared();
let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let result = encode_hint_stream(&po, &so, None).expect("encode");
assert!(result.shared_section_offset_in_uncompressed > 0);
}
#[test]
fn two_page_compressed_starts_with_zlib_header() {
let plan = two_page_plan_with_shared();
let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let result = encode_hint_stream(&po, &so, None).expect("encode");
assert!(result.compressed.len() >= 2);
assert_eq!(result.compressed[0], 0x78);
}
#[test]
fn two_page_uncompressed_larger_than_single_page() {
let single_plan = single_page_plan();
let renumber_s = RenumberMap::from_plan(&single_plan);
let po_s = PageOffsetHintTable::from_plan(
&single_plan,
&renumber_s,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so_s = SharedObjectHintTable::from_plan(
&single_plan,
&renumber_s,
&Default::default(),
&Default::default(),
&Default::default(),
);
let single_result = encode_hint_stream(&po_s, &so_s, None).expect("encode");
let two_plan = two_page_plan_with_shared();
let renumber_t = RenumberMap::from_plan(&two_plan);
let po_t = PageOffsetHintTable::from_plan(
&two_plan,
&renumber_t,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so_t = SharedObjectHintTable::from_plan(
&two_plan,
&renumber_t,
&Default::default(),
&Default::default(),
&Default::default(),
);
let two_result = encode_hint_stream(&po_t, &so_t, None).expect("encode");
assert!(
two_result.uncompressed.len() > single_result.uncompressed.len(),
"two-page plan with shared objects must produce a larger stream"
);
}
#[test]
fn no_shared_encode_succeeds() {
let plan = single_page_plan(); let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let result = encode_hint_stream(&po, &so, None).expect("encode");
assert!(result.shared_section_offset_in_uncompressed > 0);
assert!(!result.uncompressed.is_empty());
assert!(!result.compressed.is_empty());
}
#[test]
fn page_offset_header_size_is_36_bytes() {
let plan = single_page_plan();
let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let result = encode_hint_stream(&po, &so, None).expect("encode");
assert_eq!(
result.shared_section_offset_in_uncompressed, 36,
"single-page plan with all-zero bit widths: shared section must start at byte 36"
);
}
#[test]
fn shared_object_header_total_size() {
let plan = single_page_plan(); let renumber = RenumberMap::from_plan(&plan);
let po = PageOffsetHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
&Default::default(),
);
let so = SharedObjectHintTable::from_plan(
&plan,
&renumber,
&Default::default(),
&Default::default(),
&Default::default(),
);
let result = encode_hint_stream(&po, &so, None).expect("encode");
assert_eq!(
result.uncompressed.len(),
60,
"single-page no-shared plan: uncompressed stream must be 60 bytes (36 + 24)"
);
}
}