| 1 |
//! Fuzzy testing. |
| 2 |
//! Tries to discover panics with random bytes. |
| 3 |
//! This test is expensive and therefore marked with `#[ignore]`. To run this test, use `cargo test -- --ignored`. |
| 4 |
|
| 5 |
use std::panic::{catch_unwind}; |
| 6 |
use rand::rngs::{StdRng}; |
| 7 |
use rand::{Rng}; |
| 8 |
|
| 9 |
extern crate exr; |
| 10 |
use exr::prelude::*; |
| 11 |
use std::path::PathBuf; |
| 12 |
use std::ffi::OsStr; |
| 13 |
use std::fs::File; |
| 14 |
use std::io::{Write, Cursor}; |
| 15 |
use exr::image::read::read_first_rgba_layer_from_file; |
| 16 |
use exr::image::pixel_vec::PixelVec; |
| 17 |
|
| 18 |
fn exr_files(path: &'static str, filter: bool) -> impl Iterator<Item=PathBuf> { |
| 19 |
walkdir::WalkDir::new(path).into_iter().map(std::result::Result::unwrap) |
| 20 |
.filter(|entry| entry.path().is_file()) |
| 21 |
|
| 22 |
.filter(move |entry| !filter || entry.path().extension() == Some(OsStr::new("exr"))) |
| 23 |
.map(walkdir::DirEntry::into_path) |
| 24 |
} |
| 25 |
|
| 26 |
|
| 27 |
/// Just don't panic. |
| 28 |
#[test] |
| 29 |
pub fn fuzzed(){ |
| 30 |
for ref file in exr_files("tests/images/fuzzed", false) { |
| 31 |
let _ = read().no_deep_data().largest_resolution_level().all_channels() |
| 32 |
.first_valid_layer().all_attributes().pedantic().from_file(file); |
| 33 |
|
| 34 |
let _ = read().no_deep_data().all_resolution_levels().all_channels() |
| 35 |
.all_layers().all_attributes().pedantic().from_file(file); |
| 36 |
} |
| 37 |
} |
| 38 |
|
| 39 |
/// Require an error but no panic. |
| 40 |
#[test] |
| 41 |
pub fn damaged(){ |
| 42 |
let mut passed = true; |
| 43 |
|
| 44 |
for ref file in exr_files("tests/images/invalid", false) { |
| 45 |
let result = catch_unwind(move || { |
| 46 |
let _meta_data = MetaData::read_from_file(file, false)?; |
| 47 |
|
| 48 |
{ |
| 49 |
let _minimal = read().no_deep_data() |
| 50 |
.largest_resolution_level() |
| 51 |
.rgba_channels( |
| 52 |
|_size, _channels| (), |
| 53 |
|_: &mut (), _position: Vec2<usize>, _pixel: (Sample, Sample, Sample, Sample)| {} |
| 54 |
) |
| 55 |
.first_valid_layer().all_attributes() |
| 56 |
.from_file(&file)?; |
| 57 |
} |
| 58 |
|
| 59 |
{ |
| 60 |
let _minimal = read().no_deep_data() |
| 61 |
.largest_resolution_level() // TODO all levels |
| 62 |
.rgba_channels( |
| 63 |
|_size, _channels| (), |
| 64 |
|_: &mut (), _position: Vec2<usize>, _pixel: (Sample, Sample, Sample, Sample)| {} |
| 65 |
) |
| 66 |
.all_layers().all_attributes() |
| 67 |
.pedantic() |
| 68 |
.from_file(&file)?; |
| 69 |
} |
| 70 |
|
| 71 |
{ |
| 72 |
let _rgba = read_first_rgba_layer_from_file( |
| 73 |
file, |
| 74 |
PixelVec::<(Sample, Sample, Sample, Sample)>::constructor, |
| 75 |
PixelVec::set_pixel |
| 76 |
)?; |
| 77 |
} |
| 78 |
|
| 79 |
{ |
| 80 |
let _full = read_all_data_from_file(file)?; |
| 81 |
} |
| 82 |
|
| 83 |
Ok(()) |
| 84 |
}); |
| 85 |
|
| 86 |
// this should not panic, only err: |
| 87 |
passed = passed && match result { |
| 88 |
Ok(Err(Error::Invalid(message))) => { |
| 89 |
println!("✓ Recognized as invalid ({}): {:?}", message, file); |
| 90 |
true |
| 91 |
}, |
| 92 |
|
| 93 |
Ok(Err(Error::NotSupported(message))) => { |
| 94 |
println!("- Unsupported ({}): {:?}", message, file); |
| 95 |
true |
| 96 |
}, |
| 97 |
|
| 98 |
Ok(Err(Error::Io(error))) => { |
| 99 |
println!("✗ Unexpected IO Error: {:?}, {:?}", file, error); |
| 100 |
false |
| 101 |
}, |
| 102 |
|
| 103 |
Err(_) => { |
| 104 |
println!("✗ Not recognized as invalid: {:?}", file); |
| 105 |
false |
| 106 |
}, |
| 107 |
|
| 108 |
Ok(Ok(_)) => { |
| 109 |
let meta_data = MetaData::read_from_file(file, true); |
| 110 |
|
| 111 |
if let Err(error) = meta_data { |
| 112 |
println!("✓ Recognized as invalid when pedantic ({}): {:?}", error, file); |
| 113 |
true |
| 114 |
} |
| 115 |
else { |
| 116 |
println!("✗ Oh no, there is nothing wrong with: {:#?}", file); |
| 117 |
false |
| 118 |
} |
| 119 |
}, |
| 120 |
|
| 121 |
_ => unreachable!(), |
| 122 |
}; |
| 123 |
} |
| 124 |
|
| 125 |
assert!(passed, "A damaged file was not handled correctly"); |
| 126 |
} |
| 127 |
|
| 128 |
#[test] |
| 129 |
#[ignore] |
| 130 |
pub fn fuzz(){ |
| 131 |
println!("started fuzzing"); |
| 132 |
let files: Vec<PathBuf> = exr_files("tests/images", true).collect(); |
| 133 |
|
| 134 |
let seed = [92,1,0,130,211,8,21,70,74,4,9,5,0,23,0,3,20,25,6,5,229,30,0,34,218,0,40,7,5,2,7,0,]; |
| 135 |
let mut random: StdRng = rand::SeedableRng::from_seed(seed); |
| 136 |
|
| 137 |
let mut records = File::create("tests/images/fuzzed/list.txt").unwrap(); |
| 138 |
records.write_all(format!("seed = {:?}", seed).as_bytes()).unwrap(); |
| 139 |
|
| 140 |
let start_index = 0; // default is 0. increase this integer for debugging a specific fuzz case |
| 141 |
for fuzz_index in 0 .. 1024_u64 * 2048 * 4 { |
| 142 |
|
| 143 |
let file_1_name = &files[random.gen_range(0 .. files.len())]; |
| 144 |
let mutation_point = random.gen::<f32>().powi(3); |
| 145 |
let mutation = random.gen::<u8>(); |
| 146 |
|
| 147 |
if fuzz_index >= start_index { |
| 148 |
let mut file = std::fs::read(file_1_name).unwrap(); |
| 149 |
let index = ((mutation_point * file.len() as f32) as usize + 4) % file.len(); |
| 150 |
file[index] = mutation; |
| 151 |
|
| 152 |
let file = file.as_slice(); |
| 153 |
let result = catch_unwind(move || { |
| 154 |
let read_all_data = read().no_deep_data() |
| 155 |
.all_resolution_levels().all_channels().all_layers().all_attributes(); |
| 156 |
|
| 157 |
match read_all_data.from_buffered(Cursor::new(file)) { |
| 158 |
Err(Error::Invalid(error)) => println!("✓ No Panic. [{}]: Invalid: {}.", fuzz_index, error), |
| 159 |
Err(Error::NotSupported(error)) => println!("- No Panic. [{}]: Unsupported: {}.", fuzz_index, error), |
| 160 |
_ => {}, |
| 161 |
} |
| 162 |
}); |
| 163 |
|
| 164 |
if let Err(_) = result { |
| 165 |
records.write_all(fuzz_index.to_string().as_bytes()).unwrap(); |
| 166 |
records.flush().unwrap(); |
| 167 |
|
| 168 |
let seed = seed.iter().map(|num| num.to_string()).collect::<Vec<String>>().join("-"); |
| 169 |
let mut saved = File::create(format!("tests/images/fuzzed/fuzz_{}_{}.exr", fuzz_index, seed)).unwrap(); |
| 170 |
saved.write_all(file).unwrap(); |
| 171 |
|
| 172 |
println!("✗ PANIC! [{}]", fuzz_index); |
| 173 |
} |
| 174 |
} |
| 175 |
} |
| 176 |
} |