extern crate std;
use super::format::{HEADER_V3_SIZE, HEADER_V4_SIZE, LOGGER_ENTRY_MAX_LEN};
use super::*;
use alloc::{format, vec};
use core::cell::Cell;
use core::future::Future;
use core::pin::pin;
use core::task::{Context, Poll, Waker};
use crate::base::connection::{Connection, ConnectionConfig, HostBanner};
use crate::base::mock::{clse, cnxn, now, okay, wrte, Mock, MockError, NoAuth};
use crate::error::ProtocolError;
std::thread_local! {
pub(super) static MOVED: Cell<usize> = const { Cell::new(0) };
}
fn make_v4_entry(
pid: i32,
tid: u32,
sec: i32,
nsec: i32,
lid: u32,
uid: u32,
payload: &[u8],
) -> Vec<u8> {
let hdr_size: u16 = HEADER_V4_SIZE as u16;
let payload_len = payload.len() as u16;
let mut buf = Vec::with_capacity(HEADER_V4_SIZE + payload.len());
buf.extend_from_slice(&payload_len.to_le_bytes());
buf.extend_from_slice(&hdr_size.to_le_bytes());
buf.extend_from_slice(&pid.to_le_bytes());
buf.extend_from_slice(&tid.to_le_bytes());
buf.extend_from_slice(&sec.to_le_bytes());
buf.extend_from_slice(&nsec.to_le_bytes());
buf.extend_from_slice(&lid.to_le_bytes());
buf.extend_from_slice(&uid.to_le_bytes());
buf.extend_from_slice(payload);
buf
}
fn text_payload(priority: u8, tag: &[u8], message: &[u8]) -> Vec<u8> {
let mut p = Vec::with_capacity(1 + tag.len() + 1 + message.len() + 1);
p.push(priority);
p.extend_from_slice(tag);
p.push(0);
p.extend_from_slice(message);
p.push(0);
p
}
#[test]
fn parse_empty_buffer() {
assert_eq!(parse_entry(&[]), Ok(None));
}
#[test]
fn parse_partial_header() {
assert_eq!(parse_entry(&[0x10, 0x00]), Ok(None));
}
#[test]
fn parse_incomplete_entry() {
let data = make_v4_entry(1, 1, 0, 0, 0, 0, b"short");
assert_eq!(parse_entry(&data[..data.len() - 2]), Ok(None));
}
#[test]
fn parse_invalid_header_size() {
let mut buf = [0u8; 32];
buf[0..2].copy_from_slice(&10u16.to_le_bytes());
buf[2..4].copy_from_slice(&4u16.to_le_bytes());
assert_eq!(parse_entry(&buf), Err(LogcatError::InvalidHeader));
}
#[test]
fn parse_header_over_logger_entry_max_len() {
let payload = vec![b'x'; LOGGER_ENTRY_MAX_LEN - HEADER_V4_SIZE];
let mut data = make_v4_entry(1, 1, 0, 0, 0, 0, &payload);
assert_eq!(parse_entry(&data).unwrap().unwrap().1, LOGGER_ENTRY_MAX_LEN);
data[0..2].copy_from_slice(&(payload.len() as u16 + 1).to_le_bytes());
assert_eq!(parse_entry(&data), Err(LogcatError::InvalidHeader));
}
#[test]
fn parse_v4_entry() {
let payload = text_payload(4, b"MyTag", b"Hello world");
let data = make_v4_entry(1234, 5678, 1_000_000, 123_456_789, 0, 10042, &payload);
let (entry, consumed) = parse_entry(&data).unwrap().unwrap();
assert_eq!(consumed, data.len());
assert_eq!(entry.pid, 1234);
assert_eq!(entry.tid, 5678);
assert_eq!(entry.sec, 1_000_000);
assert_eq!(entry.nsec, 123_456_789);
assert_eq!(entry.uid, 10042);
assert_eq!(entry.log_id, LogId::Main);
assert_eq!(entry.priority, Priority::Info);
assert_eq!(entry.tag, b"MyTag");
assert_eq!(entry.message, b"Hello world");
}
#[test]
fn parse_v3_entry_no_uid() {
let payload = text_payload(6, b"CrashTag", b"segfault");
let hdr_size: u16 = HEADER_V3_SIZE as u16;
let payload_len = payload.len() as u16;
let mut buf = Vec::new();
buf.extend_from_slice(&payload_len.to_le_bytes());
buf.extend_from_slice(&hdr_size.to_le_bytes());
buf.extend_from_slice(&100i32.to_le_bytes());
buf.extend_from_slice(&200u32.to_le_bytes());
buf.extend_from_slice(&999i32.to_le_bytes());
buf.extend_from_slice(&0i32.to_le_bytes());
buf.extend_from_slice(&4u32.to_le_bytes());
buf.extend_from_slice(&payload);
let (entry, consumed) = parse_entry(&buf).unwrap().unwrap();
assert_eq!(consumed, buf.len());
assert_eq!(entry.pid, 100);
assert_eq!(entry.uid, 0);
assert_eq!(entry.log_id, LogId::Crash);
assert_eq!(entry.priority, Priority::Error);
assert_eq!(entry.tag, b"CrashTag");
assert_eq!(entry.message, b"segfault");
}
#[test]
fn parse_events_buffer_raw_payload() {
let raw_event = b"\x01\x02\x03\x04EVENTDATA";
let data = make_v4_entry(42, 42, 0, 0, 2, 0, raw_event);
let (entry, _) = parse_entry(&data).unwrap().unwrap();
assert_eq!(entry.log_id, LogId::Events);
assert_eq!(entry.priority, Priority::Unknown);
assert!(entry.tag.is_empty());
assert_eq!(entry.message, raw_event);
}
#[test]
fn each_buffer_decodes_in_its_own_format() {
let payload = text_payload(4, b"Tag", b"msg");
let text = [0, 1, 3, 4, 7];
for lid in 0..=8 {
let data = make_v4_entry(1, 1, 0, 0, lid, 0, &payload);
let (entry, _) = parse_entry(&data).unwrap().unwrap();
assert_eq!(entry.log_id.number(), lid);
assert_eq!(entry.log_id.is_text(), text.contains(&lid), "{lid}");
let got = (entry.priority, &entry.tag[..], &entry.message[..]);
let want = if text.contains(&lid) {
(Priority::Info, &b"Tag"[..], &b"msg"[..])
} else {
(Priority::Unknown, &b""[..], &payload[..])
};
assert_eq!(got, want, "{}", entry.log_id);
}
}
#[test]
fn parse_empty_payload() {
let data = make_v4_entry(1, 1, 0, 0, 0, 0, &[]);
let (entry, _) = parse_entry(&data).unwrap().unwrap();
assert_eq!(entry.priority, Priority::Unknown);
assert!(entry.tag.is_empty());
assert!(entry.message.is_empty());
}
#[test]
fn parse_two_entries_in_sequence() {
let p1 = text_payload(2, b"A", b"first");
let p2 = text_payload(5, b"B", b"second");
let mut buf = make_v4_entry(1, 1, 0, 0, 0, 0, &p1);
let second = make_v4_entry(2, 2, 1, 0, 3, 0, &p2);
buf.extend_from_slice(&second);
let (e1, c1) = parse_entry(&buf).unwrap().unwrap();
assert_eq!(e1.tag, b"A");
assert_eq!(e1.message, b"first");
assert_eq!(e1.priority, Priority::Verbose);
let (e2, c2) = parse_entry(&buf[c1..]).unwrap().unwrap();
assert_eq!(e2.tag, b"B");
assert_eq!(e2.message, b"second");
assert_eq!(e2.priority, Priority::Warn);
assert_eq!(c1 + c2, buf.len());
}
#[test]
fn parse_message_without_trailing_nul() {
let mut payload = Vec::new();
payload.push(4);
payload.extend_from_slice(b"Tag\0");
payload.extend_from_slice(b"no trailing nul");
let data = make_v4_entry(1, 1, 0, 0, 0, 0, &payload);
let (entry, _) = parse_entry(&data).unwrap().unwrap();
assert_eq!(entry.message, b"no trailing nul");
}
#[test]
fn every_priority_byte_survives_parsing() {
for byte in 0..=u8::MAX {
let data = make_v4_entry(1, 1, 0, 0, 0, 0, &text_payload(byte, b"Tag", b"msg"));
let (entry, _) = parse_entry(&data).unwrap().unwrap();
assert_eq!(u8::from(entry.priority), byte);
}
}
#[test]
fn each_named_priority_has_the_byte_android_gives_it() {
let named = [
(Priority::Unknown, 0),
(Priority::Default, 1),
(Priority::Verbose, 2),
(Priority::Debug, 3),
(Priority::Info, 4),
(Priority::Warn, 5),
(Priority::Error, 6),
(Priority::Fatal, 7),
(Priority::Silent, 8),
];
for (priority, byte) in named {
assert_eq!(Priority::from(byte), priority, "{byte}");
assert_eq!(u8::from(priority), byte, "{priority}");
}
for byte in [9, u8::MAX] {
let priority = Priority::from(byte);
assert!(
matches!(priority, Priority::Other(_)),
"{byte}: {priority:?}"
);
}
}
#[test]
fn priorities_order_as_their_bytes_do() {
for a in 0..=u8::MAX {
for b in 0..=u8::MAX {
let got = Priority::from(a).cmp(&Priority::from(b));
assert_eq!(got, a.cmp(&b), "{a} against {b}");
}
}
}
#[test]
fn every_priority_displays_its_name_and_letter() {
let named = [
("UNKNOWN", '?'),
("DEFAULT", '?'),
("VERBOSE", 'V'),
("DEBUG", 'D'),
("INFO", 'I'),
("WARN", 'W'),
("ERROR", 'E'),
("FATAL", 'F'),
("SILENT", 'S'),
];
for (byte, (name, letter)) in (0..).zip(named) {
let priority = Priority::from(byte);
assert_eq!(format!("{priority}"), name);
assert_eq!(priority.as_char(), letter, "{name}");
}
let other = Priority::from(9);
assert_eq!(format!("{other}"), "OTHER(9)");
assert_eq!(other.as_char(), '?');
}
#[test]
fn every_buffer_displays_the_name_logcat_gives_it() {
let names = [
"main", "radio", "events", "system", "crash", "stats", "security", "kernel",
];
for (number, name) in (0..).zip(names) {
assert_eq!(format!("{}", LogId::from(number)), name);
}
assert_eq!(format!("{}", LogId::from(8)), "unknown(8)");
}
#[test]
fn log_id_numbers_round_trip() {
let known = [
(LogId::Main, 0),
(LogId::Radio, 1),
(LogId::Events, 2),
(LogId::System, 3),
(LogId::Crash, 4),
(LogId::Stats, 5),
(LogId::Security, 6),
(LogId::Kernel, 7),
];
for (id, number) in known {
assert_eq!(LogId::from(number), id, "{number}");
assert_eq!(id.number(), number, "{id}");
assert_eq!(u32::from(id), number, "{id}");
}
for number in [8, u32::MAX] {
let id = LogId::from(number);
assert!(matches!(id, LogId::Unknown(_)), "{number}: {id:?}");
assert_eq!(id.number(), number);
assert_eq!(u32::from(id), number);
}
}
#[test]
fn a_buffer_number_and_format_can_be_read_in_a_const() {
const KERNEL: (u32, bool) = (LogId::Kernel.number(), LogId::Kernel.is_text());
assert_eq!(KERNEL, (7, true));
}
#[test]
fn tag_and_message_lossy() {
let entry = LogEntry {
pid: 0,
tid: 0,
sec: 0,
nsec: 0,
uid: 0,
log_id: LogId::Main,
priority: Priority::Info,
tag: b"valid".to_vec(),
message: vec![0xFF, 0xFE, b'!'],
};
assert_eq!(entry.tag_lossy(), "valid");
assert!(entry.message_lossy().contains('!'));
}
#[test]
fn destination_no_args() {
let mut buf = [0u8; 128];
let len = shell_v2::write_argv_destination(&mut buf, b"logcat -B", &[]).unwrap();
assert_eq!(&buf[..len], b"shell,v2,raw:logcat -B\0");
}
#[test]
fn destination_with_args() {
let mut buf = [0u8; 128];
let len =
shell_v2::write_argv_destination(&mut buf, b"logcat -B", &["-b", "main,system"]).unwrap();
assert_eq!(&buf[..len], b"shell,v2,raw:logcat -B -b main,system\0");
}
#[test]
fn destination_dump() {
let mut buf = [0u8; 128];
let len = shell_v2::write_argv_destination(&mut buf, b"logcat -B -d", &["-t", "50"]).unwrap();
assert_eq!(&buf[..len], b"shell,v2,raw:logcat -B -d -t 50\0");
}
#[test]
fn destination_text() {
let mut buf = [0u8; 128];
let len =
shell_v2::write_argv_destination(&mut buf, b"logcat", &["-d", "-v", "threadtime"]).unwrap();
assert_eq!(&buf[..len], b"shell,v2,raw:logcat -d -v threadtime\0");
}
#[test]
fn destination_buffer_too_small() {
let mut buf = [0u8; 10];
assert_eq!(
shell_v2::write_argv_destination(&mut buf, b"logcat -B", &[]),
Err(crate::base::destination::DestinationError::TooLong)
);
}
fn frame(id: FrameId, payload: &[u8]) -> Vec<u8> {
let mut f = Vec::with_capacity(shell_v2::HEADER_SIZE + payload.len());
f.push(id.into());
f.extend_from_slice(&(payload.len() as u32).to_le_bytes());
f.extend_from_slice(payload);
f
}
fn entries(n: usize, len: usize) -> Vec<u8> {
let payload = vec![b'x'; len - HEADER_V4_SIZE];
let mut out = Vec::with_capacity(n * len);
for i in 0..n {
out.extend_from_slice(&make_v4_entry(i as i32, 0, 0, 0, 0, 0, &payload));
}
out
}
fn device_sending(wrtes: &[&[u8]]) -> Connection<Mock> {
let mut mock = Mock::new();
mock.feed(&cnxn()).feed(&okay(1));
for payload in wrtes {
mock.feed(&wrte(1, payload));
}
now(Connection::connect(
mock,
NoAuth,
HostBanner::Features(&[]),
ConnectionConfig::new(),
))
.unwrap()
}
fn read_to_end(
conn: &mut Connection<Mock>,
buf: &mut [u8],
) -> (Result<Vec<LogEntry>, Error<MockError>>, usize) {
let mut logcat = now(open(conn, &[], buf)).unwrap();
MOVED.with(|moved| moved.set(0));
let mut got = Vec::new();
let end = loop {
match now(logcat.read_entry()) {
Ok(entry) => got.push(entry),
Err(Error::ChannelClosed) => break Ok(got),
Err(e) => break Err(e),
}
};
(end, MOVED.with(Cell::get))
}
#[test]
fn a_frame_of_small_entries_is_not_moved() {
let stdout = entries(2340, HEADER_V4_SIZE);
let mut wire = frame(FrameId::Stdout, &stdout);
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let wrtes: Vec<&[u8]> = wire.chunks(1000).collect();
let mut conn = device_sending(&wrtes);
let mut buf = vec![0u8; wire.len() + 64];
let (got, moved) = read_to_end(&mut conn, &mut buf);
assert_eq!(got.unwrap().len(), 2340);
assert_eq!(moved, 0);
}
#[test]
fn entries_read_on_when_no_frame_ends_where_an_entry_does() {
let stdout = entries(100, HEADER_V4_SIZE);
let mut wire = frame(FrameId::Stdout, &stdout[..HEADER_V4_SIZE + 1]);
for piece in stdout[HEADER_V4_SIZE + 1..].chunks(HEADER_V4_SIZE) {
wire.extend_from_slice(&frame(FrameId::Stdout, piece));
}
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 128];
let (got, _) = read_to_end(&mut conn, &mut buf);
assert_eq!(got.unwrap().len(), 100);
}
#[test]
fn a_wrte_of_one_entry_frames_is_not_moved() {
let stdout = entries(1985, HEADER_V4_SIZE);
let mut wire = Vec::new();
for entry in stdout.chunks(HEADER_V4_SIZE) {
wire.extend_from_slice(&frame(FrameId::Stdout, entry));
}
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let mut conn = device_sending(&[&wire]);
let mut buf = vec![0u8; wire.len() + 64];
let (got, moved) = read_to_end(&mut conn, &mut buf);
assert_eq!(got.unwrap().len(), 1985);
assert_eq!(moved, 0);
}
#[test]
fn a_frame_a_device_never_sends_is_refused() {
let mut wire = frame(FrameId::WindowSizeChange, &[0; 8]);
wire.extend_from_slice(&frame(FrameId::Stdout, &entries(1, HEADER_V4_SIZE)));
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 256];
let (got, _) = read_to_end(&mut conn, &mut buf);
assert!(
matches!(
got,
Err(Error::Protocol(ProtocolError::UnexpectedShellFrame(5)))
),
"got {got:?}"
);
}
fn read_cut(
stdout: &[u8],
frame_cut: usize,
wrte_cut: usize,
buf_len: usize,
) -> Result<Vec<LogEntry>, Error<MockError>> {
let mut wire = frame(FrameId::Stdout, &stdout[..frame_cut]);
wire.extend_from_slice(&frame(FrameId::Stdout, &stdout[frame_cut..]));
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let mut conn = device_sending(&[&wire[..wrte_cut], &wire[wrte_cut..]]);
let mut buf = vec![0u8; buf_len];
read_to_end(&mut conn, &mut buf).0
}
#[test]
fn a_buffer_four_bytes_longer_than_an_entry_reads_every_cut() {
const LEN: usize = 40;
let stdout = entries(2, LEN);
let mut ran_out = 0;
for frame_cut in 1..stdout.len() {
for wrte_cut in 1..stdout.len() + 16 {
let got = read_cut(&stdout, frame_cut, wrte_cut, LEN + 4);
assert_eq!(got.unwrap().len(), 2, "cuts {frame_cut}/{wrte_cut}");
match read_cut(&stdout, frame_cut, wrte_cut, LEN + 3) {
Ok(got) => assert_eq!(got.len(), 2),
Err(Error::ReceiveBufferFull) => ran_out += 1,
Err(e) => panic!("cuts {frame_cut}/{wrte_cut}: {e:?}"),
}
}
}
assert!(ran_out > 0, "three bytes over an entry never ran out");
}
#[test]
fn empty_stdout_and_stderr_frames_between_entries_are_harmless() {
let entry = entries(1, HEADER_V4_SIZE);
let mut wire = frame(FrameId::Stdout, &[]);
wire.extend_from_slice(&frame(FrameId::Stdout, &entry));
wire.extend_from_slice(&frame(FrameId::Stderr, &[]));
wire.extend_from_slice(&frame(FrameId::Stdout, &[]));
wire.extend_from_slice(&frame(FrameId::Stdout, &entry));
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 128];
let (got, _) = read_to_end(&mut conn, &mut buf);
assert_eq!(got.unwrap().len(), 2);
}
#[test]
fn an_entry_longer_than_the_buffer_fails_instead_of_waiting() {
let mut wire = frame(FrameId::Stdout, &entries(1, 200));
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 128];
let (got, _) = read_to_end(&mut conn, &mut buf);
assert!(matches!(got, Err(Error::ReceiveBufferFull)), "got {got:?}");
}
#[test]
fn an_exit_frame_without_a_status_is_refused() {
let mut wire = frame(FrameId::Stdout, &entries(1, HEADER_V4_SIZE));
wire.extend_from_slice(&frame(FrameId::Exit, &[]));
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 128];
let (got, _) = read_to_end(&mut conn, &mut buf);
assert!(
matches!(got, Err(Error::Protocol(ProtocolError::ShortExitPayload))),
"got {got:?}"
);
}
#[test]
fn the_stream_ends_at_the_status_byte_of_a_longer_exit_frame() {
let mut wire = frame(FrameId::Stdout, &entries(1, HEADER_V4_SIZE));
wire.extend_from_slice(&frame(FrameId::Exit, &[0; 100])[..shell_v2::HEADER_SIZE + 1]);
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 128];
let (got, _) = read_to_end(&mut conn, &mut buf);
assert_eq!(got.unwrap().len(), 1);
}
#[test]
fn the_exit_error_keeps_the_first_kib_of_stderr() {
let mut wire = frame(FrameId::Stderr, b"abc");
wire.extend_from_slice(&frame(FrameId::Stderr, &[b'e'; 2000]));
wire.extend_from_slice(&frame(FrameId::Exit, &[1]));
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 256];
let (got, _) = read_to_end(&mut conn, &mut buf);
let Err(Error::Logcat(LogcatError::Exited { code: 1, stderr })) = got else {
panic!("got {got:?}");
};
assert_eq!(stderr.len(), 1024);
assert!(stderr.starts_with(b"abceee"));
}
#[test]
fn a_channel_that_closes_before_the_exit_status_fails() {
let wire = frame(FrameId::Stdout, &entries(2, HEADER_V4_SIZE));
let mut mock = Mock::new();
mock.feed(&cnxn())
.feed(&okay(1))
.feed(&wrte(1, &wire))
.feed(&clse(1));
let mut conn = now(Connection::connect(
mock,
NoAuth,
HostBanner::Features(&[]),
ConnectionConfig::new(),
))
.unwrap();
let mut buf = [0u8; 128];
let mut logcat = now(open(&mut conn, &[], &mut buf)).unwrap();
assert_eq!(now(logcat.read_entry()).unwrap().pid, 0);
assert_eq!(now(logcat.read_entry()).unwrap().pid, 1);
let got = now(logcat.read_entry());
assert!(
matches!(got, Err(Error::Logcat(LogcatError::ClosedWithoutExit))),
"got {got:?}"
);
}
#[test]
fn a_transport_that_ends_is_not_taken_for_a_closed_channel() {
let mut conn = device_sending(&[&frame(FrameId::Stdout, &entries(2, HEADER_V4_SIZE))]);
let mut buf = [0u8; 128];
let (got, _) = read_to_end(&mut conn, &mut buf);
assert!(matches!(got, Err(Error::UnexpectedEof)), "got {got:?}");
}
fn poll_briefly<F: Future>(fut: F) -> Option<F::Output> {
let mut fut = pin!(fut);
let mut cx = Context::from_waker(Waker::noop());
(0..8).find_map(|_| match fut.as_mut().poll(&mut cx) {
Poll::Ready(out) => Some(out),
Poll::Pending => None,
})
}
#[test]
fn a_call_dropped_anywhere_in_the_stream_costs_nothing() {
let stdout = entries(2, HEADER_V4_SIZE);
let mut wire = frame(FrameId::Stdout, &stdout[..HEADER_V4_SIZE + 3]);
wire.extend_from_slice(&frame(FrameId::Stderr, b"warning\n"));
wire.extend_from_slice(&frame(FrameId::Stdout, &stdout[HEADER_V4_SIZE + 3..]));
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
for cut in 0..wire.len() {
let mut conn = device_sending(&[]);
let mut buf = [0u8; 128];
let mut logcat = now(open(&mut conn, &[], &mut buf)).unwrap();
let device = logcat.channel.session.transport_mut();
device.parks_when_drained();
if cut > 0 {
device.feed(&wrte(1, &wire[..cut]));
}
let mut pids = Vec::new();
while let Some(entry) = poll_briefly(logcat.read_entry()) {
pids.push(entry.unwrap().pid);
}
let device = logcat.channel.session.transport_mut();
device.feed(&wrte(1, &wire[cut..]));
let end = loop {
match now(logcat.read_entry()) {
Ok(entry) => pids.push(entry.pid),
end => break end,
}
};
assert!(
matches!(end, Err(Error::ChannelClosed)),
"dropped {cut} bytes in: {end:?}"
);
assert_eq!(pids, [0, 1], "dropped {cut} bytes in");
}
}
#[test]
fn an_entry_cut_short_by_a_clean_exit_is_reported() {
let stdout = entries(2, HEADER_V4_SIZE);
let mut wire = frame(FrameId::Stdout, &stdout[..HEADER_V4_SIZE + 10]);
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 128];
let mut logcat = now(open(&mut conn, &[], &mut buf)).unwrap();
assert_eq!(now(logcat.read_entry()).unwrap().pid, 0);
let got = now(logcat.read_entry());
assert!(
matches!(got, Err(Error::Logcat(LogcatError::TruncatedEntry))),
"got {got:?}"
);
}
#[test]
fn a_failed_exit_wins_over_the_entry_it_cut_short() {
let stdout = entries(2, HEADER_V4_SIZE);
let mut wire = frame(FrameId::Stdout, &stdout[..HEADER_V4_SIZE + 10]);
wire.extend_from_slice(&frame(FrameId::Exit, &[1]));
let mut conn = device_sending(&[&wire]);
let mut buf = [0u8; 128];
let mut logcat = now(open(&mut conn, &[], &mut buf)).unwrap();
assert_eq!(now(logcat.read_entry()).unwrap().pid, 0);
let got = now(logcat.read_entry());
assert!(
matches!(got, Err(Error::Logcat(LogcatError::Exited { code: 1, .. }))),
"got {got:?}"
);
}
#[test]
fn text_in_place_of_entries_fails_every_read_and_the_dump() {
let text = b"main: ring buffer is 5 MiB (4 MiB consumed, 23 MiB readable), \
max entry is 5120 B, max payload is 4068 B\n";
let mut wire = frame(FrameId::Stdout, text);
wire.extend_from_slice(&frame(FrameId::Exit, &[0]));
let mut buf = [0u8; 256];
let mut conn = device_sending(&[&wire]);
let mut logcat = now(open(&mut conn, &["-g"], &mut buf)).unwrap();
for _ in 0..2 {
let got = now(logcat.read_entry());
assert!(
matches!(got, Err(Error::Logcat(LogcatError::InvalidHeader))),
"got {got:?}"
);
}
let mut conn = device_sending(&[&wire]);
let got = now(dump(&mut conn, &["-g"], &mut buf));
assert!(
matches!(got, Err(Error::Logcat(LogcatError::InvalidHeader))),
"got {got:?}"
);
}