test_dtutil.c

/* test_dtutil.c -- Cross-validation of DTUTIL algorithms in C
 *
 * Since we can't compile RPG on Windows (the AS/400 is,
 * regrettably, not a USB peripheral), we re-implement the
 * core algorithms in C and verify them against known values.
 *
 * If these pass, the RPG does the same maths with the same
 * logic, just in a language that uses *ON instead of true.
 *
 * Build: gcc -o test_dtutil test_dtutil.c -Wall
 * Run:   ./test_dtutil
 *
 * (c) 2026 Zane Hambly. Apache 2.0.
 */

#include <stdio.h>
#include <stdlib.h>

static int g_pass = 0, g_fail = 0;

#define CHK(name, cond) do { \
    if (cond) { printf("PASS: %s\n", name); g_pass++; } \
    else { printf("FAIL: %s\n", name); g_fail++; } \
} while(0)

#define CHKI(name, got, want) do { \
    int _g = (got), _w = (want); \
    if (_g == _w) { printf("PASS: %s\n", name); g_pass++; } \
    else { printf("FAIL: %s (got %d, want %d)\n", name, _g, _w); g_fail++; } \
} while(0)

/* ---- Date as packed int: YYYYMMDD ---- */

typedef int dt_t;  /* 20260326 = March 26 2026 */

static int dt_y(dt_t d) { return d / 10000; }
static int dt_m(dt_t d) { return (d / 100) % 100; }
static int dt_d(dt_t d) { return d % 100; }
static dt_t dt_mk(int y, int m, int d) { return y*10000 + m*100 + d; }

/* ---- Leap year ---- */

static int dt_isleap(int y)
{
    if (y % 400 == 0) return 1;
    if (y % 100 == 0) return 0;
    if (y % 4 == 0)   return 1;
    return 0;
}

/* ---- Days in month ---- */

static int dt_dim(int y, int m)
{
    static const int t[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    if (m < 1 || m > 12) return 0;
    if (m == 2 && dt_isleap(y)) return 29;
    return t[m];
}

/* ---- Day of year ---- */

static int dt_doy(dt_t d)
{
    int y = dt_y(d), m = dt_m(d), day = dt_d(d);
    int doy = 0, i;
    for (i = 1; i < m; i++) doy += dt_dim(y, i);
    return doy + day;
}

/* ---- Julian Day Number (for day arithmetic) ---- */

static int to_jdn(dt_t d)
{
    int y = dt_y(d), m = dt_m(d), day = dt_d(d);
    int a = (14 - m) / 12;
    int yy = y + 4800 - a;
    int mm = m + 12*a - 3;
    return day + (153*mm + 2)/5 + 365*yy + yy/4 - yy/100 + yy/400 - 32045;
}

static dt_t from_jdn(int jdn)
{
    int a = jdn + 32044;
    int b = (4*a + 3) / 146097;
    int c = a - (146097*b)/4;
    int d = (4*c + 3) / 1461;
    int e = c - (1461*d)/4;
    int m = (5*e + 2) / 153;
    int day = e - (153*m + 2)/5 + 1;
    int mon = m + 3 - 12*(m/10);
    int yr  = 100*b + d - 4800 + m/10;
    return dt_mk(yr, mon, day);
}

static int dt_diff(dt_t d1, dt_t d2)
{
    return to_jdn(d2) - to_jdn(d1);
}

static dt_t dt_add(dt_t d, int n)
{
    return from_jdn(to_jdn(d) + n);
}

/* ---- Day of week (ISO: 1=Mon..7=Sun) ---- */

static int dt_dow(dt_t d)
{
    int jdn = to_jdn(d);
    int w = (jdn % 7);  /* 0=Mon in JDN */
    w = w + 1;           /* 1=Mon..7=Sun */
    if (w > 7) w -= 7;
    return w;
}

/* ---- ISO week ---- */

static int dt_isoweek(dt_t d)
{
    int doy = dt_doy(d);
    int dow = dt_dow(d);
    int wk = (doy - dow + 10) / 7;
    int y = dt_y(d);

    if (wk < 1) {
        return dt_isoweek(dt_mk(y-1, 12, 31));
    }
    if (wk == 53) {
        int jan1dow = dt_dow(dt_mk(y+1, 1, 1));
        if (jan1dow != 5) {
            if (!(jan1dow == 4 && dt_isleap(y)))
                wk = 1;
        }
    }
    return wk;
}

/* ---- Quarter ---- */

static int dt_qtr(dt_t d) { return (dt_m(d) - 1) / 3 + 1; }

/* ---- End of month ---- */

static int dt_iseom(dt_t d)
{
    return dt_d(d) == dt_dim(dt_y(d), dt_m(d));
}

/* ---- Weekday ---- */

static int dt_iswkd(dt_t d) { int w = dt_dow(d); return w >= 1 && w <= 5; }

/* ---- Business days ---- */

static int dt_bdays(dt_t d1, dt_t d2)
{
    int total, weeks, extra, cnt, i;
    dt_t cur;
    if (to_jdn(d1) > to_jdn(d2)) { dt_t tmp = d1; d1 = d2; d2 = tmp; }
    total = dt_diff(d1, d2);
    if (total == 0) return 0;
    weeks = total / 7;
    extra = total % 7;
    cnt = weeks * 5;
    cur = dt_add(d1, weeks * 7);
    for (i = 0; i < extra; i++) {
        if (dt_iswkd(cur)) cnt++;
        cur = dt_add(cur, 1);
    }
    return cnt;
}

/* ---- Easter (Anonymous Gregorian) ---- */

static dt_t dt_easter(int y)
{
    int a = y % 19;
    int b = y / 100;
    int c = y % 100;
    int d = b / 4;
    int e = b % 4;
    int f = (b + 8) / 25;
    int g = (b - f + 1) / 3;
    int h = (19*a + b - d - g + 15) % 30;
    int i = c / 4;
    int k = c % 4;
    int l = (32 + 2*e + 2*i - h - k) % 7;
    int m = (a + 11*h + 22*l) / 451;
    int p = h + l - 7*m + 114;
    int em = p / 31;
    int ed = p % 31 + 1;
    return dt_mk(y, em, ed);
}

/* ---- Age ---- */

static int dt_age(dt_t birth, dt_t asof)
{
    int by = dt_y(birth), bm = dt_m(birth), bd = dt_d(birth);
    int ay = dt_y(asof),  am = dt_m(asof),  ad = dt_d(asof);
    int age = ay - by;
    if (am < bm) age--;
    else if (am == bm && ad < bd) age--;
    if (age < 0) age = 0;
    return age;
}

/* ---- Matariki (legislated table, 2022-2052) ---- */

static dt_t dt_mtk(int y)
{
    /* Te Kāhui o Matariki Public Holiday Act 2022, Schedule 1 */
    static const struct { int yr; int mm; int dd; } tbl[] = {
        {2022,6,24},{2023,7,14},{2024,6,28},{2025,6,20},{2026,7,10},
        {2027,6,25},{2028,7,14},{2029,7, 6},{2030,6,21},{2031,7,11},
        {2032,7, 2},{2033,6,24},{2034,7, 7},{2035,6,29},{2036,7,18},
        {2037,7,10},{2038,6,25},{2039,7,15},{2040,7, 6},{2041,7,19},
        {2042,7,11},{2043,7, 3},{2044,6,24},{2045,7, 7},{2046,6,29},
        {2047,7,19},{2048,7, 3},{2049,6,25},{2050,7,15},{2051,6,30},
        {2052,6,21},
    };
    int i;
    for (i = 0; i < 31; i++)
        if (tbl[i].yr == y)
            return dt_mk(y, tbl[i].mm, tbl[i].dd);
    return dt_mk(1, 1, 1);  /* outside range */
}

/* ---- NZ Holidays ---- */

static dt_t mondayise(dt_t h)
{
    int dow = dt_dow(h);
    if (dow == 6) return dt_add(h, 2);  /* Sat → Mon */
    if (dow == 7) return dt_add(h, 1);  /* Sun → Mon */
    return h;
}

static int dt_nzhol(dt_t d)
{
    int y = dt_y(d);
    dt_t h;

    /* New Year's Day */
    if (d == mondayise(dt_mk(y,1,1))) return 1;
    /* Day after NY — special: if Sun→Tue */
    h = dt_mk(y,1,2);
    if (dt_dow(h) == 6) h = dt_add(h, 2);
    else if (dt_dow(h) == 7) h = dt_add(h, 2); /* Sun → Tue */
    if (d == h) return 1;
    /* Waitangi */
    if (d == mondayise(dt_mk(y,2,6))) return 1;
    /* ANZAC */
    if (d == mondayise(dt_mk(y,4,25))) return 1;
    /* Good Friday / Easter Monday */
    if (d == dt_add(dt_easter(y), -2)) return 1;
    if (d == dt_add(dt_easter(y), 1)) return 1;
    /* Matariki */
    h = dt_mtk(y);
    if (h != dt_mk(1,1,1) && d == h) return 1;
    /* King's Birthday: 1st Monday of June */
    h = dt_mk(y,6,1);
    if (dt_dow(h) != 1) h = dt_add(h, (8 - dt_dow(h)) % 7);
    if (d == h) return 1;
    /* Labour Day: 4th Monday of October */
    h = dt_mk(y,10,1);
    if (dt_dow(h) != 1) h = dt_add(h, (8 - dt_dow(h)) % 7);
    h = dt_add(h, 21);
    if (d == h) return 1;
    /* Christmas */
    if (d == mondayise(dt_mk(y,12,25))) return 1;
    /* Boxing Day — special: if Sun→Tue */
    h = dt_mk(y,12,26);
    if (dt_dow(h) == 6) h = dt_add(h, 2);
    else if (dt_dow(h) == 7) h = dt_add(h, 2);
    if (d == h) return 1;

    return 0;
}

/* ================================================================ */

int main(void)
{
    printf("=== DTUTIL Algorithm Validation ===\n\n");

    /* Leap year */
    CHK("leap: 2024", dt_isleap(2024));
    CHK("leap: 2023 not", !dt_isleap(2023));
    CHK("leap: 2000", dt_isleap(2000));
    CHK("leap: 1900 not", !dt_isleap(1900));
    CHK("leap: 2100 not", !dt_isleap(2100));

    /* Days in month */
    CHKI("dim: Jan", dt_dim(2026,1), 31);
    CHKI("dim: Feb non-leap", dt_dim(2023,2), 28);
    CHKI("dim: Feb leap", dt_dim(2024,2), 29);
    CHKI("dim: Apr", dt_dim(2026,4), 30);
    CHKI("dim: invalid", dt_dim(2026,13), 0);

    /* Day of week */
    CHKI("dow: 2026-03-26=Thu", dt_dow(20260326), 4);
    CHKI("dow: 2026-03-22=Sun", dt_dow(20260322), 7);
    CHKI("dow: 2026-03-23=Mon", dt_dow(20260323), 1);
    CHKI("dow: 2026-03-28=Sat", dt_dow(20260328), 6);

    /* Day of year */
    CHKI("doy: Jan 1", dt_doy(20260101), 1);
    CHKI("doy: Mar 1 non-leap", dt_doy(20260301), 60);
    CHKI("doy: Mar 1 leap", dt_doy(20240301), 61);
    CHKI("doy: Dec 31 non-leap", dt_doy(20261231), 365);
    CHKI("doy: Dec 31 leap", dt_doy(20241231), 366);

    /* ISO week */
    CHKI("isoweek: 2026-01-01", dt_isoweek(20260101), 1);
    CHKI("isoweek: 2025-12-29", dt_isoweek(20251229), 1);

    /* Quarter */
    CHKI("qtr: Jan=Q1", dt_qtr(20260115), 1);
    CHKI("qtr: Apr=Q2", dt_qtr(20260401), 2);
    CHKI("qtr: Jul=Q3", dt_qtr(20260731), 3);
    CHKI("qtr: Dec=Q4", dt_qtr(20261225), 4);

    /* End of month */
    CHK("iseom: Mar 31", dt_iseom(20260331));
    CHK("iseom: Mar 30 not", !dt_iseom(20260330));
    CHK("iseom: Feb 28 non-leap", dt_iseom(20260228));
    CHK("iseom: Feb 29 leap", dt_iseom(20240229));
    CHK("iseom: Feb 28 leap not", !dt_iseom(20240228));

    /* Weekday */
    CHK("iswkd: Thu", dt_iswkd(20260326));
    CHK("iswkd: Sat not", !dt_iswkd(20260328));

    /* Business days */
    CHKI("bdays: Mon-Fri", dt_bdays(20260323, 20260327), 4);
    CHKI("bdays: 2 weeks", dt_bdays(20260309, 20260323), 10);

    /* Date arithmetic */
    CHKI("diff: 10 days", dt_diff(20260301, 20260311), 10);
    CHKI("diff: negative", dt_diff(20260311, 20260301), -10);
    CHKI("add: +30", dt_add(20260101, 30), 20260131);
    CHKI("add: -1 from Mar 1", dt_add(20260301, -1), 20260228);

    /* Easter */
    CHKI("easter: 2026", dt_easter(2026), 20260405);
    CHKI("easter: 2024", dt_easter(2024), 20240331);
    CHKI("easter: 2025", dt_easter(2025), 20250420);
    CHKI("gfri: 2026", dt_add(dt_easter(2026), -2), 20260403);
    CHKI("emon: 2026", dt_add(dt_easter(2026), 1), 20260406);

    /* NZ Holidays */
    CHK("nzhol: Good Friday 2026", dt_nzhol(20260403));
    CHK("nzhol: Easter Monday 2026", dt_nzhol(20260406));
    CHK("nzhol: Waitangi 2026", dt_nzhol(20260206));
    CHK("nzhol: Christmas 2026", dt_nzhol(20261225));
    CHK("nzhol: random Tue", !dt_nzhol(20260324));
    CHK("nzhol: ANZAC 2026 Sat->Mon", dt_nzhol(20260427));
    CHK("nzhol: NY 2027 Fri", dt_nzhol(20270101));
    CHK("nzhol: Labour 2026", dt_nzhol(20261026));

    /* Matariki */
    CHKI("mtk: 2022", dt_mtk(2022), 20220624);
    CHKI("mtk: 2026", dt_mtk(2026), 20260710);
    CHKI("mtk: 2033", dt_mtk(2033), 20330624);
    CHKI("mtk: 2052", dt_mtk(2052), 20520621);
    CHK("nzhol: Matariki 2026", dt_nzhol(20260710));
    CHK("nzhol: Matariki 2024", dt_nzhol(20240628));
    CHK("nzhol: Matariki 2025", dt_nzhol(20250620));
    CHK("nzhol: day before Matariki", !dt_nzhol(20260709));
    /* Verify all 31 dates are Fridays */
    {
        int mtk_ok = 1, yr;
        for (yr = 2022; yr <= 2052; yr++) {
            dt_t md = dt_mtk(yr);
            if (md != dt_mk(1,1,1) && dt_dow(md) != 5) {
                printf("  Matariki %d is not a Friday!\n", yr);
                mtk_ok = 0;
            }
        }
        CHK("mtk: all 31 dates are Fridays", mtk_ok);
    }

    /* Age */
    CHKI("age: basic", dt_age(19900615, 20260326), 35);
    CHKI("age: before bday", dt_age(19900615, 20260614), 35);
    CHKI("age: on bday", dt_age(19900615, 20260615), 36);

    printf("\n=== %d pass, %d fail ===\n", g_pass, g_fail);
    return g_fail > 0 ? 1 : 0;
}