Day 1 Part 1

day_1/test/day_1_test.gleam

@@ -1,13 +1,178 @@
+import day_1.{Left, Right, rotate}
+import gleam/list
 import gleeunit
+import simplifile
 
 pub fn main() -> Nil {
   gleeunit.main()
 }
 
-// gleeunit test functions end in `_test`
-pub fn hello_world_test() {
-  let name = "Joe"
-  let greeting = "Hello, " <> name <> "!"
+pub fn normal_right_rotate_test() {
+  let initial = 5
+  let rotation = Right(5)
+  let final = rotate(initial, rotation)
 
-  assert greeting == "Hello, Joe!"
+  assert final == 10
+}
+
+pub fn overflow_right_rotate_test() {
+  let initial = 60
+  let rotation = Right(95)
+  let final = rotate(initial, rotation)
+
+  assert final == 55
+}
+
+pub fn normal_left_rotate_test() {
+  let initial = 40
+  let rotation = Left(10)
+  let final = rotate(initial, rotation)
+
+  assert final == 30
+}
+
+pub fn underflow_left_rotate_test() {
+  let initial = 40
+  let rotation = Left(50)
+  let final = rotate(initial, rotation)
+
+  assert final == 90
+}
+
+pub fn right_rotate_to_zero_test() {
+  assert rotate(52, Right(48)) == 0
+}
+
+pub fn left_rotate_to_zero_test() {
+  assert rotate(20, Left(20)) == 0
+}
+
+pub fn right_rotate_off_zero_test() {
+  assert rotate(0, Right(1)) == 1
+}
+
+pub fn left_rotate_off_zero_test() {
+  assert rotate(0, Left(1)) == 99
+}
+
+pub fn rotate_left_step_test() {
+  let initial = [50]
+  let rotation = Left(68)
+  let final = day_1.rotate_step(initial, rotation)
+
+  assert final == [82, 50]
+}
+
+pub fn rotate_1st_step_test() {
+  assert day_1.rotate_step([], Left(68)) == [82, 50]
+}
+
+pub fn rotate_2nd_step_test() {
+  assert day_1.rotate_step([82, 50], Left(30)) == [52, 82, 50]
+}
+
+pub fn count_list_of_zeros_test() {
+  assert { day_1.count_zeros([0, 0, 0]) == 3 }
+}
+
+pub fn count_empty_list_test() {
+  assert { day_1.count_zeros([]) == 0 }
+}
+
+pub fn count_dirty_list_test() {
+  assert { day_1.count_zeros([0, 1, 2, 0]) == 2 }
+}
+
+pub fn the_big_test() {
+  let rotations = [
+    Left(68),
+    Left(30),
+    Right(48),
+    Left(5),
+    Right(60),
+    Left(55),
+    Left(1),
+    Left(99),
+    Right(14),
+    Left(82),
+  ]
+
+  assert { list.fold(rotations, [], day_1.rotate_step) |> day_1.count_zeros }
+    == 3
+}
+
+pub fn good_right_parse_test() {
+  assert day_1.line_to_rotation("R16") == Ok(Right(16))
+}
+
+pub fn good_left_parse_test() {
+  assert day_1.line_to_rotation("L32") == Ok(Left(32))
+}
+
+pub fn no_leading_letter_test() {
+  assert day_1.line_to_rotation("13") == Error(Nil)
+}
+
+pub fn no_numeral_test() {
+  assert day_1.line_to_rotation("L") == Error(Nil)
+}
+
+pub fn empty_string_test() {
+  assert day_1.line_to_rotation("") == Error(Nil)
+}
+
+pub fn garbage_string_test() {
+  assert day_1.line_to_rotation("a983u4") == Error(Nil)
+}
+
+pub fn split_good_file_test() {
+  assert day_1.read_line("test/good_file.txt") == Ok(["hello", "world", ""])
+}
+
+pub fn split_bad_file_test() {
+  assert day_1.read_line("test/bad_file.txt") == Error(simplifile.Enoent)
+}
+
+pub fn parse_rotats_test() {
+  assert day_1.file_to_rotations("test/parse_rotats.txt")
+    == Ok([
+      Left(68),
+      Left(30),
+      Right(48),
+      Left(5),
+      Right(60),
+      Left(55),
+      Left(1),
+      Left(99),
+      Right(14),
+      Left(82),
+    ])
+}
+
+pub fn apply_empty_rots_test() {
+  assert day_1.apply_rotations([]) == []
+}
+
+pub fn apply_first_rot_test() {
+  assert day_1.apply_rotations([Left(68)]) == [82, 50]
+}
+
+pub fn apply_10_rots_test() {
+  assert day_1.apply_rotations([
+      Left(68),
+      Left(30),
+      Right(48),
+      Left(5),
+      Right(60),
+      Left(55),
+      Left(1),
+      Left(99),
+      Right(14),
+      Left(82),
+    ])
+    == [32, 14, 0, 99, 0, 55, 95, 0, 52, 82, 50]
+}
+
+pub fn proving_test() {
+  assert day_1.rotations_file_to_zeros("test/parse_rotats.txt") == Ok(3)
 }

day_1/test/good_file.txt

@@ -0,0 +1,2 @@
+hello
+world

day_1/test/parse_rotats.txt

@@ -0,0 +1,10 @@
+L68
+L30
+R48
+L5
+R60
+L55
+L1
+L99
+R14
+L82