Add test cases for 2022 days 1 to 7

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]

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() {
+    let result = solve(&infile_path)?;
-        println!("{max}");
+
-    }
+    println!("{result}");
 
     Ok(())
 }
+
+fn solve(path: &str) -> io::Result<u32> {
+    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(())
+    }
+}

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::<Vec<_>>();
+
+    let result = solve(&infile_path)?;
+
+    println!("{result}");
+
+    Ok(())
+}
+
+fn solve(path: &str) -> io::Result<u32> {
+    let mut sums = aoc_2022_01::input_sums(path)?.collect::<Vec<_>>();
 
     sums.sort_by(|a, b| b.cmp(a));
 
     let three_highest_sum: &u32 = &sums[..3].iter().sum();
-    println!("{three_highest_sum}");
+
+    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(())
+    }
+}

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]

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<u64> {
+    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(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(())
+    }
+}

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<u64> {
+    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(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(())
+    }
+}

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"

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<u32> {
+    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(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(())
+    }
+}

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<u32> {
+    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(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(())
+    }
+}

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]

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

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 {
+fn main() -> io::Result<()> {
-    (l1 >= r1 && l2 <= r2) || (r1 >= l1 && r2 <= l2)
+    let infile_path = env::args().nth(1).expect("input file");
+
+    let result = solve(&infile_path)?;
+
+    println!("{result}");
+
+    Ok(())
 }
 
-fn main() -> io::Result<()> {
+fn solve(path: &str) -> io::Result<usize> {
-    let infile_path = env::args().nth(1).unwrap();
+    let inputs = parse_inputs(path)?;
-    let inputs = parse_inputs(infile_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 {
+    (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(())
+    }
+}

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<usize> {
+    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<()> {
+#[cfg(test)]
-    let infile_path = env::args().nth(1).unwrap();
+mod test {
-    let inputs = parse_inputs(infile_path)?;
+    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(())
     }
+
+    #[test]
+    fn puzzle() -> io::Result<()> {
+        let result = solve("inputs/puzzle.txt")?;
+
+        assert_eq!(936, result);
+
+        Ok(())
+    }
+}

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]

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<String> {
+    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<()> {
+#[cfg(test)]
-    let infile_path = env::args().nth(1).expect("input file");
+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 {
+        assert_eq!("CMZ", result);
-        move_stack(&mut stacks, instruction);
-    }
-
-    for (_, stack) in stacks {
-        let first = stack.front().unwrap();
-        print!("{first}");
-    }
-    println!();
 
         Ok(())
     }
+
+    #[test]
+    fn puzzle() -> io::Result<()> {
+        let result = solve("inputs/puzzle.txt")?;
+
+        assert_eq!("QNNTGTPFN", result);
+
+        Ok(())
+    }
+}

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<String> {
+    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<()> {
+#[cfg(test)]
-    let infile_path = env::args().nth(1).expect("input file");
+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 {
+        assert_eq!("MCD", result);
-        move_stack(&mut stacks, instruction);
-    }
-
-    for (_, stack) in stacks {
-        let first = stack.front().unwrap();
-        print!("{first}");
-    }
-    println!();
 
         Ok(())
     }
+
+    #[test]
+    fn puzzle() -> io::Result<()> {
+        let result = solve("inputs/puzzle.txt")?;
+
+        assert_eq!("GGNPJBTTR", result);
+
+        Ok(())
+    }
+}

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"

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<usize> {
+    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(())
+    }
+}

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<usize> {
+    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(())
+    }
+}

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]

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<usize> {
+    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(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(())
+    }
+}

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<usize> {
+    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(**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(())
+    }
+}