qubit-io-binary 0.8.6

Synchronous and asynchronous binary stream I/O adapters for Rust
Documentation
// =============================================================================
//    Copyright (c) 2025 - 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================

use std::io::Cursor;
use std::io::ErrorKind;

use qubit_codec::ByteOrder;
use qubit_io_binary::BinaryReadExt;

macro_rules! assert_read_ordered_integer {
    ($method:ident, $be:ident, $le:ident, $ty:ty, $value:expr) => {{
        let value: $ty = $value;
        let mut input = Cursor::new(value.to_be_bytes());
        assert_eq!(value, input.$method(ByteOrder::BigEndian).expect("runtime BE read"));
        let mut input = Cursor::new(value.to_le_bytes());
        assert_eq!(value, input.$method(ByteOrder::LittleEndian).expect("runtime LE read"));
        let mut input = Cursor::new(value.to_ne_bytes());
        assert_eq!(
            value,
            input.$method(ByteOrder::NativeEndian).expect("runtime native read")
        );
        let mut input = Cursor::new(value.to_be_bytes());
        assert_eq!(value, input.$be().expect("fixed BE read"));
        let mut input = Cursor::new(value.to_le_bytes());
        assert_eq!(value, input.$le().expect("fixed LE read"));
    }};
}

macro_rules! assert_read_ordered_float {
    ($method:ident, $be:ident, $le:ident, $ty:ty, $value:expr) => {{
        let value: $ty = $value;
        let mut input = Cursor::new(value.to_bits().to_be_bytes());
        assert_eq!(
            value.to_bits(),
            input.$method(ByteOrder::BigEndian).expect("runtime BE read").to_bits()
        );
        let mut input = Cursor::new(value.to_bits().to_le_bytes());
        assert_eq!(
            value.to_bits(),
            input
                .$method(ByteOrder::LittleEndian)
                .expect("runtime LE read")
                .to_bits()
        );
        let mut input = Cursor::new(value.to_bits().to_ne_bytes());
        assert_eq!(
            value.to_bits(),
            input
                .$method(ByteOrder::NativeEndian)
                .expect("runtime native read")
                .to_bits()
        );
        let mut input = Cursor::new(value.to_bits().to_be_bytes());
        assert_eq!(value.to_bits(), input.$be().expect("fixed BE read").to_bits());
        let mut input = Cursor::new(value.to_bits().to_le_bytes());
        assert_eq!(value.to_bits(), input.$le().expect("fixed LE read").to_bits());
    }};
}

#[test]
fn test_binary_read_ext_float_bits() {
    for bits in [0x8000_0000_u32, 0x7f80_0000, 0xff80_0000, 0x7fc1_2345, 0xffc5_4321] {
        assert_read_ordered_float!(read_f32, read_f32_be, read_f32_le, f32, f32::from_bits(bits));
    }
    for bits in [
        0x8000_0000_0000_0000_u64,
        0x7ff0_0000_0000_0000,
        0xfff0_0000_0000_0000,
        0x7ff8_1234_5678_9abc,
        0xfff8_abcd_ef01_2345,
    ] {
        assert_read_ordered_float!(read_f64, read_f64_be, read_f64_le, f64, f64::from_bits(bits));
    }
}

#[test]
fn test_binary_read_ext_reads_all_scalar_methods() {
    let mut input = Cursor::new([0x12]);
    assert_eq!(0x12, input.read_u8().expect("u8 should be read"));
    let mut input = Cursor::new([0xfe]);
    assert_eq!(-2, input.read_i8().expect("i8 should be read"));

    assert_read_ordered_integer!(read_u16, read_u16_be, read_u16_le, u16, 0x1234);
    assert_read_ordered_integer!(read_u32, read_u32_be, read_u32_le, u32, 0x1234_5678);
    assert_read_ordered_integer!(read_u64, read_u64_be, read_u64_le, u64, 0x0123_4567_89ab_cdef);
    assert_read_ordered_integer!(
        read_u128,
        read_u128_be,
        read_u128_le,
        u128,
        0x0123_4567_89ab_cdef_fedc_ba98_7654_3210
    );
    assert_read_ordered_integer!(read_i16, read_i16_be, read_i16_le, i16, -0x1234);
    assert_read_ordered_integer!(read_i32, read_i32_be, read_i32_le, i32, -0x0123_4567);
    assert_read_ordered_integer!(read_i64, read_i64_be, read_i64_le, i64, -0x0123_4567_89ab_cdef);
    assert_read_ordered_integer!(
        read_i128,
        read_i128_be,
        read_i128_le,
        i128,
        -0x0123_4567_89ab_cdef_fedc_ba98_7654_3210
    );
    assert_read_ordered_float!(read_f32, read_f32_be, read_f32_le, f32, 12.5);
    assert_read_ordered_float!(read_f64, read_f64_be, read_f64_le, f64, -25.25);
}

#[test]
fn test_binary_read_ext_reports_errors() {
    let mut input = Cursor::new([0x12, 0x34, 0x56]);
    assert_eq!(
        ErrorKind::UnexpectedEof,
        input.read_u32_be().expect_err("truncated u32 should fail").kind()
    );
}