Added some protocol tests.

Author: jonathanpallant

neotron-bmc-protocol/src/lib.rs

@@ -34,7 +34,7 @@ pub trait Receivable<'a>: Sized {
 // ============================================================================
 
 /// The ways this API can fail
-#[derive(Debug, Copy, Clone, Format)]
+#[derive(Debug, Copy, Clone, Format, PartialEq, Eq)]
 pub enum Error {
 	BadCrc,
 	BadLength,
@@ -45,7 +45,7 @@ pub enum Error {
 
 /// The kinds of [`Request`] the *Host* can make to the NBMC
 #[repr(u8)]
-#[derive(Debug, Copy, Clone, Format)]
+#[derive(Debug, Copy, Clone, Format, PartialEq, Eq)]
 pub enum RequestType {
 	Read = 0xC0,
 	ReadAlt = 0xC1,
@@ -57,7 +57,7 @@ pub enum RequestType {
 
 /// The NBMC returns this code to indicate whether the previous [`Request`] was
 /// succesful or not.
-#[derive(Debug, Copy, Clone, Format)]
+#[derive(Debug, Copy, Clone, Format, PartialEq, Eq)]
 pub enum ResponseResult {
 	/// The [`Request`] was correctly understood and actioned.
 	Ok = 0xA0,
@@ -85,7 +85,7 @@ pub enum ResponseResult {
 // ============================================================================
 
 /// A *Request* made by the *Host* to the *NBMC*
-#[derive(Debug, Clone, Format)]
+#[derive(Debug, Clone, Format, PartialEq, Eq)]
 pub struct Request {
 	pub request_type: RequestType,
 	pub register: u8,
@@ -94,7 +94,7 @@ pub struct Request {
 }
 
 /// A *Response* sent by the *NBMC* in reply to a [`Request`] from a *Host*
-#[derive(Debug, Clone, Format)]
+#[derive(Debug, Clone, Format, PartialEq, Eq)]
 pub struct Response<'a> {
 	pub result: ResponseResult,
 	pub data: &'a [u8],
@@ -103,7 +103,7 @@ pub struct Response<'a> {
 
 /// Describes the [semantic version](https://semver.org) of this implementation
 /// of the NBMC interface.
-#[derive(Debug, Copy, Clone, Format)]
+#[derive(Debug, Copy, Clone, Format, PartialEq, Eq)]
 pub struct ProtocolVersion {
 	major: u8,
 	minor: u8,
@@ -140,9 +140,9 @@ impl Request {
 	pub fn new_read(use_alt: bool, register: u8, length: u8) -> Request {
 		let mut req = Request {
 			request_type: if use_alt {
-				RequestType::Read
-			} else {
 				RequestType::ReadAlt
+			} else {
+				RequestType::Read
 			},
 			register,
 			length_or_data: length,
@@ -161,9 +161,9 @@ impl Request {
 	pub fn new_short_write(use_alt: bool, register: u8, data: u8) -> Request {
 		let mut req = Request {
 			request_type: if use_alt {
-				RequestType::ShortWrite
-			} else {
 				RequestType::ShortWriteAlt
+			} else {
+				RequestType::ShortWrite
 			},
 			register,
 			length_or_data: data,
@@ -183,9 +183,9 @@ impl Request {
 	pub fn new_long_write(use_alt: bool, register: u8, length: u8) -> Request {
 		let mut req = Request {
 			request_type: if use_alt {
-				RequestType::LongWrite
-			} else {
 				RequestType::LongWriteAlt
+			} else {
+				RequestType::LongWrite
 			},
 			register,
 			length_or_data: length,
@@ -377,21 +377,21 @@ impl ProtocolVersion {
 	///
 	/// // This is compatible.
 	/// let bmc_a = ProtocolVersion::new(1, 1, 1);
-	/// assert!(bmc_a.is_compatible(&my_version));
+	/// assert!(bmc_a.is_compatible_with(&my_version));
 	///
 	/// // This is incompatible - patch is too low.
 	/// let bmc_b = ProtocolVersion::new(1, 0, 0);
-	/// assert!(!bmc_b.is_compatible(&my_version));
+	/// assert!(!bmc_b.is_compatible_with(&my_version));
 	///
 	/// // This is incompatible - major is too high.
 	/// let bmc_c = ProtocolVersion::new(2, 0, 0);
-	/// assert!(!bmc_c.is_compatible(&my_version));
+	/// assert!(!bmc_c.is_compatible_with(&my_version));
 	///
 	/// // This is incompatible - major is too low.
 	/// let bmc_d = ProtocolVersion::new(0, 1, 0);
-	/// assert!(!bmc_d.is_compatible(&my_version));
+	/// assert!(!bmc_d.is_compatible_with(&my_version));
 	/// ```
-	pub const fn is_compatible(&self, my_version: &ProtocolVersion) -> bool {
+	pub const fn is_compatible_with(&self, my_version: &ProtocolVersion) -> bool {
 		if self.major == my_version.major {
 			if self.minor > my_version.minor {
 				true