Function test_lazy_serialize

block-buffer/tests/mod.rs:274–333

()

#[test]
fn test_lazy_serialize() {
    type Buf = LazyBuffer<U4>;

    let mut buf1 = Buf::default();
    let ser0 = buf1.serialize();
    assert_eq!(&ser0[..], &[0, 0, 0, 0, 0]);
    Buf::deserialize(&ser0).unwrap();
    assert_eq!(Buf::deserialize(&ser0).unwrap().serialize(), ser0);

    buf1.digest_blocks(&[41, 42], |_| {});

    let ser1 = buf1.serialize();
    assert_eq!(&ser1[..], &[2, 41, 42, 0, 0]);

    let mut buf2 = Buf::deserialize(&ser1).unwrap();
    assert_eq!(buf1.serialize(), ser1);

    buf1.digest_blocks(&[43], |_| {});
    buf2.digest_blocks(&[43], |_| {});

    let ser2 = buf1.serialize();
    assert_eq!(&ser2[..], &[3, 41, 42, 43, 0]);
    assert_eq!(buf1.serialize(), ser2);

    let mut buf3 = Buf::deserialize(&ser2).unwrap();
    assert_eq!(buf3.serialize(), ser2);

    buf1.digest_blocks(&[44], |_| {});
    buf2.digest_blocks(&[44], |_| {});
    buf3.digest_blocks(&[44], |_| {});

    let ser3 = buf1.serialize();
    assert_eq!(&ser3[..], &[4, 41, 42, 43, 44]);
    assert_eq!(buf2.serialize(), ser3);
    assert_eq!(buf3.serialize(), ser3);

    buf1.digest_blocks(&[45], |_| {});
    buf2.digest_blocks(&[45], |_| {});
    buf3.digest_blocks(&[45], |_| {});

    let ser4 = buf1.serialize();
    assert_eq!(&ser4[..], &[1, 45, 0, 0, 0]);
    assert_eq!(buf2.serialize(), ser4);
    assert_eq!(buf3.serialize(), ser4);

    // Invalid position
    let buf = Array([10, 0, 0, 0, 0]);
    assert!(Buf::deserialize(&buf).is_err());
    let buf = Array([5, 0, 0, 0, 0]);
    assert!(Buf::deserialize(&buf).is_err());
    // "Garbage" bytes are not zeroized
    let buf = Array([0, 1, 0, 0, 0]);
    assert!(Buf::deserialize(&buf).is_err());
    let buf = Array([1, 0, 1, 0, 0]);
    assert!(Buf::deserialize(&buf).is_err());
    let buf = Array([2, 0, 0, 1, 0]);
    assert!(Buf::deserialize(&buf).is_err());
    let buf = Array([3, 0, 0, 0, 1]);