more coverage

Author: Balinus

test/legacy_compat_test.jl

@@ -95,4 +95,35 @@
     @test ClimateTools.daymean_factor("6h") == 4
     @test ClimateTools.pr_timefactor("3h") == 10800.0
     @test size(ensemble_fct(cube)) == (3, 2, 2)
+end
+
+@testset "Legacy compatibility helpers" begin
+    @test ClimateTools._infer_temperature_unit([1.0, 10.0, 25.0]) == :Celsius
+    @test ClimateTools._infer_temperature_unit([280.0, 281.0, 282.0]) == :K
+    @test ClimateTools._infer_temperature_unit([missing, missing]) == :K
+    @test ClimateTools._infer_temperature_unit([1.0, 2.0]; temperature_unit=:Kelvin) == :Kelvin
+
+    @test ClimateTools._as_kelvin([0.0, 10.0]; temperature_unit=:degC) == [273.15, 283.15]
+    @test ClimateTools._as_kelvin([300.0, 301.0]; temperature_unit=:K) == [300.0, 301.0]
+    @test ClimateTools._as_celsius([273.15, 283.15]; temperature_unit=:Kelvin) == [0.0, 10.0]
+    @test ClimateTools._as_celsius([0.0, 10.0]; temperature_unit=:Celsius) == [0.0, 10.0]
+
+    hourly_times = collect(0.0:(1 / 24):1.0)
+    monthly_times = [0.0, 31.0, 60.0]
+    yearly_times = [0.0, 365.0, 730.0]
+    @test ClimateTools.timeresolution(Float64[]) == "N/A"
+    @test ClimateTools.timeresolution(hourly_times) == "1h"
+    @test ClimateTools.timeresolution(monthly_times) == "Monthly"
+    @test ClimateTools.timeresolution(yearly_times) == "Yearly"
+
+    @test ClimateTools.pr_timefactor("unknown") == 1.0
+    @test ClimateTools.daymean_factor("unknown") == 1
+
+    missing_times = collect(DateTime(2004, 1, 1):Day(1):DateTime(2005, 12, 31))
+    missing_cube = YAXArray(
+        (Dim{:longitude}(1:1), Dim{:latitude}(1:1), Dim{:time}(missing_times)),
+        fill(NaN, 1, 1, length(missing_times)),
+    )
+    yearly_missing = ClimateTools.prcp1(missing_cube)
+    @test all(isnan, Array(yearly_missing))
 end

test/markov_test.jl

@@ -17,4 +17,28 @@ using Dates
     result_three = ClimateTools.MSModel(cube; k_regime=3)
     @test size(result_three) == (1,)
     @test Array(result_three)[1] isa ClimateTools.MarSwitching.MSM
+end
+
+@testset "Markov Switching multidimensional cube" begin
+    times = collect(Date(2021, 1, 1):Day(1):Date(2021, 2, 19))
+    lon = [10.0, 20.0]
+    lat = [45.0, 50.0]
+
+    base_signal = vcat(fill(-3.0, 25), fill(3.0, 25))
+    data = Array{Float64}(undef, length(lon), length(lat), length(times))
+    for ilon in eachindex(lon), ilat in eachindex(lat)
+        data[ilon, ilat, :] .= base_signal .+ 0.1 * ilon .- 0.05 * ilat
+    end
+
+    cube = YAXArray((Dim{:longitude}(lon), Dim{:latitude}(lat), Dim{:time}(times)), data)
+    result = ClimateTools.MSModel(cube; k_regime=2, intercept="switching")
+
+    @test size(result) == (length(lon), length(lat), 1)
+    @test Tuple(Symbol.(name.(result.axes))) == (:longitude, :latitude, :MSM)
+    @test all(model -> model isa ClimateTools.MarSwitching.MSM, Array(result))
+end
+
+@testset "Markov Switching validation" begin
+    cube = YAXArray((Dim{:longitude}([1.0, 2.0]), Dim{:latitude}([3.0, 4.0])), [1.0 2.0; 3.0 4.0])
+    @test_throws ErrorException ClimateTools.MSModel(cube)
 end

test/regrid_test.jl

@@ -3,6 +3,7 @@ using ClimateTools
 using YAXArrays
 using DimensionalData
 using Dates
+using Serialization
 
 @testset "Regridder rectilinear workflow" begin
     src_lon = collect(0.0:1.0:4.0)
@@ -313,3 +314,98 @@ end
     out_multi = regrid_cube(ds, :pr, dest_multi; method="bilinear")
     @test Base.maximum(abs.(Array(out_multi) .- expected)) < 1e-6
 end
+
+@testset "Regrid helper coverage" begin
+    @test ClimateTools._normalize_regrid_method("linear") == :bilinear
+    @test ClimateTools._normalize_regrid_method("nearest") == :nearest_s2d
+    @test ClimateTools._normalize_regrid_method("idw") == :idw
+    @test_throws ErrorException ClimateTools._normalize_regrid_method("cubic")
+
+    ascending, asc_flip = ClimateTools._prepare_source_coordinate([1.0, 2.0, 3.0], :longitude)
+    descending, desc_flip = ClimateTools._prepare_source_coordinate([3.0, 2.0, 1.0], :latitude)
+    @test ascending == [1.0, 2.0, 3.0]
+    @test asc_flip == false
+    @test descending == [1.0, 2.0, 3.0]
+    @test desc_flip == true
+    @test_throws ErrorException ClimateTools._prepare_source_coordinate([1.0, 1.0, 2.0], :longitude)
+    @test_throws ErrorException ClimateTools._prepare_source_coordinate([1.0, 3.0, 2.0], :longitude)
+
+    @test ClimateTools._weighted_value((1.0, 2.0, 3.0, 4.0), (0.25, 0.25, 0.25, 0.25)) ≈ 2.5
+    @test isnan(ClimateTools._weighted_value((1.0, missing, 3.0, 4.0), (0.25, 0.25, 0.25, 0.25)))
+    @test ClimateTools._weighted_value((1.0, missing, 3.0, 5.0), (0.25, 0.25, 0.25, 0.25); skipna=true, na_thres=0.3) ≈ 3.0
+    @test isnan(ClimateTools._weighted_value((1.0, missing, 3.0, 5.0), (0.25, 0.25, 0.25, 0.25); skipna=true, na_thres=0.2))
+
+    lon2d, lat2d = ClimateTools._destination_grid([0.0, 1.0], [10.0, 11.0])
+    @test size(lon2d) == (2, 2)
+    @test size(lat2d) == (2, 2)
+    @test_throws ErrorException ClimateTools._destination_grid(reshape([0.0, 1.0], 2, 1), [10.0, 11.0])
+    @test_throws ErrorException ClimateTools._destination_grid(ones(2, 2), ones(3, 1))
+
+    pts = [0.0 10.0; 1.0 11.0]
+    lon_grid = [0.0 1.0; 0.0 1.0]
+    lat_grid = [10.0 10.0; 11.0 11.0]
+    @test all(isnan, ClimateTools.idw_griddata(pts, [NaN, NaN], lon_grid, lat_grid))
+
+    src_lon = [0.0, 1.0]
+    src_lat = [10.0, 11.0]
+    src = YAXArray((Dim{:longitude}(src_lon), Dim{:latitude}(src_lat)), [1.0 2.0; 3.0 4.0])
+    dest = YAXArray((Dim{:longitude}([0.5]), Dim{:latitude}([10.5])), zeros(1, 1))
+    regridder = Regridder(src, dest; method="bilinear")
+    @test_throws ErrorException regrid(src, regridder; na_thres=1.5)
+
+    payload = ClimateTools._regridder_payload(regridder)
+    restored = ClimateTools._regridder_from_payload(payload)
+    @test restored.method == regridder.method
+    @test restored.dest_lon == regridder.dest_lon
+
+    mktempdir() do tmpdir
+        missing_version_path = joinpath(tmpdir, "missing-version.bin")
+        open(missing_version_path, "w") do io
+            Serialization.serialize(io, (method=:bilinear,))
+        end
+        @test_throws ErrorException load_regridder(missing_version_path)
+
+        bad_version_path = joinpath(tmpdir, "bad-version.bin")
+        open(bad_version_path, "w") do io
+            Serialization.serialize(io, (version=999, method=:bilinear))
+        end
+        @test_throws ErrorException load_regridder(bad_version_path)
+    end
+end
+
+@testset "Regrid rotated dataset helper fallback" begin
+    north_pole_lon = 0.0
+    north_pole_lat = 42.5
+
+    rlon_vals = collect(0.0:1.0:3.0)
+    rlat_vals = collect(-1.0:1.0:2.0)
+    rlon2d, rlat2d = ClimateTools.ndgrid(rlon_vals, rlat_vals)
+    data = Float64.(rlon2d .+ 2 .* rlat2d)
+
+    pr_cube = YAXArray(
+        (Dim{:rlon}(rlon_vals), Dim{:rlat}(rlat_vals)),
+        data,
+        Dict{String, Any}("grid_mapping" => "rotated_pole"),
+    )
+    rp_cube = YAXArray(
+        (Dim{:maxStrlen64}(1:1),),
+        [' '],
+        Dict{String, Any}(
+            "grid_north_pole_longitude" => north_pole_lon,
+            "grid_north_pole_latitude" => north_pole_lat,
+        ),
+    )
+    ds = Dataset(pr=pr_cube, rotated_pole=rp_cube)
+
+    lon_geo, lat_geo = ClimateTools._extract_geographic_coords(ds, pr_cube, "rotated_pole")
+    @test size(lon_geo) == size(data)
+    @test size(lat_geo) == size(data)
+    @test all(isfinite, lon_geo)
+    @test all(isfinite, lat_geo)
+
+    dest = YAXArray((Dim{:longitude}(collect(range(minimum(lon_geo), maximum(lon_geo), length=3))), Dim{:latitude}(collect(range(minimum(lat_geo), maximum(lat_geo), length=3)))), zeros(3, 3))
+    regridder = Regridder(ds, :pr, dest; method="idw")
+    out = regrid(ds[:pr], regridder)
+    @test size(out) == (3, 3)
+    @test all(isfinite, Array(out))
+end

test/runtests.jl

@@ -55,6 +55,7 @@ using Dates
     include("spatial_test.jl")
     include("spatialsubset_test.jl")
     include("regrid_test.jl")
+    include("xmap_utils_test.jl")
     include("functions_new_test.jl")
     include("functions_helpers_test.jl")
     include("climatology_test.jl")

test/xmap_utils_test.jl

@@ -0,0 +1,87 @@
+using ClimateTools
+using Test
+using YAXArrays
+using DimensionalData
+
+_xmap_sum_kernel(xout, xin; scale=1.0) = xout .= sum(xin) * scale
+
+function _xmap_pair_kernel(xout, x1, x2, offset; scale=1.0)
+    xout .= (sum(x1) + sum(x2) + offset) * scale
+end
+
+@testset "xmap utility helpers" begin
+    @test ClimateTools._normalize_xmap_dim(:time) == :time
+    @test ClimateTools._normalize_xmap_dim("time") == :time
+    @test ClimateTools._normalize_xmap_dims(:time) == (:time,)
+    @test ClimateTools._normalize_xmap_dims((:longitude, "time")) == (:longitude, :time)
+    @test ClimateTools._normalize_xmap_dims(["longitude", :latitude]) == (:longitude, :latitude)
+
+    axis = Dim{:stat}(["sum"])
+    @test ClimateTools._normalize_xmap_output_axes() == ()
+    @test ClimateTools._normalize_xmap_output_axes(axis) == (axis,)
+    @test ClimateTools._normalize_xmap_output_axes((axis,)) == (axis,)
+    @test ClimateTools._normalize_xmap_output_axes([axis]) == (axis,)
+
+    cube = YAXArray(
+        (Dim{:longitude}([10.0, 20.0]), Dim{:latitude}([45.0, 50.0]), Dim{:time}(1:3)),
+        reshape(Float64.(1:12), 2, 2, 3),
+    )
+
+    single_window = ClimateTools._xmap_window(cube, (:time,))
+    pair_window = ClimateTools._xmap_window(cube, (:longitude, :time))
+    @test parentmodule(typeof(single_window)) == YAXArrays.Xmap
+    @test parentmodule(typeof(pair_window)) == YAXArrays.Xmap
+
+    spec_no_axes = ClimateTools._xmap_output_spec(())
+    spec_with_axes = ClimateTools._xmap_output_spec((axis,); outtype=Float32)
+    @test spec_no_axes isa YAXArrays.Xmap.XOutput
+    @test spec_with_axes isa YAXArrays.Xmap.XOutput
+
+    dropped = ClimateTools._drop_reduced_xmap_dims(
+        YAXArray((Dim{:longitude}([10.0]), Dim{:latitude}([45.0, 50.0])), reshape([1.0, 2.0], 1, 2)),
+        (:longitude,),
+    )
+    @test size(dropped) == (2,)
+    @test Tuple(Symbol.(name.(dropped.axes))) == (:latitude,)
+end
+
+@testset "xmap call reductions" begin
+    cube = YAXArray(
+        (Dim{:longitude}([10.0, 20.0]), Dim{:latitude}([45.0, 50.0]), Dim{:time}(1:4)),
+        reshape(Float64.(1:16), 2, 2, 4),
+    )
+
+    reduced = ClimateTools._xmap_call(
+        _xmap_sum_kernel,
+        cube;
+        reduced_dims="time",
+        function_kwargs=(scale=2.0,),
+    )
+    @test size(reduced) == (2, 2)
+    @test Array(reduced) == 2.0 .* dropdims(sum(Array(cube); dims=3); dims=3)
+
+    stat_axis = Dim{:stat}(["combined"])
+    shifted = YAXArray(cube.axes, Array(cube) .+ 1.0)
+    combined = ClimateTools._xmap_call(
+        _xmap_pair_kernel,
+        (cube, shifted);
+        reduced_dims=[:longitude, "time"],
+        output_axes=[stat_axis],
+        function_args=(5.0,),
+        function_kwargs=(scale=0.5,),
+        outtype=Float32,
+    )
+
+    # Note: Xmap adds new dimensions (stat) BEFORE the existing ones (latitude)
+    expected = Array{Float32}(undef, 1, 2)
+    raw_cube = Array(cube)
+    raw_shifted = Array(shifted)
+    for ilat in 1:2
+        expected[1, ilat] = Float32((sum(raw_cube[:, ilat, :]) + sum(raw_shifted[:, ilat, :]) + 5.0) * 0.5)
+    end
+
+    @test size(combined) == (1, 2)
+    @test Tuple(Symbol.(name.(combined.axes))) == (:stat, :latitude)
+    @test Array(combined) ≈ expected
+    @test eltype(Array(combined)) == Float32
+end