From 9c28d5d31fc15e1aaca0f02ab8ed0a1c5e48a7fd Mon Sep 17 00:00:00 2001 From: Charles Hubain Date: Sun, 7 Jul 2024 21:31:58 +0900 Subject: [PATCH] Improve some test coverage --- src/tests/arithmetic.rs | 6 +++--- src/tests/binary.rs | 43 ++++++++++------------------------------- src/tests/bitvector.rs | 35 +++++++++++++++++++++++++++++++-- src/tests/mod.rs | 32 ++++++++++++++++++++++++++++-- 4 files changed, 76 insertions(+), 40 deletions(-) diff --git a/src/tests/arithmetic.rs b/src/tests/arithmetic.rs index 50e716b..3d869ca 100644 --- a/src/tests/arithmetic.rs +++ b/src/tests/arithmetic.rs @@ -4,7 +4,7 @@ mod add { use crate::tests::*; use crate::utils::StaticCast; - op_test_section!(Add::add, AddAssign::add_assign, { op_test_block }); + op_test_section!(Add::add, AddAssign::add_assign, { op_test_block, op_test_block2 }); } mod div { @@ -22,7 +22,7 @@ mod sub { use crate::tests::*; use crate::utils::StaticCast; - op_test_section!(Sub::sub, SubAssign::sub_assign, { op_test_block }); + op_test_section!(Sub::sub, SubAssign::sub_assign, { op_test_block, op_test_block2 }); } mod mul { @@ -31,7 +31,7 @@ mod mul { use crate::tests::*; use crate::utils::StaticCast; - op_test_section!(Mul::mul, MulAssign::mul_assign, { op_test_block }); + op_test_section!(Mul::mul, MulAssign::mul_assign, { op_test_block, op_test_block2 }); } mod rem { diff --git a/src/tests/binary.rs b/src/tests/binary.rs index 60e72f0..98d9b59 100644 --- a/src/tests/binary.rs +++ b/src/tests/binary.rs @@ -19,6 +19,7 @@ mod not { fn bvf_test_inner() { for size in 0..BVF::::capacity() { let (bv, bi) = random_test_bv::>(size); + assert_eq!(!&bv, !&bi); assert_eq!(!bv, !bi); } } @@ -32,6 +33,7 @@ mod not { fn bvd() { for size in 0..512 { let (bv, bi) = random_test_bv::(size); + assert_eq!(!&bv, !&bi); assert_eq!(!bv, !bi); } } @@ -40,6 +42,7 @@ mod not { fn bv() { for size in 0..512 { let (bv, bi) = random_test_bv::(size); + assert_eq!(!&bv, !&bi); assert_eq!(!bv, !bi); } } @@ -63,38 +66,12 @@ mod shift { use crate::auto::BV; use crate::dynamic::BVD; use crate::fixed::BVF; - use crate::tests::{bvf_inner_unroll, random_test_bv}; + use crate::tests::{bvf_inner_unroll, random_test_bv, shift_test_block}; use crate::utils::Integer; - macro_rules! op_test_block { - ($lhs:ty, {$($rhs:ty),+}, $op:path, $op_assign:path, $size:ident) => { - $( - op_test_block!($lhs, $rhs, $op, $op_assign, $size); - )+ - }; - ($lhs:ty, $rhs:ty, $op:path, $op_assign:path, $size:ident) => { - let modulo = BigInt::from(1u8) << $size; - let shift = (random::() % (2 * $size)) as $rhs; - let (bv, bi) = random_test_bv::<$lhs>($size); - let reference = $op(&bi, shift) % modulo; - // Normal op - assert_eq!($op(&bv, &shift), reference); - assert_eq!($op(bv.clone(), &shift), reference); - assert_eq!($op(&bv, shift), reference); - assert_eq!($op(bv.clone(), shift), reference); - // Assign op - let mut bv2 = bv.clone(); - $op_assign(&mut bv2, &shift); - assert_eq!(bv2, reference); - bv2 = bv.clone(); - $op_assign(&mut bv2, shift); - assert_eq!(bv2, reference); - }; - } - fn shl_bvf_inner() { for size in 1..BVF::::capacity() { - op_test_block!(BVF, {u8, u16, u32, u64, u128, usize}, Shl::shl, ShlAssign::shl_assign, size); + shift_test_block!(BVF, {u8, u16, u32, u64, u128, usize}, Shl::shl, ShlAssign::shl_assign, size); } } @@ -106,20 +83,20 @@ mod shift { #[test] fn shl_bvd() { for size in 1..512 { - op_test_block!(BVD, {u8, u16, u32, u64, u128, usize}, Shl::shl, ShlAssign::shl_assign, size); + shift_test_block!(BVD, {u8, u16, u32, u64, u128, usize}, Shl::shl, ShlAssign::shl_assign, size); } } #[test] fn shl_bv() { for size in 1..512 { - op_test_block!(BV, {u8, u16, u32, u64, u128, usize}, Shl::shl, ShlAssign::shl_assign, size); + shift_test_block!(BV, {u8, u16, u32, u64, u128, usize}, Shl::shl, ShlAssign::shl_assign, size); } } fn shr_bvf_inner() { for size in 1..BVF::::capacity() { - op_test_block!(BVF, {u8, u16, u32, u64, u128, usize}, Shr::shr, ShrAssign::shr_assign, size); + shift_test_block!(BVF, {u8, u16, u32, u64, u128, usize}, Shr::shr, ShrAssign::shr_assign, size); } } @@ -131,14 +108,14 @@ mod shift { #[test] fn shr_bvd() { for size in 1..512 { - op_test_block!(BVD, {u8, u16, u32, u64, u128, usize}, Shr::shr, ShrAssign::shr_assign, size); + shift_test_block!(BVD, {u8, u16, u32, u64, u128, usize}, Shr::shr, ShrAssign::shr_assign, size); } } #[test] fn shr_bv() { for size in 1..512 { - op_test_block!(BV, {u8, u16, u32, u64, u128, usize}, Shr::shr, ShrAssign::shr_assign, size); + shift_test_block!(BV, {u8, u16, u32, u64, u128, usize}, Shr::shr, ShrAssign::shr_assign, size); } } } diff --git a/src/tests/bitvector.rs b/src/tests/bitvector.rs index 0ac1d4a..1c48b77 100644 --- a/src/tests/bitvector.rs +++ b/src/tests/bitvector.rs @@ -2,14 +2,14 @@ use std::io::Cursor; use std::iter::repeat; use rand::seq::SliceRandom; -use rand::{thread_rng, Rng}; +use rand::{thread_rng, Rng, RngCore}; use crate::auto::BV; use crate::bit::Bit; use crate::dynamic::BVD; use crate::fixed::BVF; use crate::tests::{bvf_inner_unroll_cap, random_bv}; -use crate::{BitVector, Endianness}; +use crate::{BitVector, ConvertionError, Endianness}; fn with_capacity_inner(max_capacity: usize) { for c in 0..max_capacity { @@ -127,6 +127,29 @@ fn from_to_bytes_inner(max_capacity: usize) { #[test] fn from_to_bytes_bvf() { bvf_inner_unroll_cap!(from_to_bytes_inner, {u8, u16, u32, u64, u128}, {1, 2, 3, 4, 5}); + + let mut buffer: Vec<_> = repeat(0u8).take(64).collect(); + thread_rng().fill_bytes(&mut buffer); + assert_eq!( + BVF::::from_bytes(&buffer, Endianness::BE), + Err(ConvertionError::NotEnoughCapacity) + ); + assert_eq!( + BVF::::from_bytes(&buffer, Endianness::BE), + Err(ConvertionError::NotEnoughCapacity) + ); + assert_eq!( + BVF::::from_bytes(&buffer, Endianness::BE), + Err(ConvertionError::NotEnoughCapacity) + ); + assert_eq!( + BVF::::from_bytes(&buffer, Endianness::BE), + Err(ConvertionError::NotEnoughCapacity) + ); + assert_eq!( + BVF::::from_bytes(&buffer, Endianness::BE), + Err(ConvertionError::NotEnoughCapacity) + ); } #[test] @@ -163,6 +186,14 @@ fn read_write_inner(max_capacity: usize) { #[test] fn read_write_inner_bvf() { bvf_inner_unroll_cap!(read_write_inner, {u8, u16, u32, u64, u128}, {1, 2, 3, 4, 5}); + + let mut buffer: Vec<_> = repeat(0u8).take(64).collect(); + thread_rng().fill_bytes(&mut buffer); + assert!(BVF::::read(&mut Cursor::new(&buffer), 512, Endianness::BE).is_err()); + assert!(BVF::::read(&mut Cursor::new(&buffer), 512, Endianness::BE).is_err()); + assert!(BVF::::read(&mut Cursor::new(&buffer), 512, Endianness::BE).is_err()); + assert!(BVF::::read(&mut Cursor::new(&buffer), 512, Endianness::BE).is_err()); + assert!(BVF::::read(&mut Cursor::new(&buffer), 512, Endianness::BE).is_err()); } #[test] diff --git a/src/tests/mod.rs b/src/tests/mod.rs index 5119fb5..bc868cb 100644 --- a/src/tests/mod.rs +++ b/src/tests/mod.rs @@ -143,9 +143,9 @@ macro_rules! op_test_block2 { ($lhs:ty, $rhs:ty, $op:path, $op_assign:path, $size:ident) => { let modulo = BigInt::from(1u8) << $size; let (bv1, bi1) = random_test_bv::<$lhs>($size); - let (mut bv2, mut bi2) = random_test_bv::<$rhs>(usize::min(1, $size)); + let (mut bv2, mut bi2) = random_test_bv::<$rhs>(usize::max(1, $size / 2)); while bv2.is_zero() { - (bv2, bi2) = random_test_bv::<$rhs>(usize::min(1, $size)); + (bv2, bi2) = random_test_bv::<$rhs>(usize::max(1, $size / 2)); } let reference = $op(&bi1, &bi2) % &modulo; // Normal op @@ -163,6 +163,33 @@ macro_rules! op_test_block2 { }; } +// Variant suited for shifts. +macro_rules! shift_test_block { + ($lhs:ty, {$($rhs:ty),+}, $op:path, $op_assign:path, $size:ident) => { + $( + shift_test_block!($lhs, $rhs, $op, $op_assign, $size); + )+ + }; + ($lhs:ty, $rhs:ty, $op:path, $op_assign:path, $size:ident) => { + let modulo = BigInt::from(1u8) << $size; + let shift = (random::() % (2 * $size)) as $rhs; + let (bv, bi) = random_test_bv::<$lhs>($size); + let reference = $op(&bi, shift) % modulo; + // Normal op + assert_eq!($op(&bv, &shift), reference); + assert_eq!($op(bv.clone(), &shift), reference); + assert_eq!($op(&bv, shift), reference); + assert_eq!($op(bv.clone(), shift), reference); + // Assign op + let mut bv2 = bv.clone(); + $op_assign(&mut bv2, &shift); + assert_eq!(bv2, reference); + bv2 = bv.clone(); + $op_assign(&mut bv2, shift); + assert_eq!(bv2, reference); + }; +} + macro_rules! op_test_section { ($op:path, $op_assign:path, {$($block:path),+}) => { fn bvf_bvf_inner< @@ -253,3 +280,4 @@ pub(crate) use bvf_inner_unroll_cap; pub(crate) use op_test_block; pub(crate) use op_test_block2; pub(crate) use op_test_section; +pub(crate) use shift_test_block;