Reduce allocations in tests (#179)

* Reduce allocations in tests

* Reduce allocations further

Author: jishnub

test/test_bandedblockbanded.jl

@@ -256,7 +256,7 @@ import ArrayLayouts: RangeCumsum
         @test_throws BandError V[3,1] = 5
 
         view(V, band(0)) .= -3
-        @test all(A[Block(3,4)][band(0)] .== -3)
+        @test all(==(-3), A[Block(3,4)][band(0)])
 
         @test BandedMatrix(V) isa BandedMatrix{Int,Matrix{Int}}
         @test BandedMatrix{Float64}(V) isa BandedMatrix{Float64,Matrix{Float64}}
@@ -321,7 +321,7 @@ import ArrayLayouts: RangeCumsum
 
         x = randn(size(B,2))
         y = similar(x, size(B,1))
-        @test all((similar(y) .= MulAdd(B, x)) .=== (similar(y) .= MulAdd(V,x)))
+        @test (similar(y) .= MulAdd(B, x)) == (similar(y) .= MulAdd(V,x))
     end
 
     @testset "BLAS arithmetic" begin

test/test_blockbanded.jl

@@ -138,7 +138,7 @@ import BlockBandedMatrices: MemoryLayout, ColumnMajor, BroadcastStyle,
 
         x = randn(size(B,2))
         y = similar(x, size(B,1))
-        @test all((similar(y) .= MulAdd(B, x)) .=== (similar(y) .= MulAdd(V,x)))
+        @test (similar(y) .= MulAdd(B, x)) == (similar(y) .= MulAdd(V,x))
     end
 
     @testset "BlockBandedMatrix indexing" begin
@@ -195,7 +195,7 @@ import BlockBandedMatrices: MemoryLayout, ColumnMajor, BroadcastStyle,
         @test sum(A) == 20
         @test sum(B) == 20
         C = BlockBandedMatrix{Float64}(undef, [2,2], [2,2,2], (0,3))
-        @test all(mul!(C,A,B) .=== ArrayLayouts.materialize!(MulAdd(1.0,A,B,0.0,similar(C))) .=== A*B)
+        @test mul!(C,A,B) == ArrayLayouts.materialize!(MulAdd(1.0,A,B,0.0,similar(C))) == A*B
         AB = A*B
         @test AB isa BlockBandedMatrix
         @test Matrix(AB) ≈ Matrix(A)*Matrix(B)

test/test_blockskyline.jl

@@ -132,8 +132,8 @@ Random.seed!(0)
             expu = max.(u, bs.u)
 
             Cbs = C.block_sizes
-            @test all(Cbs.l .== expl)
-            @test all(Cbs.u .== expu)
+            @test Cbs.l == expl
+            @test Cbs.u == expu
         end
 
         for (l,u) = [([0,0,0,0],[0,0,0,0]),

test/test_linalg.jl

@@ -88,8 +88,8 @@ end
 
     C = BandedMatrix{Float64}(undef, size(V), 2 .*bandwidths(V))
     C .= MulAdd(V,V)
-    @test all(C .=== BandedMatrix(V)*BandedMatrix(V))
-    @test all(muladd!(2.0, V,V, 1.0, copy(C)) .=== BandedMatrices.gbmm!('N', 'N', 2.0, V, V, 1.0, deepcopy(C)))
+    @test C == BandedMatrix(V)*BandedMatrix(V)
+    @test muladd!(2.0, V,V, 1.0, copy(C)) == BandedMatrices.gbmm!('N', 'N', 2.0, V, V, 1.0, deepcopy(C))
 
     C = BandedBlockBandedMatrix{Float64}(undef, rows,cols, (2l,2u), (2λ,2μ))
     C .= MulAdd(A,A)

test/test_triblockbanded.jl

@@ -21,29 +21,29 @@ import BlockArrays: BlockedUnitRange, blockisequal
         @test MemoryLayout(typeof(U)) == TriangularLayout{'U','N',BandedBlockBandedColumnMajor}()
         b = randn(size(U,1))
         @test U*b isa Vector{Float64}
-        @test all(lmul(U,b) .=== U*b)
+        @test lmul(U,b) == U*b
         @test U*b  ≈ Matrix(U)*b
 
         U = UnitUpperTriangular(A)
         @test MemoryLayout(typeof(U)) == TriangularLayout{'U','U',BandedBlockBandedColumnMajor}()
         b = randn(size(U,1))
         @test U*b isa Vector{Float64}
-        @test all(lmul(U,b) .=== U*b)
+        @test lmul(U,b) == U*b
         @test U*b  ≈ Matrix(U)*b
 
         L = LowerTriangular(A)
         @test MemoryLayout(typeof(L)) == TriangularLayout{'L','N',BandedBlockBandedColumnMajor}()
         b = randn(size(U,1))
         @test L*b isa Vector{Float64}
-        @test all(lmul(L,b) .=== L*b)
+        @test lmul(L,b) == L*b
         @test L*b  ≈ Matrix(L)*b
 
 
         L = UnitLowerTriangular(A)
         @test MemoryLayout(typeof(L)) == TriangularLayout{'L','U',BandedBlockBandedColumnMajor}()
         b = randn(size(L,1))
         @test L*b isa Vector{Float64}
-        @test all(lmul(L,b) .=== L*b)
+        @test lmul(L,b) == L*b
         @test L*b  ≈ Matrix(L)*b
     end
 
@@ -80,17 +80,17 @@ import BlockArrays: BlockedUnitRange, blockisequal
         U = UpperTriangular(A)
         b = randn(size(U,1))
         @test copyto!(similar(b), Ldiv(U,b)) ≈ Matrix(U) \ b
-        @test all((similar(b) .= Ldiv(U, b)) .=== copyto!(similar(b), Ldiv(U,b)))
+        @test (similar(b) .= Ldiv(U, b)) == copyto!(similar(b), Ldiv(U,b))
 
         U = UnitUpperTriangular(A)
         b = randn(size(U,1))
         @test copyto!(similar(b), Ldiv(U,b)) ≈ (Matrix(U) \ b)
-        @test all((similar(b) .= Ldiv(U, b)) .=== copyto!(similar(b), Ldiv(U,b)))
+        @test (similar(b) .= Ldiv(U, b)) == copyto!(similar(b), Ldiv(U,b))
 
         L = LowerTriangular(A)
         b = randn(size(L,1))
         @test copyto!(similar(b), Ldiv(L,b)) ≈ (Matrix(L) \ b)
-        @test all((similar(b) .= Ldiv(L, b)) .=== copyto!(similar(b), Ldiv(L,b)))
+        @test (similar(b) .= Ldiv(L, b)) == copyto!(similar(b), Ldiv(L,b))
     end
 
     @testset "Rectangular blocks BlockBandedMatrix linear algebra" begin
@@ -105,7 +105,7 @@ import BlockArrays: BlockedUnitRange, blockisequal
 
         V = view(A, Block.(1:3), Block.(1:4))
         @test blockisequal(axes(V), axes(A))
-        @test all(Matrix(V) .=== Matrix(A))
+        @test Matrix(V) == Matrix(A)
         @test view(V, Block(2)[1:2], Block(3)) ≡ view(A, Block(2)[1:2], Block(3))
 
         @test similar(Ldiv(UpperTriangular(A), b)) isa PseudoBlockVector
@@ -145,7 +145,7 @@ import BlockArrays: BlockedUnitRange, blockisequal
         r = UpperTriangular(Matrix(V)) \ b
         @test_broken BlockBandedMatrices.blockbanded_squareblocks_trtrs!(V, copy(b)) ≈ r
 
-        @test_broken all(ldiv!(UpperTriangular(V), copy(b)) .=== BlockBandedMatrices.blockbanded_squareblocks_trtrs!(V, copy(b)))
+        @test_broken ldiv!(UpperTriangular(V), copy(b)) == BlockBandedMatrices.blockbanded_squareblocks_trtrs!(V, copy(b))
 
         V = view(A, Block.(2:3), Block(3))
         @test unsafe_load(pointer(V)) == A[2,4]
@@ -155,8 +155,8 @@ import BlockArrays: BlockedUnitRange, blockisequal
         @test size(V) == (5,3)
         b = randn(size(V,2))
 
-        @test all((similar(b,size(V,1)) .= MulAdd(V,b)) .=== Matrix(V)*b .===
-                    BLAS.gemv!('N', 1.0, V, b, 0.0, Vector{Float64}(undef, size(V,1))))
+        @test (similar(b,size(V,1)) .= MulAdd(V,b)) == Matrix(V)*b ==
+                    BLAS.gemv!('N', 1.0, V, b, 0.0, Vector{Float64}(undef, size(V,1)))
 
         V = view(A, Block.(1:3), Block(3)[2:3])
         @test_throws ArgumentError pointer(V)
@@ -172,8 +172,8 @@ import BlockArrays: BlockedUnitRange, blockisequal
 
         @test size(V) == (5,2)
         b = randn(size(V,2))
-        @test all((similar(b,size(V,1)) .= MulAdd(V,b)) .=== Matrix(V)*b .===
-                    BLAS.gemv!('N', 1.0, V, b, 0.0, Vector{Float64}(undef, size(V,1))))
+        @test (similar(b,size(V,1)) .= MulAdd(V,b)) == Matrix(V)*b ==
+                    BLAS.gemv!('N', 1.0, V, b, 0.0, Vector{Float64}(undef, size(V,1)))
 
         V = view(A, Block.(1:3), Block(3)[2:3])
         @test_throws ArgumentError pointer(V)
@@ -190,18 +190,18 @@ import BlockArrays: BlockedUnitRange, blockisequal
         @test unsafe_load(pointer(V_22)) == V_22[1,1] == V[1,1]
         @test strides(V_22) == strides(V) == (1,9)
         b = randn(N)
-        @test all(copyto!(similar(b) , MulAdd(V,b)) .=== copyto!(similar(b) , MulAdd(V_22,b)) .===
-            Matrix(V)*b .===
-            BLAS.gemv!('N', 1.0, V, b, 0.0, Vector{Float64}(undef, size(V,1))))
+        @test copyto!(similar(b) , MulAdd(V,b)) == copyto!(similar(b) , MulAdd(V_22,b)) ==
+            Matrix(V)*b ==
+            BLAS.gemv!('N', 1.0, V, b, 0.0, Vector{Float64}(undef, size(V,1)))
 
-        @test_skip all(UpperTriangular(V_22) \ b .=== ldiv!(UpperTriangular(V_22) , copy(b)) .=== ldiv!(UpperTriangular(V) , copy(b)) .===
-            ldiv!(UpperTriangular(Matrix(V_22)) , copy(b)))
+        @test_skip UpperTriangular(V_22) \ b == ldiv!(UpperTriangular(V_22) , copy(b)) == ldiv!(UpperTriangular(V) , copy(b)) ==
+            ldiv!(UpperTriangular(Matrix(V_22)) , copy(b))
 
         V = view(A, Block.(rows), Block.(cols))
         V2 = view(A, 1:size(A,1), 1:size(A,2))
         b = randn(size(V,1))
 
-        @test all(Matrix(V) .=== Matrix(V2))
+        @test Matrix(V) == Matrix(V2)
         @test UpperTriangular(V2) \ b ≈ UpperTriangular(V) \ b
     end
 end