unityrs-core 1.0.0

Read and write Unity asset bundles, serialized files and typetrees.
Documentation
use super::*;
use crate::budget::{Reservation, Unbounded};
use crate::codec::{BlockCodec, Decoded, Lz4, Lzma};
use crate::limits::ChargeError;

#[test]
fn every_packer_roundtrips_and_releases_its_charge() {
    let data = b"Bundle payload with a repeated repeated repeated tail.".repeat(1024);
    for codec in [Codec::None, Codec::Lzma, Codec::Lz4, Codec::Lz4Hc] {
        let meter = Meter::unlimited();
        let packed = compress(&data, codec, &meter).unwrap();
        assert!(meter.used() > 0);
        if codec == Codec::None {
            assert_eq!(packed.as_ref(), data);
        } else {
            let mut out =
                DecodeBuf::new(&meter, 0, data.len() as u64, LimitKind::BlockOutput).unwrap();
            let decoder: &dyn BlockCodec = if codec == Codec::Lzma { &Lzma } else { &Lz4 };
            assert_eq!(
                decoder
                    .decode(&packed, u32::try_from(data.len()).unwrap(), &mut out)
                    .unwrap(),
                Decoded::Written
            );
            assert_eq!(out.as_slice(), data);
        }
        drop(packed);
        assert_eq!(meter.used(), 0, "{codec:?}");
    }
}

#[test]
fn chunk_rows_preserve_flags_and_store_only_growing_chunks() {
    let meter = Meter::unlimited();
    let mut data = vec![0; 0x20000];
    data.push(7);
    let result = chunk_based_compress(&data, 0x243, &meter).unwrap();
    assert_eq!(result.blocks.len(), 2);
    let rows = result.blocks.as_slice();
    assert_eq!(rows[0].uncompressed, 0x20000);
    assert_eq!(rows[0].flags, 0x243);
    assert!(rows[0].compressed < rows[0].uncompressed);
    assert_eq!(
        rows[1],
        BlockInfo {
            uncompressed: 1,
            compressed: 1,
            flags: 0x240,
            offset: None,
        }
    );
    assert_eq!(result.data.last(), Some(&7));
    drop(result);
    assert_eq!(meter.used(), 0);
}

#[test]
fn empty_payload_rows_and_unsupported_codecs_follow_the_packer() {
    let meter = Meter::unlimited();
    let stored = chunk_based_compress(&[], 0x240, &meter).unwrap();
    assert_eq!(
        stored.blocks.as_slice(),
        &[BlockInfo {
            uncompressed: 0,
            compressed: 0,
            flags: 0x240,
            offset: None,
        }]
    );
    for flags in [1, 2, 3] {
        let packed = chunk_based_compress(&[], flags, &meter).unwrap();
        assert!(packed.data.is_empty());
        assert!(packed.blocks.is_empty());
    }
    for codec in [Codec::Lzham, Codec::Other(5), Codec::Other(1)] {
        assert_eq!(
            compress(&[], codec, &meter),
            Err(SaveError::UnsupportedCodec(codec))
        );
    }
    assert!(matches!(
        chunk_based_compress(&[], 4, &meter),
        Err(SaveError::UnsupportedCodec(Codec::Lzham))
    ));
}

#[test]
fn refused_encoder_state_returns_all_charges() {
    for codec in [Codec::Lzma, Codec::Lz4, Codec::Lz4Hc] {
        let meter = Meter::new(1024, Arc::new(Unbounded), Reservation::Input);
        assert!(matches!(
            compress(b"payload", codec, &meter),
            Err(SaveError::Charge(ChargeError::Limit(_)))
        ));
        assert_eq!(meter.used(), 0);
    }
}

#[test]
fn refused_work_stops_before_compression_and_releases_state() {
    for codec in [Codec::Lzma, Codec::Lz4, Codec::Lz4Hc] {
        let meter = Meter::with_decode_work(u64::MAX, 3, Arc::new(Unbounded), Reservation::Input);
        assert!(matches!(
            compress(b"payload", codec, &meter),
            Err(SaveError::Charge(ChargeError::Limit(_)))
        ));
        assert_eq!(meter.used(), 0);
    }
}

#[test]
fn hc_state_zeroing_is_charged_as_writer_work() {
    let state_bytes = u64::try_from(unityrs_compress_sys::lz4_state_words().unwrap()).unwrap() * 8;
    let meter = Meter::with_decode_work(
        u64::MAX,
        state_bytes - 1,
        Arc::new(Unbounded),
        Reservation::Input,
    );
    assert!(matches!(
        compress(b"", Codec::Lz4Hc, &meter),
        Err(SaveError::Charge(ChargeError::Limit(_)))
    ));
    assert_eq!(meter.used(), 0);
}