mod deflate_stream {
    use crate::zlib::stream::DeflateWriter;
    use crate::zlib::stream::InflateReader;
    use std::io::{Read, Write};

    #[test]
    fn all_at_once() -> Result<(), Box<dyn std::error::Error>> {
        let mut w = DeflateWriter::new(Vec::new());
        assert_eq!(w.write(b"hello")?, 5);
        w.flush()?;

        let out = w.inner;
        assert!(out.len() == 12 || out.len() == 13);

        assert_deflate_buffer(out, b"hello")
    }

    fn assert_deflate_buffer(out: Vec<u8>, expected: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
        let mut actual = Vec::new();
        InflateReader::from_read(out.as_slice()).read_to_end(&mut actual)?;
        assert_eq!(actual, expected);
        Ok(())
    }

    #[test]
    fn big_file_small_writes() -> Result<(), Box<dyn std::error::Error>> {
        let mut w = DeflateWriter::new(Vec::new());
        let bytes =
            include_bytes!("../../../../tests/fixtures/packs/pack-11fdfa9e156ab73caae3b6da867192221f2089c2.pack");
        for chunk in bytes.chunks(2) {
            assert_eq!(w.write(chunk)?, chunk.len());
        }
        w.flush()?;

        assert_deflate_buffer(w.inner, bytes)
    }

    #[test]
    fn big_file_a_few_big_writes() -> Result<(), Box<dyn std::error::Error>> {
        let mut w = DeflateWriter::new(Vec::new());
        let bytes =
            include_bytes!("../../../../tests/fixtures/packs/pack-11fdfa9e156ab73caae3b6da867192221f2089c2.pack");
        for chunk in bytes.chunks(4096 * 9) {
            assert_eq!(w.write(chunk)?, chunk.len());
        }
        w.flush()?;

        assert_deflate_buffer(w.inner, bytes)
    }
}

mod deflate {
    use crate::zlib::stream::{deflate::Deflate, Status};
    use miniz_oxide::MZFlush;

    #[test]
    fn compress_all_data_at_once() {
        let mut buf = [0u8; 16];
        assert_eq!(
            Deflate::default()
                .compress(b"hello", &mut buf, MZFlush::Finish)
                .expect("compression to memory to work"),
            Status::StreamEnd
        );
    }

    #[test]
    fn output_too_small_try_finish() -> Result<(), Box<dyn std::error::Error>> {
        let mut buf = [0u8; 6];
        let mut deflate = Deflate::default();
        let input = b"hello";
        assert_eq!(deflate.compress(input, &mut buf, MZFlush::Finish)?, Status::Ok);
        assert_eq!(deflate.total_in, 5);
        assert_eq!(deflate.total_out, 6);
        assert_eq!(
            deflate.compress(&input[deflate.total_in as usize..], &mut buf, MZFlush::Finish)?,
            Status::Ok
        );
        assert_eq!(deflate.total_in, 5);
        assert!(deflate.total_out == 13 || deflate.total_out == 12);
        assert_eq!(
            deflate.compress(&input[deflate.total_in as usize..], &mut buf, MZFlush::Finish)?,
            Status::StreamEnd
        );
        assert!(deflate.total_out == 13 || deflate.total_out == 12);
        Ok(())
    }

    #[test]
    fn output_too_small_do_not_try_to_finish() -> Result<(), Box<dyn std::error::Error>> {
        let mut buf = [0u8; 6];
        let mut deflate = Deflate::default();
        let input = b"hellohellohellohellohellohellohellohellhellohellohellohellohellohellohellohellhellohellohellohellohellohellohellohellooohellohellohellohellohellohellohellohello";
        assert_eq!(deflate.compress(input, &mut buf, MZFlush::None)?, Status::Ok);
        assert_eq!(deflate.total_in, 160);
        assert_eq!(deflate.total_out, 0);
        assert_eq!(
            deflate.compress(&input[deflate.total_in as usize..], &mut buf, MZFlush::None)?,
            Status::BufError,
            "the output buffer is too small to drop any information"
        );
        let mut buf = [0u8; 32];
        assert_eq!(
            deflate.compress(&input[deflate.total_in as usize..], &mut buf, MZFlush::None)?,
            Status::BufError,
            "after the first buf error, unless providing more input, probably nothing can be done"
        );
        assert_eq!(deflate.total_out, 0);
        assert_eq!(
            deflate.compress(&input[deflate.total_in as usize..], &mut buf, MZFlush::Finish)?,
            Status::Ok,
            "it wrote some data, but not all"
        );
        assert!(deflate.total_out == 31 || deflate.total_out == 32);
        assert_eq!(
            deflate.compress(&input[deflate.total_in as usize..], &mut buf, MZFlush::Finish)?,
            Status::StreamEnd,
        );
        assert_eq!(deflate.total_out, 35);
        Ok(())
    }

    #[test]
    fn multiple_inputs_sufficient_output() -> Result<(), Box<dyn std::error::Error>> {
        let mut buf = [0u8; 32];
        let mut deflate = Deflate::default();
        let input = b"hello";
        let step = 2;
        let mut cur = 0;
        assert_eq!(
            deflate.compress(&input[cur..cur + step], &mut buf, MZFlush::None)?,
            Status::Ok
        );
        assert_eq!(deflate.total_in, 2);
        assert_eq!(deflate.total_out, 0);
        cur += step;
        assert_eq!(
            deflate.compress(&input[cur..cur + step], &mut buf, MZFlush::None)?,
            Status::Ok
        );
        assert_eq!(deflate.total_in, 4);
        assert_eq!(deflate.total_out, 0);
        cur += step;
        assert_eq!(
            deflate.compress(&input[cur..], &mut buf, MZFlush::Finish)?,
            Status::StreamEnd
        );
        assert_eq!(deflate.total_in, 5);
        assert!(deflate.total_out == 13 || deflate.total_out == 12);
        Ok(())
    }
}