futures-byteorder 1.0.1

macro_rules! integer_tests {
    (
        $(
            $ty:ty: {
                value: $value:expr,
                be_bytes: $be_bytes:expr,
                le_bytes: $le_bytes:expr,
            }
        ),* $(,)?
    ) => {
        $(
            paste! {
                // Big Endian Read
                #[test]
                fn [<test_read_ $ty _be>]() -> io::Result<()> {
                    let mut data = Cursor::new($be_bytes);
                    let mut reader = AsyncReadBytes::new(&mut data);
                    assert_eq!(block_on(reader.[<read_ $ty>]::<BE>())?, $value);
                    Ok(())
                }

                // Little Endian Read
                #[test]
                fn [<test_read_ $ty _le>]() -> io::Result<()> {
                    let mut data = Cursor::new($le_bytes);
                    let mut reader = AsyncReadBytes::new(&mut data);
                    assert_eq!(block_on(reader.[<read_ $ty>]::<LE>())?, $value);
                    Ok(())
                }

                // Native Endian Read
                #[test]
                fn [<test_read_ $ty _ne>]() -> io::Result<()> {
                    let value: $ty = $value;
                    let bytes = value.to_ne_bytes();
                    let mut data = Cursor::new(bytes);
                    let mut reader = AsyncReadBytes::new(&mut data);
                    assert_eq!(block_on(reader.[<read_ $ty _ne>]())?, value);
                    Ok(())
                }

                // Big Endian Write
                #[test]
                fn [<test_write_ $ty _be>]() -> io::Result<()> {
                    let mut buf = Vec::new();
                    let mut writer = AsyncWriteBytes::new(&mut buf);
                    block_on(writer.[<write_ $ty>]::<BE>($value))?;
                    assert_eq!(buf, $be_bytes);
                    Ok(())
                }

                // Little Endian Write
                #[test]
                fn [<test_write_ $ty _le>]() -> io::Result<()> {
                    let mut buf = Vec::new();
                    let mut writer = AsyncWriteBytes::new(&mut buf);
                    block_on(writer.[<write_ $ty>]::<LE>($value))?;
                    assert_eq!(buf, $le_bytes);
                    Ok(())
                }

                // Native Endian Write
                #[test]
                fn [<test_write_ $ty _ne>]() -> io::Result<()> {
                    let value: $ty = $value;
                    let mut buf = Vec::new();
                    let mut writer = AsyncWriteBytes::new(&mut buf);
                    block_on(writer.[<write_ $ty _ne>](value))?;
                    assert_eq!(buf, value.to_ne_bytes());
                    Ok(())
                }
            }
        )*
    };
}

// Separate macro for floats to avoid float equality warnings
macro_rules! float_tests {
    (
        $(
            $ty:ty: {
                value: $value:expr,
                be_bytes: $be_bytes:expr,
                le_bytes: $le_bytes:expr,
            }
        ),* $(,)?
    ) => {
        $(
            paste! {
                // Big Endian Read - compare byte representation, not float value
                #[test]
                fn [<test_read_ $ty _be>]() -> io::Result<()> {
                    let mut data = Cursor::new($be_bytes);
                    let mut reader = AsyncReadBytes::new(&mut data);
                    let result = block_on(reader.[<read_ $ty>]::<BE>())?;
                    assert_eq!(result.to_bits(), ($value as $ty).to_bits());
                    Ok(())
                }

                // Little Endian Read
                #[test]
                fn [<test_read_ $ty _le>]() -> io::Result<()> {
                    let mut data = Cursor::new($le_bytes);
                    let mut reader = AsyncReadBytes::new(&mut data);
                    let result = block_on(reader.[<read_ $ty>]::<LE>())?;
                    assert_eq!(result.to_bits(), ($value as $ty).to_bits());
                    Ok(())
                }

                // Native Endian Read
                #[test]
                fn [<test_read_ $ty _ne>]() -> io::Result<()> {
                    let value: $ty = $value;
                    let bytes = value.to_ne_bytes();
                    let mut data = Cursor::new(bytes);
                    let mut reader = AsyncReadBytes::new(&mut data);
                    let result = block_on(reader.[<read_ $ty _ne>]())?;
                    assert_eq!(result.to_bits(), value.to_bits());
                    Ok(())
                }

                // Big Endian Write
                #[test]
                fn [<test_write_ $ty _be>]() -> io::Result<()> {
                    let mut buf = Vec::new();
                    let mut writer = AsyncWriteBytes::new(&mut buf);
                    block_on(writer.[<write_ $ty>]::<BE>($value))?;
                    assert_eq!(buf, $be_bytes);
                    Ok(())
                }

                // Little Endian Write
                #[test]
                fn [<test_write_ $ty _le>]() -> io::Result<()> {
                    let mut buf = Vec::new();
                    let mut writer = AsyncWriteBytes::new(&mut buf);
                    block_on(writer.[<write_ $ty>]::<LE>($value))?;
                    assert_eq!(buf, $le_bytes);
                    Ok(())
                }

                // Native Endian Write
                #[test]
                fn [<test_write_ $ty _ne>]() -> io::Result<()> {
                    let value: $ty = $value;
                    let mut buf = Vec::new();
                    let mut writer = AsyncWriteBytes::new(&mut buf);
                    block_on(writer.[<write_ $ty _ne>](value))?;
                    assert_eq!(buf, value.to_ne_bytes());
                    Ok(())
                }
            }
        )*
    };
}