chore(ci): remove doc tests using macro

Author: believer

rust/2017/day_01/src/main.rs

@@ -3,7 +3,7 @@ use std::time::Instant;
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 
 fn main() -> Result<()> {
-    let input = parse_input(include_str!("../input"));
+    let input = parse_input("input");
 
     println!("Results for Day 1");
     println!("============================");

rust/2017/day_02/src/main.rs

@@ -17,7 +17,7 @@ where
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 
 fn main() {
-    let input = parse_input(include_str!("../input"));
+    let input = parse_input("input");
 
     println!("Results for Day 2");
     println!("============================");
@@ -64,12 +64,6 @@ mod tests {
         assert_eq!(day_02::part_01(&parse_input(data)), 18);
     }
 
-    #[test]
-    fn real_input_part_01() {
-        let input = parse_input(include_str!("../input"));
-        assert_eq!(day_02::part_01(&input), 34925)
-    }
-
     #[test]
     fn test_data_part_02() {
         let data = "

rust/2023/src/day_01.rs

@@ -46,12 +46,6 @@ fn sum_first_and_last_digit(line: &str) -> u32 {
 * Note that the last line only has one number, so it is repeated.
 *
 */
-// Your puzzle answer was
- ```
- use advent_of_code_2023::day_01::*;
- let data = include_str!("../input/2023/day1.txt");
- assert_eq!(solve_part_01(&input_generator(data)), 54304);
- ```
 #[aoc(day1, part1)]
 pub fn solve_part_01(input: &str) -> u32 {
     input.lines().map(sum_first_and_last_digit).sum()
@@ -88,12 +82,6 @@ const TRANSLATIONS: [(&str, &str); 9] = [
 * Some of the numbers overlap, like eightwothree should be 823 when cleaned.
 *
 */
-// Your puzzle answer was
- ```
- use advent_of_code_2023::day_01::*;
- let data = include_str!("../input/2023/day1.txt");
- assert_eq!(solve_part_02(&input_generator(data)), 54418);
- ```
 #[aoc(day1, part2)]
 pub fn solve_part_02(input: &str) -> u32 {
     input

rust/2023/src/day_04.rs

@@ -53,12 +53,6 @@ pub fn input_generator(input: &str) -> Input {
 * So winning numbers sums for each card is:
 * 8 + 2 + 2 + 1 + 0 + 0 = 13
 */
-// Your puzzle answer was
- ```
- use advent_of_code_2023::day_04::*;
- let data = include_str!("../input/2023/day4.txt");
- assert_eq!(solve_part_01(&input_generator(data)), 27454);
- ```
 #[aoc(day4, part1)]
 pub fn solve_part_01(input: &Input) -> u32 {
     input
@@ -85,12 +79,6 @@ pub fn solve_part_01(input: &Input) -> u32 {
 * Find out how many scratchcards we win.
 *
 */
-// Your puzzle answer was
- ```
- use advent_of_code_2023::day_04::*;
- let data = include_str!("../input/2023/day4.txt");
- assert_eq!(solve_part_02(&input_generator(data)), 6857330);
- ```
 #[aoc(day4, part2)]
 pub fn solve_part_02(input: &Input) -> u32 {
     // Create a list of starting cards, one of each

rust/2023/src/day_05.rs

@@ -141,7 +141,6 @@ pub fn input_generator(input: &str) -> Input {
 *
 * Given a list of seeds, and a list of maps, walk through the maps
 * to find the location of the seeds. Return the lowest location.
-*
 */
 #[aoc(day5, part1)]
 pub fn solve_part_01(input: &Input) -> u64 {
@@ -157,8 +156,6 @@ pub fn solve_part_01(input: &Input) -> u64 {
 * number is the length of the range.
 *
 * Otherwise, the calculation is the same as part one. Just A LOT more seeds.
-*
-* No doctest for this one, it takes too long.
 */
 #[aoc(day5, part2)]
 pub fn solve_part_02(input: &Input) -> u64 {

rust/2023/src/day_08.rs

@@ -69,14 +69,7 @@ pub fn input_generator(input: &str) -> Input {
 * We get a list of directions, and a list of instructions.
 * Steps through the directions, and select the correct instruction (left or right).
 * Keep track of the steps, and return the number of steps when we reach the ZZZ location.
-*
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_08::*;
-let data = include_str!("../input/2023/day8.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 22411);
-```"#]
 #[aoc(day8, part1)]
 pub fn solve_part_01(input: &Input) -> u64 {
     let Input {
@@ -108,13 +101,7 @@ pub fn solve_part_01(input: &Input) -> u64 {
 * with an A as a start location. We then need to calculate the
 * number of steps it takes for _all of them_ to reach a location
 * that ends with a Z.
-*
 */
-#[doc = r#"```
-use advent_of_code_2023::day_08::*;
-let data = include_str!("../input/2023/day8.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 11188774513823);
-```"#]
 #[aoc(day8, part2)]
 pub fn solve_part_02(input: &Input) -> i64 {
     let Input {

rust/2023/src/day_09.rs

@@ -70,12 +70,6 @@ pub fn input_generator(input: &str) -> Input {
 * Add all the last values together, and you get the answer = 114
 *
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_09::*;
-let data = include_str!("../input/2023/day9.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 1853145119);
-```"#]
 #[aoc(day9, part1)]
 pub fn solve_part_01(input: &Input) -> i64 {
     input
@@ -110,11 +104,6 @@ pub fn solve_part_01(input: &Input) -> i64 {
 * Add all the first values together, and you get the answer = 2
 *
 */
-#[doc = r#"```
-use advent_of_code_2023::day_09::*;
-let data = include_str!("../input/2023/day9.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 923);
-```"#]
 #[aoc(day9, part2)]
 pub fn solve_part_02(input: &Input) -> i64 {
     input

rust/2023/src/day_11.rs

@@ -77,26 +77,14 @@ fn galaxy_distance(input: &Input, expansion_rate: usize) -> usize {
 *
 *
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_11::*;
-let data = include_str!("../input/2023/day11.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 9795148);
-```"#]
 #[aoc(day11, part1)]
 pub fn solve_part_01(input: &Input) -> usize {
     galaxy_distance(input, 2)
 }
 
 /* Part Two
 *
-*
 */
-#[doc = r#"```
-use advent_of_code_2023::day_11::*;
-let data = include_str!("../input/2023/day11.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 650672493820);
-```"#]
 #[aoc(day11, part2)]
 pub fn solve_part_02(input: &Input) -> usize {
     galaxy_distance(input, 1_000_000)

rust/2023/src/day_12.rs

@@ -84,12 +84,6 @@ pub fn possible_arrangements(springs: &[u8], damaged: &[usize]) -> usize {
 *
 *
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_12::*;
-let data = include_str!("../input/2023/day12.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 8270);
-```"#]
 #[aoc(day12, part1)]
 pub fn solve_part_01(input: &Input) -> usize {
     input
@@ -103,11 +97,6 @@ pub fn solve_part_01(input: &Input) -> usize {
 *
 *
 */
-#[doc = r#"```
-use advent_of_code_2023::day_12::*;
-let data = include_str!("../input/2023/day12.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 204640299929836);
-```"#]
 #[aoc(day12, part2)]
 pub fn solve_part_02(input: &Input) -> usize {
     input

rust/2023/src/day_13.rs

@@ -83,28 +83,15 @@ fn summarize(input: &Input, smudges: i32) -> i32 {
 
 /* Part One
 *
-*
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_13::*;
-let data = include_str!("../input/2023/day13.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 27300);
-```"#]
 #[aoc(day13, part1)]
 pub fn solve_part_01(input: &Input) -> i32 {
     summarize(input, 0)
 }
 
 /* Part Two
 *
-*
 */
-#[doc = r#"```
-use advent_of_code_2023::day_13::*;
-let data = include_str!("../input/2023/day13.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 29276);
-```"#]
 #[aoc(day13, part2)]
 pub fn solve_part_02(input: &Input) -> i32 {
     summarize(input, 1)

rust/2023/src/day_14.rs

@@ -62,14 +62,7 @@ fn tilt_north(grid: &mut Grid<u8>) {
 
 /* Part One
 *
-*
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_14::*;
-let data = include_str!("../input/2023/day14.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 108614);
-```"#]
 #[aoc(day14, part1)]
 pub fn solve_part_01(input: &Input) -> i32 {
     let mut grid = input.grid.clone();
@@ -80,13 +73,7 @@ pub fn solve_part_01(input: &Input) -> i32 {
 
 /* Part Two
 *
-*
 */
-#[doc = r#"```
-use advent_of_code_2023::day_14::*;
-let data = include_str!("../input/2023/day14.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 96447);
-```"#]
 #[aoc(day14, part2)]
 pub fn solve_part_02(input: &Input) -> i32 {
     let mut grid = input.grid.clone();

rust/2023/src/day_15.rs

@@ -41,14 +41,7 @@ fn hash(steps: &str) -> usize {
 *
 * Get the ASCII value of each character in the sequence and add it to 0.
 * Then multiply the result by 17 and get the remainder of 256.
-*
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_15::*;
-let data = include_str!("../input/2023/day15.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 516070);
-```"#]
 #[aoc(day15, part1)]
 pub fn solve_part_01(input: &Input) -> usize {
     input.steps.iter().map(|step| hash(step)).sum()
@@ -61,13 +54,7 @@ pub fn solve_part_01(input: &Input) -> usize {
 *
 * Then get the "focusing power" by multiplying the box number + 1 with the
 * sequence number + 1 and the operation.
-*
 */
-#[doc = r#"```
-use advent_of_code_2023::day_15::*;
-let data = include_str!("../input/2023/day15.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 244981);
-```"#]
 #[aoc(day15, part2)]
 pub fn solve_part_02(input: &Input) -> usize {
     let mut boxes = vec![Vec::new(); 256];

rust/2023/src/day_16.rs

@@ -99,12 +99,6 @@ pub fn input_generator(input: &str) -> Input {
 * Find the number of energized tiles after firing the beam from the top left
 * of the grid.
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_16::*;
-let data = include_str!("../input/2023/day16.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 7562);
-```"#]
 #[aoc(day16, part1)]
 pub fn solve_part_01(input: &Input) -> usize {
     fire_ze_lasers(input, Beam::new(ORIGIN, RIGHT))
@@ -114,13 +108,7 @@ pub fn solve_part_01(input: &Input) -> usize {
 *
 * Find the maximum number of energized tiles after firing the beam
 * inwards from all edges of the grid.
-*
 */
-#[doc = r#"```
-use advent_of_code_2023::day_16::*;
-let data = include_str!("../input/2023/day16.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 7793);
-```"#]
 #[aoc(day16, part2)]
 pub fn solve_part_02(input: &Input) -> usize {
     let mut possible_starts = vec![];

rust/2023/src/day_17.rs

@@ -95,14 +95,7 @@ fn dijkstra(grid: &Grid<u8>, min_steps: u32, max_steps: u32) -> u32 {
 * Find the lowest cost path from the top left corner to the bottom
 * right corner. You can only move a maximum of 3 steps in a straight
 * line before needing to turn left or right.
-*
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_17::*;
-let data = include_str!("../input/2023/day17.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 1013);
-```"#]
 #[aoc(day17, part1)]
 pub fn solve_part_01(input: &Input) -> u32 {
     dijkstra(&input.grid, 1, 3)
@@ -115,13 +108,7 @@ pub fn solve_part_01(input: &Input) -> u32 {
 * line before needing to turn left or right. You must take at least
 * 4 steps before turning left or right, this includes at least
 * 4 steps before reaching the end.
-*
 */
-#[doc = r#"```
-use advent_of_code_2023::day_17::*;
-let data = include_str!("../input/2023/day17.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 1215);
-```"#]
 #[aoc(day17, part2)]
 pub fn solve_part_02(input: &Input) -> u32 {
     dijkstra(&input.grid, 4, 10)

rust/2023/src/day_19.rs

@@ -79,12 +79,6 @@ pub fn input_generator(input: &str) -> Input {
 /* Part One
 *
 */
-// Your puzzle answer was
-#[doc = r#"```
-use advent_of_code_2023::day_19::*;
-let data = include_str!("../input/2023/day19.txt");
-assert_eq!(solve_part_01(&input_generator(data)), 331208);
-```"#]
 #[aoc(day19, part1)]
 pub fn solve_part_01(input: &Input) -> u64 {
     let mut accepted = 0;
@@ -211,13 +205,7 @@ fn count_accepted(
 
 /* Part Two
 *
-*
 */
-#[doc = r#"```
-use advent_of_code_2023::day_19::*;
-let data = include_str!("../input/2023/day19.txt");
-assert_eq!(solve_part_02(&input_generator(data)), 121464316215623);
-```"#]
 #[aoc(day19, part2)]
 pub fn solve_part_02(input: &Input) -> u64 {
     let mut ranges: HashMap<char, (u64, u64)> = HashMap::new();