Add 132 tests across all 6 exercises targeting audit gaps

Covers parser boundaries, overflow isolation, negative ranges, malformed
delimiters, round-trip symmetry, movement order, CLI entry points, rate
limiting, validation utilities, and FK constraints. Total: 968 tests.

  CashRegister (Rust):        79 → 94   (+15)
  MissingNumber (Zig):        53 → 70   (+17)
  MorseCode (Perl):          200 → 232  (+32)
  OnScreenKeyboard (Python):  74 → 94   (+20)
  GildedRose (Go):            82 → 107  (+25)
  RestaurantReviews (TS):    348 → 371  (+23)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: georgeglarson

CashRegister/src/parse.rs

@@ -239,4 +239,79 @@ mod tests {
             other => panic!("expected MalformedLine, got {:?}", other),
         }
     }
+
+    #[test]
+    fn parse_rejects_negative_amount() {
+        let err = parse_dollars_to_cents("-2.13").unwrap_err();
+        assert!(
+            err.contains("invalid") || err.contains("not a valid"),
+            "expected rejection of negative amount, got: {err}"
+        );
+    }
+
+    #[test]
+    fn parse_rejects_negative_penny() {
+        let err = parse_dollars_to_cents("-0.01").unwrap_err();
+        assert!(
+            err.contains("invalid") || err.contains("not a valid"),
+            "expected rejection of negative amount, got: {err}"
+        );
+    }
+
+    #[test]
+    fn parse_zero_dollars_and_cents() {
+        assert_eq!(parse_dollars_to_cents("0.00"), Ok(0));
+    }
+
+    #[test]
+    fn parse_near_overflow_boundary_ok() {
+        // 42949672 * 100 + 95 = 4294967295 = u32::MAX
+        assert_eq!(
+            parse_dollars_to_cents("42949672.95"),
+            Ok(u32::MAX),
+            "42949672.95 should parse to u32::MAX (4294967295 cents)"
+        );
+    }
+
+    #[test]
+    fn parse_line_multiple_commas_errors() {
+        let result = parse_line("2.13,,3.00", 1);
+        assert!(
+            result.is_err(),
+            "multiple commas should produce an error, got: {:?}",
+            result
+        );
+    }
+
+    #[test]
+    fn parse_line_zero_payment() {
+        let tx = parse_line("0.00,0.00", 1).unwrap();
+        assert_eq!(tx.owed_cents, 0);
+        assert_eq!(tx.paid_cents, 0);
+        assert_eq!(tx.change_cents, 0);
+    }
+
+    #[test]
+    fn parse_input_all_blank_lines() {
+        let results = parse_input("\n\n\n");
+        assert!(
+            results.is_empty(),
+            "all-blank input should produce empty vec, got {} results",
+            results.len()
+        );
+    }
+
+    #[test]
+    fn parse_input_line_numbering_after_multiple_blanks() {
+        // Lines: 1="", 2="", 3="bad_line", 4=""
+        let input = "\n\nbad_line\n";
+        let results = parse_input(input);
+        assert_eq!(results.len(), 1);
+        match &results[0] {
+            Err(CashRegisterError::MalformedLine { line, .. }) => {
+                assert_eq!(*line, 3, "expected line 3, got {line}");
+            }
+            other => panic!("expected MalformedLine for line 3, got {:?}", other),
+        }
+    }
 }

CashRegister/tests/integration.rs

@@ -392,6 +392,170 @@ fn verbose_eur() {
     assert!(lines[1].starts_with("Owed €3.33, Paid €5.00 -> "));
 }
 
+// ─── Negative amount tests ──────────────────────────────────────────
+
+#[test]
+fn negative_amount_errors() {
+    let dir = env!("CARGO_MANIFEST_DIR");
+    let path = format!("{dir}/test_negative.txt");
+    std::fs::write(&path, "-2.13,3.00\n").unwrap();
+
+    let output = cargo_bin()
+        .arg(&path)
+        .output()
+        .expect("failed to run binary");
+
+    std::fs::remove_file(&path).ok();
+
+    assert!(!output.status.success());
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("line 1"),
+        "expected line number in error, got: {stderr}"
+    );
+    // stdout should be empty — no valid lines
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.is_empty(), "expected no stdout, got: {stdout}");
+}
+
+#[test]
+fn exit_code_is_2_on_line_error() {
+    let dir = env!("CARGO_MANIFEST_DIR");
+    let path = format!("{dir}/test_exit2.txt");
+    std::fs::write(&path, "bad_line\n").unwrap();
+
+    let output = cargo_bin()
+        .arg(&path)
+        .output()
+        .expect("failed to run binary");
+
+    std::fs::remove_file(&path).ok();
+
+    assert_eq!(
+        output.status.code(),
+        Some(2),
+        "expected exit code 2, got: {:?}",
+        output.status.code()
+    );
+}
+
+#[test]
+fn exit_code_is_0_on_success() {
+    let output = cargo_bin()
+        .args(["sample_input.txt", "--seed", "42"])
+        .output()
+        .expect("failed to run binary");
+
+    assert_eq!(
+        output.status.code(),
+        Some(0),
+        "expected exit code 0, got: {:?}",
+        output.status.code()
+    );
+}
+
+#[test]
+fn empty_input_produces_no_output_and_exits_0() {
+    let dir = env!("CARGO_MANIFEST_DIR");
+    let path = format!("{dir}/test_empty.txt");
+    std::fs::write(&path, "\n\n").unwrap();
+
+    let output = cargo_bin()
+        .arg(&path)
+        .output()
+        .expect("failed to run binary");
+
+    std::fs::remove_file(&path).ok();
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(stdout.is_empty(), "expected no stdout, got: {stdout}");
+    assert!(stderr.is_empty(), "expected no stderr, got: {stderr}");
+    assert_eq!(
+        output.status.code(),
+        Some(0),
+        "expected exit code 0, got: {:?}",
+        output.status.code()
+    );
+}
+
+#[test]
+fn invalid_seed_flag_is_silently_ignored() {
+    // --seed abc cannot be parsed as u64, so parse_flag returns None
+    // and the program runs with a random (non-seeded) RNG — no error.
+    let output = cargo_bin()
+        .args(["sample_input.txt", "--seed", "abc"])
+        .output()
+        .expect("failed to run binary");
+
+    assert!(
+        output.status.success(),
+        "bad --seed should not crash; stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert_eq!(
+        stdout.lines().count(),
+        3,
+        "should still produce 3 output lines"
+    );
+}
+
+#[test]
+fn missing_divisor_value_uses_default() {
+    // --divisor is the last arg with no value following it.
+    // parse_flag returns None, so divisor defaults to 3.
+    let output = cargo_bin()
+        .args(["sample_input.txt", "--divisor"])
+        .output()
+        .expect("failed to run binary");
+
+    assert!(
+        output.status.success(),
+        "missing --divisor value should fall back to default; stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert_eq!(
+        stdout.lines().count(),
+        3,
+        "should still produce 3 output lines"
+    );
+}
+
+#[test]
+fn all_lines_invalid_gives_empty_stdout_and_stderr_errors() {
+    let dir = env!("CARGO_MANIFEST_DIR");
+    let path = format!("{dir}/test_all_bad.txt");
+    std::fs::write(&path, "bad\nalso_bad\nstill_bad\n").unwrap();
+
+    let output = cargo_bin()
+        .arg(&path)
+        .output()
+        .expect("failed to run binary");
+
+    std::fs::remove_file(&path).ok();
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(stdout.is_empty(), "expected no stdout, got: {stdout}");
+    assert!(
+        stderr.contains("line 1"),
+        "expected line 1 error, got: {stderr}"
+    );
+    assert!(
+        stderr.contains("line 2"),
+        "expected line 2 error, got: {stderr}"
+    );
+    assert!(
+        stderr.contains("line 3"),
+        "expected line 3 error, got: {stderr}"
+    );
+    assert!(!output.status.success());
+    assert_eq!(output.status.code(), Some(2));
+}
+
 // ─── Helpers ────────────────────────────────────────────────────────
 
 /// Parse a USD output line like "1 dollar,2 quarters,1 nickel,2 pennies" into total cents.

GildedRose/inventory/inventory_test.go

@@ -283,6 +283,127 @@ func TestMultiDay_100DaysNoNegativeQuality(t *testing.T) {
 	}
 }
 
+func TestMultiDay_backstageAt50SellIn6_cappedThenDrops(t *testing.T) {
+	items := []item.Item{
+		{Name: "VIP Pass", Category: "Backstage Passes", SellIn: 6, Quality: 50},
+	}
+	inv := New(items)
+
+	// Day 1: SellIn=5, +2 → capped at 50
+	inv.NextDay()
+	if inv.FindByName("VIP Pass").Quality != 50 {
+		t.Errorf("day 1: expected 50, got %d", inv.FindByName("VIP Pass").Quality)
+	}
+
+	// Day 2: SellIn=4, +3 → capped at 50
+	inv.NextDay()
+	if inv.FindByName("VIP Pass").Quality != 50 {
+		t.Errorf("day 2: expected 50, got %d", inv.FindByName("VIP Pass").Quality)
+	}
+
+	// Days 3–6: keep advancing through SellIn 3,2,1,0
+	for i := 3; i <= 6; i++ {
+		inv.NextDay()
+		if inv.FindByName("VIP Pass").Quality != 50 {
+			t.Errorf("day %d: expected 50, got %d", i, inv.FindByName("VIP Pass").Quality)
+		}
+	}
+
+	// Day 7: SellIn=-1, concert over → quality drops to 0
+	inv.NextDay()
+	if inv.FindByName("VIP Pass").Quality != 0 {
+		t.Errorf("day 7 (post-concert): expected 0, got %d", inv.FindByName("VIP Pass").Quality)
+	}
+}
+
+func TestMultiDay_itemStartingPastSellBy(t *testing.T) {
+	items := []item.Item{
+		{Name: "Old Sword", Category: "Weapon", SellIn: -5, Quality: 10},
+	}
+	inv := New(items)
+
+	// Already past sell-by: degrades by 2 per day
+	inv.NextDay() // SellIn=-6, Quality=8
+	if inv.FindByName("Old Sword").Quality != 8 {
+		t.Errorf("day 1: expected 8, got %d", inv.FindByName("Old Sword").Quality)
+	}
+
+	inv.NextDay() // SellIn=-7, Quality=6
+	if inv.FindByName("Old Sword").Quality != 6 {
+		t.Errorf("day 2: expected 6, got %d", inv.FindByName("Old Sword").Quality)
+	}
+
+	inv.NextDay() // SellIn=-8, Quality=4
+	inv.NextDay() // SellIn=-9, Quality=2
+	inv.NextDay() // SellIn=-10, Quality=0
+
+	if inv.FindByName("Old Sword").Quality != 0 {
+		t.Errorf("day 5: expected 0, got %d", inv.FindByName("Old Sword").Quality)
+	}
+	if inv.FindByName("Old Sword").SellIn != -10 {
+		t.Errorf("day 5: expected sellIn -10, got %d", inv.FindByName("Old Sword").SellIn)
+	}
+}
+
+// ============================================================
+// Empty inventory
+// ============================================================
+
+func TestNew_emptyInventory_itemsReturnsEmptySlice(t *testing.T) {
+	inv := New([]item.Item{})
+	items := inv.Items()
+	if len(items) != 0 {
+		t.Errorf("expected 0 items, got %d", len(items))
+	}
+}
+
+func TestNew_emptyInventory_trashReturnsEmpty(t *testing.T) {
+	inv := New([]item.Item{})
+	trash := inv.Trash()
+	if trash != nil && len(trash) != 0 {
+		t.Errorf("expected nil or empty trash, got %d items", len(trash))
+	}
+}
+
+// ============================================================
+// FindByName edge cases
+// ============================================================
+
+func TestFindByName_emptyString_returnsNil(t *testing.T) {
+	inv := New(sampleItems())
+	itm := inv.FindByName("")
+	if itm != nil {
+		t.Error("expected nil for empty string search")
+	}
+}
+
+// ============================================================
+// Multiple trash items
+// ============================================================
+
+func TestTrash_multipleTrashItems(t *testing.T) {
+	items := []item.Item{
+		{Name: "Good Sword", Category: "Weapon", SellIn: 10, Quality: 10},
+		{Name: "Broken Shield", Category: "Armor", SellIn: 0, Quality: 0},
+		{Name: "Rotten Cheese", Category: "Food", SellIn: -5, Quality: 0},
+		{Name: "Cursed Ring", Category: "Misc", SellIn: -3, Quality: -2},
+	}
+	inv := New(items)
+	trash := inv.Trash()
+	if len(trash) != 3 {
+		t.Fatalf("expected 3 trash items, got %d", len(trash))
+	}
+	names := map[string]bool{}
+	for _, itm := range trash {
+		names[itm.Name] = true
+	}
+	for _, expected := range []string{"Broken Shield", "Rotten Cheese", "Cursed Ring"} {
+		if !names[expected] {
+			t.Errorf("expected %q in trash", expected)
+		}
+	}
+}
+
 func TestMultiDay_100DaysNoQualityAbove50_exceptSulfuras(t *testing.T) {
 	inv := New(sampleItems())
 	for i := 0; i < 100; i++ {