diff options
author | Pavel Grigorenko <grigorenkopv@ya.ru> | 2023-08-21 15:37:47 +0300 |
---|---|---|
committer | Pavel Grigorenko <grigorenkopv@ya.ru> | 2023-08-21 16:01:22 +0300 |
commit | e1e53335d3043729763d1c7afbee82676323ad91 (patch) | |
tree | 9e37a91896f84d777f7736e0e2ea8e2da2f70da0 /src | |
parent | 5981fc87250ed4fe4d95c5c9dc8bc8c8e92e309c (diff) |
Move tests to a separate `#[cfg(test)]` module
Diffstat (limited to 'src')
-rw-r--r-- | src/main.rs (renamed from src/bin/hexyl.rs) | 158 | ||||
-rw-r--r-- | src/tests.rs | 156 |
2 files changed, 159 insertions, 155 deletions
diff --git a/src/bin/hexyl.rs b/src/main.rs index 5456c32..5e022f3 100644 --- a/src/bin/hexyl.rs +++ b/src/main.rs @@ -19,6 +19,9 @@ use terminal_size::terminal_size; use hexyl::{Base, BorderStyle, Endianness, Input, PrinterBuilder}; +#[cfg(test)] +mod tests; + const DEFAULT_BLOCK_SIZE: i64 = 512; fn run() -> Result<()> { @@ -765,158 +768,3 @@ fn try_parse_as_hex_number(n: &str) -> Option<Result<i64, ByteOffsetParseError>> i64::from_str_radix(num, 16).map_err(ParseNum) }) } - -#[test] -fn unit_multipliers() { - use Unit::*; - assert_eq!(Kilobyte.get_multiplier(), 1000 * Byte.get_multiplier()); - assert_eq!(Megabyte.get_multiplier(), 1000 * Kilobyte.get_multiplier()); - assert_eq!(Gigabyte.get_multiplier(), 1000 * Megabyte.get_multiplier()); - assert_eq!(Terabyte.get_multiplier(), 1000 * Gigabyte.get_multiplier()); - - assert_eq!(Kibibyte.get_multiplier(), 1024 * Byte.get_multiplier()); - assert_eq!(Mebibyte.get_multiplier(), 1024 * Kibibyte.get_multiplier()); - assert_eq!(Gibibyte.get_multiplier(), 1024 * Mebibyte.get_multiplier()); - assert_eq!(Tebibyte.get_multiplier(), 1024 * Gibibyte.get_multiplier()); -} - -#[test] -fn test_process_sign() { - use ByteOffsetKind::*; - use ByteOffsetParseError::*; - assert_eq!(process_sign_of("123"), Ok(("123", ForwardFromBeginning))); - assert_eq!(process_sign_of("+123"), Ok(("123", ForwardFromLastOffset))); - assert_eq!(process_sign_of("-123"), Ok(("123", BackwardFromEnd))); - assert_eq!(process_sign_of("-"), Err(EmptyAfterSign)); - assert_eq!(process_sign_of("+"), Err(EmptyAfterSign)); - assert_eq!(process_sign_of(""), Err(Empty)); -} - -#[test] -fn test_parse_as_hex() { - assert_eq!(try_parse_as_hex_number("73"), None); - assert_eq!(try_parse_as_hex_number("0x1337"), Some(Ok(0x1337))); - assert!(matches!(try_parse_as_hex_number("0xnope"), Some(Err(_)))); - assert!(matches!(try_parse_as_hex_number("0x-1"), Some(Err(_)))); -} - -#[test] -fn extract_num_and_unit() { - use ByteOffsetParseError::*; - use Unit::*; - // byte is default unit - assert_eq!(extract_num_and_unit_from("4"), Ok((4, Byte))); - // blocks are returned without customization - assert_eq!( - extract_num_and_unit_from("2blocks"), - Ok((2, Block { custom_size: None })) - ); - // no normalization is performed - assert_eq!(extract_num_and_unit_from("1024kb"), Ok((1024, Kilobyte))); - - // unit without number results in error - assert_eq!( - extract_num_and_unit_from("gib"), - Err(EmptyWithUnit("gib".to_string())) - ); - // empty string results in error - assert_eq!(extract_num_and_unit_from(""), Err(Empty)); - // an invalid unit results in an error - assert_eq!( - extract_num_and_unit_from("25litres"), - Err(InvalidUnit("litres".to_string())) - ); -} - -#[test] -fn test_parse_byte_offset() { - use ByteOffsetParseError::*; - - macro_rules! success { - ($input: expr, $expected_kind: ident $expected_value: expr) => { - success!($input, $expected_kind $expected_value; block_size: DEFAULT_BLOCK_SIZE) - }; - ($input: expr, $expected_kind: ident $expected_value: expr; block_size: $block_size: expr) => { - assert_eq!( - parse_byte_offset($input, PositiveI64::new($block_size).unwrap()), - Ok( - ByteOffset { - value: NonNegativeI64::new($expected_value).unwrap(), - kind: ByteOffsetKind::$expected_kind, - } - ), - ); - }; - } - - macro_rules! error { - ($input: expr, $expected_err: expr) => { - assert_eq!( - parse_byte_offset($input, PositiveI64::new(DEFAULT_BLOCK_SIZE).unwrap()), - Err($expected_err), - ); - }; - } - - success!("0", ForwardFromBeginning 0); - success!("1", ForwardFromBeginning 1); - success!("1", ForwardFromBeginning 1); - success!("100", ForwardFromBeginning 100); - success!("+100", ForwardFromLastOffset 100); - - success!("0x0", ForwardFromBeginning 0); - success!("0xf", ForwardFromBeginning 15); - success!("0xdeadbeef", ForwardFromBeginning 3_735_928_559); - - success!("1KB", ForwardFromBeginning 1000); - success!("2MB", ForwardFromBeginning 2000000); - success!("3GB", ForwardFromBeginning 3000000000); - success!("4TB", ForwardFromBeginning 4000000000000); - success!("+4TB", ForwardFromLastOffset 4000000000000); - - success!("1GiB", ForwardFromBeginning 1073741824); - success!("2TiB", ForwardFromBeginning 2199023255552); - success!("+2TiB", ForwardFromLastOffset 2199023255552); - - success!("0xff", ForwardFromBeginning 255); - success!("0xEE", ForwardFromBeginning 238); - success!("+0xFF", ForwardFromLastOffset 255); - - success!("1block", ForwardFromBeginning 512; block_size: 512); - success!("2block", ForwardFromBeginning 1024; block_size: 512); - success!("1block", ForwardFromBeginning 4; block_size: 4); - success!("2block", ForwardFromBeginning 8; block_size: 4); - - // empty string is invalid - error!("", Empty); - // These are also bad. - error!("+", EmptyAfterSign); - error!("-", EmptyAfterSign); - error!("K", InvalidNumAndUnit("K".to_owned())); - error!("k", InvalidNumAndUnit("k".to_owned())); - error!("m", InvalidNumAndUnit("m".to_owned())); - error!("block", EmptyWithUnit("block".to_owned())); - // leading/trailing space is invalid - error!(" 0", InvalidNumAndUnit(" 0".to_owned())); - error!("0 ", InvalidUnit(" ".to_owned())); - // Signs after the hex prefix make no sense - error!("0x-12", SignFoundAfterHexPrefix('-')); - // This was previously accepted but shouldn't be. - error!("0x+12", SignFoundAfterHexPrefix('+')); - // invalid suffix - error!("1234asdf", InvalidUnit("asdf".to_owned())); - // bad numbers - error!("asdf1234", InvalidNumAndUnit("asdf1234".to_owned())); - error!("a1s2d3f4", InvalidNumAndUnit("a1s2d3f4".to_owned())); - // multiplication overflows u64 - error!("20000000TiB", UnitMultiplicationOverflow); - - assert!( - match parse_byte_offset("99999999999999999999", PositiveI64::new(512).unwrap()) { - // We can't check against the kind of the `ParseIntError`, so we'll just make sure it's the - // same as trying to do the parse directly. - Err(ParseNum(e)) => e == "99999999999999999999".parse::<i64>().unwrap_err(), - _ => false, - } - ); -} diff --git a/src/tests.rs b/src/tests.rs new file mode 100644 index 0000000..73f4404 --- /dev/null +++ b/src/tests.rs @@ -0,0 +1,156 @@ +use super::*; + +#[test] +fn unit_multipliers() { + use Unit::*; + assert_eq!(Kilobyte.get_multiplier(), 1000 * Byte.get_multiplier()); + assert_eq!(Megabyte.get_multiplier(), 1000 * Kilobyte.get_multiplier()); + assert_eq!(Gigabyte.get_multiplier(), 1000 * Megabyte.get_multiplier()); + assert_eq!(Terabyte.get_multiplier(), 1000 * Gigabyte.get_multiplier()); + + assert_eq!(Kibibyte.get_multiplier(), 1024 * Byte.get_multiplier()); + assert_eq!(Mebibyte.get_multiplier(), 1024 * Kibibyte.get_multiplier()); + assert_eq!(Gibibyte.get_multiplier(), 1024 * Mebibyte.get_multiplier()); + assert_eq!(Tebibyte.get_multiplier(), 1024 * Gibibyte.get_multiplier()); +} + +#[test] +fn test_process_sign() { + use ByteOffsetKind::*; + use ByteOffsetParseError::*; + assert_eq!(process_sign_of("123"), Ok(("123", ForwardFromBeginning))); + assert_eq!(process_sign_of("+123"), Ok(("123", ForwardFromLastOffset))); + assert_eq!(process_sign_of("-123"), Ok(("123", BackwardFromEnd))); + assert_eq!(process_sign_of("-"), Err(EmptyAfterSign)); + assert_eq!(process_sign_of("+"), Err(EmptyAfterSign)); + assert_eq!(process_sign_of(""), Err(Empty)); +} + +#[test] +fn test_parse_as_hex() { + assert_eq!(try_parse_as_hex_number("73"), None); + assert_eq!(try_parse_as_hex_number("0x1337"), Some(Ok(0x1337))); + assert!(matches!(try_parse_as_hex_number("0xnope"), Some(Err(_)))); + assert!(matches!(try_parse_as_hex_number("0x-1"), Some(Err(_)))); +} + +#[test] +fn extract_num_and_unit() { + use ByteOffsetParseError::*; + use Unit::*; + // byte is default unit + assert_eq!(extract_num_and_unit_from("4"), Ok((4, Byte))); + // blocks are returned without customization + assert_eq!( + extract_num_and_unit_from("2blocks"), + Ok((2, Block { custom_size: None })) + ); + // no normalization is performed + assert_eq!(extract_num_and_unit_from("1024kb"), Ok((1024, Kilobyte))); + + // unit without number results in error + assert_eq!( + extract_num_and_unit_from("gib"), + Err(EmptyWithUnit("gib".to_string())) + ); + // empty string results in error + assert_eq!(extract_num_and_unit_from(""), Err(Empty)); + // an invalid unit results in an error + assert_eq!( + extract_num_and_unit_from("25litres"), + Err(InvalidUnit("litres".to_string())) + ); +} + +#[test] +fn test_parse_byte_offset() { + use ByteOffsetParseError::*; + + macro_rules! success { + ($input: expr, $expected_kind: ident $expected_value: expr) => { + success!($input, $expected_kind $expected_value; block_size: DEFAULT_BLOCK_SIZE) + }; + ($input: expr, $expected_kind: ident $expected_value: expr; block_size: $block_size: expr) => { + assert_eq!( + parse_byte_offset($input, PositiveI64::new($block_size).unwrap()), + Ok( + ByteOffset { + value: NonNegativeI64::new($expected_value).unwrap(), + kind: ByteOffsetKind::$expected_kind, + } + ), + ); + }; + } + + macro_rules! error { + ($input: expr, $expected_err: expr) => { + assert_eq!( + parse_byte_offset($input, PositiveI64::new(DEFAULT_BLOCK_SIZE).unwrap()), + Err($expected_err), + ); + }; + } + + success!("0", ForwardFromBeginning 0); + success!("1", ForwardFromBeginning 1); + success!("1", ForwardFromBeginning 1); + success!("100", ForwardFromBeginning 100); + success!("+100", ForwardFromLastOffset 100); + + success!("0x0", ForwardFromBeginning 0); + success!("0xf", ForwardFromBeginning 15); + success!("0xdeadbeef", ForwardFromBeginning 3_735_928_559); + + success!("1KB", ForwardFromBeginning 1000); + success!("2MB", ForwardFromBeginning 2000000); + success!("3GB", ForwardFromBeginning 3000000000); + success!("4TB", ForwardFromBeginning 4000000000000); + success!("+4TB", ForwardFromLastOffset 4000000000000); + + success!("1GiB", ForwardFromBeginning 1073741824); + success!("2TiB", ForwardFromBeginning 2199023255552); + success!("+2TiB", ForwardFromLastOffset 2199023255552); + + success!("0xff", ForwardFromBeginning 255); + success!("0xEE", ForwardFromBeginning 238); + success!("+0xFF", ForwardFromLastOffset 255); + + success!("1block", ForwardFromBeginning 512; block_size: 512); + success!("2block", ForwardFromBeginning 1024; block_size: 512); + success!("1block", ForwardFromBeginning 4; block_size: 4); + success!("2block", ForwardFromBeginning 8; block_size: 4); + + // empty string is invalid + error!("", Empty); + // These are also bad. + error!("+", EmptyAfterSign); + error!("-", EmptyAfterSign); + error!("K", InvalidNumAndUnit("K".to_owned())); + error!("k", InvalidNumAndUnit("k".to_owned())); + error!("m", InvalidNumAndUnit("m".to_owned())); + error!("block", EmptyWithUnit("block".to_owned())); + // leading/trailing space is invalid + error!(" 0", InvalidNumAndUnit(" 0".to_owned())); + error!("0 ", InvalidUnit(" ".to_owned())); + // Signs after the hex prefix make no sense + error!("0x-12", SignFoundAfterHexPrefix('-')); + // This was previously accepted but shouldn't be. + error!("0x+12", SignFoundAfterHexPrefix('+')); + // invalid suffix + error!("1234asdf", InvalidUnit("asdf".to_owned())); + // bad numbers + error!("asdf1234", InvalidNumAndUnit("asdf1234".to_owned())); + error!("a1s2d3f4", InvalidNumAndUnit("a1s2d3f4".to_owned())); + // multiplication overflows u64 + error!("20000000TiB", UnitMultiplicationOverflow); + + assert!( + match parse_byte_offset("99999999999999999999", PositiveI64::new(512).unwrap()) { + // We can't check against the kind of the `ParseIntError`, so we'll just make sure it's the + // same as trying to do the parse directly. + Err(ParseNum(e)) => e == "99999999999999999999".parse::<i64>().unwrap_err(), + _ => false, + } + ); +} |