pbdems2 0.2.2

Game-neutral Source 2 PBDEMS2 demo parsing primitives
Documentation
use crate::error::Error;
use crate::limits::DecodeLimits;
use crate::test_utils::BitWriter;

use super::*;

fn push_raw_entry(writer: &mut BitWriter, string: Option<&str>, user_data: Option<&[u8]>) {
    writer.push_bool(true);
    writer.push_bool(string.is_some());
    if let Some(string) = string {
        writer.push_bool(false);
        writer.push_c_string(string);
    }
    writer.push_bool(user_data.is_some());
    if let Some(user_data) = user_data {
        writer.push_bits(user_data.len() as u64, MAX_USERDATA_BITS);
        writer.push_bytes(user_data);
    }
}

#[test]
fn parses_raw_and_history_strings_with_variable_user_data() {
    let mut writer = BitWriter::default();
    push_raw_entry(&mut writer, Some("alpha"), Some(&[1, 2, 3]));

    writer.push_bool(true);
    writer.push_bool(true);
    writer.push_bool(true);
    writer.push_bits(0, 5);
    writer.push_bits(3, MAX_STRING_BITS);
    writer.push_c_string("ine");
    writer.push_bool(false);

    let mut container = StringTableContainer::new();
    assert!(
        !container
            .handle_create(CreateStringTable::new("names", 2, writer.finish()))
            .expect("valid table")
    );

    let table = container.find_table("names").expect("created table");
    assert_eq!(table.name(), "names");
    assert_eq!(table.entries().len(), 2);
    assert_eq!(table.get(0).unwrap().string.as_deref(), Some("alpha"));
    assert_eq!(
        table.get(0).unwrap().user_data.as_deref(),
        Some(&[1, 2, 3][..])
    );
    assert_eq!(table.get(1).unwrap().string.as_deref(), Some("alpine"));
    assert!(table.get(1).unwrap().user_data.is_none());
    assert_eq!(table.dirty_indices(), &[0, 1]);
    assert!(table.get(2).is_none());
}

#[test]
fn parses_fixed_width_user_data_with_partial_final_byte() {
    let mut writer = BitWriter::default();
    writer.push_bool(true);
    writer.push_bool(false);
    writer.push_bool(true);
    writer.push_bits(0x0cab, 12);

    let mut container = StringTableContainer::new();
    container
        .handle_create(
            CreateStringTable::new("fixed", 1, writer.finish()).with_fixed_user_data(2, 12),
        )
        .expect("valid fixed-width data");

    assert_eq!(
        container
            .find_table("fixed")
            .unwrap()
            .get(0)
            .unwrap()
            .user_data,
        Some(vec![0xab, 0x0c])
    );
}

#[test]
fn decompresses_outer_table_data_and_inner_entry_data() {
    let expected = b"repeated payload repeated payload";
    let compressed_user_data = snap::raw::Encoder::new().compress_vec(expected).unwrap();

    let mut writer = BitWriter::default();
    writer.push_bool(true);
    writer.push_bool(false);
    writer.push_bool(true);
    writer.push_bool(true);
    writer.push_ubitvar(compressed_user_data.len() as u32);
    writer.push_bytes(&compressed_user_data);
    let compressed_table_data = snap::raw::Encoder::new()
        .compress_vec(&writer.finish())
        .unwrap();

    let message = CreateStringTable::new("compressed", 1, compressed_table_data)
        .with_flags(1)
        .with_varint_bitcounts()
        .with_compressed_data();
    let mut container = StringTableContainer::new();
    container
        .handle_create(message)
        .expect("valid compressed data");

    assert_eq!(
        container
            .find_table("compressed")
            .unwrap()
            .get(0)
            .unwrap()
            .user_data
            .as_deref(),
        Some(expected.as_slice())
    );
}

#[test]
fn updates_existing_entries_without_clearing_omitted_fields() {
    let mut create = BitWriter::default();
    push_raw_entry(&mut create, Some("persistent"), Some(&[1]));
    let mut container = StringTableContainer::new();
    container
        .handle_create(CreateStringTable::new("updates", 1, create.finish()))
        .unwrap();
    container.clear_dirty();

    let mut update = BitWriter::default();
    push_raw_entry(&mut update, None, Some(&[9, 8]));
    assert!(
        !container
            .handle_update(UpdateStringTable::new(0, 1, update.finish()))
            .expect("valid update")
    );

    let table = container.find_table("updates").unwrap();
    let entry = table.get(0).unwrap();
    assert_eq!(entry.string.as_deref(), Some("persistent"));
    assert_eq!(entry.user_data.as_deref(), Some(&[9, 8][..]));
    assert_eq!(table.dirty_indices(), &[0]);
}

#[test]
fn explicit_indices_create_gaps() {
    let mut writer = BitWriter::default();
    writer.push_bool(false);
    writer.push_uvarint32(1);
    writer.push_bool(true);
    writer.push_bool(false);
    writer.push_c_string("third");
    writer.push_bool(false);

    let mut container = StringTableContainer::new();
    container
        .handle_create(CreateStringTable::new("sparse", 1, writer.finish()))
        .expect("valid sparse table");

    let table = container.find_table("sparse").unwrap();
    assert_eq!(table.entries().len(), 3);
    assert!(table.get(0).unwrap().string.is_none());
    assert!(table.get(1).unwrap().string.is_none());
    assert_eq!(table.get(2).unwrap().string.as_deref(), Some("third"));
    assert_eq!(table.dirty_indices(), &[2]);
}

#[test]
fn full_updates_extend_tables_and_refresh_instance_baselines() {
    let mut writer = BitWriter::default();
    push_raw_entry(&mut writer, Some("7"), Some(&[1, 2]));
    let mut container = StringTableContainer::new();
    assert!(
        container
            .handle_create(CreateStringTable::new(
                INSTANCE_BASELINE_TABLE_NAME,
                1,
                writer.finish(),
            ))
            .unwrap()
    );
    container.update_instance_baselines();
    assert_eq!(container.instance_baseline(7), Some(&[1, 2][..]));

    container
        .do_full_update([
            (
                INSTANCE_BASELINE_TABLE_NAME.to_owned(),
                vec![
                    StringTableEntry::new(Some("ignored replacement".to_owned()), Some(vec![3])),
                    StringTableEntry::new(Some("8".to_owned()), Some(vec![4, 5])),
                ],
            ),
            (
                "unknown".to_owned(),
                vec![StringTableEntry::new(None, Some(vec![99]))],
            ),
        ])
        .unwrap();
    container.update_instance_baselines();

    let table = container.find_table(INSTANCE_BASELINE_TABLE_NAME).unwrap();
    assert_eq!(table.get(0).unwrap().string.as_deref(), Some("7"));
    assert_eq!(table.get(0).unwrap().user_data.as_deref(), Some(&[3][..]));
    assert_eq!(table.get(1).unwrap().string.as_deref(), Some("8"));
    assert_eq!(container.instance_baseline(7), Some(&[3][..]));
    assert_eq!(container.instance_baseline(8), Some(&[4, 5][..]));
    assert_eq!(table.dirty_indices(), &[0, 0, 1]);

    container.clear_dirty();
    assert!(
        container
            .tables()
            .iter()
            .all(|table| table.dirty_indices().is_empty())
    );
}

#[test]
fn rejects_negative_identifiers_and_counts() {
    let mut container = StringTableContainer::new();
    let create_error = container
        .handle_create(CreateStringTable::new("bad", -1, Vec::new()))
        .expect_err("negative count is invalid");
    assert!(
        matches!(create_error, Error::Parse { context } if context.contains("negative string-table entry count"))
    );

    let update_error = container
        .handle_update(UpdateStringTable::new(-1, 0, Vec::new()))
        .expect_err("negative table ID is invalid");
    assert!(
        matches!(update_error, Error::Parse { context } if context.contains("negative string table ID"))
    );
}

#[test]
fn enforces_table_entry_data_and_snapshot_limits() {
    let entry_limits = DecodeLimits::default().with_max_string_table_entries(0);
    let mut container = StringTableContainer::new();
    let entry_error = container
        .handle_create_with_limits(
            CreateStringTable::new("limited", 1, Vec::new()),
            &entry_limits,
        )
        .expect_err("entry count exceeds limit");
    assert!(matches!(
        entry_error,
        Error::LimitExceeded {
            resource: "string table entries",
            limit: 0,
            actual: 1
        }
    ));

    let data_limits = DecodeLimits::default().with_max_string_table_bytes(0, 0);
    let data_error = container
        .handle_create_with_limits(CreateStringTable::new("limited", 0, vec![0]), &data_limits)
        .expect_err("encoded data exceeds limit");
    assert!(matches!(
        data_error,
        Error::LimitExceeded {
            resource: "string-table data",
            limit: 0,
            actual: 1
        }
    ));

    container
        .handle_create(CreateStringTable::new("snapshot", 0, Vec::new()))
        .unwrap();
    let snapshot_error = container
        .do_full_update_with_limits(
            [(
                "snapshot".to_owned(),
                vec![StringTableEntry::new(None, None)],
            )],
            &entry_limits,
        )
        .expect_err("snapshot exceeds limit");
    assert!(matches!(
        snapshot_error,
        Error::LimitExceeded {
            resource: "full string-table entries",
            limit: 0,
            actual: 1
        }
    ));
}

#[test]
fn rejects_invalid_compressed_payloads_and_oversized_fixed_data() {
    let mut container = StringTableContainer::new();
    let compressed_error = container
        .handle_create(
            CreateStringTable::new("compressed", 0, vec![1, 2, 3]).with_compressed_data(),
        )
        .expect_err("invalid Snappy data");
    assert!(matches!(compressed_error, Error::Decompress(_)));

    let mut writer = BitWriter::default();
    writer.push_bool(true);
    writer.push_bool(false);
    writer.push_bool(true);
    let fixed_error = container
        .handle_create(
            CreateStringTable::new("fixed", 1, writer.finish())
                .with_fixed_user_data((MAX_USERDATA_SIZE + 1) as i32, 8),
        )
        .expect_err("fixed data exceeds parser buffer");
    assert!(matches!(fixed_error, Error::Parse { context } if context.contains("fixed user data")));
}

#[test]
fn rejects_invalid_inner_compression_and_user_data_limit() {
    let mut invalid = BitWriter::default();
    invalid.push_bool(true);
    invalid.push_bool(false);
    invalid.push_bool(true);
    invalid.push_bool(true);
    invalid.push_bits(3, MAX_USERDATA_BITS);
    invalid.push_bytes(&[1, 2, 3]);
    let mut container = StringTableContainer::new();
    let error = container
        .handle_create(CreateStringTable::new("inner", 1, invalid.finish()).with_flags(1))
        .expect_err("invalid inner Snappy payload");
    assert!(matches!(error, Error::Decompress(_)));

    let mut oversized = BitWriter::default();
    push_raw_entry(&mut oversized, None, Some(&[1, 2]));
    let limits = DecodeLimits::default().with_max_string_table_user_data_bytes(1);
    let error = container
        .handle_create_with_limits(
            CreateStringTable::new("limited-data", 1, oversized.finish()),
            &limits,
        )
        .expect_err("entry user data exceeds limit");
    assert!(matches!(
        error,
        Error::LimitExceeded {
            resource: "string-table user data",
            limit: 1,
            actual: 2
        }
    ));
}