Debian Codegraph @

.cargo/vendor/exr/tests/fuzz.rs

raw
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 }