qubit-codec-binary 0.9.2

Buffer-oriented binary codecs for Rust
Documentation
// =============================================================================
//    Copyright (c) 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================

use core::num::NonZeroUsize;

use qubit_codec_binary::Leb128DecodeError;
use qubit_codec_binary::Leb128DecodeErrorKind;
use qubit_utils::nonzero;

#[test]
fn test_incomplete_stores_start_error_required_available_and_additional_units() {
    let required = nonzero(3);
    let error = Leb128DecodeError::incomplete(5, required, 2);

    assert_eq!(Leb128DecodeErrorKind::Incomplete, error.kind());
    assert!(error.is_incomplete());
    assert!(!error.is_malformed());
    assert!(!error.is_noncanonical());
    assert_eq!(5, error.start_index());
    assert_eq!(7, error.error_index());
    assert_eq!(None, error.consumed());
    assert_eq!(Some(required), error.required());
    assert_eq!(Some(2), error.available());
    assert_eq!(NonZeroUsize::new(1), error.additional());
    assert_eq!(
        "incomplete LEB128 integer at byte 5: need at least 3 bytes, only 2 available (next byte boundary 7)",
        error.to_string(),
    );
}

#[test]
fn test_incomplete_rejects_satisfied_required_bound() {
    let required = nonzero(2);

    let result = std::panic::catch_unwind(|| Leb128DecodeError::incomplete(5, required, 2));

    assert!(result.is_err());
}

#[test]
fn test_incomplete_rejects_error_boundary_overflow() {
    let required = nonzero(2);

    let result = std::panic::catch_unwind(|| Leb128DecodeError::incomplete(usize::MAX, required, 1));

    assert!(result.is_err());
}

#[test]
fn test_invalid_errors_store_start_error_and_consumed_units() {
    let malformed_consumed = nonzero(4);
    let noncanonical_consumed = nonzero(2);
    let malformed = Leb128DecodeError::malformed(5, 7, malformed_consumed);
    let noncanonical = Leb128DecodeError::noncanonical(9, noncanonical_consumed);

    assert!(malformed.is_malformed());
    assert!(!malformed.is_incomplete());
    assert!(!malformed.is_noncanonical());
    assert!(noncanonical.is_noncanonical());
    assert!(!noncanonical.is_incomplete());
    assert!(!noncanonical.is_malformed());
    assert_eq!(5, malformed.start_index());
    assert_eq!(7, malformed.error_index());
    assert_eq!(9, noncanonical.start_index());
    assert_eq!(10, noncanonical.error_index());
    assert_eq!(Some(malformed_consumed), malformed.consumed());
    assert_eq!(Some(noncanonical_consumed), noncanonical.consumed());
    assert_eq!(None, malformed.required());
    assert_eq!(None, malformed.additional());
    assert_eq!(None, noncanonical.available());
    assert_eq!(
        "malformed LEB128 integer at byte 5: detected at byte 7; consumable byte count: 4",
        malformed.to_string(),
    );
    assert_eq!(
        "non-canonical LEB128 integer at byte 9: detected at byte 10; consumable byte count: 2",
        noncanonical.to_string(),
    );
}

#[test]
fn test_malformed_rejects_error_index_outside_consumed_span() {
    let consumed = nonzero(2);

    let before_start = std::panic::catch_unwind(|| Leb128DecodeError::malformed(5, 4, consumed));
    let after_consumed = std::panic::catch_unwind(|| Leb128DecodeError::malformed(5, 7, consumed));

    assert!(before_start.is_err());
    assert!(after_consumed.is_err());

    let overflow = std::panic::catch_unwind(|| Leb128DecodeError::malformed(usize::MAX, usize::MAX, consumed));
    assert!(overflow.is_err());
}