crates/serialport/examples/hardware_check.rs - platform/external/rust/android-crates-io - Git at Google

 //! This example performs a test using real hardware ports.
 //!
 //! This tool serves as a debugging aid when encountering errors using `serialport-rs`. It should
 //! expose any kernel or driver bugs that your system may have by running physical ports through
 //! many configurations.
 //!
 //! There are 3 ways to run this example:
 //!
 //!  1) With a single port not connected to an external device:
 //!     `cargo run --example hardware_check /dev/ttyUSB0`
 //!
 //!  2) With a single port physically connected in loopback mode (RX<->TX)
 //!     `cargo run --example hardware_check /dev/ttyUSB0 --loopback`
 //!
 //!  3) With two ports physically connected to each other
 //!     `cargo run --example hardware_check /dev/ttyUSB0 /dev/ttyUSB1`

 use std::io::Write;
 use std::str;
 use std::time::Duration;

 use assert_hex::assert_eq_hex;
 use clap::{Arg, Command};

 use serialport::{ClearBuffer, DataBits, FlowControl, Parity, SerialPort, StopBits};

 const TEST_MESSAGE: &[u8] = "Test Message".as_bytes();

 fn main() {
     let matches = Command::new("Serialport Example - Hardware Check")
         .about("Test hardware capabilities of serial ports")
         .disable_version_flag(true)
         .arg(Arg::new("port")
              .help("The device path to a serial port")
              .use_value_delimiter(false)
              .required(true))
         .arg(Arg::new("loopback")
              .help("Run extra tests if the port is configured for hardware loopback. Mutually exclusive with the --loopback-port option")
              .use_value_delimiter(false)
              .conflicts_with("loopback-port")
              .long("loopback"))
         .arg(Arg::new("loopback-port")
              .help("The device path of a second serial port that is connected to the first serial port. Mutually exclusive with the --loopback option.")
              .use_value_delimiter(false)
              .takes_value(true)
              .long("loopback-port"))
         .get_matches();

     let port1_name = matches.value_of("port").unwrap();
     let port2_name = matches.value_of("loopback-port").unwrap_or("");
     let port1_loopback = matches.is_present("loopback");

     // Loopback mode is only available when a single port is specified
     if port1_loopback && !port2_name.is_empty() {
         eprintln!("ERROR: loopback mode can only be enabled when a single port is specified.");
         ::std::process::exit(1);
     }

     // Run single-port tests on port1
     let mut port1 = match serialport::new(port1_name, 9600).open() {
         Err(e) => {
             eprintln!("Failed to open \"{}\". Error: {}", port1_name, e);
             ::std::process::exit(1);
         }
         Ok(p) => p,
     };
     test_single_port(&mut *port1, port1_loopback);

     if !port2_name.is_empty() {
         // Run single-port tests on port2
         let mut port2 = match serialport::new(port2_name, 9600).open() {
             Err(e) => {
                 eprintln!("Failed to open \"{}\". Error: {}", port2_name, e);
                 ::std::process::exit(1);
             }
             Ok(p) => p,
         };
         test_single_port(&mut *port2, false);

         // Test loopback pair
         test_dual_ports(&mut *port1, &mut *port2);
     }
 }

 macro_rules! baud_rate_check {
     ($port:ident, $baud:expr) => {
         let baud_rate = $baud;
         if let Err(e) = $port.set_baud_rate(baud_rate) {
             println!("  {:?}: FAILED ({})", baud_rate, e);
         }
         match $port.baud_rate() {
             Err(_) => println!("  {:?}: FAILED (error retrieving baud rate)", baud_rate),
             Ok(r) if r != baud_rate => println!(
                 "  {:?}: FAILED (baud rate {:?} does not match set baud rate {:?})",
                 baud_rate, r, baud_rate
             ),
             Ok(_) => println!("  {:?}: success", baud_rate),
         }
     };
 }

 macro_rules! data_bits_check {
     ($port:ident, $data_bits:path) => {
         let data_bits = $data_bits;
         if let Err(e) = $port.set_data_bits(data_bits) {
             println!("  {:?}: FAILED ({})", data_bits, e);
         } else {
             match $port.data_bits() {
                 Err(_) => println!("FAILED to retrieve data bits"),
                 Ok(r) if r != data_bits => println!(
                     "  {:?}: FAILED (data bits {:?} does not match set data bits {:?})",
                     data_bits, r, data_bits
                 ),
                 Ok(_) => println!("  {:?}: success", data_bits),
             }
         }
     };
 }

 macro_rules! flow_control_check {
     ($port:ident, $flow_control:path) => {
         let flow_control = $flow_control;
         if let Err(e) = $port.set_flow_control(flow_control) {
             println!("  {:?}: FAILED ({})", flow_control, e);
         } else {
             match $port.flow_control() {
                 Err(_) => println!("FAILED to retrieve flow control"),
                 Ok(r) if r != flow_control => println!(
                     "  {:?}: FAILED (flow control {:?} does not match set flow control {:?})",
                     flow_control, r, flow_control
                 ),
                 Ok(_) => println!("  {:?}: success", flow_control),
             }
         }
     };
 }

 macro_rules! parity_check {
     ($port:ident, $parity:path) => {
         let parity = $parity;
         if let Err(e) = $port.set_parity(parity) {
             println!("  {:?}: FAILED ({})", parity, e);
         } else {
             match $port.parity() {
                 Err(_) => println!("FAILED to retrieve parity"),
                 Ok(r) if r != parity => println!(
                     "  {:?}: FAILED (parity {:?} does not match set parity {:?})",
                     parity, r, parity
                 ),
                 Ok(_) => println!("  {:?}: success", parity),
             }
         }
     };
 }

 macro_rules! stop_bits_check {
     ($port:ident, $stop_bits:path) => {
         let stop_bits = $stop_bits;
         if let Err(e) = $port.set_stop_bits(stop_bits) {
             println!("  {:?}: FAILED ({})", stop_bits, e);
         } else {
             match $port.stop_bits() {
                 Err(_) => println!("FAILED to retrieve stop bits"),
                 Ok(r) if r != stop_bits => println!(
                     "FAILED, stop bits {:?} does not match set stop bits {:?}",
                     r, stop_bits
                 ),
                 Ok(_) => println!("  {:?}: success", stop_bits),
             }
         }
     };
 }

 macro_rules! clear_check {
     ($port:ident, $buffer_direction:path) => {
         let buffer_direction = $buffer_direction;
         match $port.clear(buffer_direction) {
             Ok(_) => println!("  {:?}: success", buffer_direction),
             Err(ref e) => println!("  {:?}: FAILED ({})", buffer_direction, e),
         }
     };
 }

 macro_rules! call_query_method_check {
     ($port:ident, $func:path) => {
         match $func($port) {
             Ok(_) => println!("  {}: success", stringify!($func)),
             Err(ref e) => println!("  {}: FAILED ({})", stringify!($func), e),
         }
     };
 }

 fn test_single_port(port: &mut dyn serialport::SerialPort, loopback: bool) {
     println!("Testing '{}':", port.name().unwrap());

     // Test setting standard baud rates
     println!("Testing baud rates...");
     baud_rate_check!(port, 9600);
     baud_rate_check!(port, 38_400);
     baud_rate_check!(port, 115_200);

     // Test setting non-standard baud rates
     println!("Testing non-standard baud rates...");
     baud_rate_check!(port, 10_000);
     baud_rate_check!(port, 600_000);
     baud_rate_check!(port, 1_800_000);

     // Test setting the data bits
     println!("Testing data bits...");
     data_bits_check!(port, DataBits::Five);
     data_bits_check!(port, DataBits::Six);
     data_bits_check!(port, DataBits::Seven);
     data_bits_check!(port, DataBits::Eight);

     // Test setting flow control
     println!("Testing flow control...");
     flow_control_check!(port, FlowControl::Software);
     flow_control_check!(port, FlowControl::Hardware);
     flow_control_check!(port, FlowControl::None);

     // Test setting parity
     println!("Testing parity...");
     parity_check!(port, Parity::Odd);
     parity_check!(port, Parity::Even);
     parity_check!(port, Parity::None);

     // Test setting stop bits
     println!("Testing stop bits...");
     stop_bits_check!(port, StopBits::Two);
     stop_bits_check!(port, StopBits::One);

     // Test bytes to read and write
     println!("Testing bytes to read and write...");
     call_query_method_check!(port, SerialPort::bytes_to_write);
     call_query_method_check!(port, SerialPort::bytes_to_read);

     // Test clearing a buffer
     println!("Test clearing software buffers...");
     clear_check!(port, ClearBuffer::Input);
     clear_check!(port, ClearBuffer::Output);
     clear_check!(port, ClearBuffer::All);

     // Test transmitting data
     print!("Testing data transmission...");
     std::io::stdout().flush().unwrap();
     // Make sure the port has sane defaults
     set_defaults(port);
     let msg = "Test Message";
     port.write_all(msg.as_bytes())
         .expect("Unable to write bytes.");
     println!("success");

     if loopback {
         print!("Testing data reception...");
         port.set_timeout(Duration::from_millis(250)).ok();

         let mut buf = [0u8; 12];
         if let Err(e) = port.read_exact(&mut buf) {
             println!("FAILED ({})", e);
         } else {
             assert_eq!(
                 str::from_utf8(&buf).unwrap(),
                 msg,
                 "Received message does not match sent"
             );
             println!("success");
         }
     }
 }

 fn check_test_message(sender: &mut dyn SerialPort, receiver: &mut dyn SerialPort) {
     // Ignore any "residue" from previous tests.
     sender.clear(ClearBuffer::All).unwrap();
     receiver.clear(ClearBuffer::All).unwrap();

     let send_buf = TEST_MESSAGE;
     let mut recv_buf = [0u8; TEST_MESSAGE.len()];

     sender.write_all(send_buf).unwrap();
     sender.flush().unwrap();

     match receiver.read_exact(&mut recv_buf) {
         Ok(()) => {
             assert_eq_hex!(recv_buf, send_buf, "Received message does not match sent",);
             println!("        success");
         }
         Err(e) => println!("FAILED: {:?}", e),
     }
 }

 fn test_dual_ports(port1: &mut dyn serialport::SerialPort, port2: &mut dyn serialport::SerialPort) {
     println!(
         "Testing paired ports '{}' and '{}':",
         port1.name().unwrap(),
         port2.name().unwrap()
     );

     // Make sure both ports are set to sane defaults
     set_defaults(port1);
     set_defaults(port2);

     // Test sending strings from port1 to port2
     println!(
         "  Transmitting from {} to {}...",
         port1.name().unwrap(),
         port2.name().unwrap()
     );

     let baud_rate = 2_000_000;
     println!("     At {},8,n,1,noflow...", baud_rate);
     std::io::stdout().flush().unwrap();
     if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
         check_test_message(port1, port2);
         check_test_message(port2, port1);
     } else {
         println!("FAILED (does this platform & port support arbitrary baud rates?)");
     }

     let baud_rate = 115_200;
     println!("     At {},8,n,1,noflow...", baud_rate);
     std::io::stdout().flush().unwrap();
     if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
         check_test_message(port1, port2);
         check_test_message(port2, port1);
     } else {
         println!("FAILED");
     }

     let baud_rate = 57_600;
     println!("     At {},8,n,1,noflow...", baud_rate);
     std::io::stdout().flush().unwrap();
     if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
         check_test_message(port1, port2);
         check_test_message(port2, port1);
     } else {
         println!("FAILED");
     }

     let baud_rate = 10_000;
     println!("     At {},8,n,1,noflow...", baud_rate);
     std::io::stdout().flush().unwrap();
     if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
         check_test_message(port1, port2);
         check_test_message(port2, port1);
     } else {
         println!("FAILED (does this platform & port support arbitrary baud rates?)");
     }
     let baud_rate = 9600;
     println!("     At {},8,n,1,noflow...", baud_rate);
     std::io::stdout().flush().unwrap();
     if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
         check_test_message(port1, port2);
         check_test_message(port2, port1);
     } else {
         println!("FAILED");
     }

     // Test flow control
     port1.set_flow_control(FlowControl::Software).unwrap();
     port2.set_flow_control(FlowControl::Software).unwrap();
     println!("     At 9600,8,n,1,softflow...");
     std::io::stdout().flush().unwrap();
     check_test_message(port1, port2);
     check_test_message(port2, port1);

     port1.set_flow_control(FlowControl::Hardware).unwrap();
     port2.set_flow_control(FlowControl::Hardware).unwrap();
     println!("     At 9600,8,n,1,hardflow...");
     std::io::stdout().flush().unwrap();
     check_test_message(port1, port2);
     check_test_message(port2, port1);
 }

 fn set_defaults(port: &mut dyn serialport::SerialPort) {
     port.set_baud_rate(9600).unwrap();
     port.set_data_bits(DataBits::Eight).unwrap();
     port.set_flow_control(FlowControl::Software).unwrap();
     port.set_parity(Parity::None).unwrap();
     port.set_stop_bits(StopBits::One).unwrap();
     // TODO: Clean up timeouts and use a less-arbitrary value here. The previous timeout of 0 made
     // test_dual_ports fail due to a timeout where having at least some some made them pass.
     port.set_timeout(Duration::from_millis(1000)).unwrap();
 }
	//! This example performs a test using real hardware ports.
	//!
	//! This tool serves as a debugging aid when encountering errors using `serialport-rs`. It should
	//! expose any kernel or driver bugs that your system may have by running physical ports through
	//! many configurations.
	//!
	//! There are 3 ways to run this example:
	//!
	//! 1) With a single port not connected to an external device:
	//! `cargo run --example hardware_check /dev/ttyUSB0`
	//!
	//! 2) With a single port physically connected in loopback mode (RX<->TX)
	//! `cargo run --example hardware_check /dev/ttyUSB0 --loopback`
	//!
	//! 3) With two ports physically connected to each other
	//! `cargo run --example hardware_check /dev/ttyUSB0 /dev/ttyUSB1`

	use std::io::Write;
	use std::str;
	use std::time::Duration;

	use assert_hex::assert_eq_hex;
	use clap::{Arg, Command};

	use serialport::{ClearBuffer, DataBits, FlowControl, Parity, SerialPort, StopBits};

	const TEST_MESSAGE: &[u8] = "Test Message".as_bytes();

	fn main() {
	let matches = Command::new("Serialport Example - Hardware Check")
	.about("Test hardware capabilities of serial ports")
	.disable_version_flag(true)
	.arg(Arg::new("port")
	.help("The device path to a serial port")
	.use_value_delimiter(false)
	.required(true))
	.arg(Arg::new("loopback")
	.help("Run extra tests if the port is configured for hardware loopback. Mutually exclusive with the --loopback-port option")
	.use_value_delimiter(false)
	.conflicts_with("loopback-port")
	.long("loopback"))
	.arg(Arg::new("loopback-port")
	.help("The device path of a second serial port that is connected to the first serial port. Mutually exclusive with the --loopback option.")
	.use_value_delimiter(false)
	.takes_value(true)
	.long("loopback-port"))
	.get_matches();

	let port1_name = matches.value_of("port").unwrap();
	let port2_name = matches.value_of("loopback-port").unwrap_or("");
	let port1_loopback = matches.is_present("loopback");

	// Loopback mode is only available when a single port is specified
	if port1_loopback && !port2_name.is_empty() {
	eprintln!("ERROR: loopback mode can only be enabled when a single port is specified.");
	::std::process::exit(1);
	}

	// Run single-port tests on port1
	let mut port1 = match serialport::new(port1_name, 9600).open() {
	Err(e) => {
	eprintln!("Failed to open \"{}\". Error: {}", port1_name, e);
	::std::process::exit(1);
	}
	Ok(p) => p,
	};
	test_single_port(&mut *port1, port1_loopback);

	if !port2_name.is_empty() {
	// Run single-port tests on port2
	let mut port2 = match serialport::new(port2_name, 9600).open() {
	Err(e) => {
	eprintln!("Failed to open \"{}\". Error: {}", port2_name, e);
	::std::process::exit(1);
	}
	Ok(p) => p,
	};
	test_single_port(&mut *port2, false);

	// Test loopback pair
	test_dual_ports(&mut port1, &mut port2);
	}
	}

	macro_rules! baud_rate_check {
	($port:ident, $baud:expr) => {
	let baud_rate = $baud;
	if let Err(e) = $port.set_baud_rate(baud_rate) {
	println!(" {:?}: FAILED ({})", baud_rate, e);
	}
	match $port.baud_rate() {
	Err(_) => println!(" {:?}: FAILED (error retrieving baud rate)", baud_rate),
	Ok(r) if r != baud_rate => println!(
	" {:?}: FAILED (baud rate {:?} does not match set baud rate {:?})",
	baud_rate, r, baud_rate
	),
	Ok(_) => println!(" {:?}: success", baud_rate),
	}
	};
	}

	macro_rules! data_bits_check {
	($port:ident, $data_bits:path) => {
	let data_bits = $data_bits;
	if let Err(e) = $port.set_data_bits(data_bits) {
	println!(" {:?}: FAILED ({})", data_bits, e);
	} else {
	match $port.data_bits() {
	Err(_) => println!("FAILED to retrieve data bits"),
	Ok(r) if r != data_bits => println!(
	" {:?}: FAILED (data bits {:?} does not match set data bits {:?})",
	data_bits, r, data_bits
	),
	Ok(_) => println!(" {:?}: success", data_bits),
	}
	}
	};
	}

	macro_rules! flow_control_check {
	($port:ident, $flow_control:path) => {
	let flow_control = $flow_control;
	if let Err(e) = $port.set_flow_control(flow_control) {
	println!(" {:?}: FAILED ({})", flow_control, e);
	} else {
	match $port.flow_control() {
	Err(_) => println!("FAILED to retrieve flow control"),
	Ok(r) if r != flow_control => println!(
	" {:?}: FAILED (flow control {:?} does not match set flow control {:?})",
	flow_control, r, flow_control
	),
	Ok(_) => println!(" {:?}: success", flow_control),
	}
	}
	};
	}

	macro_rules! parity_check {
	($port:ident, $parity:path) => {
	let parity = $parity;
	if let Err(e) = $port.set_parity(parity) {
	println!(" {:?}: FAILED ({})", parity, e);
	} else {
	match $port.parity() {
	Err(_) => println!("FAILED to retrieve parity"),
	Ok(r) if r != parity => println!(
	" {:?}: FAILED (parity {:?} does not match set parity {:?})",
	parity, r, parity
	),
	Ok(_) => println!(" {:?}: success", parity),
	}
	}
	};
	}

	macro_rules! stop_bits_check {
	($port:ident, $stop_bits:path) => {
	let stop_bits = $stop_bits;
	if let Err(e) = $port.set_stop_bits(stop_bits) {
	println!(" {:?}: FAILED ({})", stop_bits, e);
	} else {
	match $port.stop_bits() {
	Err(_) => println!("FAILED to retrieve stop bits"),
	Ok(r) if r != stop_bits => println!(
	"FAILED, stop bits {:?} does not match set stop bits {:?}",
	r, stop_bits
	),
	Ok(_) => println!(" {:?}: success", stop_bits),
	}
	}
	};
	}

	macro_rules! clear_check {
	($port:ident, $buffer_direction:path) => {
	let buffer_direction = $buffer_direction;
	match $port.clear(buffer_direction) {
	Ok(_) => println!(" {:?}: success", buffer_direction),
	Err(ref e) => println!(" {:?}: FAILED ({})", buffer_direction, e),
	}
	};
	}

	macro_rules! call_query_method_check {
	($port:ident, $func:path) => {
	match $func($port) {
	Ok(_) => println!(" {}: success", stringify!($func)),
	Err(ref e) => println!(" {}: FAILED ({})", stringify!($func), e),
	}
	};
	}

	fn test_single_port(port: &mut dyn serialport::SerialPort, loopback: bool) {
	println!("Testing '{}':", port.name().unwrap());

	// Test setting standard baud rates
	println!("Testing baud rates...");
	baud_rate_check!(port, 9600);
	baud_rate_check!(port, 38_400);
	baud_rate_check!(port, 115_200);

	// Test setting non-standard baud rates
	println!("Testing non-standard baud rates...");
	baud_rate_check!(port, 10_000);
	baud_rate_check!(port, 600_000);
	baud_rate_check!(port, 1_800_000);

	// Test setting the data bits
	println!("Testing data bits...");
	data_bits_check!(port, DataBits::Five);
	data_bits_check!(port, DataBits::Six);
	data_bits_check!(port, DataBits::Seven);
	data_bits_check!(port, DataBits::Eight);

	// Test setting flow control
	println!("Testing flow control...");
	flow_control_check!(port, FlowControl::Software);
	flow_control_check!(port, FlowControl::Hardware);
	flow_control_check!(port, FlowControl::None);

	// Test setting parity
	println!("Testing parity...");
	parity_check!(port, Parity::Odd);
	parity_check!(port, Parity::Even);
	parity_check!(port, Parity::None);

	// Test setting stop bits
	println!("Testing stop bits...");
	stop_bits_check!(port, StopBits::Two);
	stop_bits_check!(port, StopBits::One);

	// Test bytes to read and write
	println!("Testing bytes to read and write...");
	call_query_method_check!(port, SerialPort::bytes_to_write);
	call_query_method_check!(port, SerialPort::bytes_to_read);

	// Test clearing a buffer
	println!("Test clearing software buffers...");
	clear_check!(port, ClearBuffer::Input);
	clear_check!(port, ClearBuffer::Output);
	clear_check!(port, ClearBuffer::All);

	// Test transmitting data
	print!("Testing data transmission...");
	std::io::stdout().flush().unwrap();
	// Make sure the port has sane defaults
	set_defaults(port);
	let msg = "Test Message";
	port.write_all(msg.as_bytes())
	.expect("Unable to write bytes.");
	println!("success");

	if loopback {
	print!("Testing data reception...");
	port.set_timeout(Duration::from_millis(250)).ok();

	let mut buf = [0u8; 12];
	if let Err(e) = port.read_exact(&mut buf) {
	println!("FAILED ({})", e);
	} else {
	assert_eq!(
	str::from_utf8(&buf).unwrap(),
	msg,
	"Received message does not match sent"
	);
	println!("success");
	}
	}
	}

	fn check_test_message(sender: &mut dyn SerialPort, receiver: &mut dyn SerialPort) {
	// Ignore any "residue" from previous tests.
	sender.clear(ClearBuffer::All).unwrap();
	receiver.clear(ClearBuffer::All).unwrap();

	let send_buf = TEST_MESSAGE;
	let mut recv_buf = [0u8; TEST_MESSAGE.len()];

	sender.write_all(send_buf).unwrap();
	sender.flush().unwrap();

	match receiver.read_exact(&mut recv_buf) {
	Ok(()) => {
	assert_eq_hex!(recv_buf, send_buf, "Received message does not match sent",);
	println!(" success");
	}
	Err(e) => println!("FAILED: {:?}", e),
	}
	}

	fn test_dual_ports(port1: &mut dyn serialport::SerialPort, port2: &mut dyn serialport::SerialPort) {
	println!(
	"Testing paired ports '{}' and '{}':",
	port1.name().unwrap(),
	port2.name().unwrap()
	);

	// Make sure both ports are set to sane defaults
	set_defaults(port1);
	set_defaults(port2);

	// Test sending strings from port1 to port2
	println!(
	" Transmitting from {} to {}...",
	port1.name().unwrap(),
	port2.name().unwrap()
	);

	let baud_rate = 2_000_000;
	println!(" At {},8,n,1,noflow...", baud_rate);
	std::io::stdout().flush().unwrap();
	if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
	check_test_message(port1, port2);
	check_test_message(port2, port1);
	} else {
	println!("FAILED (does this platform & port support arbitrary baud rates?)");
	}

	let baud_rate = 115_200;
	println!(" At {},8,n,1,noflow...", baud_rate);
	std::io::stdout().flush().unwrap();
	if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
	check_test_message(port1, port2);
	check_test_message(port2, port1);
	} else {
	println!("FAILED");
	}

	let baud_rate = 57_600;
	println!(" At {},8,n,1,noflow...", baud_rate);
	std::io::stdout().flush().unwrap();
	if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
	check_test_message(port1, port2);
	check_test_message(port2, port1);
	} else {
	println!("FAILED");
	}

	let baud_rate = 10_000;
	println!(" At {},8,n,1,noflow...", baud_rate);
	std::io::stdout().flush().unwrap();
	if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
	check_test_message(port1, port2);
	check_test_message(port2, port1);
	} else {
	println!("FAILED (does this platform & port support arbitrary baud rates?)");
	}
	let baud_rate = 9600;
	println!(" At {},8,n,1,noflow...", baud_rate);
	std::io::stdout().flush().unwrap();
	if port1.set_baud_rate(baud_rate).is_ok() && port2.set_baud_rate(baud_rate).is_ok() {
	check_test_message(port1, port2);
	check_test_message(port2, port1);
	} else {
	println!("FAILED");
	}

	// Test flow control
	port1.set_flow_control(FlowControl::Software).unwrap();
	port2.set_flow_control(FlowControl::Software).unwrap();
	println!(" At 9600,8,n,1,softflow...");
	std::io::stdout().flush().unwrap();
	check_test_message(port1, port2);
	check_test_message(port2, port1);

	port1.set_flow_control(FlowControl::Hardware).unwrap();
	port2.set_flow_control(FlowControl::Hardware).unwrap();
	println!(" At 9600,8,n,1,hardflow...");
	std::io::stdout().flush().unwrap();
	check_test_message(port1, port2);
	check_test_message(port2, port1);
	}

	fn set_defaults(port: &mut dyn serialport::SerialPort) {
	port.set_baud_rate(9600).unwrap();
	port.set_data_bits(DataBits::Eight).unwrap();
	port.set_flow_control(FlowControl::Software).unwrap();
	port.set_parity(Parity::None).unwrap();
	port.set_stop_bits(StopBits::One).unwrap();
	// TODO: Clean up timeouts and use a less-arbitrary value here. The previous timeout of 0 made
	// test_dual_ports fail due to a timeout where having at least some some made them pass.
	port.set_timeout(Duration::from_millis(1000)).unwrap();
	}