libadb 0.7.0

Low-level ADB protocol library for direct TCP and USB communication
Documentation
extern crate std;

use alloc::vec;
use alloc::vec::Vec;

use super::decoder::make_frame;
use super::{
    encode_window_size, parse_header, Frame, FrameDecoder, CLOSE_STDIN, EXIT, HEADER_SIZE, STDERR,
    STDIN, STDOUT, WINDOW_SIZE_CHANGE,
};

fn write_header(rx: &mut [u8], offset: usize, id: u8, length: u32) {
    rx[offset] = id;
    rx[offset + 1..offset + 5].copy_from_slice(&length.to_le_bytes());
}

#[test]
fn parse_header_decodes_id_and_little_endian_length() {
    let buf = [STDOUT, 0x04, 0x03, 0x02, 0x01];
    assert_eq!(parse_header(&buf), (STDOUT, 0x0102_0304));
}

#[test]
fn parse_header_accepts_zero_length() {
    let buf = [EXIT, 0, 0, 0, 0];
    assert_eq!(parse_header(&buf), (EXIT, 0));
}

#[test]
fn parse_header_accepts_max_length() {
    let buf = [STDERR, 0xFF, 0xFF, 0xFF, 0xFF];
    assert_eq!(parse_header(&buf), (STDERR, u32::MAX));
}

#[test]
fn encode_window_size_packs_rows_then_cols_and_pads_with_zeros() {
    let bytes = encode_window_size(24, 80);
    assert_eq!(bytes, [24, 0, 80, 0, 0, 0, 0, 0]);
}

#[test]
fn encode_window_size_handles_zero_dimensions() {
    assert_eq!(encode_window_size(0, 0), [0; 8]);
}

#[test]
fn encode_window_size_preserves_full_u16_range() {
    let bytes = encode_window_size(u16::MAX, u16::MAX);
    assert_eq!(bytes, [0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0]);
}

#[test]
fn make_frame_routes_stdout_payload() {
    let frame = make_frame(STDOUT, vec![b'h', b'i']).unwrap();
    assert!(matches!(frame, Frame::Stdout(p) if p == b"hi"));
}

#[test]
fn make_frame_routes_stderr_payload() {
    let frame = make_frame(STDERR, vec![b'e', b'r', b'r']).unwrap();
    assert!(matches!(frame, Frame::Stderr(p) if p == b"err"));
}

#[test]
fn make_frame_extracts_exit_code_from_first_byte() {
    let frame = make_frame(EXIT, vec![42, 99]).unwrap();
    assert!(matches!(frame, Frame::Exit(42)));
}

#[test]
fn make_frame_rejects_empty_exit_payload() {
    use crate::base::error::ProtocolError;
    assert!(matches!(
        make_frame(EXIT, Vec::new()),
        Err(ProtocolError::ShortExitPayload)
    ));
}

#[test]
fn make_frame_wraps_unknown_id_as_other() {
    let frame = make_frame(STDIN, vec![1, 2, 3]).unwrap();
    let Frame::Other { id, payload } = frame else {
        panic!("expected Frame::Other");
    };
    assert_eq!(id, STDIN);
    assert_eq!(payload, vec![1, 2, 3]);
}

#[test]
fn make_frame_wraps_close_stdin_as_other() {
    assert!(matches!(
        make_frame(CLOSE_STDIN, Vec::new()).unwrap(),
        Frame::Other {
            id: CLOSE_STDIN,
            ..
        }
    ));
}

#[test]
fn make_frame_wraps_window_size_change_as_other() {
    assert!(matches!(
        make_frame(WINDOW_SIZE_CHANGE, Vec::new()).unwrap(),
        Frame::Other {
            id: WINDOW_SIZE_CHANGE,
            ..
        }
    ));
}

#[test]
fn header_size_constant_matches_header_buffer() {
    let buf = [0u8; HEADER_SIZE];
    let _ = parse_header(&buf);
}

#[test]
fn frame_decoder_new_starts_at_origin() {
    let d = FrameDecoder::new();
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 0);
    assert_eq!(d.large_remaining(), 0);
}

#[test]
fn frame_decoder_commit_advances_tail() {
    let mut d = FrameDecoder::new();
    d.commit(5);
    d.commit(3);
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 8);
}

#[test]
fn frame_decoder_returns_none_on_empty_buffer() {
    let mut d = FrameDecoder::new();
    let rx = [0u8; 16];
    assert!(d.try_next_raw(&rx).unwrap().is_none());
}

#[test]
fn frame_decoder_returns_none_until_header_complete() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 16];
    rx[0] = STDOUT;
    rx[1..4].copy_from_slice(&[3, 0, 0]);
    d.commit(4);
    assert!(d.try_next_raw(&rx).unwrap().is_none());
    assert_eq!(d.tail(), 4);
}

#[test]
fn frame_decoder_returns_none_when_payload_incomplete() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 16];
    write_header(&mut rx, 0, STDOUT, 5);
    rx[5..8].copy_from_slice(b"abc");
    d.commit(8);
    assert!(d.try_next_raw(&rx).unwrap().is_none());
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 8);
}

#[test]
fn frame_decoder_decodes_single_complete_frame() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 16];
    write_header(&mut rx, 0, STDOUT, 3);
    rx[5..8].copy_from_slice(b"abc");
    d.commit(8);

    let (id, payload) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, STDOUT);
    assert_eq!(payload, b"abc");
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 0);
}

#[test]
fn frame_decoder_decodes_zero_length_payload() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 16];
    write_header(&mut rx, 0, CLOSE_STDIN, 0);
    d.commit(5);

    let (id, payload) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, CLOSE_STDIN);
    assert!(payload.is_empty());
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 0);
}

#[test]
fn frame_decoder_decodes_two_frames_back_to_back() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 32];
    write_header(&mut rx, 0, STDOUT, 2);
    rx[5..7].copy_from_slice(b"hi");
    write_header(&mut rx, 7, STDERR, 3);
    rx[12..15].copy_from_slice(b"err");
    d.commit(15);

    let (id, p) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, STDOUT);
    assert_eq!(p, b"hi");

    let (id, p) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, STDERR);
    assert_eq!(p, b"err");

    assert!(d.try_next_raw(&rx).unwrap().is_none());
}

#[test]
fn frame_decoder_leaves_trailing_partial_frame_for_next_call() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 32];
    write_header(&mut rx, 0, STDOUT, 2);
    rx[5..7].copy_from_slice(b"hi");
    write_header(&mut rx, 7, STDERR, 5);
    rx[12..14].copy_from_slice(b"er");
    d.commit(14);

    let (id, p) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, STDOUT);
    assert_eq!(p, b"hi");

    assert!(d.try_next_raw(&rx).unwrap().is_none());
    assert_eq!(d.head(), 7);
    assert_eq!(d.tail(), 14);
}

#[test]
fn frame_decoder_delivers_oversized_frame_in_chunks() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 8];
    write_header(&mut rx, 0, STDOUT, 10);
    rx[5..8].copy_from_slice(b"abc");
    d.commit(8);

    let (id, p) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, STDOUT);
    assert_eq!(p, b"abc");
    assert_eq!(d.large_remaining(), 7);
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 0);

    rx[..5].copy_from_slice(b"defgh");
    d.commit(5);
    let (id, p) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, STDOUT);
    assert_eq!(p, b"defgh");
    assert_eq!(d.large_remaining(), 2);

    rx[..2].copy_from_slice(b"ij");
    d.commit(2);
    let (id, p) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, STDOUT);
    assert_eq!(p, b"ij");
    assert_eq!(d.large_remaining(), 0);
}

#[test]
fn frame_decoder_registers_oversized_frame_when_only_header_buffered() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 8];
    write_header(&mut rx, 0, STDOUT, 10);
    d.commit(5);

    assert!(d.try_next_raw(&rx).unwrap().is_none());
    assert_eq!(d.large_remaining(), 10);
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 0);
}

#[test]
fn frame_decoder_yields_none_during_oversized_wait_with_empty_buffer() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 8];
    write_header(&mut rx, 0, STDOUT, 10);
    rx[5..8].copy_from_slice(b"abc");
    d.commit(8);

    d.try_next_raw(&rx).unwrap().unwrap();
    assert!(d.try_next_raw(&rx).unwrap().is_none());
    assert_eq!(d.large_remaining(), 7);
}

#[test]
fn frame_decoder_compact_shifts_unread_bytes_to_front() {
    let mut d = FrameDecoder::new();
    let mut rx = [1u8, 2, 3, 4, 5, 6, 7, 8];
    d.commit(7);
    d.head = 3;
    d.compact(&mut rx);
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 4);
    assert_eq!(&rx[..4], &[4, 5, 6, 7]);
}

#[test]
fn frame_decoder_compact_is_noop_when_head_at_zero() {
    let mut d = FrameDecoder::new();
    let mut rx = [1u8, 2, 3, 4];
    d.commit(3);
    d.compact(&mut rx);
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 3);
    assert_eq!(&rx[..3], &[1, 2, 3]);
}

#[test]
fn frame_decoder_decodes_frame_after_compaction() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 16];
    write_header(&mut rx, 0, STDOUT, 2);
    rx[5..7].copy_from_slice(b"ok");
    write_header(&mut rx, 7, STDERR, 2);
    rx[12..14].copy_from_slice(b"no");
    d.commit(14);

    d.try_next_raw(&rx).unwrap().unwrap();
    d.compact(&mut rx);
    assert_eq!(d.head(), 0);
    assert_eq!(d.tail(), 7);

    let (id, p) = d.try_next_raw(&rx).unwrap().unwrap();
    assert_eq!(id, STDERR);
    assert_eq!(p, b"no");
}

#[test]
fn frame_decoder_try_next_frame_wraps_raw_into_enum() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 16];
    write_header(&mut rx, 0, EXIT, 1);
    rx[5] = 7;
    d.commit(6);

    let frame = d.try_next_frame(&rx).unwrap().unwrap();
    assert!(matches!(frame, Frame::Exit(7)));
}

#[test]
fn frame_decoder_try_next_frame_returns_none_when_incomplete() {
    let mut d = FrameDecoder::new();
    let mut rx = [0u8; 16];
    write_header(&mut rx, 0, STDOUT, 4);
    rx[5..7].copy_from_slice(b"ab");
    d.commit(7);

    assert!(d.try_next_frame(&rx).unwrap().is_none());
}