#![cfg(test)]
#![cfg(feature="std")]
use super::*;
use ::enc::encode::BrotliEncoderParameter;
use core;
#[test]
fn test_compress_workpool() {
  let input = [102, 114, 111, 109, 32, 99, 116, 121, 112, 101, 115, 32, 105, 109, 112, 111, 114, 116, 32, 42, 10, 10, 99, 108, 97, 115, 115, 32, 69, 110, 117, 109, 84, 121, 112, 101, 40, 116, 121, 112, 101, 40, 99, 95, 117, 105, 110, 116, 41, 41, 58, 10, 32, 32, 32, 32, 100, 101, 102, 32, 95, 95, 110, 101, 119, 95, 95, 40, 109, 101, 116, 97, 99, 108, 115, 41, 58, 10, 32, 32, 32, 32, 32, 32, 32, 32, 112, 97, 115, 115, 10];
  let params = [BrotliEncoderParameter::BROTLI_PARAM_QUALITY, BrotliEncoderParameter::BROTLI_PARAM_LGWIN, BrotliEncoderParameter::BROTLI_PARAM_SIZE_HINT, BrotliEncoderParameter::BROTLI_PARAM_CATABLE, BrotliEncoderParameter::BROTLI_PARAM_MAGIC_NUMBER, BrotliEncoderParameter::BROTLI_PARAM_Q9_5];
  let values = [11u32,16u32,91u32,0u32,0u32,0u32];
  let mut encoded_size = BrotliEncoderMaxCompressedSizeMulti(input.len(), 4);
  let mut encoded_backing = [0u8;145];
  let encoded = &mut encoded_backing[..encoded_size];
  let ret = unsafe {
    let wp = BrotliEncoderCreateWorkPool(8, None, None, core::ptr::null_mut());
    let inner_ret = BrotliEncoderCompressWorkPool(
      wp,
      params.len(),
      params[..].as_ptr(),
      values[..].as_ptr(),
      input.len(),
      input[..].as_ptr(),
      &mut encoded_size,
      encoded.as_mut_ptr(),
      4,
      None,
      None,
      core::ptr::null_mut());
    BrotliEncoderDestroyWorkPool(wp);
    inner_ret
  };
  assert_eq!(ret, 1);
  let mut rt_size = 256;
  let mut rt_buffer = [0u8;256];
  let ret2 = unsafe {
    super::super::decompressor::CBrotliDecoderDecompress(encoded_size, encoded.as_ptr(),
                                                         &mut rt_size, rt_buffer.as_mut_ptr())
  };
  match ret2 {
    super::super::decompressor::ffi::interface::BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS => {
    },
    _ => panic!("{}", ret2 as i32),
  }
  assert_eq!(rt_size, input.len());
  assert_eq!(&rt_buffer[..rt_size], &input[..]);
}

#[test]
fn test_compress_empty_workpool() {
  let input = [];
  let params = [BrotliEncoderParameter::BROTLI_PARAM_QUALITY, BrotliEncoderParameter::BROTLI_PARAM_LGWIN, BrotliEncoderParameter::BROTLI_PARAM_SIZE_HINT, BrotliEncoderParameter::BROTLI_PARAM_CATABLE, BrotliEncoderParameter::BROTLI_PARAM_MAGIC_NUMBER, BrotliEncoderParameter::BROTLI_PARAM_Q9_5];
  let values = [3u32,16u32,91u32,0u32,0u32,0u32];
  let mut encoded_size = BrotliEncoderMaxCompressedSizeMulti(input.len(), 4);
  let mut encoded_backing = [0u8;145];
  let encoded = &mut encoded_backing[..encoded_size];
  let ret = unsafe {
    let wp = BrotliEncoderCreateWorkPool(8, None, None, core::ptr::null_mut());
    let inner_ret = BrotliEncoderCompressWorkPool(
      wp,
      params.len(),
      params[..].as_ptr(),
      values[..].as_ptr(),
      input.len(),
      input[..].as_ptr(),
      &mut encoded_size,
      encoded.as_mut_ptr(),
      4,
      None,
      None,
      core::ptr::null_mut());
    BrotliEncoderDestroyWorkPool(wp);
    inner_ret
  };
  assert_eq!(ret, 1);
  let mut rt_size = 256;
  let mut rt_buffer = [0u8;256];
  assert!(encoded_size != 0);
  let ret2 = unsafe {
    super::super::decompressor::CBrotliDecoderDecompress(encoded_size, encoded.as_ptr(),
                                                         &mut rt_size, rt_buffer.as_mut_ptr())
  };
  match ret2 {
    super::super::decompressor::ffi::interface::BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS => {
    },
    _ => panic!("{}", ret2 as i32),
  }
  assert_eq!(rt_size, input.len());
  assert_eq!(&rt_buffer[..rt_size], &input[..]);
}


#[test]
fn test_compress_empty_multi_raw() {
  let input = [];
  let params = [BrotliEncoderParameter::BROTLI_PARAM_QUALITY, BrotliEncoderParameter::BROTLI_PARAM_LGWIN, BrotliEncoderParameter::BROTLI_PARAM_SIZE_HINT, BrotliEncoderParameter::BROTLI_PARAM_CATABLE, BrotliEncoderParameter::BROTLI_PARAM_MAGIC_NUMBER, BrotliEncoderParameter::BROTLI_PARAM_Q9_5];
  let values = [3u32,16u32,0u32,0u32,0u32,0u32];
  let mut encoded_size = BrotliEncoderMaxCompressedSizeMulti(input.len(), 4);
  let mut encoded_backing = [0u8;145];
  let encoded = &mut encoded_backing[..encoded_size];
  let ret = unsafe {
    BrotliEncoderCompressMulti(
      params.len(),
      params[..].as_ptr(),
      values[..].as_ptr(),
      input.len(),
      input[..].as_ptr(),
      &mut encoded_size,
      encoded.as_mut_ptr(),
      4,
      None,
      None,
      core::ptr::null_mut())
  };
  assert_eq!(ret, 1);
  let mut rt_size = 256;
  let mut rt_buffer = [0u8;256];
  assert!(encoded_size != 0);
  let ret2 = unsafe {
    super::super::decompressor::CBrotliDecoderDecompress(encoded_size, encoded.as_ptr(),
                                                         &mut rt_size, rt_buffer.as_mut_ptr())
  };
  match ret2 {
    super::super::decompressor::ffi::interface::BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS => {
    },
    _ => panic!("{}", ret2 as i32),
  }
  assert_eq!(rt_size, input.len());
  assert_eq!(&rt_buffer[..rt_size], &input[..]);
}

#[test]
fn test_compress_null_multi_raw() {
  let params = [BrotliEncoderParameter::BROTLI_PARAM_QUALITY, BrotliEncoderParameter::BROTLI_PARAM_LGWIN, BrotliEncoderParameter::BROTLI_PARAM_SIZE_HINT, BrotliEncoderParameter::BROTLI_PARAM_CATABLE, BrotliEncoderParameter::BROTLI_PARAM_MAGIC_NUMBER, BrotliEncoderParameter::BROTLI_PARAM_Q9_5];
  let values = [3u32,16u32,0u32,0u32,0u32,0u32];
  let mut encoded_size = BrotliEncoderMaxCompressedSizeMulti(0, 4);
  let mut encoded_backing = [0u8;145];
  let encoded = &mut encoded_backing[..encoded_size];
  let ret = unsafe {
    BrotliEncoderCompressMulti(
      params.len(),
      params[..].as_ptr(),
      values[..].as_ptr(),
      0,
      core::ptr::null(),
      &mut encoded_size,
      encoded.as_mut_ptr(),
      4,
      None,
      None,
      core::ptr::null_mut())
  };
  assert_eq!(ret, 1);
  let mut rt_size = 256;
  let mut rt_buffer = [0u8;256];
  assert!(encoded_size != 0);
  let ret2 = unsafe {
    super::super::decompressor::CBrotliDecoderDecompress(encoded_size, encoded.as_ptr(),
                                                         &mut rt_size, rt_buffer.as_mut_ptr())
  };
  match ret2 {
    super::super::decompressor::ffi::interface::BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS => {
    },
    _ => panic!("{}", ret2 as i32),
  }
  assert_eq!(rt_size, 0);
}



#[test]
fn test_compress_empty_multi_raw_one_thread() {
  let input = [];
  let params = [BrotliEncoderParameter::BROTLI_PARAM_QUALITY, BrotliEncoderParameter::BROTLI_PARAM_Q9_5, BrotliEncoderParameter::BROTLI_PARAM_CATABLE,  BrotliEncoderParameter::BROTLI_PARAM_APPENDABLE, BrotliEncoderParameter::BROTLI_PARAM_MAGIC_NUMBER, ];
  let values = [10u32,1u32,1u32,1u32,1u32];
  let mut encoded_size = BrotliEncoderMaxCompressedSizeMulti(input.len(), 1);
  let mut encoded_backing = [0u8;25];
  let encoded = &mut encoded_backing[..encoded_size];
  assert_eq!(params.len(), 5);
  assert_eq!(encoded_size, 25);  
  let ret = unsafe {
    BrotliEncoderCompressMulti(
      params.len(),
      params[..].as_ptr(),
      values[..].as_ptr(),
      input.len(),
      input[..].as_ptr(),
      &mut encoded_size,
      encoded.as_mut_ptr(),
      1,
      None,
      None,
      core::ptr::null_mut())
  };
  assert_eq!(ret, 1);
  let mut rt_size = 256;
  let mut rt_buffer = [0u8;256];
  assert!(encoded_size != 0);
  let ret2 = unsafe {
    super::super::decompressor::CBrotliDecoderDecompress(encoded_size, encoded.as_ptr(),
                                                         &mut rt_size, rt_buffer.as_mut_ptr())
  };
  match ret2 {
    super::super::decompressor::ffi::interface::BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS => {
    },
    _ => panic!("{}", ret2 as i32),
  }
  assert_eq!(rt_size, input.len());
  assert_eq!(&rt_buffer[..rt_size], &input[..]);
}


#[test]
fn test_compress_empty_multi_catable() {
  let input = [];
  let params = [BrotliEncoderParameter::BROTLI_PARAM_QUALITY, BrotliEncoderParameter::BROTLI_PARAM_LGWIN, BrotliEncoderParameter::BROTLI_PARAM_SIZE_HINT, BrotliEncoderParameter::BROTLI_PARAM_CATABLE, BrotliEncoderParameter::BROTLI_PARAM_MAGIC_NUMBER, BrotliEncoderParameter::BROTLI_PARAM_Q9_5];
  let values = [3u32,16u32,0u32,1u32,1u32,0u32];
  let mut encoded_size = BrotliEncoderMaxCompressedSizeMulti(input.len(), 4);
  let mut encoded_backing = [0u8;145];
  let encoded = &mut encoded_backing[..encoded_size];
  let ret = unsafe {
    BrotliEncoderCompressMulti(
      params.len(),
      params[..].as_ptr(),
      values[..].as_ptr(),
      input.len(),
      input[..].as_ptr(),
      &mut encoded_size,
      encoded.as_mut_ptr(),
      4,
      None,
      None,
      core::ptr::null_mut())
  };
  assert_eq!(ret, 1);
  let mut rt_size = 256;
  let mut rt_buffer = [0u8;256];
  assert!(encoded_size != 0);
  let ret2 = unsafe {
    super::super::decompressor::CBrotliDecoderDecompress(encoded_size, encoded.as_ptr(),
                                                         &mut rt_size, rt_buffer.as_mut_ptr())
  };
  match ret2 {
    super::super::decompressor::ffi::interface::BrotliDecoderResult::BROTLI_DECODER_RESULT_SUCCESS => {
    },
    _ => panic!("{:?}", ret2 as i32),
  }
  assert_eq!(rt_size, input.len());
  assert_eq!(&rt_buffer[..rt_size], &input[..]);
}

