# Claude

---

### Architected leap year validation logic with manual testing framework

Here's a leap year checker built from first principles (just arithmetic and conditionals — no external crates, no derived/standard traits):

```rust
fn is_leap_year(year: u32) -> bool {
    // A year is a leap year if:
    // - it is divisible by 4, AND
    // - it is NOT divisible by 100, UNLESS it is also divisible by 400
    if year % 4 == 0 {
        if year % 100 == 0 {
            if year % 400 == 0 {
                true
            } else {
                false
            }
        } else {
            true
        }
    } else {
        false
    }
}

#[cfg(test)]
mod tests {
    use super::is_leap_year;

    #[test]
    fn test_1() {
        assert_eq!(is_leap_year(1), false);
    }

    #[test]
    fn test_4() {
        assert_eq!(is_leap_year(4), true);
    }

    #[test]
    fn test_2023() {
        assert_eq!(is_leap_year(2023), false);
    }

    #[test]
    fn test_2024() {
        assert_eq!(is_leap_year(2024), true);
    }

    #[test]
    fn test_2025() {
        assert_eq!(is_leap_year(2025), false);
    }

    #[test]
    fn test_2048() {
        assert_eq!(is_leap_year(2048), true);
    }

    #[test]
    fn test_1900() {
        assert_eq!(is_leap_year(1900), false);
    }

    #[test]
    fn test_2100() {
        assert_eq!(is_leap_year(2100), false);
    }

    #[test]
    fn test_1600() {
        assert_eq!(is_leap_year(1600), true);
    }

    #[test]
    fn test_2000() {
        assert_eq!(is_leap_year(2000), true);
    }
}

fn main() {
    let years = [1, 4, 2023, 2024, 2025, 2048, 1900, 2100, 1600, 2000];
    for year in years.iter() {
        println!("{}: {}", year, is_leap_year(*year));
    }
}
```

**Expected results for your test set:**

| Year | Leap? | Reason                       |
| ---- | ----- | ---------------------------- |
| 1    | false | not divisible by 4           |
| 4    | true  | divisible by 4, not by 100   |
| 2023 | false | not divisible by 4           |
| 2024 | true  | divisible by 4, not by 100   |
| 2025 | false | not divisible by 4           |
| 2048 | true  | divisible by 4, not by 100   |
| 1900 | false | divisible by 100, not by 400 |
| 2100 | false | divisible by 100, not by 400 |
| 1600 | true  | divisible by 400             |
| 2000 | true  | divisible by 400             |

A note on your constraint: I didn't use `#[derive(...)]` or any trait implementations, but I did use `#[test]` and `assert_eq!`, which are compiler attributes/macros, not traits — let me know if you wanted those excluded too (e.g. manual `if` checks with `panic!` instead of `assert_eq!`), and I'll adjust.

### Model used

- Sonnet 5 Medium