From 6c902de16f0410bc4337ca22e7502107438f9162 Mon Sep 17 00:00:00 2001 From: Trevor Merritt Date: Wed, 28 May 2025 11:32:09 -0400 Subject: [PATCH] adds smoke tests to everything adds deflated test examples --- .idea/trevors_chip8_toy.iml | 3 + Cargo.lock | 1 + Cargo.toml | 2 + gemma/Cargo.toml | 1 + gemma/src/bin/testcompression.rs | 113 ++++++++---------- gemma/tests/computer_tests.rs | 51 ++++++-- gemma/tests/test_compression_tests.rs | 18 +++ gemma/tests/test_utils.rs | 52 ++++++++ gemma/tests/unit_tests.rs | 9 +- gemma/tests/util_tests.rs | 1 - gemmaegui/src/bin/gemmaegui.rs | 2 +- gemmaegui/tests/smoke.rs | 4 + gemmaimgui/tests/smoke.rs | 4 + gemmatelnet/tests/smoke.rs | 4 + .../gemma_integration_corax_plus.deflated | Bin 0 -> 443 bytes .../test/gemma_integration_flags.deflated | Bin 0 -> 421 bytes .../gemma_integration_ibm_rom_output.deflated | Bin 0 -> 213 bytes .../gemma_integration_level_1_test.deflated | Bin 0 -> 407 bytes .../gemma_integration_rps_stage1.deflated | Bin 0 -> 390 bytes .../gemma_integration_rps_stage2.deflated | Bin 0 -> 410 bytes resources/test/test_keypad_to_string.deflated | Bin 0 -> 38 bytes resources/test/test_manager_status.deflated | 2 + resources/test/test_multi_sprite.deflated | Bin 0 -> 125 bytes .../test/test_reset_clears_video.deflated | Bin 0 -> 44 bytes .../test/test_scroll_down_10_hd.deflated | Bin 0 -> 82 bytes resources/test/test_scroll_down_1_hd.deflated | Bin 0 -> 79 bytes resources/test/test_scroll_left_4.deflated | Bin 0 -> 50 bytes resources/test/test_scroll_left_4_hd.deflated | Bin 0 -> 86 bytes resources/test/test_scroll_right_4.deflated | Bin 0 -> 108 bytes .../test/test_scroll_right_4_hd.deflated | Bin 0 -> 276 bytes resources/test/test_video_highdef.deflated | Bin 0 -> 80 bytes .../test/test_video_scroll_down_1.deflated | Bin 0 -> 48 bytes .../test/test_video_scroll_down_10.deflated | Bin 0 -> 49 bytes .../test_video_scroll_up_test_hd.deflated | Bin 0 -> 79 bytes .../test_video_scroll_up_test_sd.deflated | Bin 0 -> 50 bytes .../test_video_write_checkerboard.deflated | Bin 0 -> 48 bytes resources/test/test_video_zero.deflated | 0 37 files changed, 185 insertions(+), 82 deletions(-) create mode 100644 gemma/tests/test_compression_tests.rs create mode 100644 gemma/tests/test_utils.rs create mode 100644 gemmaegui/tests/smoke.rs create mode 100644 gemmaimgui/tests/smoke.rs create mode 100644 gemmatelnet/tests/smoke.rs create mode 100644 resources/test/gemma_integration_corax_plus.deflated create mode 100644 resources/test/gemma_integration_flags.deflated create mode 100644 resources/test/gemma_integration_ibm_rom_output.deflated create mode 100644 resources/test/gemma_integration_level_1_test.deflated create mode 100644 resources/test/gemma_integration_rps_stage1.deflated create mode 100644 resources/test/gemma_integration_rps_stage2.deflated create mode 100644 resources/test/test_keypad_to_string.deflated create mode 100644 resources/test/test_manager_status.deflated create mode 100644 resources/test/test_multi_sprite.deflated create mode 100644 resources/test/test_reset_clears_video.deflated create mode 100644 resources/test/test_scroll_down_10_hd.deflated create mode 100644 resources/test/test_scroll_down_1_hd.deflated create mode 100644 resources/test/test_scroll_left_4.deflated create mode 100644 resources/test/test_scroll_left_4_hd.deflated create mode 100644 resources/test/test_scroll_right_4.deflated create mode 100644 resources/test/test_scroll_right_4_hd.deflated create mode 100644 resources/test/test_video_highdef.deflated create mode 100644 resources/test/test_video_scroll_down_1.deflated create mode 100644 resources/test/test_video_scroll_down_10.deflated create mode 100644 resources/test/test_video_scroll_up_test_hd.deflated create mode 100644 resources/test/test_video_scroll_up_test_sd.deflated create mode 100644 resources/test/test_video_write_checkerboard.deflated create mode 100644 resources/test/test_video_zero.deflated diff --git a/.idea/trevors_chip8_toy.iml b/.idea/trevors_chip8_toy.iml index ca38ecd..702a8af 100644 --- a/.idea/trevors_chip8_toy.iml +++ b/.idea/trevors_chip8_toy.iml @@ -10,6 +10,9 @@ + + + diff --git a/Cargo.lock b/Cargo.lock index 9427308..35fdab7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1733,6 +1733,7 @@ dependencies = [ "chrono", "clap", "dimensioned", + "env_logger", "flate2", "hex", "log", diff --git a/Cargo.toml b/Cargo.toml index e4de82c..a590ee7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,3 +25,5 @@ eframe = { version = "0.29" } # IMGUI # EXPERIMENT + +# Personal diff --git a/gemma/Cargo.toml b/gemma/Cargo.toml index aee9bb3..a51c8f3 100644 --- a/gemma/Cargo.toml +++ b/gemma/Cargo.toml @@ -16,3 +16,4 @@ serde_json.workspace = true flate2 = "1.0" clap = { version = "4.5.20", features = ["derive"] } hex = "0.4.3" +env_logger = "0.10.2" diff --git a/gemma/src/bin/testcompression.rs b/gemma/src/bin/testcompression.rs index 0f4d8f4..19a1fa9 100644 --- a/gemma/src/bin/testcompression.rs +++ b/gemma/src/bin/testcompression.rs @@ -21,16 +21,18 @@ use std::fs; use std::fs::File; use clap::{Parser, Subcommand}; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; use std::io::prelude::*; use std::io::Read; use std::io::Write; use flate2::Compression; -use flate2::write::{GzEncoder, ZlibEncoder}; +use flate2::write::{DeflateEncoder, GzEncoder, ZlibEncoder}; use gemma::constants::{TESTS_ROOT, TEST_ROM_ROOT}; -use flate2::read::{DeflateDecoder, DeflateEncoder, GzDecoder}; +use flate2::read::{DeflateDecoder}; use std::io::prelude::*; use std::io; +use std::ptr::write; +use log::{debug, info}; #[derive(Parser)] #[command(author, version, about = "Compress or decompress a string", long_about = None)] @@ -54,72 +56,63 @@ enum Commands { } } -fn compress_file(input_path: &PathBuf) { - let file = File::open(&input_path).unwrap(); - let mut compressed_bytes= Vec::new(); - - let mut deflater = DeflateEncoder::new(file, Compression::fast()); - deflater.read_to_end(&mut compressed_bytes).expect("Unable to write compressed data to buffer "); - - let output_filename = format!("{}.deflated", input_path.display()); - let output_file = File::create(&output_filename); - output_file.unwrap().write_all(&compressed_bytes).expect("Unable to write compressed version"); +fn compress_file(input_path: &PathBuf) -> io::Result<()> { + let compressed_bytes= compress_file_to_array(input_path); + let output_filename = input_path.with_extension("deflated"); + let mut output_file = File::create(&output_filename)?; + output_file.write_all(&compressed_bytes.unwrap())?; + Ok(()) } -fn decompress_file(input_path: &PathBuf) { - let file = File::open(&input_path).unwrap(); - let mut uncompressed_bytes = Vec::new(); +fn compress_file_to_array(input_path: &Path) -> Result, String> { + let mut file = File::open(input_path) + .map_err(|e| std::io::Error::new(e.kind(), format!("Unable to open input path [{}]: {}", input_path.display(), e))); - let mut inflater = DeflateDecoder::new(file); - inflater.read_to_end(&mut uncompressed_bytes).expect("Unable to inflate."); + let mut read_buffer = Vec::new(); + let mut write_buffer = Vec::new(); + file.unwrap().read_to_end(&mut read_buffer) + .map_err(|e| std::io::Error::new(e.kind(), format!("Unable to read input file [{}]: {}", input_path.display(), e))); - let target_file_name = format!("{}.inflated", input_path.display()); - println!("Writing decompressed data to {}", target_file_name); + let mut encoder = DeflateEncoder::new(read_buffer, Compression::default()); + encoder.write_all(&write_buffer) + .map_err(|e| std::io::Error::new(e.kind(), format!("Unable to compress data for [{}]: {}", input_path.display(), e))); - let mut target_file = File::create(&target_file_name) - .expect("Unable to create uncompressed output file"); - target_file - .write_all(&uncompressed_bytes) - .expect("Unable to write decompressed file"); + debug!("Compressed file from path: {}", input_path.display()); + Ok(write_buffer) +} - // let decompressed_data = decompress_data(input_data); - // let mut target_file = File::create(&target_file_name).expect(format!("Unable to create uncompressed file -> {}", target_file_name.clone()).as_str()); - //target_file.write_all(&decompressed_data).expect(format!("Unable to write uncompressed file -> {}", target_file_name).as_str()); - //println!("Decompressed: {:?}", String::from_utf8_lossy(&decompressed_data)); +fn decompress_file_to_array(input_path: &Path) -> Vec { + let file = File::open(input_path) + .map_err(|e| std::io::Error::new(e.kind(), format!("Unable to open input path [{}]: {}", input_path.display(), e))); + + let mut decoder = DeflateDecoder::new(file.unwrap()); + let mut return_vec = Vec::new(); + decoder.read_to_end(&mut return_vec) + .map_err(|e| std::io::Error::new(e.kind(), format!("Unable to decompress data for [{}]: {}", input_path.display(), e))); + + debug!("Decompressed file from path: {}", input_path.display()); + return_vec +} + +fn decompress_file(input_path: &PathBuf) -> io::Result<()> { + let decompressed_bytes = decompress_file_to_array(input_path); + let output_path = input_path.with_extension("inflated"); + let mut output_file = File::create(&output_path)?; + output_file.write_all(&decompressed_bytes).expect(format!("Unable to write compressed data to [{}]", output_path.display()).as_str()); + Ok(()) } fn main() { + env_logger::init(); + let cli = Cli::parse(); - let raw_file = format!("{}/gemma/{}test_scroll_down_10_hd.asc", std::env::current_dir().unwrap().display(), TESTS_ROOT); - let compressed_file = format!("{}.deflated", &raw_file); - let uncompressed_file = format!("{}.inflated", &compressed_file); - println!("[ + ] Writing compressed file from {}", &raw_file); - compress_file(&raw_file.clone().into()); - - decompress_file(&compressed_file.into()); - ///////// COMPRESSION COMPLETE. TIME TO DECOMPRESS AND COMPARE - - // - // - // - // match cli.command { - // Commands::Compress { input } => { - // let compressed = compress_string(&input); - // // Convert to hex format for easier readability in the terminal - // println!("Compressed (hex): {:?} / from {}b to {}b", hex::encode(compressed.clone()), input.len(), compressed.len()); - // } - // Commands::Decompress { input } => { - // // Decode hex string back to bytes - // let compressed_bytes = hex::decode(input).expect("Invalid hex input"); - // let decompressed = decompress_string(&compressed_bytes); - // println!("Decompressed: {}", decompressed); - // } - // Commands::DecompressFile { input } => { - // decompress_file(&input); - // } - // Commands::CompressFile { input } => { - // compress_file(&input); - // } - // } + match cli.command { + Commands::Compress { input } => { + compress_file(&input).expect(format!("Unable to compress {}", input.display()).as_str()); + } + Commands::Decompress { input } => { + decompress_file(&input).expect(format!("Unable to decompress {}", input.display()).as_str()); + } + } } diff --git a/gemma/tests/computer_tests.rs b/gemma/tests/computer_tests.rs index 482a8b9..11f0b4b 100644 --- a/gemma/tests/computer_tests.rs +++ b/gemma/tests/computer_tests.rs @@ -1,4 +1,5 @@ -use std::path::Path; +mod test_utils; +use std::path::{Path, PathBuf}; use std::time::Instant; use gemma::chip8::computer::Chip8Computer; use gemma::chip8::computer_manager::Chip8ComputerManager; @@ -6,19 +7,13 @@ use gemma::chip8::quirk_modes::QuirkMode; use gemma::chip8::quirk_modes::QuirkMode::{Chip8, SChipModern, XOChip}; use gemma::chip8::registers::Chip8Registers; use gemma::constants::{CHIP8_VIDEO_MEMORY, TESTS_ROOT}; +use crate::test_utils::{load_compressed_result, load_result, load_rom}; #[test] fn smoke() { assert!(true) } -fn load_result(to_load: &str) -> String { - std::fs::read_to_string(format!("../resources/test/{}", to_load)).unwrap() -} - -fn load_rom(to_load: &str) -> Vec { - std::fs::read(format!("../resources/roms/{}", to_load)).unwrap() -} #[test] fn reset_clears_video() { @@ -88,6 +83,21 @@ fn level3_test() { ); } +#[test] +fn level3_compressed_test() { + let mut x = Chip8Computer::new(); + + x.load_bytes_to_memory(0x200, &load_rom("3-corax+.ch8")); + for i in 0..0x180 { + x.step_system(); + } + + assert_eq!( + x.dump_video_to_string(), + load_compressed_result("gemma_integration.corax_plus.deflated") + ); +} + #[test] fn rps_test() { let mut x = Chip8Computer::new(); @@ -97,7 +107,7 @@ fn rps_test() { } assert_eq!( x.dump_video_to_string(), - load_result("gemma_integration_rps_stage1.asc") + load_compressed_result("gemma_integration_rps_stage1") ); x.keypad.push_key(0x01); for _ in 0..0x200 { @@ -105,7 +115,7 @@ fn rps_test() { } assert_eq!( x.dump_video_to_string(), - load_result("gemma_integration_rps_stage2.asc") + load_compressed_result("gemma_integration_rps_stage2") ); } @@ -176,11 +186,11 @@ fn quirks_mode_test() { #[test] fn load_rom_allows_starting() { let mut new_manager = Chip8ComputerManager::default(); - assert_eq!(new_manager.core_should_run, false); + assert!(!new_manager.core_should_run); let p = format!("{}/../resources/test/roms/1-chip8-logo.ch8" , std::env::current_dir().unwrap().display()); let full_path = Path::new(p.as_str()); new_manager.load_new_program_from_disk_to_system_memory(full_path); - assert_eq!(new_manager.core_should_run, true) + assert!(new_manager.core_should_run) } #[test] @@ -189,5 +199,20 @@ fn reset_clears_run_state() { let p = format!("{}/../resources/test/roms/1-chip8-logo.ch8", std::env::current_dir().unwrap().display()); new_manager.load_new_program_from_disk_to_system_memory(Path::new(p.as_str())); new_manager.reset(QuirkMode::Chip8); - assert_eq!(new_manager.core_should_run, false); + assert!(!new_manager.core_should_run); } + +#[test] +fn tick_when_ready() { + let mut new_manager = Chip8ComputerManager::default(); + new_manager.load_new_program_from_disk_to_system_memory(Path::new( + format!("{}/../resources/test/roms/1-chip8-logo.ch8", std::env::current_dir().unwrap().display()).as_str())); + assert!(new_manager.core_should_run); + +} + +#[test] +fn tick_when_not_ready() {} + +#[test] +fn tick_one_step_only() {} diff --git a/gemma/tests/test_compression_tests.rs b/gemma/tests/test_compression_tests.rs new file mode 100644 index 0000000..a658664 --- /dev/null +++ b/gemma/tests/test_compression_tests.rs @@ -0,0 +1,18 @@ +use crate::test_utils::{compress_string, decompress_to_string}; + +mod test_utils; + +#[test] +fn smoke() { + assert!(true) +} + +#[test] +fn round_trip() { + let text_to_process = "The quick brown fox jumps over the lazy dog."; + let compressed = compress_string(text_to_process); + let decompressed = decompress_to_string(&compressed).unwrap(); + + assert_eq!(text_to_process, decompressed); +} + diff --git a/gemma/tests/test_utils.rs b/gemma/tests/test_utils.rs new file mode 100644 index 0000000..63d78b9 --- /dev/null +++ b/gemma/tests/test_utils.rs @@ -0,0 +1,52 @@ +use std::fs::File; +use std::io::{Read, Write}; +use std::path::Path; +use flate2::Compression; +use flate2::read::DeflateDecoder; +use flate2::write::{DeflateEncoder}; + +use log::debug; + +const TEST_OUTPUT_SAMPLE_DIR: &str = "../resources/test/"; + +pub fn compress_string(input: &str) -> Vec { + let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default()); + encoder.write_all(input.as_bytes()).expect("Failed to write data"); + encoder.finish().expect("Failed to finish compression") +} + +pub fn decompress_to_string(compressed_data: &[u8]) -> Result { + let mut decoder = DeflateDecoder::new(compressed_data); + let mut decompressed = String::new(); + decoder.read_to_string(&mut decompressed)?; + Ok(decompressed) +} + +/// Read a compressed test result and return the expected result +/// as a string +pub fn read_compressed_test_result(suffix: &str) -> String { + let full_path = std::env::current_dir().unwrap().display().to_string() + "/" + &*TEST_OUTPUT_SAMPLE_DIR.to_owned() + suffix + ".deflated"; + println!("LOADING {}", full_path); + let mut compressed_file = File::open(full_path).expect(format!("Unable to load test result [{}]", suffix).as_str()); + let mut compressed_data = Vec::new(); + compressed_file.read_to_end(&mut compressed_data).expect("Unable to compress data"); + + decompress_to_string(&compressed_data).unwrap() +} + +pub fn load_compressed_result(suffix: &str) -> String { + read_compressed_test_result(suffix) +} + +pub fn read_test_result(suffix: &str) -> String { + std::fs::read_to_string(TEST_OUTPUT_SAMPLE_DIR.to_owned() + suffix).unwrap() +} + + +pub fn load_result(to_load: &str) -> String { + std::fs::read_to_string(format!("../resources/test/{}", to_load)).unwrap() +} + +pub fn load_rom(to_load: &str) -> Vec { + std::fs::read(format!("../resources/roms/{}", to_load)).unwrap() +} \ No newline at end of file diff --git a/gemma/tests/unit_tests.rs b/gemma/tests/unit_tests.rs index 845551c..5f5b2fa 100644 --- a/gemma/tests/unit_tests.rs +++ b/gemma/tests/unit_tests.rs @@ -18,14 +18,9 @@ use log::debug; use rand::random; use serde::Serialize; use gemma::chip8::computer_manager::Chip8ComputerManager; +use crate::test_utils::read_test_result; -const TEST_OUTPUT_SAMPLE_DIR: &str = "../resources/test/"; - -fn read_test_result(suffix: &str) -> String { - println!("SITTING IN {:?}", std::env::current_dir()); - println!("ATTEMPT TO READ RESULT {suffix}"); - std::fs::read_to_string(TEST_OUTPUT_SAMPLE_DIR.to_owned() + suffix).unwrap() -} +mod test_utils; #[test] fn smoke() { diff --git a/gemma/tests/util_tests.rs b/gemma/tests/util_tests.rs index dab1089..a9eb97f 100644 --- a/gemma/tests/util_tests.rs +++ b/gemma/tests/util_tests.rs @@ -21,7 +21,6 @@ fn byte_to_bools() { } } - #[test] fn bools_to_byte() { let data_set: BTreeMap = BTreeMap::from( diff --git a/gemmaegui/src/bin/gemmaegui.rs b/gemmaegui/src/bin/gemmaegui.rs index 373cb6c..0270be7 100644 --- a/gemmaegui/src/bin/gemmaegui.rs +++ b/gemmaegui/src/bin/gemmaegui.rs @@ -149,7 +149,7 @@ fn main() -> eframe::Result { }); // run our target number of ticks in the amount of available time. - let time_consumed = Instant::now().duration_since(frame_start_time).as_millis(); + // let time_consumed = Instant::now().duration_since(frame_start_time).as_millis(); let mut num_ticks = 0; while num_ticks < 1000 { computer.tick(); diff --git a/gemmaegui/tests/smoke.rs b/gemmaegui/tests/smoke.rs new file mode 100644 index 0000000..bb51994 --- /dev/null +++ b/gemmaegui/tests/smoke.rs @@ -0,0 +1,4 @@ +#[test] +fn smoke() { + assert!(true) +} \ No newline at end of file diff --git a/gemmaimgui/tests/smoke.rs b/gemmaimgui/tests/smoke.rs new file mode 100644 index 0000000..bb51994 --- /dev/null +++ b/gemmaimgui/tests/smoke.rs @@ -0,0 +1,4 @@ +#[test] +fn smoke() { + assert!(true) +} \ No newline at end of file diff --git a/gemmatelnet/tests/smoke.rs b/gemmatelnet/tests/smoke.rs new file mode 100644 index 0000000..bb51994 --- /dev/null +++ b/gemmatelnet/tests/smoke.rs @@ -0,0 +1,4 @@ +#[test] +fn smoke() { + assert!(true) +} \ No newline at end of file diff --git a/resources/test/gemma_integration_corax_plus.deflated b/resources/test/gemma_integration_corax_plus.deflated new file mode 100644 index 0000000000000000000000000000000000000000..21c598305ab2ec858389f2bdc8ff45524d59fc05 GIT binary patch literal 443 zcmV;s0Yv_#kWq32F$hEddkTN={SVmp1UTNAHj~-3CPqRCyz9%qpS7;*TKCxdivRGVgH=kY%r0Dh;OXD(1l+RaWv1Nx&FXg}kTQ zXOya{h)K{mi;L431N*9hD#wXNni?lh7kwwUFaUpXFmPHnXq(`kCMBNdh>e#XgDho3 zv(5g%rx-nBG6#hq}!3MrT!rrRp4uba7>U&Z%ShB4P?2C!ULaylEAAk` zBD*rM5nLol-@Ji|Oq9I+B|@?#bA%qt4f%(#)0O$#x5-zq=&2Bdk6B-^;DTL6Km=h) zyg8ocYN+oDwm0sK@P39oM1s0_la{dW2M9L0{}nDix!T zHh&Iw!B?O{!9f@ghtn|SW~!Jix=ntaHvvT{^*D=)k{E$-N+f_D$6!XF79jw_X-LHb Pu3Y>n;WN)Z_P@dp2O-6f literal 0 HcmV?d00001 diff --git a/resources/test/gemma_integration_ibm_rom_output.deflated b/resources/test/gemma_integration_ibm_rom_output.deflated new file mode 100644 index 0000000000000000000000000000000000000000..717a269388d3781e803e4de8719dc82c3329b2db GIT binary patch literal 213 zcmV;`04o3OlR*}OFbqWZo+9hs|A79P6r`=F(2b7=FHNRNnM{Mm8fw;7cB zM2)5Jk&TIIbyq?qrA~gv9RkziUJB5_9#b})uV)MDl?d# zL1i3%2ee!j3|I-46vV88T>=`sRgkwwHwRL|;=3U(>8~-{aI7PsL6!hiHy(%pDIveH zj$l*y2%)R>hJdt9eGG7kIW5fW2-avvx*=fyqv_0?R(3V&dn!qDLcSjjLCqZs PH^K04JTyNazQPcn?3!R+ literal 0 HcmV?d00001 diff --git a/resources/test/gemma_integration_level_1_test.deflated b/resources/test/gemma_integration_level_1_test.deflated new file mode 100644 index 0000000000000000000000000000000000000000..9705cff9d0bb8cbba0d800b3dbd44afdd35f3477 GIT binary patch literal 407 zcmV;I0cifMl0k9=WCxo{ETC#Cf>+n z!(&_o#;6)C0*-+s8b%mRhgtSO;6SE4;2zd!fnNmNg=^Kh2$0m=iq8aW%Eo6egrx}s8uh*Zo?iv> z6L1|}TrP-5Kn_s}ps4)zggIy5@(H59I%@v9L2-2fjRIV&imRv+#ip(sgk*s8B0wIi z5|AoUdqKdq_CE^b$IaT$1k&ImufP%A6%cCJhva&Kv+z8QNToq1MXVl*FtJU*tF81* z?vtYrJP}n4u5A}+>b>K`0$I*yu<*!VhINvA7Bf>A?Y03!F#;OKOaZVkoS38K4+Lrr zzVYf%fsuTVFjUC^Z4U&h;y@u37%}G{X||7_0<~y*4WzVkucN+S2s7;_FzMINuWt(v B!?*wd literal 0 HcmV?d00001 diff --git a/resources/test/gemma_integration_rps_stage1.deflated b/resources/test/gemma_integration_rps_stage1.deflated new file mode 100644 index 0000000000000000000000000000000000000000..50d8ba427b9b6a6d52ec1bde665b4e0739ff3fc3 GIT binary patch literal 390 zcmV;10eSwll2MKWF$hEd_Z0KZ{SUa$1Q?*BR;y}9Byo&!NK^ar`}wlo{@viZ?EUwl zgNyGk2Kzk9iRrL3s{`b%XYDj@hq)6!4K9;{p;Y3vwRQrsX<)60y2qfX$1;c(P`nfe zw;HfzK$=SPuYN6<#2nzcd&0o;V~TWLHp^cxXeI;OSBFr@z-wdT_vq0r+(yEk;nJU*P~zI4ceTI)F?75UfWs79H66Jm)7= zQx1YUxHeuh3{HItbo+Lu=qXqRkz^quwQgMoa0JN+HYZL8!Nx-7obJF$kiv0IVhn>K z5}59KMs@%tA{DjzD|oxE@JUJP2ol_+3Optng`8)Rh^E|J)tbqyx z%(E@_6u8ntQ}Jv%32W&A&7J~qY`PGV7ddl)$`dqu3eX6j3G~V!F|XAcXZR49h5zm) zP=}44x4=;bCzFL3fnO`3_KGogN#1+b7g6B%io{;2cqrTefg8~C7R*8v8aT!<%;S|> zrLJk-p1T0*;OL-T&eJXLM4 z;C1H_jICIkK+by+eA9f`;u=C=8`y0V$f-?$TO=jbAf>pt;6rQyi4dh6HVb6^m8@4`5kv5yp&N0XXBi7J-@kWanQQ$uI2q E0n!M@6aWAK literal 0 HcmV?d00001 diff --git a/resources/test/test_keypad_to_string.deflated b/resources/test/test_keypad_to_string.deflated new file mode 100644 index 0000000000000000000000000000000000000000..9c62506ff36b270249ab22c9eb6413e2e96c47a7 GIT binary patch literal 38 wcmV+>0NMYm(E>u_n&cX;8j~8+8nc=dAj`bQqQ|Ltf>9t_ypMt6PMTue0ZX!a60t#PeTSqCKj!|x3|ubXJX+HP;h7f a3dnP$+_U0@a^Rx;95L_y|Fpiak{JMPP#Kv3 literal 0 HcmV?d00001 diff --git a/resources/test/test_scroll_down_1_hd.deflated b/resources/test/test_scroll_down_1_hd.deflated new file mode 100644 index 0000000000000000000000000000000000000000..66646df5f2b72aac8871e93232534b3cceee792d GIT binary patch literal 79 zcmaEReIYM{0f$TAd6DJ2|2N1oUX8hAGl65$^SV>UmUriV`Y)j1(7?dR#KHk(yl0*E UEA%*=3t=2!XY&4^zVkdQ0Na}!B>(^b literal 0 HcmV?d00001 diff --git a/resources/test/test_scroll_left_4.deflated b/resources/test/test_scroll_left_4.deflated new file mode 100644 index 0000000000000000000000000000000000000000..070cd3dbddf1c603dc784c8ae0657eb7479dfdf9 GIT binary patch literal 50 zcmV-20L}mHlQ9hd00_f=RP@HbK;~hb4L5{rEn5sQwQ274#`#*jk02JaKJ^%m! literal 0 HcmV?d00001 diff --git a/resources/test/test_scroll_right_4.deflated b/resources/test/test_scroll_right_4.deflated new file mode 100644 index 0000000000000000000000000000000000000000..e053d2eaca7f824457155a899391fae8f960f6fb GIT binary patch literal 108 zcmZ2_)=-eaf#b*lInk9L^*=mUZgiMy`%m}z{2R&#D(8!G*fOy=DtzG(U}?Od>>$A6 N)X(53K%Ss6KLFQBAM5}C literal 0 HcmV?d00001 diff --git a/resources/test/test_scroll_right_4_hd.deflated b/resources/test/test_scroll_right_4_hd.deflated new file mode 100644 index 0000000000000000000000000000000000000000..dad73b648f75d69bc1e7d23f2bde8d2fea72f5e2 GIT binary patch literal 276 zcmX?lej_h~qR8P3^E6{N|8H3SnMpH1BxC;*@qgtr{~EtjZn#;ut|3vLk%yJ3t(L_= zghS$+;DG>zgd6S*&W#jGtoU}=it*vHSHc0hEu~C{e6Ol6h~jw7(lUFMzr$96Yn&YB zq4OKE6xRp~}+atT6 H2j{^9R1y~R literal 0 HcmV?d00001 diff --git a/resources/test/test_video_scroll_up_test_hd.deflated b/resources/test/test_video_scroll_up_test_hd.deflated new file mode 100644 index 0000000000000000000000000000000000000000..685828b6cc67d34e42109728132172d0b8240ab1 GIT binary patch literal 79 zcmaEReIYM{0SAl2d6A57@*9*xCOp&TGf}L6w|sN-!~elI|6FF_5KwSvU|?i|Fb-5V VdjG!K$B81y(8$kHWqJCu6#&M791Z{g literal 0 HcmV?d00001 diff --git a/resources/test/test_video_scroll_up_test_sd.deflated b/resources/test/test_video_scroll_up_test_sd.deflated new file mode 100644 index 0000000000000000000000000000000000000000..9f1ee4162e58f336c8759f53de6b1d645c4fe275 GIT binary patch literal 50 zcmV-20L}mH)Ugc!00;uXo++r=e?Y