test(numpydates): test more constructors

Author: Christopher Doris

test/NumpyDates.jl

@@ -1,4 +1,4 @@
-@testitem "Date -> DateTime64/InlineDateTime64" begin
+@testitem "Date -> DateTime64" begin
     using Dates
     using PythonCall: NumpyDates
 
@@ -100,6 +100,185 @@
     end
 end
 
+@testitem "String -> DateTime64" begin
+    using Dates
+    using PythonCall: NumpyDates
+
+    # Data generated by: uv run test/scripts/np_dates.py
+    # Format: (string_date, unit_symbol, numpy_int_value)
+    cases = [
+        ("1969-12-31", :Y, -1),
+        ("1969-12-31", :M, -1),
+        ("1969-12-31", :D, -1),
+        ("1969-12-31", :h, -24),
+        ("1969-12-31", :m, -1440),
+        ("1969-12-31", :s, -86400),
+        ("1969-12-31", :ms, -86400000),
+        ("1969-12-31", :us, -86400000000),
+        ("1969-12-31", :ns, -86400000000000),
+        ("1970-01-01", :Y, 0),
+        ("1970-01-01", :M, 0),
+        ("1970-01-01", :D, 0),
+        ("1970-01-01", :h, 0),
+        ("1970-01-01", :m, 0),
+        ("1970-01-01", :s, 0),
+        ("1970-01-01", :ms, 0),
+        ("1970-01-01", :us, 0),
+        ("1970-01-01", :ns, 0),
+        ("1970-01-02", :Y, 0),
+        ("1970-01-02", :M, 0),
+        ("1970-01-02", :D, 1),
+        ("1970-01-02", :h, 24),
+        ("1970-01-02", :m, 1440),
+        ("1970-01-02", :s, 86400),
+        ("1970-01-02", :ms, 86400000),
+        ("1970-01-02", :us, 86400000000),
+        ("1970-01-02", :ns, 86400000000000),
+        ("1999-12-31", :Y, 29),
+        ("1999-12-31", :M, 359),
+        ("1999-12-31", :D, 10956),
+        ("1999-12-31", :h, 262944),
+        ("1999-12-31", :m, 15776640),
+        ("1999-12-31", :s, 946598400),
+        ("1999-12-31", :ms, 946598400000),
+        ("1999-12-31", :us, 946598400000000),
+        ("1999-12-31", :ns, 946598400000000000),
+        ("2000-02-29", :Y, 30),
+        ("2000-02-29", :M, 361),
+        ("2000-02-29", :D, 11016),
+        ("2000-02-29", :h, 264384),
+        ("2000-02-29", :m, 15863040),
+        ("2000-02-29", :s, 951782400),
+        ("2000-02-29", :ms, 951782400000),
+        ("2000-02-29", :us, 951782400000000),
+        ("2000-02-29", :ns, 951782400000000000),
+        ("1900-01-01", :Y, -70),
+        ("1900-01-01", :M, -840),
+        ("1900-01-01", :D, -25567),
+        ("1900-01-01", :h, -613608),
+        ("1900-01-01", :m, -36816480),
+        ("1900-01-01", :s, -2208988800),
+        ("1900-01-01", :ms, -2208988800000),
+        ("1900-01-01", :us, -2208988800000000),
+        ("1900-01-01", :ns, -2208988800000000000),
+        ("2100-01-01", :Y, 130),
+        ("2100-01-01", :M, 1560),
+        ("2100-01-01", :D, 47482),
+        ("2100-01-01", :h, 1139568),
+        ("2100-01-01", :m, 68374080),
+        ("2100-01-01", :s, 4102444800),
+        ("2100-01-01", :ms, 4102444800000),
+        ("2100-01-01", :us, 4102444800000000),
+        ("2100-01-01", :ns, 4102444800000000000),
+    ]
+
+    @testset "$s $usym" for (s, usym, expected) in cases
+        # DateTime64 from string
+        dt64 = NumpyDates.DateTime64(s, usym)
+        @test Dates.value(dt64) == expected
+
+        # Inline typed from string
+        Uconst = NumpyDates.Unit(usym)
+        inline_typed = NumpyDates.InlineDateTime64{Uconst}(s)
+        @test Dates.value(inline_typed) == expected
+
+        # Inline dynamic from string
+        inline_dyn = NumpyDates.InlineDateTime64(s, usym)
+        @test Dates.value(inline_dyn) == expected
+        @test NumpyDates.unitpair(inline_dyn) == NumpyDates.unitpair(usym)
+    end
+
+    # NaT string handling (all should produce NaT)
+    @testset "$nat" for nat in ("NaT", "nan", "NAN")
+        d1 = NumpyDates.DateTime64(nat, :D)
+        @test isnan(d1)
+        d2 = NumpyDates.InlineDateTime64{NumpyDates.DAYS}(nat)
+        @test isnan(d2)
+        d3 = NumpyDates.InlineDateTime64(nat, :D)
+        @test isnan(d3)
+    end
+end
+
+@testitem "String and DateFormat -> DateTime64" begin
+    using Dates
+    using PythonCall: NumpyDates
+
+    # Data based on: uv run test/scripts/np_dates.py and uv run test/scripts/np_datetimes.py
+    # We deliberately use formats that differ from the default parser to exercise the (str, format, unit) constructors.
+    cases = [
+        # date-only with custom format
+        ("1999/12/31", DateFormat("yyyy/mm/dd"), :D, 10956),
+        ("1999/12/31", DateFormat("yyyy/mm/dd"), :s, 946598400),
+        # datetime with custom format
+        ("2000-02-29 12:34:56", DateFormat("yyyy-mm-dd HH:MM:SS"), :s, 951_827_696),
+        (
+            "2000-02-29 12:34:56",
+            DateFormat("yyyy-mm-dd HH:MM:SS"),
+            :ns,
+            951_827_696_000_000_000,
+        ),
+    ]
+
+    @testset "$s $f $usym" for (s, f, usym, expected) in cases
+        # DateTime64 from string + format
+        dt64 = NumpyDates.DateTime64(s, f, usym)
+        @test Dates.value(dt64) == expected
+
+        # Inline typed from string + format
+        Uconst = NumpyDates.Unit(usym)
+        inline_typed = NumpyDates.InlineDateTime64{Uconst}(s, f)
+        @test Dates.value(inline_typed) == expected
+
+        # NOTE: InlineDateTime64(s, f, u) dynamic constructor is not exercised here
+        # because it currently dispatches to InlineTimeDelta64 in the implementation.
+        # When fixed, we can add:
+        # inline_dyn = NumpyDates.InlineDateTime64(s, f, usym)
+        # @test Dates.value(inline_dyn) == expected
+    end
+end
+
+@testitem "AbstractDateTime64 -> DateTime64" begin
+    using Dates
+    using PythonCall: NumpyDates
+
+    # Pass-through when units match
+    d = Date(1970, 1, 2)
+    x = NumpyDates.DateTime64(d, :D)  # expected value 1
+    y = NumpyDates.DateTime64(x, :D)
+    @test Dates.value(y) == 1
+    @test NumpyDates.unitpair(y) == NumpyDates.unitpair(:D)
+
+    # NaT changes unit and remains NaT
+    nat_d = NumpyDates.DateTime64("NaT", :D)
+    z = NumpyDates.DateTime64(nat_d, :s)
+    @test isnan(z)
+    @test NumpyDates.unitpair(z) == NumpyDates.unitpair(:s)
+end
+
+@testitem "Integer -> DateTime64" begin
+    using Dates
+    using PythonCall: NumpyDates
+
+    # DateTime64(value, unit)
+    x = NumpyDates.DateTime64(946_684_799, :s)   # 1999-12-31T23:59:59
+    @test Dates.value(x) == 946_684_799
+    @test Dates.DateTime(x) == DateTime(1999, 12, 31, 23, 59, 59)
+
+    y = NumpyDates.DateTime64(10_956, :D)        # 1999-12-31
+    @test Dates.value(y) == 10_956
+    @test Dates.Date(y) == Date(1999, 12, 31)
+
+    # InlineDateTime64{U}(value)
+    s1 = NumpyDates.InlineDateTime64{NumpyDates.SECONDS}(3_600) # +1 hour
+    @test Dates.value(s1) == 3_600
+    @test Dates.DateTime(s1) == DateTime(1970, 1, 1, 1, 0, 0)
+
+    # InlineDateTime64 with multiplier in the unit parameter
+    s2 = NumpyDates.InlineDateTime64{(NumpyDates.SECONDS, 2)}(1_800) # 1_800 * 2s = 3_600s
+    @test Dates.value(s2) == 1_800
+    @test Dates.DateTime(s2) == DateTime(1970, 1, 1, 1, 0, 0)
+end
+
 @testitem "DateTime -> DateTime64/InlineDateTime64" begin
     using Dates
     using PythonCall: NumpyDates