cerc-io/lighthouse
10
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Add bitvector tests

Browse Source
This commit is contained in:
Paul Hauner 2019-07-09 16:37:09 +10:00
parent 000d941e2e
commit 57cc946018
No known key found for this signature in database
GPG Key ID: 5E2CFF9B75FA63DF
1 changed files with 265 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

431
eth2/utils/ssz_types/src/bitfield.rs
View File

@ -132,9 +132,10 @@ impl<N: Unsigned + Clone> Bitfield<BitList<N>> {
impl<N: Unsigned + Clone> Bitfield<BitVector<N>> { impl<N: Unsigned + Clone> Bitfield<BitVector<N>> {
pub fn new() -> Self { pub fn new() -> Self {
let num_bits = N::to_usize(); let num_bits = N::to_usize();
let num_bytes = std::cmp::max(bytes_for_bit_len(num_bits), 1);
Self { Self {
bytes: vec![0; num_bits], bytes: vec![0; num_bytes],
len: num_bits, len: num_bits,
_phantom: PhantomData, _phantom: PhantomData,
} }
@ -554,191 +555,286 @@ impl<N: Unsigned + Clone> cached_tree_hash::CachedTreeHash for Bitfield<BitVecto
} }
#[cfg(test)] #[cfg(test)]
mod test { mod bitvector {
use super::*; use super::*;
mod bitlist { pub type BitVector<N> = crate::Bitfield<crate::BitVector<N>>;
use super::*; pub type BitVector0 = BitVector<typenum::U0>;
pub type BitVector1 = BitVector<typenum::U1>;
pub type BitVector4 = BitVector<typenum::U4>;
pub type BitVector8 = BitVector<typenum::U8>;
pub type BitVector16 = BitVector<typenum::U16>;
pub type BitList<N> = crate::Bitfield<crate::BitList<N>>; #[test]
pub type BitList0 = BitList<typenum::U0>; fn ssz_encode() {
pub type BitList1 = BitList<typenum::U1>; assert_eq!(BitVector0::new().as_ssz_bytes(), vec![0b0000_0000]);
pub type BitList8 = BitList<typenum::U8>; assert_eq!(BitVector1::new().as_ssz_bytes(), vec![0b0000_0000]);
pub type BitList16 = BitList<typenum::U16>; assert_eq!(BitVector4::new().as_ssz_bytes(), vec![0b0000_0000]);
assert_eq!(BitVector8::new().as_ssz_bytes(), vec![0b0000_0000]);
assert_eq!(
BitVector16::new().as_ssz_bytes(),
vec![0b0000_0000, 0b0000_0000]
);
#[test] let mut b = BitVector8::new();
fn ssz_encode() { for i in 0..8 {
assert_eq!( b.set(i, true).unwrap();
BitList0::with_capacity(0).unwrap().as_ssz_bytes(), }
vec![0b0000_00001], assert_eq!(b.as_ssz_bytes(), vec![255]);
);
assert_eq!( let mut b = BitVector4::new();
BitList1::with_capacity(0).unwrap().as_ssz_bytes(), for i in 0..4 {
vec![0b0000_00001], b.set(i, true).unwrap();
); }
assert_eq!(b.as_ssz_bytes(), vec![0b0000_1111]);
}
assert_eq!( #[test]
BitList1::with_capacity(1).unwrap().as_ssz_bytes(), fn ssz_decode() {
vec![0b0000_00010], assert!(BitVector0::from_ssz_bytes(&[0b0000_0000]).is_ok());
); assert!(BitVector0::from_ssz_bytes(&[0b0000_0001]).is_err());
assert!(BitVector0::from_ssz_bytes(&[0b0000_0010]).is_err());
assert_eq!( assert!(BitVector1::from_ssz_bytes(&[0b0000_0001]).is_ok());
BitList8::with_capacity(8).unwrap().as_ssz_bytes(), assert!(BitVector1::from_ssz_bytes(&[0b0000_0010]).is_err());
vec![0b0000_0001, 0b0000_0000], assert!(BitVector1::from_ssz_bytes(&[0b0000_0100]).is_err());
); assert!(BitVector1::from_ssz_bytes(&[0b0000_0000, 0b0000_0000]).is_err());
assert_eq!( assert!(BitVector8::from_ssz_bytes(&[0b0000_0000]).is_ok());
BitList8::with_capacity(7).unwrap().as_ssz_bytes(), assert!(BitVector8::from_ssz_bytes(&[1, 0b0000_0000]).is_err());
vec![0b1000_0000] assert!(BitVector8::from_ssz_bytes(&[0b0000_0001]).is_ok());
); assert!(BitVector8::from_ssz_bytes(&[0b0000_0010]).is_ok());
assert!(BitVector8::from_ssz_bytes(&[0b0000_0001, 0b0000_0100]).is_err());
assert!(BitVector8::from_ssz_bytes(&[0b0000_0010, 0b0000_0100]).is_err());
let mut b = BitList8::with_capacity(8).unwrap(); assert!(BitVector16::from_ssz_bytes(&[0b0000_0000]).is_err());
for i in 0..8 { assert!(BitVector16::from_ssz_bytes(&[0b0000_0000, 0b0000_0000]).is_ok());
b.set(i, true).unwrap(); assert!(BitVector16::from_ssz_bytes(&[1, 0b0000_0000, 0b0000_0000]).is_err());
}
#[test]
fn ssz_round_trip() {
assert_round_trip(BitVector0::new());
let mut b = BitVector1::new();
b.set(0, true);
assert_round_trip(b);
let mut b = BitVector8::new();
for j in 0..8 {
if j % 2 == 0 {
b.set(j, true);
} }
assert_eq!(b.as_ssz_bytes(), vec![0b0000_0001, 255]); }
assert_round_trip(b);
let mut b = BitList8::with_capacity(8).unwrap(); let mut b = BitVector8::new();
for i in 0..4 { for j in 0..8 {
b.set(i, true).unwrap(); b.set(j, true);
}
assert_round_trip(b);
let mut b = BitVector16::new();
for j in 0..16 {
if j % 2 == 0 {
b.set(j, true);
} }
assert_eq!(b.as_ssz_bytes(), vec![0b0000_0001, 0b0000_1111]); }
assert_round_trip(b);
assert_eq!( let mut b = BitVector16::new();
BitList16::with_capacity(16).unwrap().as_ssz_bytes(), for j in 0..16 {
vec![0b0000_0001, 0b0000_0000, 0b0000_0000] b.set(j, true);
); }
assert_round_trip(b);
}
fn assert_round_trip<T: Encode + Decode + PartialEq + std::fmt::Debug>(t: T) {
assert_eq!(T::from_ssz_bytes(&t.as_ssz_bytes()).unwrap(), t);
}
}
#[cfg(test)]
mod bitlist {
use super::*;
pub type BitList<N> = super::Bitfield<crate::BitList<N>>;
pub type BitList0 = BitList<typenum::U0>;
pub type BitList1 = BitList<typenum::U1>;
pub type BitList8 = BitList<typenum::U8>;
pub type BitList16 = BitList<typenum::U16>;
pub type BitList1024 = BitList<typenum::U1024>;
#[test]
fn ssz_encode() {
assert_eq!(
BitList0::with_capacity(0).unwrap().as_ssz_bytes(),
vec![0b0000_00001],
);
assert_eq!(
BitList1::with_capacity(0).unwrap().as_ssz_bytes(),
vec![0b0000_00001],
);
assert_eq!(
BitList1::with_capacity(1).unwrap().as_ssz_bytes(),
vec![0b0000_00010],
);
assert_eq!(
BitList8::with_capacity(8).unwrap().as_ssz_bytes(),
vec![0b0000_0001, 0b0000_0000],
);
assert_eq!(
BitList8::with_capacity(7).unwrap().as_ssz_bytes(),
vec![0b1000_0000]
);
let mut b = BitList8::with_capacity(8).unwrap();
for i in 0..8 {
b.set(i, true).unwrap();
}
assert_eq!(b.as_ssz_bytes(), vec![0b0000_0001, 255]);
let mut b = BitList8::with_capacity(8).unwrap();
for i in 0..4 {
b.set(i, true).unwrap();
}
assert_eq!(b.as_ssz_bytes(), vec![0b0000_0001, 0b0000_1111]);
assert_eq!(
BitList16::with_capacity(16).unwrap().as_ssz_bytes(),
vec![0b0000_0001, 0b0000_0000, 0b0000_0000]
);
}
#[test]
fn ssz_decode() {
assert!(BitList0::from_ssz_bytes(&[0b0000_0000]).is_err());
assert!(BitList1::from_ssz_bytes(&[0b0000_0000, 0b0000_0000]).is_err());
assert!(BitList8::from_ssz_bytes(&[0b0000_0000]).is_err());
assert!(BitList16::from_ssz_bytes(&[0b0000_0000]).is_err());
assert!(BitList0::from_ssz_bytes(&[0b0000_0001]).is_ok());
assert!(BitList0::from_ssz_bytes(&[0b0000_0010]).is_err());
assert!(BitList1::from_ssz_bytes(&[0b0000_0001]).is_ok());
assert!(BitList1::from_ssz_bytes(&[0b0000_0010]).is_ok());
assert!(BitList1::from_ssz_bytes(&[0b0000_0100]).is_err());
assert!(BitList8::from_ssz_bytes(&[0b0000_0001]).is_ok());
assert!(BitList8::from_ssz_bytes(&[0b0000_0010]).is_ok());
assert!(BitList8::from_ssz_bytes(&[0b0000_0001, 0b0000_0100]).is_ok());
assert!(BitList8::from_ssz_bytes(&[0b0000_0010, 0b0000_0100]).is_err());
}
#[test]
fn ssz_round_trip() {
assert_round_trip(BitList0::with_capacity(0).unwrap());
for i in 0..2 {
assert_round_trip(BitList1::with_capacity(i).unwrap());
}
for i in 0..9 {
assert_round_trip(BitList8::with_capacity(i).unwrap());
}
for i in 0..17 {
assert_round_trip(BitList16::with_capacity(i).unwrap());
} }
#[test] let mut b = BitList1::with_capacity(1).unwrap();
fn ssz_decode() { b.set(0, true);
assert!(BitList0::from_ssz_bytes(&[0b0000_0000]).is_err()); assert_round_trip(b);
assert!(BitList1::from_ssz_bytes(&[0b0000_0000, 0b0000_0000]).is_err());
assert!(BitList8::from_ssz_bytes(&[0b0000_0000]).is_err());
assert!(BitList16::from_ssz_bytes(&[0b0000_0000]).is_err());
assert!(BitList0::from_ssz_bytes(&[0b0000_0001]).is_ok()); for i in 0..8 {
assert!(BitList0::from_ssz_bytes(&[0b0000_0010]).is_err()); let mut b = BitList8::with_capacity(i).unwrap();
for j in 0..i {
assert!(BitList1::from_ssz_bytes(&[0b0000_0001]).is_ok()); if j % 2 == 0 {
assert!(BitList1::from_ssz_bytes(&[0b0000_0010]).is_ok()); b.set(j, true);
assert!(BitList1::from_ssz_bytes(&[0b0000_0100]).is_err()); }
assert!(BitList8::from_ssz_bytes(&[0b0000_0001]).is_ok());
assert!(BitList8::from_ssz_bytes(&[0b0000_0010]).is_ok());
assert!(BitList8::from_ssz_bytes(&[0b0000_0001, 0b0000_0100]).is_ok());
assert!(BitList8::from_ssz_bytes(&[0b0000_0010, 0b0000_0100]).is_err());
}
#[test]
fn ssz_round_trip() {
assert_round_trip(BitList0::with_capacity(0).unwrap());
for i in 0..2 {
assert_round_trip(BitList1::with_capacity(i).unwrap());
} }
for i in 0..9 {
assert_round_trip(BitList8::with_capacity(i).unwrap());
}
for i in 0..17 {
assert_round_trip(BitList16::with_capacity(i).unwrap());
}
let mut b = BitList1::with_capacity(1).unwrap();
b.set(0, true);
assert_round_trip(b); assert_round_trip(b);
for i in 0..8 { let mut b = BitList8::with_capacity(i).unwrap();
let mut b = BitList8::with_capacity(i).unwrap(); for j in 0..i {
for j in 0..i { b.set(j, true);
if j % 2 == 0 {
b.set(j, true);
}
}
assert_round_trip(b);
let mut b = BitList8::with_capacity(i).unwrap();
for j in 0..i {
b.set(j, true);
}
assert_round_trip(b);
}
for i in 0..16 {
let mut b = BitList16::with_capacity(i).unwrap();
for j in 0..i {
if j % 2 == 0 {
b.set(j, true);
}
}
assert_round_trip(b);
let mut b = BitList16::with_capacity(i).unwrap();
for j in 0..i {
b.set(j, true);
}
assert_round_trip(b);
} }
assert_round_trip(b);
} }
fn assert_round_trip<T: Encode + Decode + PartialEq + std::fmt::Debug>(t: T) { for i in 0..16 {
assert_eq!(T::from_ssz_bytes(&t.as_ssz_bytes()).unwrap(), t); let mut b = BitList16::with_capacity(i).unwrap();
for j in 0..i {
if j % 2 == 0 {
b.set(j, true);
}
}
assert_round_trip(b);
let mut b = BitList16::with_capacity(i).unwrap();
for j in 0..i {
b.set(j, true);
}
assert_round_trip(b);
} }
} }
type Bitfield = crate::Bitfield<BitList<typenum::U1024>>; fn assert_round_trip<T: Encode + Decode + PartialEq + std::fmt::Debug>(t: T) {
assert_eq!(T::from_ssz_bytes(&t.as_ssz_bytes()).unwrap(), t);
}
#[test] #[test]
fn from_raw_bytes() { fn from_raw_bytes() {
assert!(Bitfield::from_raw_bytes(vec![0b0000_0000], 0).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0000], 0).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0001], 1).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0001], 1).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0011], 2).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0011], 2).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0111], 3).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0111], 3).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0000_1111], 4).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_1111], 4).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0001_1111], 5).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0001_1111], 5).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0011_1111], 6).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0011_1111], 6).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0111_1111], 7).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0111_1111], 7).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b1111_1111], 8).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b1111_1111], 8).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0001, 0b1111_1111], 9).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0001, 0b1111_1111], 9).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0011, 0b1111_1111], 10).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0011, 0b1111_1111], 10).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0111, 0b1111_1111], 11).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0111, 0b1111_1111], 11).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0000_1111, 0b1111_1111], 12).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0000_1111, 0b1111_1111], 12).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0001_1111, 0b1111_1111], 13).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0001_1111, 0b1111_1111], 13).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0011_1111, 0b1111_1111], 14).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0011_1111, 0b1111_1111], 14).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b0111_1111, 0b1111_1111], 15).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b0111_1111, 0b1111_1111], 15).is_some());
assert!(Bitfield::from_raw_bytes(vec![0b1111_1111, 0b1111_1111], 16).is_some()); assert!(BitList1024::from_raw_bytes(vec![0b1111_1111, 0b1111_1111], 16).is_some());
for i in 0..8 { for i in 0..8 {
assert!(Bitfield::from_raw_bytes(vec![], i).is_none()); assert!(BitList1024::from_raw_bytes(vec![], i).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b1111_1111], i).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b1111_1111], i).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b1111_1110, 0b0000_0000], i).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b1111_1110, 0b0000_0000], i).is_none());
} }
assert!(Bitfield::from_raw_bytes(vec![0b0000_0001], 0).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0001], 0).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0001], 0).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0001], 0).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0011], 1).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0011], 1).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0111], 2).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0111], 2).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0000_1111], 3).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_1111], 3).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0001_1111], 4).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0001_1111], 4).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0011_1111], 5).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0011_1111], 5).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0111_1111], 6).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0111_1111], 6).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b1111_1111], 7).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b1111_1111], 7).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0001, 0b1111_1111], 8).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0001, 0b1111_1111], 8).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0011, 0b1111_1111], 9).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0011, 0b1111_1111], 9).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0000_0111, 0b1111_1111], 10).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_0111, 0b1111_1111], 10).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0000_1111, 0b1111_1111], 11).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0000_1111, 0b1111_1111], 11).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0001_1111, 0b1111_1111], 12).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0001_1111, 0b1111_1111], 12).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0011_1111, 0b1111_1111], 13).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0011_1111, 0b1111_1111], 13).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b0111_1111, 0b1111_1111], 14).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b0111_1111, 0b1111_1111], 14).is_none());
assert!(Bitfield::from_raw_bytes(vec![0b1111_1111, 0b1111_1111], 15).is_none()); assert!(BitList1024::from_raw_bytes(vec![0b1111_1111, 0b1111_1111], 15).is_none());
} }
fn test_set_unset(num_bits: usize) { fn test_set_unset(num_bits: usize) {
let mut bitfield = Bitfield::with_capacity(num_bits).unwrap(); let mut bitfield = BitList1024::with_capacity(num_bits).unwrap();
for i in 0..num_bits + 1 { for i in 0..num_bits + 1 {
if i < num_bits { if i < num_bits {
@ -760,7 +856,7 @@ mod test {
fn test_bytes_round_trip(num_bits: usize) { fn test_bytes_round_trip(num_bits: usize) {
for i in 0..num_bits { for i in 0..num_bits {
let mut bitfield = Bitfield::with_capacity(num_bits).unwrap(); let mut bitfield = BitList1024::with_capacity(num_bits).unwrap();
bitfield.set(i, true).unwrap(); bitfield.set(i, true).unwrap();
let bytes = bitfield.clone().to_raw_bytes(); let bytes = bitfield.clone().to_raw_bytes();
@ -784,7 +880,7 @@ mod test {
#[test] #[test]
fn to_raw_bytes() { fn to_raw_bytes() {
let mut bitfield = Bitfield::with_capacity(9).unwrap(); let mut bitfield = BitList1024::with_capacity(9).unwrap();
bitfield.set(0, true); bitfield.set(0, true);
assert_eq!( assert_eq!(
bitfield.clone().to_raw_bytes(), bitfield.clone().to_raw_bytes(),
@ -834,31 +930,34 @@ mod test {
#[test] #[test]
fn highest_set_bit() { fn highest_set_bit() {
assert_eq!(Bitfield::with_capacity(16).unwrap().highest_set_bit(), None); assert_eq!(
BitList1024::with_capacity(16).unwrap().highest_set_bit(),
None
);
assert_eq!( assert_eq!(
Bitfield::from_raw_bytes(vec![0b0000_000, 0b0000_0001], 16) BitList1024::from_raw_bytes(vec![0b0000_000, 0b0000_0001], 16)
.unwrap() .unwrap()
.highest_set_bit(), .highest_set_bit(),
Some(0) Some(0)
); );
assert_eq!( assert_eq!(
Bitfield::from_raw_bytes(vec![0b0000_000, 0b0000_0010], 16) BitList1024::from_raw_bytes(vec![0b0000_000, 0b0000_0010], 16)
.unwrap() .unwrap()
.highest_set_bit(), .highest_set_bit(),
Some(1) Some(1)
); );
assert_eq!( assert_eq!(
Bitfield::from_raw_bytes(vec![0b0000_1000], 8) BitList1024::from_raw_bytes(vec![0b0000_1000], 8)
.unwrap() .unwrap()
.highest_set_bit(), .highest_set_bit(),
Some(3) Some(3)
); );
assert_eq!( assert_eq!(
Bitfield::from_raw_bytes(vec![0b1000_0000, 0b0000_0000], 16) BitList1024::from_raw_bytes(vec![0b1000_0000, 0b0000_0000], 16)
.unwrap() .unwrap()
.highest_set_bit(), .highest_set_bit(),
Some(15) Some(15)
@ -867,9 +966,9 @@ mod test {
#[test] #[test]
fn intersection() { fn intersection() {
let a = Bitfield::from_raw_bytes(vec![0b1100, 0b0001], 16).unwrap(); let a = BitList1024::from_raw_bytes(vec![0b1100, 0b0001], 16).unwrap();
let b = Bitfield::from_raw_bytes(vec![0b1011, 0b1001], 16).unwrap(); let b = BitList1024::from_raw_bytes(vec![0b1011, 0b1001], 16).unwrap();
let c = Bitfield::from_raw_bytes(vec![0b1000, 0b0001], 16).unwrap(); let c = BitList1024::from_raw_bytes(vec![0b1000, 0b0001], 16).unwrap();
assert_eq!(a.intersection(&b).unwrap(), c); assert_eq!(a.intersection(&b).unwrap(), c);
assert_eq!(b.intersection(&a).unwrap(), c); assert_eq!(b.intersection(&a).unwrap(), c);
@ -882,9 +981,9 @@ mod test {
#[test] #[test]
fn union() { fn union() {
let a = Bitfield::from_raw_bytes(vec![0b1100, 0b0001], 16).unwrap(); let a = BitList1024::from_raw_bytes(vec![0b1100, 0b0001], 16).unwrap();
let b = Bitfield::from_raw_bytes(vec![0b1011, 0b1001], 16).unwrap(); let b = BitList1024::from_raw_bytes(vec![0b1011, 0b1001], 16).unwrap();
let c = Bitfield::from_raw_bytes(vec![0b1111, 0b1001], 16).unwrap(); let c = BitList1024::from_raw_bytes(vec![0b1111, 0b1001], 16).unwrap();
assert_eq!(a.union(&b).unwrap(), c); assert_eq!(a.union(&b).unwrap(), c);
assert_eq!(b.union(&a).unwrap(), c); assert_eq!(b.union(&a).unwrap(), c);
@ -895,10 +994,10 @@ mod test {
#[test] #[test]
fn difference() { fn difference() {
let a = Bitfield::from_raw_bytes(vec![0b1100, 0b0001], 16).unwrap(); let a = BitList1024::from_raw_bytes(vec![0b1100, 0b0001], 16).unwrap();
let b = Bitfield::from_raw_bytes(vec![0b1011, 0b1001], 16).unwrap(); let b = BitList1024::from_raw_bytes(vec![0b1011, 0b1001], 16).unwrap();
let a_b = Bitfield::from_raw_bytes(vec![0b0100, 0b0000], 16).unwrap(); let a_b = BitList1024::from_raw_bytes(vec![0b0100, 0b0000], 16).unwrap();
let b_a = Bitfield::from_raw_bytes(vec![0b0011, 0b1000], 16).unwrap(); let b_a = BitList1024::from_raw_bytes(vec![0b0011, 0b1000], 16).unwrap();
assert_eq!(a.difference(&b).unwrap(), a_b); assert_eq!(a.difference(&b).unwrap(), a_b);
assert_eq!(b.difference(&a).unwrap(), b_a); assert_eq!(b.difference(&a).unwrap(), b_a);
@ -907,7 +1006,7 @@ mod test {
#[test] #[test]
fn iter() { fn iter() {
let mut bitfield = Bitfield::with_capacity(9).unwrap(); let mut bitfield = BitList1024::with_capacity(9).unwrap();
bitfield.set(2, true); bitfield.set(2, true);
bitfield.set(8, true); bitfield.set(8, true);