From 659db82f542f313ba972cf415142710c551be3d7 Mon Sep 17 00:00:00 2001 From: Patrick Auernig Date: Thu, 15 Dec 2022 15:40:31 +0100 Subject: [PATCH] Add test cases for 2022 days 1 to 7 --- 2022/day-01/Cargo.toml | 6 ++++ 2022/day-01/src/bin/part_one.rs | 36 ++++++++++++++++++++--- 2022/day-01/src/bin/part_two.rs | 37 +++++++++++++++++++++-- 2022/day-02/Cargo.toml | 6 ++++ 2022/day-02/src/bin/part_one.rs | 37 ++++++++++++++++++++--- 2022/day-02/src/bin/part_two.rs | 39 +++++++++++++++++++++---- 2022/day-03/Cargo.toml | 6 ++++ 2022/day-03/src/bin/part_one.rs | 36 ++++++++++++++++++++--- 2022/day-03/src/bin/part_two.rs | 39 +++++++++++++++++++++---- 2022/day-04/Cargo.toml | 6 ++++ 2022/day-04/Justfile | 5 ++++ 2022/day-04/src/bin/part_one.rs | 44 ++++++++++++++++++++++++---- 2022/day-04/src/bin/part_two.rs | 44 ++++++++++++++++++++++++---- 2022/day-05/Cargo.toml | 6 ++++ 2022/day-05/src/bin/part_one.rs | 52 ++++++++++++++++++++++++++------- 2022/day-05/src/bin/part_two.rs | 52 ++++++++++++++++++++++++++------- 2022/day-06/Cargo.toml | 6 ++++ 2022/day-06/src/bin/part_one.rs | 36 +++++++++++++++++++++-- 2022/day-06/src/bin/part_two.rs | 36 +++++++++++++++++++++-- 2022/day-07/Cargo.toml | 6 ++++ 2022/day-07/src/bin/part_one.rs | 40 +++++++++++++++++++++---- 2022/day-07/src/bin/part_two.rs | 38 +++++++++++++++++++++--- 22 files changed, 540 insertions(+), 73 deletions(-) create mode 100644 2022/day-04/Justfile diff --git a/2022/day-01/Cargo.toml b/2022/day-01/Cargo.toml index d8d729c..1d4ad34 100644 --- a/2022/day-01/Cargo.toml +++ b/2022/day-01/Cargo.toml @@ -3,4 +3,10 @@ name = "aoc-2022-01" version = "0.1.0" edition = "2021" + +[lib] +test = false +doctest = false + + [dependencies] diff --git a/2022/day-01/src/bin/part_one.rs b/2022/day-01/src/bin/part_one.rs index 4133b66..c394a5f 100644 --- a/2022/day-01/src/bin/part_one.rs +++ b/2022/day-01/src/bin/part_one.rs @@ -2,11 +2,39 @@ use std::{env, io}; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); - let sums = aoc_2022_01::input_sums(infile_path)?; - if let Some(max) = sums.max() { - println!("{max}"); - } + let result = solve(&infile_path)?; + + println!("{result}"); Ok(()) } + +fn solve(path: &str) -> io::Result { + let max = aoc_2022_01::input_sums(path)?.max().unwrap(); + + Ok(max) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(24000, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(67658, result); + + Ok(()) + } +} diff --git a/2022/day-01/src/bin/part_two.rs b/2022/day-01/src/bin/part_two.rs index 066c52e..08c7235 100644 --- a/2022/day-01/src/bin/part_two.rs +++ b/2022/day-01/src/bin/part_two.rs @@ -2,12 +2,43 @@ use std::{env, io}; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); - let mut sums = aoc_2022_01::input_sums(infile_path)?.collect::>(); + + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let mut sums = aoc_2022_01::input_sums(path)?.collect::>(); sums.sort_by(|a, b| b.cmp(a)); let three_highest_sum: &u32 = &sums[..3].iter().sum(); - println!("{three_highest_sum}"); - Ok(()) + Ok(*three_highest_sum) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(45000, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(200158, result); + + Ok(()) + } } diff --git a/2022/day-02/Cargo.toml b/2022/day-02/Cargo.toml index 6ec49cb..86dd2d3 100644 --- a/2022/day-02/Cargo.toml +++ b/2022/day-02/Cargo.toml @@ -3,4 +3,10 @@ name = "aoc-2022-02" version = "0.1.0" edition = "2021" + +[lib] +test = false +doctest = false + + [dependencies] diff --git a/2022/day-02/src/bin/part_one.rs b/2022/day-02/src/bin/part_one.rs index 2ce55c8..05c61e9 100644 --- a/2022/day-02/src/bin/part_one.rs +++ b/2022/day-02/src/bin/part_one.rs @@ -5,7 +5,15 @@ use aoc_2022_02::{calculate_round_score, parse_lines, Player}; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); - let rounds = parse_lines(infile_path)?.map(|(a, b)| (Player::parse(&a), Player::parse(&b))); + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let rounds = parse_lines(path)?.map(|(a, b)| (Player::parse(&a), Player::parse(&b))); let mut total_score = 0u64; @@ -13,7 +21,28 @@ fn main() -> io::Result<()> { total_score += calculate_round_score(&myself, &enemy); } - println!("{total_score}"); - - Ok(()) + Ok(total_score) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(15, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(14163, result); + + Ok(()) + } } diff --git a/2022/day-02/src/bin/part_two.rs b/2022/day-02/src/bin/part_two.rs index 917c395..303cac5 100644 --- a/2022/day-02/src/bin/part_two.rs +++ b/2022/day-02/src/bin/part_two.rs @@ -4,8 +4,16 @@ use aoc_2022_02::{calculate_round_score, parse_lines, Player, RoundResult}; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); - let rounds = - parse_lines(infile_path)?.map(|(a, b)| (Player::parse(&a), RoundResult::parse(&b))); + + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let rounds = parse_lines(path)?.map(|(a, b)| (Player::parse(&a), RoundResult::parse(&b))); let mut total_score = 0u64; @@ -14,7 +22,28 @@ fn main() -> io::Result<()> { total_score += calculate_round_score(&myself, &enemy); } - println!("{total_score}"); - - Ok(()) + Ok(total_score) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(12, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(12091, result); + + Ok(()) + } } diff --git a/2022/day-03/Cargo.toml b/2022/day-03/Cargo.toml index f19cc53..a7b599a 100644 --- a/2022/day-03/Cargo.toml +++ b/2022/day-03/Cargo.toml @@ -3,5 +3,11 @@ name = "aoc-2022-03" version = "0.1.0" edition = "2021" + +[lib] +test = false +doctest = false + + [dependencies] itertools = "0.10" diff --git a/2022/day-03/src/bin/part_one.rs b/2022/day-03/src/bin/part_one.rs index bd2f720..f899f0a 100644 --- a/2022/day-03/src/bin/part_one.rs +++ b/2022/day-03/src/bin/part_one.rs @@ -4,8 +4,15 @@ use aoc_2022_03::{item_priority, parse_file}; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); + let result = solve(&infile_path)?; - let sum_of_items: u32 = parse_file(infile_path)? + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let sum_of_items: u32 = parse_file(path)? .map(|line| { let (left, right) = line.split_at(line.len() / 2); let left: HashSet<_> = left.chars().collect(); @@ -15,7 +22,28 @@ fn main() -> io::Result<()> { }) .sum(); - println!("{sum_of_items}"); - - Ok(()) + Ok(sum_of_items) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(157, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(8349, result); + + Ok(()) + } } diff --git a/2022/day-03/src/bin/part_two.rs b/2022/day-03/src/bin/part_two.rs index 9c605cc..63db553 100644 --- a/2022/day-03/src/bin/part_two.rs +++ b/2022/day-03/src/bin/part_two.rs @@ -1,13 +1,19 @@ use std::{collections::HashSet, env, io}; -use itertools::Itertools; // for easier chunking - use aoc_2022_03::{item_priority, parse_file}; +use itertools::Itertools; // for easier chunking fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); + let result = solve(&infile_path)?; - let items = parse_file(infile_path)?.chunks(3); + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let items = parse_file(path)?.chunks(3); let item_sum: u32 = items .into_iter() .map(|chunk| { @@ -21,7 +27,28 @@ fn main() -> io::Result<()> { }) .sum(); - println!("{item_sum}"); - - Ok(()) + Ok(item_sum) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(70, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(2681, result); + + Ok(()) + } } diff --git a/2022/day-04/Cargo.toml b/2022/day-04/Cargo.toml index aac300e..60f5fce 100644 --- a/2022/day-04/Cargo.toml +++ b/2022/day-04/Cargo.toml @@ -3,4 +3,10 @@ name = "aoc-2022-04" version = "0.1.0" edition = "2021" + +[lib] +test = false +doctest = false + + [dependencies] diff --git a/2022/day-04/Justfile b/2022/day-04/Justfile new file mode 100644 index 0000000..7d08527 --- /dev/null +++ b/2022/day-04/Justfile @@ -0,0 +1,5 @@ +@part PART INPUT_FILE="inputs/puzzle.txt": + cargo --quiet run --bin part_{{PART}} -- {{INPUT_FILE}} + +clean: + cargo clean diff --git a/2022/day-04/src/bin/part_one.rs b/2022/day-04/src/bin/part_one.rs index b3f1084..9265a49 100644 --- a/2022/day-04/src/bin/part_one.rs +++ b/2022/day-04/src/bin/part_one.rs @@ -2,17 +2,49 @@ use std::{env, io}; use aoc_2022_04::{parse_inputs, Section}; -fn sections_overlap((Section(l1, l2), Section(r1, r2)): &(Section, Section)) -> bool { - (l1 >= r1 && l2 <= r2) || (r1 >= l1 && r2 <= l2) +fn main() -> io::Result<()> { + let infile_path = env::args().nth(1).expect("input file"); + + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) } -fn main() -> io::Result<()> { - let infile_path = env::args().nth(1).unwrap(); - let inputs = parse_inputs(infile_path)?; +fn solve(path: &str) -> io::Result { + let inputs = parse_inputs(path)?; let count = inputs.into_iter().filter(sections_overlap).count(); println!("{count}"); - Ok(()) + Ok(count) +} + +fn sections_overlap((Section(l1, l2), Section(r1, r2)): &(Section, Section)) -> bool { + (l1 >= r1 && l2 <= r2) || (r1 >= l1 && r2 <= l2) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(2, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(569, result); + + Ok(()) + } } diff --git a/2022/day-04/src/bin/part_two.rs b/2022/day-04/src/bin/part_two.rs index 82cd879..13969c9 100644 --- a/2022/day-04/src/bin/part_two.rs +++ b/2022/day-04/src/bin/part_two.rs @@ -2,6 +2,26 @@ use std::{env, io}; use aoc_2022_04::{parse_inputs, Section}; +fn main() -> io::Result<()> { + let infile_path = env::args().nth(1).expect("input file"); + + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let inputs = parse_inputs(path)?; + + let count = inputs.into_iter().filter(sections_overlap).count(); + + println!("{count}"); + + Ok(count) +} + fn sections_overlap((Section(l1, l2), Section(r1, r2)): &(Section, Section)) -> bool { (r1 >= l1 && r1 <= l2) || (r2 <= l2 && r2 >= l1) @@ -9,13 +29,25 @@ fn sections_overlap((Section(l1, l2), Section(r1, r2)): &(Section, Section)) -> || (l2 <= r2 && l2 >= r1) } -fn main() -> io::Result<()> { - let infile_path = env::args().nth(1).unwrap(); - let inputs = parse_inputs(infile_path)?; +#[cfg(test)] +mod test { + use super::*; - let count = inputs.into_iter().filter(sections_overlap).count(); + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; - println!("{count}"); + assert_eq!(4, result); - Ok(()) + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(936, result); + + Ok(()) + } } diff --git a/2022/day-05/Cargo.toml b/2022/day-05/Cargo.toml index 88d6d96..045847a 100644 --- a/2022/day-05/Cargo.toml +++ b/2022/day-05/Cargo.toml @@ -3,4 +3,10 @@ name = "aoc-2022-05" version = "0.1.0" edition = "2021" + +[lib] +test = false +doctest = false + + [dependencies] diff --git a/2022/day-05/src/bin/part_one.rs b/2022/day-05/src/bin/part_one.rs index 1916f5e..990a881 100644 --- a/2022/day-05/src/bin/part_one.rs +++ b/2022/day-05/src/bin/part_one.rs @@ -2,6 +2,31 @@ use std::{env, io}; use aoc_2022_05::{parse_file, Instruction, Stack, Stacks}; +fn main() -> io::Result<()> { + let infile_path = env::args().nth(1).expect("input file"); + + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let (mut stacks, instructions) = parse_file(path)?; + + for instruction in instructions { + move_stack(&mut stacks, instruction); + } + + let top_of_stacks = stacks + .values() + .map(|stack| stack.front().unwrap()) + .collect(); + + Ok(top_of_stacks) +} + pub fn move_stack(stacks: &mut Stacks, (amount, from_idx, to_idx): Instruction) { let source = stacks.get_mut(&from_idx).unwrap(); let mut swap = Stack::new(); @@ -16,20 +41,25 @@ pub fn move_stack(stacks: &mut Stacks, (amount, from_idx, to_idx): Instruction) } } -fn main() -> io::Result<()> { - let infile_path = env::args().nth(1).expect("input file"); +#[cfg(test)] +mod test { + use super::*; - let (mut stacks, instructions) = parse_file(infile_path)?; + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; - for instruction in instructions { - move_stack(&mut stacks, instruction); + assert_eq!("CMZ", result); + + Ok(()) } - for (_, stack) in stacks { - let first = stack.front().unwrap(); - print!("{first}"); - } - println!(); + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; - Ok(()) + assert_eq!("QNNTGTPFN", result); + + Ok(()) + } } diff --git a/2022/day-05/src/bin/part_two.rs b/2022/day-05/src/bin/part_two.rs index e8c939c..e63ea2c 100644 --- a/2022/day-05/src/bin/part_two.rs +++ b/2022/day-05/src/bin/part_two.rs @@ -2,6 +2,31 @@ use std::{env, io}; use aoc_2022_05::{parse_file, Instruction, Stack, Stacks}; +fn main() -> io::Result<()> { + let infile_path = env::args().nth(1).expect("input file"); + + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let (mut stacks, instructions) = parse_file(path)?; + + for instruction in instructions { + move_stack(&mut stacks, instruction); + } + + let top_of_stacks = stacks + .values() + .map(|stack| stack.front().unwrap()) + .collect(); + + Ok(top_of_stacks) +} + pub fn move_stack(stacks: &mut Stacks, (amount, from_idx, to_idx): Instruction) { let source = stacks.get_mut(&from_idx).unwrap(); let mut swap = Stack::new(); @@ -16,20 +41,25 @@ pub fn move_stack(stacks: &mut Stacks, (amount, from_idx, to_idx): Instruction) } } -fn main() -> io::Result<()> { - let infile_path = env::args().nth(1).expect("input file"); +#[cfg(test)] +mod test { + use super::*; - let (mut stacks, instructions) = parse_file(infile_path)?; + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; - for instruction in instructions { - move_stack(&mut stacks, instruction); + assert_eq!("MCD", result); + + Ok(()) } - for (_, stack) in stacks { - let first = stack.front().unwrap(); - print!("{first}"); - } - println!(); + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; - Ok(()) + assert_eq!("GGNPJBTTR", result); + + Ok(()) + } } diff --git a/2022/day-06/Cargo.toml b/2022/day-06/Cargo.toml index 2404f92..b70fe6e 100644 --- a/2022/day-06/Cargo.toml +++ b/2022/day-06/Cargo.toml @@ -3,5 +3,11 @@ name = "aoc-2022-06" version = "0.1.0" edition = "2021" + +[lib] +test = false +doctest = false + + [dependencies] itertools = "0.10" diff --git a/2022/day-06/src/bin/part_one.rs b/2022/day-06/src/bin/part_one.rs index 2cf8ae5..90f8f3b 100644 --- a/2022/day-06/src/bin/part_one.rs +++ b/2022/day-06/src/bin/part_one.rs @@ -4,9 +4,41 @@ use aoc_2022_06::{find_marker, parse_input}; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); - let inputs = parse_input(infile_path)?; - println!("{}", find_marker(&inputs, 4)); + let result = solve(&infile_path)?; + + println!("{result}"); Ok(()) } + +fn solve(path: &str) -> io::Result { + let inputs = parse_input(path)?; + + let marker = find_marker(&inputs, 4); + + Ok(marker) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(7, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(1909, result); + + Ok(()) + } +} diff --git a/2022/day-06/src/bin/part_two.rs b/2022/day-06/src/bin/part_two.rs index b924599..132408c 100644 --- a/2022/day-06/src/bin/part_two.rs +++ b/2022/day-06/src/bin/part_two.rs @@ -4,9 +4,41 @@ use aoc_2022_06::{find_marker, parse_input}; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); - let inputs = parse_input(infile_path)?; - println!("{}", find_marker(&inputs, 14)); + let result = solve(&infile_path)?; + + println!("{result}"); Ok(()) } + +fn solve(path: &str) -> io::Result { + let inputs = parse_input(path)?; + + let marker = find_marker(&inputs, 14); + + Ok(marker) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(19, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(3380, result); + + Ok(()) + } +} diff --git a/2022/day-07/Cargo.toml b/2022/day-07/Cargo.toml index 5b8ee4f..0284612 100644 --- a/2022/day-07/Cargo.toml +++ b/2022/day-07/Cargo.toml @@ -3,4 +3,10 @@ name = "aoc-2022-07" version = "0.1.0" edition = "2021" + +[lib] +test = false +doctest = false + + [dependencies] diff --git a/2022/day-07/src/bin/part_one.rs b/2022/day-07/src/bin/part_one.rs index b03dbd3..7256b2d 100644 --- a/2022/day-07/src/bin/part_one.rs +++ b/2022/day-07/src/bin/part_one.rs @@ -4,14 +4,44 @@ use aoc_2022_07::{parse_input, path_sizes, DirMap}; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); - let paths = parse_input(infile_path)?; + + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let paths = parse_input(path)?; let mut sizes = DirMap::new(); path_sizes(&paths, &mut sizes); - let sum: usize = sizes.values().filter(|&&val| val <= 100_000).sum(); + let sum = sizes.values().filter(|&&val| val <= 100_000).sum(); - println!("{sum:#?}"); - - Ok(()) + Ok(sum) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(95437, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(1428881, result); + + Ok(()) + } } diff --git a/2022/day-07/src/bin/part_two.rs b/2022/day-07/src/bin/part_two.rs index 6e732ca..0360837 100644 --- a/2022/day-07/src/bin/part_two.rs +++ b/2022/day-07/src/bin/part_two.rs @@ -7,7 +7,16 @@ const REQUIRED_SIZE: usize = 30_000_000; fn main() -> io::Result<()> { let infile_path = env::args().nth(1).expect("input file"); - let paths = parse_input(infile_path)?; + + let result = solve(&infile_path)?; + + println!("{result}"); + + Ok(()) +} + +fn solve(path: &str) -> io::Result { + let paths = parse_input(path)?; let mut sizes = DirMap::new(); path_sizes(&paths, &mut sizes); @@ -23,7 +32,28 @@ fn main() -> io::Result<()> { let smol = values.iter().min().unwrap(); - println!("{smol}"); - - Ok(()) + Ok(**smol) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn sample() -> io::Result<()> { + let result = solve("inputs/test.txt")?; + + assert_eq!(24933642, result); + + Ok(()) + } + + #[test] + fn puzzle() -> io::Result<()> { + let result = solve("inputs/puzzle.txt")?; + + assert_eq!(10475598, result); + + Ok(()) + } }