More number conversion code

100% coverage

.idea/trevors_utilities.iml

@@ -3,6 +3,7 @@
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
     </content>
     <orderEntry type="inheritedJdk" />

src/bin/test.rs

@@ -1,4 +0,0 @@
-fn main() {
-    println!("Taxation is Theft");
-    println!("MANIFEST_DIR: {}", env!("CARGO_MANIFEST_DIR"));
-}

src/lib.rs

@@ -1,2 +1,2 @@
-pub mod test_loader;
 pub mod test_compression;
+pub mod number_system_conversion;

src/number_system_conversion.rs

@@ -0,0 +1,100 @@
+pub struct NumberSystemConversion {}
+
+impl NumberSystemConversion {
+    /// byte_to_bool
+    ///
+    /// Convert a u8 byte into a set of bool of the value
+    ///
+    /// ex: 0xff -> true, true, true, true, true, true, true, true
+    ///     0xa0 -> true, false, true, false, false, false, false, false
+    pub fn byte_to_bool(from: u8) -> [bool; 8] {
+        let mut return_values = [false; 8];
+        for i in 0..8 {
+            let new_value = from >> i & 0x1 == 1;
+            return_values[i as usize] = new_value;
+        }
+        return_values
+    }
+
+    /// bool_to_byte
+    ///
+    /// Convert a set of bool to a single byte
+    ///
+    /// ex: true, true, true, true, true, true, true, true         -> 0xff
+    ///     true, false, true, false, false, false, false, false   -> 0xa0
+    ///     false, false, false, false, false, false, false, false -> 0x00
+    pub fn bool_to_byte(from: [bool; 8]) -> u8 {
+        let mut return_value = 0u8;
+        for i in 0..from.len() {
+            let new_bit = 0x1 << i;
+            if from[i] {
+                return_value |= new_bit
+            }
+        }
+        return_value
+    }
+
+    /// swap_endian_u16
+    ///
+    /// Swaps endianness of a u16
+    ///
+    /// ex: 0xabcd -> 0xcdab
+    ///     0x00ff -> 0xff00
+    pub fn swap_endian_u16(from: u16) -> u16 {
+        // shift low to high and high to low
+        // merge the bits to a u16
+        (from & 0xff) << 8 | (from & 0xff00) >> 8
+    }
+
+    /// Swap endian u32
+    ///
+    /// Swaps endianness of a u32
+    ///
+    /// ex. 0x12345678 -> 0x78563412
+    pub fn swap_endian_u32(from: u32) -> u32 {
+        let mut bytes = vec![0, 0, 0, 0];
+        // mask out what we want...
+        bytes[0] = from & 0x000000ff;
+        bytes[1] = (from & 0x0000ff00) >> 8;
+        bytes[2] = (from & 0x00ff0000) >> 16;
+        bytes[3] = (from & 0xff000000) >> 24;
+        // ...shift it into the right position
+        bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]
+    }
+
+    /// split_bytes_u16
+    ///
+    /// Splits a u16 into its high and low bytes
+    ///
+    /// ex: 0xabcd -> 0xab, 0xcd
+    ///     0x0000 -> 0x00, 0x00
+    ///     0xffff -> 0xff, 0xff
+    pub fn split_bytes_u16(from: u16) -> (u8, u8) {
+        let high = from.rotate_left(8) as u8;
+        let low = (from & 0xff) as u8;
+
+        (high, low)
+    }
+
+    /// join_bytes_u16
+    pub fn join_bytes_u16(high: u16, low: u16) -> u16 {
+        low | high << 8
+    }
+
+    /// combine_u8_to_u16
+    ///
+    /// Combines a pair of u8 values into a single u16 with high
+    /// and low bytes specified
+    ///
+    /// ex: (0xff, 0x00) -> 0x00ff
+    ///     (0x00, 0xff) -> 0xff00
+    ///     (0xbe, 0xef) -> 0xefbe
+    ///     (0xef, 0xbe) -> 0xbeef
+    pub fn combine_u8_to_u16(low: u8, high: u8) -> u16 {
+        (high as u16) << 8 | low as u16
+    }
+
+    pub fn join_bytes_u16_from_u8(high: u8, low: u8) -> u16 {
+        low as u16 | ((high as u16) << 8)
+    }
+}

src/test_compression.rs

@@ -1,4 +1,4 @@
-use std::fs::File;
+use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
 use std::path::Path;
 use flate2::Compression;
@@ -16,6 +16,7 @@ impl TestCompression {
             .expect("Failed to write data");
         encoder.finish().expect("Failed to finish compression")
     }
+
     pub fn decompress_to_string(compressed_data: &[u8]) -> Result<String, std::io::Error> {
         let mut decoder = DeflateDecoder::new(compressed_data);
         let mut decompressed = String::new();
@@ -34,14 +35,23 @@ impl TestCompression {
 
     /// Save a str to a specified file as compressed data
     pub fn save_string_as_compressed_data(source: &str, target_file: &Path) {
-        let mut compressed_file = File::open(&target_file).expect(format!("Unable to open target file [{}]", target_file.display()).as_str());
+        let mut compressed_file = OpenOptions::new()
+            .write(true)
+            .truncate(true) // optional: clear existing contents
+            .create(true)
+            .open(target_file)
+            .expect(&format!("Unable to open target file [{}] for writing", target_file.display()));
+
         let compressed_data = TestCompression::compress_string(source);
-        compressed_file.write_all(&compressed_data).expect(format!("Unable to write compressed data to [{}]", target_file.display()).as_str());
+        compressed_file
+            .write_all(&compressed_data)
+            .expect(&format!("Unable to write compressed data to [{}]", target_file.display()));
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use tempfile::NamedTempFile;
     use super::*;
 
     #[test]
@@ -63,10 +73,51 @@ mod tests {
         // compress string to file...
         let string_to_compress = "The quick brown fox jumps over the lazy dog.";
         let compressed_string = TestCompression::compress_string(string_to_compress);
-        let temp_target = tempfile().unwrap();
+        let mut temp_target = NamedTempFile::new().unwrap();
+        let mut temp_reader = temp_target.reopen();
+
+        // ...write the compressed version to a file...
+        temp_target.write_all(&compressed_string).expect("Unable to write compressed file for test");
         //
         // ...decompress from file...
+        let mut compressed_read = Vec::new();
+        temp_reader.unwrap().read_to_end(&mut compressed_read).expect("Unable to read compressed data for test");
+        let decompresed = TestCompression::decompress_to_string(&compressed_read).expect("Unable to decompress string for test");
         //
         // ...verify its the same.
+        assert_eq!(
+            string_to_compress,
+            decompresed
+        );
+    }
+
+    #[test]
+    fn file_compression_reader() {
+        // Get the 'sample text'
+        let to_compress = "The quick brown fox jumps over the lazy dog.";
+
+        // ...write it to the temp file...
+        let mut temp_file = NamedTempFile::new().expect("Unable to get temp file for test");
+        temp_file.write_all(&*TestCompression::compress_string(to_compress)).expect("Unable to write compressed data to temp file for test");
+        let temp2_path = temp_file.path();
+        let uncompressed_text = TestCompression::load_compressed_file_to_string(temp2_path);
+
+        assert_eq!(uncompressed_text, to_compress);
+    }
+
+    #[test]
+    fn file_compression_writer() {
+        let to_compress = "The quick brown fox jumps over the lazy dog.";
+
+        let mut temp_file = NamedTempFile::new().expect("Unable to get temp file for test.");
+        TestCompression::save_string_as_compressed_data(to_compress, temp_file.path());
+
+        // read back the compressed text
+        let mut read_buffer = Vec::new();
+        temp_file.read_to_end(&mut read_buffer).expect("Unable to read compressed data back.");
+        let decompressed_text = TestCompression::decompress_to_string(&read_buffer).expect("Unable to decompress text");
+        assert_eq!(
+            decompressed_text,
+            to_compress);
     }
 }

src/test_loader.rs

@@ -1,15 +0,0 @@
-use std::path::Path;
-
-pub fn load_test_result(base_path: &Path, suffix: String) -> String {
-    let full_path = format!("{}/{}", base_path.display(), suffix);
-    std::fs::read_to_string(full_path).unwrap()
-}
-
-pub fn load_compressed_test_result(base_path: &Path, suffix: String) -> String {
-    // first load the data...
-
-    // ...then decompress it...
-    // let raw_result = decompress_to_string(compressed_result);
-    // ...finally return it
-    String::new()
-}

tests/number_system_conversion.rs

@@ -0,0 +1,99 @@
+use std::collections::BTreeMap;
+use trevors_utilities::number_system_conversion::NumberSystemConversion;
+
+#[test]
+fn byte_to_bool_and_bool_to_byte() {
+    // confirm a byte becomes a valid bool
+    // **** NOTE THAT THIS VISUALLY IS BACKWARDS AS INDEX 0 IS FIRST AND LSB IS LAST ****
+    let test_params: BTreeMap<u8, [bool; 8]> = BTreeMap::from([
+        (0xff, [true, true, true, true, true, true, true, true]),
+        (0x00, [false, false, false, false, false, false, false, false]),
+        (0xa0, [false, false, false, false, false, true, false, true])
+    ]);
+
+    for (src, dst) in test_params {
+        assert_eq!(
+            dst,
+            NumberSystemConversion::byte_to_bool(src),
+            "Unable to convert [{}] to [{:?}]", src, dst
+        );
+        assert_eq!(
+            src,
+            NumberSystemConversion::bool_to_byte(dst),
+            "Unable to convert [{:?}] to [{}]", dst, src
+        );
+        assert_eq!(
+            src,
+            NumberSystemConversion::bool_to_byte(
+                NumberSystemConversion::byte_to_bool(src))
+        );
+    }
+}
+
+#[test]
+fn swap_endianness_u16() {
+    let test_params: Vec<(u16, u16)> = vec![(0xabcd, 0xcdab), (0x0000, 0x0000), (0xffff, 0xffff), (0x00ff, 0xff00)];
+
+    for (src, dst) in test_params {
+        assert_eq!(src, NumberSystemConversion::swap_endian_u16(dst));
+        assert_eq!(src, NumberSystemConversion::swap_endian_u16(NumberSystemConversion::swap_endian_u16(src)));
+        assert_eq!(dst, NumberSystemConversion::swap_endian_u16(src));
+        assert_eq!(dst, NumberSystemConversion::swap_endian_u16(NumberSystemConversion::swap_endian_u16(dst)));
+    }
+}
+
+#[test]
+fn swap_endinness_u32() {
+    let test_params: Vec<(u32, u32)> = vec![
+        (0xabcdef01, 0x01efcdab),
+        (0x12345678, 0x78563412),
+        (0xbadbeef0, 0xf0eedbba)
+    ];
+
+    for (src, dst) in test_params {
+        assert_eq!(src, NumberSystemConversion::swap_endian_u32(dst));
+        assert_eq!(src, NumberSystemConversion::swap_endian_u32(
+            NumberSystemConversion::swap_endian_u32(src)));
+        assert_eq!(dst, NumberSystemConversion::swap_endian_u32(src));
+        assert_eq!(dst, NumberSystemConversion::swap_endian_u32(
+            NumberSystemConversion::swap_endian_u32(dst)));
+    }
+}
+
+#[test]
+fn split_bytes_u16_join_bytes_u16() {
+    let test_params = BTreeMap::from([
+        (0x0000, (0x00, 0x00)),
+        (0xabcd, (0xab, 0xcd)),
+        (0xffff, (0xff, 0xff)),
+        (0xbeef, (0xbe, 0xef))
+    ]);
+
+    for (joined, (high, low)) in test_params {
+        assert_eq!(
+            (high, low),
+            NumberSystemConversion::split_bytes_u16(joined));
+        assert_eq!(
+            joined,
+            NumberSystemConversion::join_bytes_u16_from_u8(high, low));
+        assert_eq!(
+            joined,
+            NumberSystemConversion::join_bytes_u16(high as u16, low as u16));
+    }
+}
+
+#[test]
+fn combine_u8_to_u16() {
+    let test_params: Vec<((u8, u8), u16)> = vec![
+        ((0xff, 0x00), 0x00ff),
+        ((0x00, 0xff), 0xff00),
+        ((0xbe, 0xef), 0xefbe),
+        ((0xef, 0xbe), 0xbeef)
+    ];
+
+    for  ((low, high), base) in test_params {
+        assert_eq!(
+            base, NumberSystemConversion::combine_u8_to_u16(low, high)
+        )
+    }
+}