neco-expr 0.2.0

exact expression graphs with certified floating-point approximations
Documentation
use neco_bigint::{BigInt, Dyadic};
use neco_expr::{
    AbsoluteBits, ConsumerId, ExprId, FailureLocation, FailureOperation, MatrixInputMismatchField,
    MatrixInputMismatchPayload, MatrixInputRole, NecoFailure, OwnerId, PrecisionFailurePayload,
    ProvenanceMismatchField, ProvenanceMismatchPayload, ProvenanceRecord, StorageFailurePayload,
    StorageResource, UnsupportedFailurePayload,
};

const STORAGE_GRAPH_ID_EXHAUSTED: &str = r#"StorageFailure { location: FailureLocation { operation: Allocate, consumer: None, expr: None, atom: None, decision: None, matrix_role: None, row: None, column: None }, payload: GraphIdExhausted }"#;
const STORAGE_DUPLICATE_ID: &str = r#"StorageFailure { location: FailureLocation { operation: Allocate, consumer: Some(ConsumerId(3)), expr: None, atom: None, decision: None, matrix_role: None, row: None, column: None }, payload: DuplicateId { resource: ProductEntries, id: 7 } }"#;
const UNSUPPORTED_REQUIRED_OPERATION: &str = r#"UnsupportedRequiredOperation { location: FailureLocation { operation: Read, consumer: None, expr: None, atom: None, decision: None, matrix_role: None, row: None, column: None }, payload: RequiredOperation("resolve-certified-f64") }"#;
const PRECISION_EXHAUSTION: &str = r#"PrecisionExhaustion { location: FailureLocation { operation: Resolve, consumer: None, expr: None, atom: None, decision: None, matrix_role: None, row: None, column: None }, requested: AbsoluteBits(8), payload: EnclosureWidth { actual_width: Dyadic { integer: BigInt { sign: Positive, magnitude: BigUint { limbs: [1] } }, exponent: 0 } } }"#;
const PROVENANCE_MISMATCH: &str = r#"ProvenanceMismatch { location: FailureLocation { operation: Assemble, consumer: Some(ConsumerId(1)), expr: None, atom: None, decision: None, matrix_role: None, row: None, column: None }, payload: ProvenanceMismatchPayload { field: Owner, expected: ProvenanceRecord { owner: Some(OwnerId(1)), consumer_id: Some(ConsumerId(1)), expr_id: Some(ExprId(2)), precision: Some(AbsoluteBits(8)), revision_identity: Some("rev"), public_api_identity: Some("api"), product_identity: None }, actual: ProvenanceRecord { owner: Some(OwnerId(2)), consumer_id: Some(ConsumerId(1)), expr_id: Some(ExprId(2)), precision: Some(AbsoluteBits(8)), revision_identity: Some("rev"), public_api_identity: Some("api"), product_identity: None } } }"#;
const MATRIX_INPUT_MISMATCH: &str = r#"MatrixInputMismatch { location: FailureLocation { operation: Read, consumer: Some(ConsumerId(1)), expr: None, atom: None, decision: None, matrix_role: Some(Stiffness), row: Some(1), column: Some(0) }, payload: MatrixInputMismatchPayload { field: NumericValue, row: Some(1), column: Some(0), expected: ProvenanceRecord { owner: Some(OwnerId(1)), consumer_id: Some(ConsumerId(1)), expr_id: Some(ExprId(2)), precision: Some(AbsoluteBits(8)), revision_identity: Some("rev"), public_api_identity: Some("api"), product_identity: None }, actual: ProvenanceRecord { owner: Some(OwnerId(2)), consumer_id: Some(ConsumerId(1)), expr_id: Some(ExprId(2)), precision: Some(AbsoluteBits(8)), revision_identity: Some("rev"), public_api_identity: Some("api"), product_identity: None }, expected_product: None, actual_product: None, expected_expr: Some(ExprId(3)), actual_expr: Some(ExprId(4)), expected_value_bits: Some(4607182418800017408), actual_value_bits: Some(4611686018427387904) } }"#;

fn provenance(owner: OwnerId) -> ProvenanceRecord {
    ProvenanceRecord::new(
        Some(owner),
        Some(ConsumerId::new(1)),
        Some(ExprId::new(2)),
        Some(AbsoluteBits::new(8)),
        Some("rev"),
        Some("api"),
    )
}

#[test]
fn neco_failure_debug_text_keeps_the_unboxed_form() {
    let cases = [
        (
            NecoFailure::StorageFailure {
                location: FailureLocation::operation(FailureOperation::Allocate),
                payload: Box::new(StorageFailurePayload::GraphIdExhausted),
            },
            STORAGE_GRAPH_ID_EXHAUSTED,
        ),
        (
            NecoFailure::StorageFailure {
                location: FailureLocation::operation(FailureOperation::Allocate)
                    .with_consumer(ConsumerId::new(3)),
                payload: Box::new(StorageFailurePayload::DuplicateId {
                    resource: StorageResource::ProductEntries,
                    id: 7,
                }),
            },
            STORAGE_DUPLICATE_ID,
        ),
        (
            NecoFailure::UnsupportedRequiredOperation {
                location: FailureLocation::operation(FailureOperation::Read),
                payload: Box::new(UnsupportedFailurePayload::RequiredOperation(
                    "resolve-certified-f64",
                )),
            },
            UNSUPPORTED_REQUIRED_OPERATION,
        ),
        (
            NecoFailure::PrecisionExhaustion {
                location: FailureLocation::operation(FailureOperation::Resolve),
                requested: AbsoluteBits::new(8),
                payload: Box::new(PrecisionFailurePayload::EnclosureWidth {
                    actual_width: Dyadic::new(BigInt::try_from(1).unwrap(), 0),
                }),
            },
            PRECISION_EXHAUSTION,
        ),
        (
            NecoFailure::ProvenanceMismatch {
                location: FailureLocation::operation(FailureOperation::Assemble)
                    .with_consumer(ConsumerId::new(1)),
                payload: Box::new(ProvenanceMismatchPayload::new(
                    ProvenanceMismatchField::Owner,
                    provenance(OwnerId::new(1)),
                    provenance(OwnerId::new(2)),
                )),
            },
            PROVENANCE_MISMATCH,
        ),
        (
            NecoFailure::MatrixInputMismatch {
                location: FailureLocation::operation(FailureOperation::Read)
                    .with_consumer(ConsumerId::new(1))
                    .with_matrix_role(MatrixInputRole::Stiffness)
                    .with_matrix_location(1, 0),
                payload: Box::new(
                    MatrixInputMismatchPayload::new(
                        MatrixInputMismatchField::NumericValue,
                        provenance(OwnerId::new(1)),
                        provenance(OwnerId::new(2)),
                    )
                    .with_location(1, 0)
                    .with_expressions(Some(ExprId::new(3)), Some(ExprId::new(4)))
                    .with_value_bits(Some(0x3ff0_0000_0000_0000), Some(0x4000_0000_0000_0000)),
                ),
            },
            MATRIX_INPUT_MISMATCH,
        ),
    ];
    for (failure, expected) in cases {
        assert_eq!(format!("{failure:?}"), expected);
    }
}