csharp_binary_encoding/
lib.rs

1#![doc = include_str!("../README.md")]
2#![cfg_attr(feature = "f16", feature(f16))]
3#![cfg_attr(docsrs, feature(doc_cfg))]
4
5mod encoding {
6    mod binaryreader;
7    pub use binaryreader::{BinaryReader, DataDecodeError, InvalidDataError};
8    mod binarywriter;
9    pub use binarywriter::BinaryWriter;
10}
11pub use encoding::{BinaryReader, DataDecodeError, InvalidDataError};
12pub use encoding::BinaryWriter;
13
14
15#[cfg(test)]
16mod tests {
17    use super::*;
18    use std::io::Error;
19    use crate::encoding::DataDecodeError;
20
21    const TEST_FOLDER: &str = "csharp_testing";
22
23    #[test]
24    fn decode_all_types() -> Result<(), DataDecodeError>{
25        use std::fs::File;
26        use xshell::{Shell, cmd};
27        let sh = Shell::new().unwrap();
28        sh.change_dir(&TEST_FOLDER.to_string());
29        cmd!(sh, "dotnet run generate").run().unwrap();
30
31        let file = File::open(TEST_FOLDER.to_string()+ "/output.bin")?;
32        let mut reader = BinaryReader::new(file);
33
34        // read the test data written in generate_test_bin.cs
35        assert!(reader.read_boolean()?);
36        assert!(!reader.read_boolean()?);
37        assert_eq!(0x45, reader.read_byte()?);
38        assert_eq!(vec![0x01, 0x02, 0x03, 0x04, 0x05], reader.read_bytes(5)?);
39        assert_eq!('\u{2603}' as char, reader.read_char()?);
40        assert_eq!(727.247_f64, reader.read_f64()?);
41        cfg_if::cfg_if! {
42            if #[cfg(feature = "f16")] {
43                assert_eq!(247_f16, reader.read_f16()?);
44            } else {
45                reader.read_bytes(2)?; // just skip the two bytes instead
46            }
47        }
48        assert_eq!(-5_i16, reader.read_i16()?);
49        assert_eq!(-100_i32, reader.read_i32()?);
50        assert_eq!(-2147483649_i64, reader.read_i64()?);
51        assert_eq!(-112_i8, reader.read_i8()?);
52        assert_eq!(5.2_f32, reader.read_f32()?);
53        assert_eq!(-723_i32, reader.read_7_bit_encoded_int()?);
54        assert_eq!(404_i32, reader.read_7_bit_encoded_int()?);
55        assert_eq!(9000000000000000000_i64, reader.read_7_bit_encoded_int64()?);
56        assert_eq!(-500000000000000000_i64, reader.read_7_bit_encoded_int64()?);
57        assert_eq!("meowmeowmeowmeowmeow".to_string(), reader.read_string()?);
58        assert_eq!(624_u16, reader.read_u16()?);
59        assert_eq!(3000000000_u32, reader.read_u32()?);
60        assert_eq!(42307830165_u64, reader.read_u64()?);
61        assert_eq!('\0', reader.read_char()?);
62
63        let _ = cmd!(sh, "rm -f output.bin").run();
64
65        Ok(())
66    }
67
68    #[test]
69    fn encode_all_types(){
70        use std::fs::File;
71        use xshell::{Shell, cmd};
72        
73        let sh = Shell::new().unwrap();
74        sh.change_dir(&TEST_FOLDER.to_string());
75
76        let _ = cmd!(sh, "rm -f input.bin").run().unwrap();
77
78        let mut file = File::create(TEST_FOLDER.to_string() + "/input.bin").unwrap();
79        let mut writer = BinaryWriter::new(&mut file);
80
81        writer.write_boolean(true).unwrap();
82        writer.write_boolean(false).unwrap();
83        writer.write_byte(0x45).unwrap();
84        writer.write_bytes([0x01, 0x02, 0x03, 0x04, 0x05].as_slice()).unwrap();
85        writer.write_char('\u{2603}').unwrap();
86        writer.write_f64(727.247_f64).unwrap();
87        cfg_if::cfg_if!{
88            if #[cfg(feature = "f16")] {
89                writer.write_f16(247_f16).unwrap();
90            } else {
91                writer.write_bytes([0x00, 0x00].as_slice()).unwrap();
92            }
93        }
94        writer.write_i16(-5).unwrap();
95        writer.write_i32(-100).unwrap();
96        writer.write_i64(-2147483649).unwrap();
97        writer.write_i8(-112).unwrap();
98        writer.write_f32(5.2_f32).unwrap();
99        writer.write_7_bit_encoded_int(-723).unwrap();
100        writer.write_7_bit_encoded_int(404).unwrap();
101        writer.write_7_bit_encoded_int64(9000000000000000000).unwrap();
102        writer.write_7_bit_encoded_int64(-500000000000000000).unwrap();
103        writer.write_string("meowmeowmeowmeowmeow").unwrap();
104        writer.write_u16(624).unwrap();
105        writer.write_u32(3000000000).unwrap();
106        writer.write_u64(42307830165).unwrap();
107        writer.write_char('\0').unwrap();
108
109        cfg_if::cfg_if!{
110            if #[cfg(feature = "f16")] {
111                cmd!(sh, "dotnet run verify f16").run().unwrap();
112            } else {
113                cmd!(sh, "dotnet run verify").run().unwrap();
114            }
115        }
116    }
117
118    #[test] 
119    fn overflow_7_bit_encoded_int() -> Result<(), DataDecodeError>{
120        use std::io::Cursor;
121        let data: [u8; 15] = [ 0xFF; 15 ];
122        let cursor = Cursor::new(data);
123
124        let mut reader = BinaryReader::new(cursor);
125        let result = reader.read_7_bit_encoded_int();
126        if let Ok(_inner) = result {
127            panic!() // it should have errored
128        }
129
130        let result_64 = reader.read_7_bit_encoded_int64();
131        if let Ok(_inner) = result_64 {
132            panic!() // it should have errored
133        }
134        Ok(())
135    }
136}
csharp_binary_encoding/lib.rs

csharp_binary_encoding/
lib.rs
