rustensor 0.1.0

Small Rust-native checkpoint format for model metadata and tensor weights.
Documentation
use rustensor::{MAX_LAYER_COUNT, ModelCheckpoint, ModelMetadata, RustensorError, WeightLayer};

#[test]
fn metadata_stores_optional_fields() {
    let metadata = ModelMetadata::new("demo", "mlp", "0.1.0")
        .unwrap()
        .with_created_by("Elmer Saucedo")
        .with_description("demo checkpoint")
        .insert_extra("framework", "rust-native");

    assert_eq!(metadata.model_name, "demo");
    assert_eq!(metadata.created_by.as_deref(), Some("Elmer Saucedo"));
    assert_eq!(metadata.description.as_deref(), Some("demo checkpoint"));
    assert_eq!(
        metadata.extra.get("framework").map(String::as_str),
        Some("rust-native")
    );
}

#[test]
fn metadata_rejects_empty_model_name() {
    let error = ModelMetadata::new("", "mlp", "0.1.0").unwrap_err();
    assert!(matches!(
        error,
        RustensorError::InvalidMetadata {
            field: "model_name"
        }
    ));
}

#[test]
fn metadata_rejects_empty_architecture() {
    let error = ModelMetadata::new("demo", "", "0.1.0").unwrap_err();
    assert!(matches!(
        error,
        RustensorError::InvalidMetadata {
            field: "architecture"
        }
    ));
}

#[test]
fn metadata_rejects_empty_model_version() {
    let error = ModelMetadata::new("demo", "mlp", "").unwrap_err();
    assert!(matches!(
        error,
        RustensorError::InvalidMetadata {
            field: "model_version"
        }
    ));
}

#[test]
fn creates_valid_f32_layer() {
    let layer = WeightLayer::f32("dense.weight", vec![2, 2], vec![1.0, 2.0, 3.0, 4.0]).unwrap();

    assert_eq!(layer.name, "dense.weight");
    assert_eq!(layer.shape, vec![2, 2]);
}

#[test]
fn rejects_empty_layer_name() {
    let error = WeightLayer::f32("", vec![2], vec![1.0, 2.0]).unwrap_err();
    assert!(matches!(error, RustensorError::InvalidLayerName));
}

#[test]
fn rejects_empty_shape() {
    let error = WeightLayer::f32("scalar", vec![], vec![1.0]).unwrap_err();
    assert!(matches!(error, RustensorError::InvalidTensorShape { .. }));
}

#[test]
fn rejects_zero_dimension() {
    let error = WeightLayer::f32("bad", vec![0, 2], vec![]).unwrap_err();
    assert!(matches!(error, RustensorError::InvalidTensorShape { .. }));
}

#[test]
fn rejects_shape_data_length_mismatch() {
    let error = WeightLayer::f32("bad", vec![2, 2], vec![1.0, 2.0]).unwrap_err();
    assert!(matches!(
        error,
        RustensorError::InvalidTensorDataLength {
            expected: 4,
            found: 2
        }
    ));
}

#[test]
fn rejects_overflowing_shape() {
    let error = WeightLayer::f32("overflow", vec![u64::MAX, 2], vec![]).unwrap_err();
    assert!(matches!(error, RustensorError::InvalidTensorShape { .. }));
}

#[test]
fn rejects_non_finite_f32_values() {
    for value in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
        let error = WeightLayer::f32("bad", vec![1], vec![value]).unwrap_err();
        assert!(matches!(error, RustensorError::InvalidTensorData { .. }));
    }
}

#[test]
fn checkpoint_adds_layers_correctly() {
    let metadata = ModelMetadata::new("demo", "mlp", "0.1.0").unwrap();
    let mut checkpoint = ModelCheckpoint::new(metadata);
    let layer = WeightLayer::f32("dense.weight", vec![2], vec![1.0, 2.0]).unwrap();

    checkpoint.add_layer(layer).unwrap();

    assert_eq!(checkpoint.layers.len(), 1);
}

#[test]
fn checkpoint_rejects_duplicate_layer_names() {
    let metadata = ModelMetadata::new("demo", "mlp", "0.1.0").unwrap();
    let mut checkpoint = ModelCheckpoint::new(metadata);

    let first = WeightLayer::f32("dense.weight", vec![1], vec![1.0]).unwrap();
    let second = WeightLayer::f32("dense.weight", vec![1], vec![2.0]).unwrap();

    checkpoint.add_layer(first).unwrap();
    let error = checkpoint.add_layer(second).unwrap_err();

    assert!(matches!(error, RustensorError::DuplicateLayerName { .. }));
}

#[test]
fn checkpoint_rejects_too_many_layers() {
    let metadata = ModelMetadata::new("demo", "mlp", "0.1.0").unwrap();
    let mut checkpoint = ModelCheckpoint::new(metadata);

    for index in 0..MAX_LAYER_COUNT {
        let layer =
            WeightLayer::f32(format!("layer.{index}"), vec![1], vec![index as f32]).unwrap();
        checkpoint.add_layer(layer).unwrap();
    }

    let extra_layer = WeightLayer::f32("layer.extra", vec![1], vec![1.0]).unwrap();
    let error = checkpoint.add_layer(extra_layer).unwrap_err();

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

#[test]
fn checkpoint_validates_all_layers() {
    let metadata = ModelMetadata::new("demo", "mlp", "0.1.0").unwrap();
    let mut checkpoint = ModelCheckpoint::new(metadata);

    checkpoint
        .add_layer(WeightLayer::f32("dense.weight", vec![2], vec![1.0, 2.0]).unwrap())
        .unwrap();

    checkpoint.validate().unwrap();
}