use saleae::client::{Client, Connection};
use saleae::device::DeviceID;
use saleae::ConnectedDevice;
use saleae::PerformanceOption;
use saleae::SampleRate;
#[test]
fn set_num_samples() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn.set_num_samples(500).unwrap();
assert_eq!(true, response);
}
#[test]
fn get_num_samples() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_message).then(|_| Ok("3000\nACK".to_string())) }
let mut conn = Client::new(conn).unwrap();
let response = conn.get_num_samples().unwrap();
assert_eq!(3000, response);
}
#[test]
#[should_panic]
fn get_num_samples_fail() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_message).then(|_| Ok("3000".to_string())) }
let mut conn = Client::new(conn).unwrap();
let response = conn.get_num_samples().unwrap();
assert_eq!(3000, response);
}
#[test]
fn set_capture_seconds() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn.set_capture_seconds(2.2).unwrap();
assert_eq!(true, response);
}
#[test]
fn set_sample_rate() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn
.set_sample_rate(&SampleRate {
AnalogSampleRate: 6_250_000,
DigitalSampleRate: 1_562_500,
})
.unwrap();
assert_eq!(true, response);
}
#[test]
fn get_sample_rate() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_message).then(|_| Ok("1000000\n0\n".to_string())) }
let mut conn = Client::new(conn).unwrap();
let response = conn.get_sample_rate().unwrap();
assert_eq!(response.DigitalSampleRate, 1_000_000);
assert_eq!(response.AnalogSampleRate, 0);
}
#[test]
fn get_performance() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_message).then(|_| Ok("100".to_string())) }
let mut conn = Client::new(conn).unwrap();
let response = conn.get_performance().unwrap();
assert_eq!(response, 100);
}
#[test]
fn set_performance() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn.set_performance(PerformanceOption::Full).unwrap();
assert_eq!(response, true);
let mut conn2 = Connection::faux();
unsafe { faux::when!(conn2.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn2.general_recieve_ack).then(|_| Ok(false)) }
let mut conn2 = Client::new(conn2).unwrap();
let response2 = conn2.set_performance(PerformanceOption::Low).unwrap();
assert_eq!(response2, false);
}
#[test]
fn get_connected_devices() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe {
faux::when!(conn.general_recieve_message).then(|_| Ok("1, Logic 8, LOGIC_8_DEVICE, 0x2dc9, ACTIVE\n2, Logic Pro 8, LOGIC_PRO_8_DEVICE, 0x7243\n3, Logic Pro 16, LOGIC_PRO_16_DEVICE, 0x673f\n4, Logic 4, LOGIC_4_DEVICE, 0x6709\nACK".to_string()))
}
let mut conn = Client::new(conn).unwrap();
let response = conn.get_connected_devices().unwrap();
assert_eq!(
response[0],
ConnectedDevice {
d_type: "1".to_string(),
name: "Logic 8".to_string(),
device_id: DeviceID::LOGIC_8_DEVICE,
index: "0x2dc9".to_string(),
is_active: true
}
);
assert_eq!(
response[1],
ConnectedDevice {
d_type: "2".to_string(),
name: "Logic Pro 8".to_string(),
device_id: DeviceID::LOGIC_PRO_8_DEVICE,
index: "0x7243".to_string(),
is_active: false
}
);
assert_eq!(
response[2],
ConnectedDevice {
d_type: "3".to_string(),
name: "Logic Pro 16".to_string(),
device_id: DeviceID::LOGIC_PRO_16_DEVICE,
index: "0x673f".to_string(),
is_active: false
}
);
assert_eq!(
response[3],
ConnectedDevice {
d_type: "4".to_string(),
name: "Logic 4".to_string(),
device_id: DeviceID::LOGIC_4_DEVICE,
index: "0x6709".to_string(),
is_active: false
}
);
}
#[test]
fn select_active_device() {
}
#[test]
fn get_active_device() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe {
faux::when!(conn.general_recieve_message).then(|_| {
Ok("digital_channels, 0, 4, 5, 7, analog_channels, 0, 1, 2, 5, 8".to_string())
})
}
let mut conn = Client::new(conn).unwrap();
let response = conn.get_active_channels().unwrap();
assert_eq!(response[0], [0, 4, 5, 7]);
assert_eq!(response[1], [0, 1, 2, 5, 8]);
}
#[test]
fn set_active_channels() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn
.set_active_channels(&[0, 4, 5, 7], &[0, 1, 2, 5, 8])
.unwrap();
assert_eq!(response, true);
}
#[test]
fn reset_active_channels() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn.reset_active_channels().unwrap();
assert_eq!(response, true);
}
#[test]
fn start_capture() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
let mut conn = Client::new(conn).unwrap();
let response = conn.start_capture().unwrap();
assert_eq!(response, true);
}
#[test]
fn start_capture_block_until_finished() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn.start_capture_block_until_finished().unwrap();
assert_eq!(response, true);
}
#[test]
fn is_processing_complete() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_message).then(|_| Ok("TRUE\nACK".to_string())) }
let mut conn = Client::new(conn).unwrap();
let response = conn.is_processing_complete().unwrap();
assert_eq!(response, true);
}
#[test]
fn stop_capture() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn.stop_capture().unwrap();
assert_eq!(response, true);
}
#[test]
fn close_all_tabs() {
let mut conn = Connection::faux();
unsafe { faux::when!(conn.run_command).then(|_| Ok(())) }
unsafe { faux::when!(conn.general_recieve_ack).then(|_| Ok(true)) }
let mut conn = Client::new(conn).unwrap();
let response = conn.close_all_tabs().unwrap();
assert_eq!(response, true);
}