rustensor 0.1.0

Small Rust-native checkpoint format for model metadata and tensor weights.
Documentation
use rustensor::RustensorError;
use rustensor::format::{
    CHECKSUM_RANGE, FLAGS_NONE, FLAGS_RANGE, FORMAT_VERSION, HEADER_SIZE, MAGIC_BYTES, MAGIC_RANGE,
    MAX_PAYLOAD_SIZE, PAYLOAD_LENGTH_RANGE, RtenHeader, VERSION_RANGE,
};

#[test]
fn header_size_is_48_bytes() {
    assert_eq!(HEADER_SIZE, 48);
}

#[test]
fn max_payload_size_is_64_mb() {
    assert_eq!(MAX_PAYLOAD_SIZE, 64 * 1024 * 1024);
}

#[test]
fn header_encode_writes_magic_bytes() {
    let header = RtenHeader::new(16, [1u8; 32]).expect("header should be valid");
    let encoded = header.encode().expect("header should encode");

    assert_eq!(&encoded[MAGIC_RANGE], MAGIC_BYTES.as_slice());
}

#[test]
fn header_encode_writes_supported_version() {
    let header = RtenHeader::new(16, [2u8; 32]).expect("header should be valid");
    let encoded = header.encode().expect("header should encode");

    let version = u16::from_le_bytes(encoded[VERSION_RANGE].try_into().unwrap());

    assert_eq!(version, FORMAT_VERSION);
}

#[test]
fn header_encode_writes_payload_length() {
    let header = RtenHeader::new(1024, [3u8; 32]).expect("header should be valid");
    let encoded = header.encode().expect("header should encode");

    let payload_length = u64::from_le_bytes(encoded[PAYLOAD_LENGTH_RANGE].try_into().unwrap());

    assert_eq!(payload_length, 1024);
}

#[test]
fn header_encode_writes_checksum() {
    let checksum = [9u8; 32];
    let header = RtenHeader::new(16, checksum).expect("header should be valid");
    let encoded = header.encode().expect("header should encode");

    assert_eq!(&encoded[CHECKSUM_RANGE], checksum.as_slice());
}

#[test]
fn header_round_trip() {
    let checksum = [7u8; 32];
    let header = RtenHeader::new(4096, checksum).expect("header should be valid");
    let encoded = header.encode().expect("header should encode");
    let decoded = RtenHeader::decode(&encoded).expect("header should decode");

    assert_eq!(decoded, header);
}

#[test]
fn decode_rejects_short_header() {
    let bytes = [0u8; HEADER_SIZE - 1];
    let error = RtenHeader::decode(&bytes).expect_err("short header must fail");

    assert!(matches!(error, RustensorError::InvalidHeader));
}

#[test]
fn decode_rejects_invalid_magic() {
    let header = RtenHeader::new(16, [1u8; 32]).expect("header should be valid");
    let mut encoded = header.encode().expect("header should encode");

    encoded[0] = b'X';

    let error = RtenHeader::decode(&encoded).expect_err("invalid magic must fail");

    assert!(matches!(error, RustensorError::InvalidMagic));
}

#[test]
fn decode_rejects_unsupported_version() {
    let header = RtenHeader::new(16, [1u8; 32]).expect("header should be valid");
    let mut encoded = header.encode().expect("header should encode");

    encoded[VERSION_RANGE].copy_from_slice(&99u16.to_le_bytes());

    let error = RtenHeader::decode(&encoded).expect_err("unsupported version must fail");

    assert!(matches!(
        error,
        RustensorError::UnsupportedVersion {
            found: 99,
            supported: FORMAT_VERSION
        }
    ));
}

#[test]
fn decode_rejects_non_zero_flags() {
    let header = RtenHeader::new(16, [1u8; 32]).expect("header should be valid");
    let mut encoded = header.encode().expect("header should encode");

    encoded[FLAGS_RANGE].copy_from_slice(&1u16.to_le_bytes());

    let error = RtenHeader::decode(&encoded).expect_err("non-zero flags must fail");

    assert!(matches!(error, RustensorError::InvalidFlags { found: 1 }));
}

#[test]
fn decode_rejects_payload_too_large() {
    let header = RtenHeader::new(16, [1u8; 32]).expect("header should be valid");
    let mut encoded = header.encode().expect("header should encode");

    encoded[PAYLOAD_LENGTH_RANGE].copy_from_slice(&(MAX_PAYLOAD_SIZE + 1).to_le_bytes());

    let error = RtenHeader::decode(&encoded).expect_err("large payload must fail");

    assert!(matches!(
        error,
        RustensorError::PayloadTooLarge {
            found,
            max: MAX_PAYLOAD_SIZE
        } if found == MAX_PAYLOAD_SIZE + 1
    ));
}

#[test]
fn new_rejects_payload_too_large() {
    let error =
        RtenHeader::new(MAX_PAYLOAD_SIZE + 1, [0u8; 32]).expect_err("large payload must fail");

    assert!(matches!(
        error,
        RustensorError::PayloadTooLarge {
            found,
            max: MAX_PAYLOAD_SIZE
        } if found == MAX_PAYLOAD_SIZE + 1
    ));
}

#[test]
fn encode_rejects_non_zero_flags() {
    let header = RtenHeader {
        version: FORMAT_VERSION,
        flags: 1,
        payload_length: 16,
        checksum: [0u8; 32],
    };

    let error = header.encode().expect_err("non-zero flags must fail");

    assert!(matches!(error, RustensorError::InvalidFlags { found: 1 }));
}

#[test]
fn encode_writes_flags_none() {
    let header = RtenHeader::new(16, [1u8; 32]).expect("header should be valid");
    let encoded = header.encode().expect("header should encode");

    let flags = u16::from_le_bytes(encoded[FLAGS_RANGE].try_into().unwrap());

    assert_eq!(flags, FLAGS_NONE);
}