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);
}