improve test coverage

Project.toml

@@ -11,7 +11,7 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
 StaticArrays = "1"
-julia = "1"
+julia = "1.8"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

src/PermMatrix.jl

@@ -165,6 +165,6 @@ end
 Base.hash(pm::AbstractPermMatrix) = hash((pm.perm, pm.vals))
 
 ######### sparse array interfaces  #########
-nnz(M::AbstractPermMatrix) = length(M.vals)
-findnz(M::PermMatrix) = (collect(1:size(M, 1)), M.perm, M.vals)
-findnz(M::PermMatrixCSC) = (M.perm, collect(1:size(M, 1)), M.vals)
+SparseArrays.nnz(M::AbstractPermMatrix) = length(M.vals)
+SparseArrays.findnz(M::PermMatrix) = (collect(1:size(M, 1)), M.perm, M.vals)
+SparseArrays.findnz(M::PermMatrixCSC) = (M.perm, collect(1:size(M, 1)), M.vals)

src/SSparseMatrixCSC.jl

@@ -1,62 +1,30 @@
-@static if VERSION < v"1.4.0"
+"""
+    SSparseMatrixCSC{Tv,Ti<:Integer, NNZ, NP} <: AbstractSparseMatrix{Tv,Ti}
 
-    """
-        SSparseMatrixCSC{Tv,Ti<:Integer, NNZ, NP} <: AbstractSparseMatrix{Tv,Ti}
+static version of SparseMatrixCSC
+"""
+struct SSparseMatrixCSC{Tv,Ti<:Integer,NNZ,NP} <:
+        SparseArrays.AbstractSparseMatrixCSC{Tv,Ti}
+    m::Int                  # Number of rows
+    n::Int                  # Number of columns
+    colptr::SVector{NP,Ti}      # Column i is in colptr[i]:(colptr[i+1]-1)
+    rowval::SVector{NNZ,Ti}      # Row values of nonzeros
+    nzval::SVector{NNZ,Tv}       # Nonzero values
 
-    static version of SparseMatrixCSC
-    """
-    struct SSparseMatrixCSC{Tv,Ti<:Integer,NNZ,NP} <: AbstractSparseMatrix{Tv,Ti}
-        m::Int                  # Number of rows
-        n::Int                  # Number of columns
-        colptr::SVector{NP,Ti}      # Column i is in colptr[i]:(colptr[i+1]-1)
-        rowval::SVector{NNZ,Ti}      # Row values of nonzeros
-        nzval::SVector{NNZ,Tv}       # Nonzero values
-
-        function SSparseMatrixCSC{Tv,Ti,NNZ,NP}(
-            m::Integer,
-            n::Integer,
-            colptr::SVector{NP,Ti},
-            rowval::SVector{NNZ,Ti},
-            nzval::SVector{NNZ,Tv},
-        ) where {Tv,Ti<:Integer,NNZ,NP}
-            m < 0 && throw(ArgumentError("number of rows (m) must be ≥ 0, got $m"))
-            n < 0 && throw(ArgumentError("number of columns (n) must be ≥ 0, got $n"))
-            new(Int(m), Int(n), colptr, rowval, nzval)
-        end
+    function SSparseMatrixCSC{Tv,Ti,NNZ,NP}(
+        m::Integer,
+        n::Integer,
+        colptr::SVector{NP,Ti},
+        rowval::SVector{NNZ,Ti},
+        nzval::SVector{NNZ,Tv},
+    ) where {Tv,Ti<:Integer,NNZ,NP}
+        m < 0 && throw(ArgumentError("number of rows (m) must be ≥ 0, got $m"))
+        n < 0 && throw(ArgumentError("number of columns (n) must be ≥ 0, got $n"))
+        new(Int(m), Int(n), colptr, rowval, nzval)
     end
-
-else
-    # NOTE: from 1.4.0, by subtyping AbstractSparseMatrixCSC, things like sparse broadcast
-    # should just work.
-
-    """
-        SSparseMatrixCSC{Tv,Ti<:Integer, NNZ, NP} <: AbstractSparseMatrix{Tv,Ti}
-
-    static version of SparseMatrixCSC
-    """
-    struct SSparseMatrixCSC{Tv,Ti<:Integer,NNZ,NP} <:
-           SparseArrays.AbstractSparseMatrixCSC{Tv,Ti}
-        m::Int                  # Number of rows
-        n::Int                  # Number of columns
-        colptr::SVector{NP,Ti}      # Column i is in colptr[i]:(colptr[i+1]-1)
-        rowval::SVector{NNZ,Ti}      # Row values of nonzeros
-        nzval::SVector{NNZ,Tv}       # Nonzero values
-
-        function SSparseMatrixCSC{Tv,Ti,NNZ,NP}(
-            m::Integer,
-            n::Integer,
-            colptr::SVector{NP,Ti},
-            rowval::SVector{NNZ,Ti},
-            nzval::SVector{NNZ,Tv},
-        ) where {Tv,Ti<:Integer,NNZ,NP}
-            m < 0 && throw(ArgumentError("number of rows (m) must be ≥ 0, got $m"))
-            n < 0 && throw(ArgumentError("number of columns (n) must be ≥ 0, got $n"))
-            new(Int(m), Int(n), colptr, rowval, nzval)
-        end
-    end
-    SparseArrays.getcolptr(M::SSparseMatrixCSC) = M.colptr
-    SparseArrays.rowvals(M::SSparseMatrixCSC) = M.rowval
-end # @static
+end
+SparseArrays.getcolptr(M::SSparseMatrixCSC) = M.colptr
+SparseArrays.rowvals(M::SSparseMatrixCSC) = M.rowval
 
 function SSparseMatrixCSC(
     m::Integer,

src/broadcast.jl

@@ -1,8 +1,3 @@
-@static if VERSION < v"1.2"
-    Base.size(bc::Broadcasted) = map(length, axes(bc))
-    Base.length(bc::Broadcasted) = prod(size(bc))
-end
-
 # patches
 LinearAlgebra.fzero(S::IMatrix) = zero(eltype(S))
 

src/conversions.jl

@@ -22,15 +22,6 @@ function SparseMatrixCSC(M::AbstractPermMatrix)
     SparseMatrixCSC(n, n, collect(1:n+1), MC.perm, MC.vals)
 end
 
-@static if VERSION < v"1.3-"
-
-    function SparseMatrixCSC(D::Diagonal{T}) where {T}
-        m = length(D.diag)
-        return SparseMatrixCSC(m, m, Vector(1:(m+1)), Vector(1:m), Vector{T}(D.diag))
-    end
-
-end
-
 SparseMatrixCSC{Tv,Ti}(M::AbstractPermMatrix{Tv,Ti}) where {Tv,Ti} = SparseMatrixCSC(M)
 SparseMatrixCSC(coo::SparseMatrixCOO) = sparse(coo.is, coo.js, coo.vs, coo.m, coo.n)
 

test/IMatrix.jl

@@ -52,12 +52,6 @@ end
     end
     @test imag(p1) == zeros(4, 4)
     @test p1' == Matrix(I, 4, 4)
-
-    # This will be lazy evaluated in 0.7+
-    @static if VERSION < v"0.7-"
-        @test typeof(p1') == typeof(p1)
-    end
-
     @test ishermitian(p1)
 end
 

test/PermMatrix.jl

@@ -13,6 +13,10 @@ sp = sprand(4, 4, 0.3)
 v = [0.5, 0.3im, 0.2, 1.0]
 
 @testset "basic" begin
+    @test_throws DimensionMismatch PermMatrix([1, 4, 2, 3], [0.1, 0.2, 0.4im])
+    @test_throws ArgumentError size(p1, 0)
+    @test size(p1, 3) == 1
+    @test [zip(findnz(p1)...)...] == [IterNz(p1)...]
     @test p1 == copy(p1)
     @test hash(p1) == hash(copy(p1))
     @test hash(p1) != hash(p2)

test/PermMatrixCSC.jl

@@ -13,6 +13,10 @@ sp = sprand(4, 4, 0.3)
 v = [0.5, 0.3im, 0.2, 1.0]
 
 @testset "basic" begin
+    @test_throws DimensionMismatch PermMatrixCSC([1, 4, 2, 3], [0.1, 0.2, 0.4im])
+    @test_throws ArgumentError size(p1, 0)
+    @test size(p1, 3) == 1
+    @test [zip(findnz(p1)...)...] == [IterNz(p1)...]
     @test p1 == copy(p1)
     @test hash(p1) == hash(copy(p1))
     @test hash(p1) != hash(p2)

test/staticize.jl

@@ -9,6 +9,7 @@ using StaticArrays: SVector, SMatrix
 Random.seed!(2)
 
 @testset "staticize" begin
+    @test staticize(1) == 1
     # permmatrix
     m = pmrand(ComplexF64, 4)
     sm = m |> staticize
@@ -24,6 +25,22 @@ Random.seed!(2)
     @test dm.perm == m.perm
     @test dm.vals == m.vals
 
+   # permmatrixcsc
+    m = pmcscrand(ComplexF64, 4)
+    println(m)
+    sm = m |> staticize
+    @test sm isa SPermMatrixCSC{4,ComplexF64}
+    @test sm.perm isa SVector
+    @test sm.vals isa SVector
+    @test sm.perm == m.perm
+    @test sm.vals == m.vals
+    dm = sm |> dynamicize
+    @test dm isa PermMatrixCSC{ComplexF64}
+    @test dm.perm isa Vector
+    @test dm.vals isa Vector
+    @test dm.perm == m.perm
+    @test dm.vals == m.vals
+
     # csc
     m = sprand(ComplexF64, 4, 4, 0.5)
     sm = m |> staticize