add/fix tests

Author: rokke-git

docs/src/index.md

@@ -113,8 +113,11 @@ julia> I = [1, 4, 3, 5]; J = [4, 7, 18, 9]; V = [1, 2, -5, 3];
 
 julia> S = sparse(I,J,V)
 5×18 SparseMatrixCSC{Int64, Int64} with 4 stored entries:
-⎡⠀⠈⠀⠀⠀⠀⠀⠀⢀⎤
-⎣⠀⠀⠀⠂⡀⠀⠀⠀⠀⎦
+ ⋅  ⋅  ⋅  1  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅   ⋅
+ ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅   ⋅
+ ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  -5
+ ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  2  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅   ⋅
+ ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  3  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅  ⋅   ⋅
 
 julia> R = sparsevec(I,V)
 5-element SparseVector{Int64, Int64} with 4 stored entries:

src/linalg.jl

@@ -2094,19 +2094,19 @@ julia> A[4:4:8] .= 1;
 
 julia> A
 3×3 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
-  ⋅   1.0   ⋅
-  ⋅    ⋅   1.0
-  ⋅    ⋅    ⋅
+ ⋅  1.0   ⋅
+ ⋅   ⋅   1.0
+ ⋅   ⋅    ⋅
 
 julia> C = spzeros(3,3);
 
 julia> C[2:4:6] .= 2;
 
 julia> C
 3×3 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
-  ⋅    ⋅    ⋅
- 2.0   ⋅    ⋅
-  ⋅   2.0   ⋅
+  ⋅    ⋅   ⋅
+ 2.0   ⋅   ⋅
+  ⋅   2.0  ⋅
 
 julia> SparseArrays.mergeinds!(C, A)
 3×3 SparseMatrixCSC{Float64, Int64} with 4 stored entries:

src/solvers/spqr.jl

@@ -192,8 +192,8 @@ Q factor:
 4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
 R factor:
 2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
- -1.41421    ⋅
-   ⋅       -1.41421
+ -1.41421      ⋅
+     ⋅     -1.41421
 Row permutation:
 4-element Vector{Int64}:
  1
@@ -471,10 +471,10 @@ when the problem is underdetermined.
 ```jldoctest
 julia> A = sparse([1,2,4], [1,1,1], [1.0,1.0,1.0], 4, 2)
 4×2 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
- 1.0   ⋅
- 1.0   ⋅
-  ⋅    ⋅
- 1.0   ⋅
+ 1.0  ⋅
+ 1.0  ⋅
+  ⋅   ⋅
+ 1.0  ⋅
 
 julia> qr(A)\\fill(1.0, 4)
 2-element Vector{Float64}:

src/sparsematrix.jl

@@ -360,7 +360,7 @@ function Base.show(io::IO, ::MIME"text/plain", S::AbstractSparseMatrixCSCInclAdj
     show_circular(io, S) && return
     io = IOContext(io, :compact=>true, :typeinfo=>eltype(S), :SHOWN_SET=>S)
 
-    if (screen[1] < size(S, 1) + 4) | (screen[2] < 3size(S, 2))
+    if (screen[1] < size(S, 1) + 5) | (screen[2] < 3size(S, 2))
         _show_with_braille_patterns(io, S)
     else
         _show_with_dotted_zeros(io, S)
@@ -410,12 +410,6 @@ end
 
 const brailleBlocks = UInt16['⠁', '⠂', '⠄', '⡀', '⠈', '⠐', '⠠', '⢀']
 function _show_with_braille_patterns(io::IO, S::AbstractSparseMatrixCSCInclAdjointAndTranspose)
-    try
-        zero(eltype(S))
-    catch
-        printstyled(io, "WARNING: could not find generic zero for given elements. expect errors and wrong results\n", color=:red)
-    end
-
     m, n = size(S)
     (m == 0 || n == 0) && return show(io, MIME("text/plain"), S)
 
@@ -424,6 +418,13 @@ function _show_with_braille_patterns(io::IO, S::AbstractSparseMatrixCSCInclAdjoi
     maxHeight = displaysize(io)[1] - 4 # -4 from [Prompt, header, newline after elements, new prompt]
     maxWidth = displaysize(io)[2] - 2 # -2 from brackets
 
+    try
+        zero(eltype(S))
+    catch
+        printstyled(stderr, "WARNING: could not find generic zero for given elements. expect errors and wrong results\n", color=:red)
+        maxHeight = maxHeight - 1
+    end
+
     # In the process of generating the braille pattern to display the nonzero
     # structure of `S`, we need to be able to scale the matrix `S` to a
     # smaller matrix with the same aspect ratio as `S`, but fits on the
@@ -511,14 +512,14 @@ function _show_with_dotted_zeros(io::IO, S::AbstractSparseMatrixCSCInclAdjointAn
     rows, cols, vals = rowvals(parent(S)), ColumnIndices(parent(S)), nonzeros(parent(S))
     (S isa Adjoint) | (S isa Transpose) && ((rows, cols) = (cols, rows))
 
-    align = [alignment(io, val) for val in vals]
+    align = [isassigned(vals, val) ? alignment(io, vals[val]) : (3, 3) for val in eachindex(vals)]
     colwidths = [max.((0, 0), align[findall(==(col), cols)]...) for col in axes(S,2)]
     displaysize(io)[2] < sum(sum.(colwidths) .+ 2) && return _show_with_braille_patterns(io, S)
 
     try
         zero(eltype(S))
     catch
-        printstyled(io, "WARNING: could not find generic zero for given elements. expect errors and wrong results\n", color=:red)
+        printstyled(stderr, "WARNING: could not find generic zero for given elements. expect errors and wrong results\n", color=:red)
     end
 
     for row in axes(S,1)
@@ -531,7 +532,9 @@ function _show_with_dotted_zeros(io::IO, S::AbstractSparseMatrixCSCInclAdjointAn
                 print(io, " "^l * "⋅" * (col==axes(S,2)[end] ? "" : " "^r))
             else
                 l, r = (l+1, r+1) .- align[index][]
-                print(io, " "^l, vals[index][], (col==axes(S,2)[end] ? "" : " "^r))
+                print(io, " "^l)
+                show(io, isassigned(vals, index[]) ? vals[index][] : "#undef")
+                col == axes(S,2)[end] || print(io, " "^r)
             end
         end
         row == axes(S,1)[end] || println(io)
@@ -1954,9 +1957,9 @@ julia> A = sparse([1, 2, 3], [1, 2, 3], [1.0, 0.0, 1.0])
 
 julia> dropzeros(A)
 3×3 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
- 1.0   ⋅    ⋅
-  ⋅    ⋅    ⋅
-  ⋅    ⋅   1.0
+ 1.0  ⋅   ⋅
+  ⋅   ⋅   ⋅
+  ⋅   ⋅  1.0
 ```
 """
 dropzeros(A::AbstractSparseMatrixCSC) = dropzeros!(copy(A))
@@ -2126,7 +2129,7 @@ argument specifies a random number generator, see [Random Numbers](@ref).
 ```jldoctest; setup = :(using Random; Random.seed!(0))
 julia> sprandn(2, 2, 0.75)
 2×2 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
- -1.20577     ⋅
+ -1.20577       ⋅
   0.311817  -0.234641
 ```
 """
@@ -2153,9 +2156,9 @@ specified.
 ```jldoctest
 julia> spzeros(3, 3)
 3×3 SparseMatrixCSC{Float64, Int64} with 0 stored entries:
-  ⋅    ⋅    ⋅
-  ⋅    ⋅    ⋅
-  ⋅    ⋅    ⋅
+ ⋅  ⋅  ⋅
+ ⋅  ⋅  ⋅
+ ⋅  ⋅  ⋅
 
 julia> spzeros(Float32, 4)
 4-element SparseVector{Float32, Int64} with 0 stored entries

test/issues.jl

@@ -758,14 +758,14 @@ let
     B = similar(A, T12960)
     @test repr(B) == "sparse([1, 2, 3], [1, 2, 3], $T12960[#undef, #undef, #undef], 3, 3)"
     @test occursin(
-        "\n #undef             ⋅            ⋅    \n       ⋅      #undef             ⋅    \n       ⋅            ⋅      #undef",
+        " #undef     ⋅       ⋅\n    ⋅    #undef     ⋅\n    ⋅       ⋅    #undef",
         repr(MIME("text/plain"), B),
     )
 
     B[1,2] = T12960()
     @test repr(B)  == "sparse([1, 1, 2, 3], [1, 2, 2, 3], $T12960[#undef, $T12960(), #undef, #undef], 3, 3)"
     @test occursin(
-        "\n #undef          T12960()        ⋅    \n       ⋅      #undef             ⋅    \n       ⋅            ⋅      #undef",
+        "\n #undef     T12960()     ⋅\n    ⋅    #undef          ⋅\n    ⋅         ⋅       #undef",
         repr(MIME("text/plain"), B),
     )
 end
@@ -805,6 +805,15 @@ end
                        7 16 4])
 end
 
+@testset "Issue #512" begin # suppresses but does not fix the error mentioned
+    x = sparse([1, 1, 3], [1, 4, 3], [20, 0, [2]])
+    @test_warn "WARNING: could not find generic zero" repr(MIME("text/plain"), x)
+    x = sparse([1, 100, 3], [1, 4, 300], [20, 0, [2]])
+    @test_warn "WARNING: could not find generic zero" repr(MIME("text/plain"), x)
+
+    @test_broken repr(MIME("text/plain"), transpose(x'))
+end
+
 @testset "Issue #574" begin
     a = spzeros(Float32, Int16, 2, 3)
     v = spzeros(Float32, Int16, 2)

test/sparsematrix_constructors_indexing.jl

@@ -1514,9 +1514,9 @@ end
     A = spzeros(Float32, Int64, 2, 2)
     for (transform, showstring) in zip(
         (identity, adjoint, transpose), (
-        "2×2 $SparseMatrixCSC{Float32, Int64} with 0 stored entries:\n  ⋅    ⋅ \n  ⋅    ⋅ ",
-        "2×2 $Adjoint{Float32, $SparseMatrixCSC{Float32, Int64}} with 0 stored entries:\n  ⋅    ⋅ \n  ⋅    ⋅ ",
-        "2×2 $Transpose{Float32, $SparseMatrixCSC{Float32, Int64}} with 0 stored entries:\n  ⋅    ⋅ \n  ⋅    ⋅ ",
+        "2×2 $SparseMatrixCSC{Float32, Int64} with 0 stored entries:\n ⋅  ⋅\n ⋅  ⋅",
+        "2×2 $Adjoint{Float32, $SparseMatrixCSC{Float32, Int64}} with 0 stored entries:\n ⋅  ⋅\n ⋅  ⋅",
+        "2×2 $Transpose{Float32, $SparseMatrixCSC{Float32, Int64}} with 0 stored entries:\n ⋅  ⋅\n ⋅  ⋅",
         ))
         show(io, MIME"text/plain"(), transform(A))
         @test String(take!(io)) == showstring