zstd 0.14.1

use super::{copy_encode, decode_all, encode_all};
use super::{Decoder, Encoder};

use partial_io::{PartialOp, PartialWrite};

use std::io;
use std::iter;

#[test]
fn test_end_of_frame() {
    use std::io::{Read, Write};

    let mut enc = Encoder::new(Vec::new(), 1).unwrap();
    enc.write_all(b"foo").unwrap();
    let mut compressed = enc.finish().unwrap();

    // Add footer/whatever to underlying storage.
    compressed.push(0);

    // Drain zstd stream until end-of-frame.
    let mut dec = Decoder::new(&compressed[..]).unwrap().single_frame();
    let mut buf = Vec::new();
    dec.read_to_end(&mut buf).unwrap();
    assert_eq!(&buf, b"foo", "Error decoding a single frame.");
}

#[test]
fn test_concatenated_frames() {
    let mut buffer = Vec::new();
    copy_encode(&b"foo"[..], &mut buffer, 1).unwrap();
    copy_encode(&b"bar"[..], &mut buffer, 2).unwrap();
    copy_encode(&b"baz"[..], &mut buffer, 3).unwrap();

    assert_eq!(
        &decode_all(&buffer[..]).unwrap(),
        b"foobarbaz",
        "Error decoding concatenated frames."
    );
}

#[test]
fn test_flush() {
    use std::io::Write;

    let buf = Vec::new();
    let mut z = Encoder::new(buf, 19).unwrap();

    z.write_all(b"hello").unwrap();

    z.flush().unwrap(); // Might corrupt stream
    let buf = z.finish().unwrap();

    let s = decode_all(&buf[..]).unwrap();
    assert_eq!(s, b"hello", "Error decoding after flush.");
}

#[test]
fn test_try_finish() {
    use std::io::Write;
    let mut z = setup_try_finish();

    z.get_mut().set_ops(iter::repeat(PartialOp::Unlimited));

    // flush() should continue to work even though write() doesn't.
    z.flush().unwrap();

    let buf = match z.try_finish() {
        Ok(buf) => buf.into_inner(),
        Err((_z, e)) => panic!("try_finish failed with {:?}", e),
    };

    // Make sure the multiple try_finish calls didn't screw up the internal
    // buffer and continued to produce valid compressed data.
    assert_eq!(&decode_all(&buf[..]).unwrap(), b"hello", "Error decoding");
}

#[test]
#[should_panic]
fn test_write_after_try_finish() {
    use std::io::Write;
    let mut z = setup_try_finish();
    z.write_all(b"hello world").unwrap();
}

fn setup_try_finish() -> Encoder<'static, PartialWrite<Vec<u8>>> {
    use std::io::Write;

    let buf =
        PartialWrite::new(Vec::new(), iter::repeat(PartialOp::Unlimited));
    let mut z = Encoder::new(buf, 19).unwrap();

    z.write_all(b"hello").unwrap();

    z.get_mut()
        .set_ops(iter::repeat(PartialOp::Err(io::ErrorKind::WouldBlock)));

    let (z, err) = z.try_finish().unwrap_err();
    assert_eq!(
        err.kind(),
        io::ErrorKind::WouldBlock,
        "expected WouldBlock error"
    );

    z
}

#[test]
fn test_failing_write() {
    use std::io::Write;

    let buf = PartialWrite::new(
        Vec::new(),
        iter::repeat(PartialOp::Err(io::ErrorKind::WouldBlock)),
    );
    let mut z = Encoder::new(buf, 1).unwrap();

    // Fill in enough data to make sure the buffer gets written out.
    let input = vec![b'b'; 128 * 1024];
    // This should work even though the inner writer rejects writes.
    assert_eq!(
        z.write(&input).unwrap(),
        128 * 1024,
        "did not write all input buffer"
    );

    // The next write would fail (the buffer still has some data in it).
    assert_eq!(
        z.write(b"abc").unwrap_err().kind(),
        io::ErrorKind::WouldBlock,
        "expected WouldBlock error"
    );

    z.get_mut().set_ops(iter::repeat(PartialOp::Unlimited));

    // This shouldn't have led to any corruption.
    let buf = z.finish().unwrap().into_inner();
    assert_eq!(
        &decode_all(&buf[..]).unwrap(),
        &input,
        "WouldBlock errors should not corrupt stream"
    );
}

#[test]
fn test_invalid_frame() {
    use std::io::Read;

    // I really hope this data is invalid...
    let data = &[1u8, 2u8, 3u8, 4u8, 5u8];
    let mut dec = Decoder::new(&data[..]).unwrap();
    assert_eq!(
        dec.read_to_end(&mut Vec::new()).err().map(|e| e.kind()),
        Some(io::ErrorKind::Other),
        "did not encounter expected 'invalid frame' error"
    );
}

#[test]
fn test_incomplete_frame() {
    use std::io::{Read, Write};

    let mut enc = Encoder::new(Vec::new(), 1).unwrap();
    enc.write_all(b"This is a regular string").unwrap();
    let mut compressed = enc.finish().unwrap();

    let half_size = compressed.len() - 2;
    compressed.truncate(half_size);

    let mut dec = Decoder::new(&compressed[..]).unwrap();
    assert_eq!(
        dec.read_to_end(&mut Vec::new()).err().map(|e| e.kind()),
        Some(io::ErrorKind::UnexpectedEof),
        "did not encounter expected EOF error"
    );
}

#[test]
fn test_cli_compatibility() {
    let input = include_bytes!("../../assets/example.txt.zst");

    let output = decode_all(&input[..]).unwrap();

    let expected = include_bytes!("../../assets/example.txt");

    assert_eq!(
        &output[..],
        &expected[..],
        "error decoding cli-compressed data"
    );
}

#[cfg(feature = "legacy")]
#[test]
fn test_legacy() {
    use std::fs;
    use std::io::Read;

    // Read the content from that file
    let expected = include_bytes!("../../assets/example.txt");

    for version in &[5, 6, 7, 8] {
        let filename = format!("assets/example.txt.v{}.zst", version);
        let file = fs::File::open(filename).unwrap();
        let mut decoder = Decoder::new(file).unwrap();

        let mut buffer = Vec::new();
        decoder.read_to_end(&mut buffer).unwrap();

        assert_eq!(
            &expected[..],
            &buffer[..],
            "error decompressing legacy version {}",
            version
        );
    }
}

// Check that compressing+decompressing some data gives back the original
fn test_full_cycle(input: &[u8], level: i32) {
    crate::test_cycle_unwrap(
        input,
        |data| encode_all(data, level),
        |data| decode_all(data),
    );
}

#[test]
fn test_empty() {
    // Test compressing empty data
    for level in 1..19 {
        test_full_cycle(b"", level);
    }
}

#[test]
fn test_ll_source() {
    // Where could I find some long text?...
    let data = include_bytes!("../../zstd-safe/zstd-sys/src/bindings_zstd.rs");
    // Test a few compression levels.
    // TODO: check them all?
    for level in 1..5 {
        // Test compressing actual data
        test_full_cycle(data, level);
    }
}

#[test]
fn reader_to_writer() {
    use std::io::{Read, Write};

    let clear = include_bytes!("../../assets/example.txt");
    // Compress using reader
    let mut encoder = super::read::Encoder::new(&clear[..], 1).unwrap();

    let mut compressed_buffer = Vec::new();
    encoder.read_to_end(&mut compressed_buffer).unwrap();

    // eprintln!("Compressed Buffer: {:?}", compressed_buffer);

    // Decompress using writer
    let mut decompressed_buffer = Vec::new();
    let mut decoder =
        super::write::Decoder::new(&mut decompressed_buffer).unwrap();
    decoder.write_all(&compressed_buffer[..]).unwrap();
    decoder.flush().unwrap();
    // eprintln!("{:?}", decompressed_buffer);

    assert_eq!(clear, &decompressed_buffer[..]);
}

#[test]
fn test_finish_empty_encoder() {
    use std::io::Write;
    let mut enc = Encoder::new(Vec::new(), 0).unwrap();
    enc.do_finish().unwrap();
    enc.write_all(b"this should not work").unwrap_err();
    enc.finish().unwrap();
}

#[test]
fn test_empty_read_buffer() {
    // `Read::read` must return `Ok(0)` for an empty buffer rather than
    // reporting that it could not make progress.
    // https://github.com/gyscos/zstd-rs/issues/318
    use std::io::Read;

    let compressed = encode_all(&b"some data to decompress"[..], 3).unwrap();

    let mut decoder = Decoder::new(&compressed[..]).unwrap();
    assert_eq!(decoder.read(&mut []).unwrap(), 0);
    // Reading normally still works afterwards.
    let mut decoded = Vec::new();
    decoder.read_to_end(&mut decoded).unwrap();
    assert_eq!(decoded, b"some data to decompress");

    // Same on the way in: a read-based encoder.
    let mut encoder =
        crate::stream::read::Encoder::new(&b"some data"[..], 3).unwrap();
    assert_eq!(encoder.read(&mut []).unwrap(), 0);
    let mut encoded = Vec::new();
    encoder.read_to_end(&mut encoded).unwrap();
    assert_eq!(decode_all(&encoded[..]).unwrap(), b"some data");
}

#[test]
fn test_compress_sized() {
    let data = &include_bytes!("../../assets/example.txt")[..];

    let frame = super::compress_sized(data, 3, data.len() as u64).unwrap();

    // The point of it: the size is in the frame, so a reader can size its
    // buffer without guessing.
    assert_eq!(super::decompressed_size(&frame), Some(data.len() as u64));
    assert_eq!(super::decode_all(&frame[..]).unwrap(), data);

    // encode_all, for contrast, cannot record it.
    let streamed = super::encode_all(data, 3).unwrap();
    assert_eq!(super::decompressed_size(&streamed), None);
}

#[test]
fn test_compress_with_wrong_size() {
    let data = &include_bytes!("../../assets/example.txt")[..];

    // Claiming the wrong length has to fail rather than write a frame whose
    // header lies about its contents.
    assert!(super::compress_sized(data, 3, data.len() as u64 + 1).is_err());
    assert!(super::compress_sized(data, 3, data.len() as u64 - 1).is_err());
}

#[test]
fn test_compress_file() {
    let expected = &include_bytes!("../../assets/example.txt")[..];

    let frame = super::compress_file("assets/example.txt", 3).unwrap();

    assert_eq!(
        super::decompressed_size(&frame),
        Some(expected.len() as u64)
    );
    assert_eq!(super::decode_all(&frame[..]).unwrap(), expected);
}

#[test]
fn test_compress_from_missing_file() {
    assert!(super::compress_file("assets/does-not-exist", 3).is_err());
}

#[test]
fn test_compress_sized_into() {
    let data = &include_bytes!("../../assets/example.txt")[..];

    let mut frame = Vec::new();
    super::compress_sized_into(data, &mut frame, 3, data.len() as u64)
        .unwrap();

    // Same frame as the Vec-returning version, size and all.
    assert_eq!(super::decompressed_size(&frame), Some(data.len() as u64));
    assert_eq!(super::decode_all(&frame[..]).unwrap(), data);
    assert_eq!(
        frame,
        super::compress_sized(data, 3, data.len() as u64).unwrap()
    );
}

#[test]
fn test_copy_compress_with_wrong_size() {
    let data = &include_bytes!("../../assets/example.txt")[..];

    let mut frame = Vec::new();
    assert!(super::compress_sized_into(
        data,
        &mut frame,
        3,
        data.len() as u64 + 1
    )
    .is_err());
}

#[test]
fn test_compress_file_into() {
    let expected = &include_bytes!("../../assets/example.txt")[..];

    let mut frame = Vec::new();
    super::compress_file_into("assets/example.txt", &mut frame, 3).unwrap();

    assert_eq!(
        super::decompressed_size(&frame),
        Some(expected.len() as u64)
    );
    assert_eq!(super::decode_all(&frame[..]).unwrap(), expected);

    // Same frame as the Vec-returning version, which is built on this one.
    assert_eq!(
        frame,
        super::compress_file("assets/example.txt", 3).unwrap()
    );
}

#[test]
fn test_copy_compress_from_missing_file() {
    let mut frame = Vec::new();
    assert!(
        super::compress_file_into("assets/does-not-exist", &mut frame, 3)
            .is_err()
    );
}