Set up libs/*/test/runtests.jl

Tokazama · Tokazama · commit 12afe43a4e9f · 2022-05-10T14:20:44.000-04:00
diff --git a/libs/ArrayInterfaceBandedMatrices/Project.toml b/libs/ArrayInterfaceBandedMatrices/Project.toml
@@ -9,4 +9,12 @@ BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
 [compat]
 ArrayInterfaceCore = "0.1"
 BandedMatrices = "0.17"
+julia = "1.6"
 
+[extras]
+ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
+BandedMatrices = "aae01518-5342-5314-be14-df237901396f"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["ArrayInterfaceCore","BandedMatrices","Test"]
diff --git a/libs/ArrayInterfaceBandedMatrices/test/runtests.jl b/libs/ArrayInterfaceBandedMatrices/test/runtests.jl
@@ -0,0 +1,20 @@
+
+using ArrayInterfaceCore
+using ArrayInterfaceBandedMatrices
+using BandedMatrices
+using Test
+
+B=BandedMatrix(Ones(5,5), (-1,2))
+B[band(1)].=[1,2,3,4]
+B[band(2)].=[5,6,7]
+@test ArrayInterfaceCore.has_sparsestruct(B)
+rowind,colind=ArrayInterfaceCore.findstructralnz(B)
+@test [B[rowind[i],colind[i]] for i in 1:length(rowind)]==[5,6,7,1,2,3,4]
+B=BandedMatrix(Ones(4,6), (-1,2))
+B[band(1)].=[1,2,3,4]
+B[band(2)].=[5,6,7,8]
+rowind,colind=ArrayInterfaceCore.findstructralnz(B)
+@test [B[rowind[i],colind[i]] for i in 1:length(rowind)]==[5,6,7,8,1,2,3,4]
+@test ArrayInterfaceCore.isstructured(typeof(B))
+@test ArrayInterfaceCore.fast_matrix_colors(typeof(B))
+
diff --git a/libs/ArrayInterfaceBlockBandedMatrices/Project.toml b/libs/ArrayInterfaceBlockBandedMatrices/Project.toml
@@ -5,11 +5,22 @@ version = "0.1.0"
 
 [deps]
 ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
-BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"
+ArrayInterfaceBandedMatrices = "2e50d22c-5be1-4042-81b1-c572ed69783d"
 BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
+BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"
 
 [compat]
 ArrayInterfaceCore = "0.1"
+ArrayInterfaceBandedMatrices = "0.1"
 BlockBandedMatrices = "0.11"
 BlockArrays = "0.16"
+julia = "1.6"
+
+[extras]
+ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
+BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
+BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
+[targets]
+test = ["ArrayInterfaceCore","BlockArrays","BlockBandedMatrices","Test"]
diff --git a/libs/ArrayInterfaceBlockBandedMatrices/src/ArrayInterfaceBlockBandedMatrices.jl b/libs/ArrayInterfaceBlockBandedMatrices/src/ArrayInterfaceBlockBandedMatrices.jl
@@ -1,10 +1,11 @@
 module ArrayInterfaceBlockBandedMatrices
 
 using ArrayInterfaceCore
+using ArrayInterfaceBandedMatrices
 using BlockArrays
 using BlockBandedMatrices
 
-struct BlockBandedMatrixIndex <: MatrixIndex
+struct BlockBandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
     count::Int
     refinds::Array{Int,1}
     refcoords::Array{Int,1}# storing col or row inds at ref points
@@ -14,8 +15,8 @@ Base.firstindex(i::BlockBandedMatrixIndex) = 1
 Base.lastindex(i::BlockBandedMatrixIndex) = i.count
 Base.length(i::BlockBandedMatrixIndex) = lastindex(i)
 function BlockBandedMatrixIndex(nrowblock, ncolblock, rowsizes, colsizes, l, u)
-    blockrowind = BandedMatrixIndex(nrowblock, ncolblock, l, u, true)
-    blockcolind = BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
+    blockrowind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, true)
+    blockcolind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
     sortedinds = sort(
         [(blockrowind[i], blockcolind[i]) for i = 1:length(blockrowind)],
         by = x -> x[1],
@@ -95,11 +96,11 @@ function ArrayInterfaceCore.findstructralnz(x::BlockBandedMatrices.BlockBandedMa
         u,
     )
 end
-struct BandedBlockBandedMatrixIndex <: MatrixIndex
+struct BandedBlockBandedMatrixIndex <: ArrayInterfaceCore.MatrixIndex
     count::Int
     refinds::Array{Int,1}
     refcoords::Array{Int,1}# storing col or row inds at ref points
-    reflocalinds::Array{BandedMatrixIndex,1}
+    reflocalinds::Array{ArrayInterfaceBandedMatrices.BandedMatrixIndex,1}
     isrow::Bool
 end
 Base.firstindex(i::BandedBlockBandedMatrixIndex) = 1
@@ -127,8 +128,8 @@ function BandedBlockBandedMatrixIndex(
     lambda,
     mu,
 )
-    blockrowind = BandedMatrixIndex(nrowblock, ncolblock, l, u, true)
-    blockcolind = BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
+    blockrowind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, true)
+    blockcolind = ArrayInterfaceBandedMatrices.BandedMatrixIndex(nrowblock, ncolblock, l, u, false)
     sortedinds = sort(
         [(blockrowind[i], blockcolind[i]) for i = 1:length(blockrowind)],
         by = x -> x[1],
@@ -142,14 +143,14 @@ function BandedBlockBandedMatrixIndex(
     refinds = Array{Int,1}()
     refrowcoords = Array{Int,1}()
     refcolcoords = Array{Int,1}()
-    reflocalrowinds = Array{BandedMatrixIndex,1}()
-    reflocalcolinds = Array{BandedMatrixIndex,1}()
+    reflocalrowinds = Array{ArrayInterfaceBandedMatrices.BandedMatrixIndex,1}()
+    reflocalcolinds = Array{ArrayInterfaceBandedMatrices.BandedMatrixIndex,1}()
     for ind in sortedinds
         rowind, colind = ind
         localrowind =
-            BandedMatrixIndex(rowsizes[rowind], colsizes[colind], lambda, mu, true)
+            ArrayInterfaceBandedMatrices.BandedMatrixIndex(rowsizes[rowind], colsizes[colind], lambda, mu, true)
         localcolind =
-            BandedMatrixIndex(rowsizes[rowind], colsizes[colind], lambda, mu, false)
+            ArrayInterfaceBandedMatrices.BandedMatrixIndex(rowsizes[rowind], colsizes[colind], lambda, mu, false)
         push!(refinds, currenti)
         push!(refrowcoords, rowheights[rowind])
         push!(refcolcoords, colwidths[colind])
diff --git a/libs/ArrayInterfaceBlockBandedMatrices/test/runtests.jl b/libs/ArrayInterfaceBlockBandedMatrices/test/runtests.jl
@@ -0,0 +1,32 @@
+
+using ArrayInterfaceBlockBandedMatrices
+using ArrayInterfaceCore
+using BlockBandedMatrices
+using Test
+
+BB=BlockBandedMatrix(Ones(10,10),[1,2,3,4],[4,3,2,1],(1,0))
+BB[Block(1,1)].=[1 2 3 4]
+BB[Block(2,1)].=[5 6 7 8;9 10 11 12]
+rowind,colind=ArrayInterfaceCore.findstructralnz(BB)
+@test [BB[rowind[i],colind[i]] for i in 1:length(rowind)]==
+    [1,5,9,2,6,10,3,7,11,4,8,12,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    1,1,1,1,1]
+@test ArrayInterfaceCore.isstructured(typeof(BB))
+@test ArrayInterfaceCore.has_sparsestruct(typeof(BB))
+@test ArrayInterfaceCore.fast_matrix_colors(typeof(BB))
+
+dense=collect(Ones(8,8))
+for i in 1:8
+    dense[:,i].=[1,2,3,4,5,6,7,8]
+end
+BBB=BandedBlockBandedMatrix(dense, [4, 4] ,[4, 4], (1, 1), (1, 1))
+rowind,colind=ArrayInterfaceCore.findstructralnz(BBB)
+@test [BBB[rowind[i],colind[i]] for i in 1:length(rowind)]==
+    [1,2,3,1,2,3,4,2,3,4,5,6,7,5,6,7,8,6,7,8,
+     1,2,3,1,2,3,4,2,3,4,5,6,7,5,6,7,8,6,7,8]
+@test ArrayInterfaceCore.isstructured(typeof(BBB))
+@test ArrayInterfaceCore.has_sparsestruct(typeof(BBB))
+@test ArrayInterfaceCore.fast_matrix_colors(typeof(BBB))
+
diff --git a/libs/ArrayInterfaceCUDA/Project.toml b/libs/ArrayInterfaceCUDA/Project.toml
@@ -11,6 +11,6 @@ CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 [compat]
 Adapt = "3"
 ArrayInterfaceCore = "0.1"
-CUDA = "3"
+CUDA = "3.9"
 julia = "1.6"
 
diff --git a/libs/ArrayInterfaceCore/Project.toml b/libs/ArrayInterfaceCore/Project.toml
@@ -15,4 +15,4 @@ SuiteSparse = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
 Compat = "3.37"
 IfElse = "0.1"
 Static = "0.6"
-julia = "1.2"
+julia = "1.6"
diff --git a/libs/ArrayInterfaceCuArrays/Project.toml b/libs/ArrayInterfaceCuArrays/Project.toml
@@ -10,6 +10,6 @@ CuArrays = "3a865a2d-5b23-5a0f-bc46-62713ec82fae"
 [compat]
 Adapt = "3"
 ArrayInterfaceCore = "0.1"
-CuArrays = "2"
+CuArrays = "2.2"
 julia = "1.6"
 
diff --git a/libs/ArrayInterfaceOffsetArrays/Project.toml b/libs/ArrayInterfaceOffsetArrays/Project.toml
@@ -4,11 +4,20 @@ version = "0.1.0"
 
 [deps]
 ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
-Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
 
 [compat]
 ArrayInterfaceCore = "0.1"
 OffsetArrays = "1.11"
 Static = "0.6"
 julia = "1.6"
+
+[extras]
+ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["ArrayInterfaceCore","OffsetArrays","Static","Test"]
diff --git a/libs/ArrayInterfaceOffsetArrays/test/runtests.jl b/libs/ArrayInterfaceOffsetArrays/test/runtests.jl
@@ -0,0 +1,28 @@
+
+using ArrayInterfaceCore
+using ArrayInterfaceOffsetArrays
+using OffsetArrays
+using Static
+using Test
+
+A = zeros(3, 4, 5);
+O = OffsetArray(A, 3, 7, 10);
+Op = PermutedDimsArray(O,(3,1,2));
+@test @inferred(ArrayInterfaceCore.offsets(O)) === (4, 8, 11)
+@test @inferred(ArrayInterfaceCore.offsets(Op)) === (11, 4, 8)
+
+@test @inferred(ArrayInterfaceCore.offsets((1,2,3))) === (StaticInt(1),)
+o = OffsetArray(vec(A), 8);
+@test @inferred(ArrayInterfaceCore.offset1(o)) === 9
+
+@test @inferred(ArrayInterfaceCore.device(OffsetArray(view(PermutedDimsArray(A, (3,1,2)), 1, :, 2:4)', 3, -173))) === ArrayInterfaceCore.CPUPointer()
+@test @inferred(ArrayInterfaceCore.device(view(OffsetArray(A,2,3,-12), 4, :, -11:-9))) === ArrayInterfaceCore.CPUPointer()
+@test @inferred(ArrayInterfaceCore.device(view(OffsetArray(A,2,3,-12), 3, :, [-11,-10,-9])')) === ArrayInterfaceCore.CPUIndex()
+
+@test @inferred(ArrayInterfaceCore.indices(OffsetArray(view(PermutedDimsArray(A, (3,1,2)), 1, :, 2:4)', 3, -173),1)) === Base.Slice(ArrayInterfaceCore.OptionallyStaticUnitRange(4,6))
+@test @inferred(ArrayInterfaceCore.indices(OffsetArray(view(PermutedDimsArray(A, (3,1,2)), 1, :, 2:4)', 3, -173),2)) === Base.Slice(ArrayInterfaceCore.OptionallyStaticUnitRange(-172,-170))
+
+@test @inferred(ArrayInterfaceCore.device(OffsetArray(1:10))) === ArrayInterfaceCore.CPUIndex()
+@test @inferred(ArrayInterfaceCore.device(OffsetArray(@view(reshape(1:8, 2,2,2)[1,1:2,:]),-3,4))) === ArrayInterfaceCore.CPUIndex()
+@test @inferred(ArrayInterfaceCore.device(OffsetArray(zeros(2,2,2),8,-2,-5))) === ArrayInterfaceCore.CPUPointer()
+
diff --git a/libs/ArrayInterfaceStaticArrays/Project.toml b/libs/ArrayInterfaceStaticArrays/Project.toml
@@ -6,12 +6,23 @@ version = "0.1.0"
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
 ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
 Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
 Adapt = "3"
 ArrayInterfaceCore = "0.1"
 Static = "0.6"
-StaticArrays = "1.2.5, 1.3"
+StaticArrays = "1.2.5, 1.3, 1.4"
 julia = "1.6"
 
+
+[extras]
+ArrayInterfaceCore = "30b0a656-2188-435a-8636-2ec0e6a096e2"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["ArrayInterfaceCore","LinearAlgebra","Static","StaticArrays","Test"]
diff --git a/libs/ArrayInterfaceStaticArrays/src/ArrayInterfaceStaticArrays.jl b/libs/ArrayInterfaceStaticArrays/src/ArrayInterfaceStaticArrays.jl
@@ -2,6 +2,7 @@ module ArrayInterfaceStaticArrays
 
 using Adapt
 using ArrayInterfaceCore
+using LinearAlgebra
 using StaticArrays
 using Static
 
@@ -29,7 +30,9 @@ ArrayInterfaceCore.known_first(::Type{<:StaticArrays.SOneTo}) = 1
 ArrayInterfaceCore.known_last(::Type{StaticArrays.SOneTo{N}}) where {N} = N
 ArrayInterfaceCore.known_length(::Type{StaticArrays.SOneTo{N}}) where {N} = N
 ArrayInterfaceCore.known_length(::Type{StaticArrays.Length{L}}) where {L} = L
-ArrayInterfaceCore.known_length(::Type{A}) where {A <: StaticArrays.StaticArray} = known_length(StaticArrays.Length(A))
+function ArrayInterfaceCore.known_length(::Type{A}) where {A <: StaticArrays.StaticArray}
+    ArrayInterfaceCore.known_length(StaticArrays.Length(A))
+end
 
 ArrayInterfaceCore.device(::Type{<:StaticArrays.MArray}) = ArrayInterfaceCore.CPUPointer()
 ArrayInterfaceCore.device(::Type{<:StaticArrays.SArray}) = ArrayInterfaceCore.CPUTuple()
@@ -63,7 +66,7 @@ end
     return t
 end
 if StaticArrays.SizedArray{Tuple{8,8},Float64,2,2} isa UnionAll
-    @inline ArrayInterfaceCore.strides(B::StaticArrays.SizedArray{S,T,M,N,A}) where {S,T,M,N,A<:SubArray} = strides(B.data)
+    @inline ArrayInterfaceCore.strides(B::StaticArrays.SizedArray{S,T,M,N,A}) where {S,T,M,N,A<:SubArray} = ArrayInterfaceCore.strides(B.data)
     ArrayInterfaceCore.parent_type(::Type{<:StaticArrays.SizedArray{S,T,M,N,A}}) where {S,T,M,N,A} = A
 else
     ArrayInterfaceCore.parent_type(::Type{<:StaticArrays.SizedArray{S,T,M,N}}) where {S,T,M,N} = Array{T,N}
diff --git a/libs/ArrayInterfaceStaticArrays/test/runtests.jl b/libs/ArrayInterfaceStaticArrays/test/runtests.jl
@@ -0,0 +1,64 @@
+using ArrayInterfaceCore
+using ArrayInterfaceStaticArrays
+using LinearAlgebra
+using StaticArrays
+using Static
+using Test
+
+x = @SVector [1,2,3]
+@test ArrayInterfaceCore.ismutable(x) == false
+@test ArrayInterfaceCore.ismutable(view(x, 1:2)) == false
+@test ArrayInterfaceCore.can_setindex(typeof(x)) == false
+@test ArrayInterfaceCore.buffer(x) == x.data
+@test @inferred(ArrayInterfaceCore.device(typeof(x))) === ArrayInterfaceCore.CPUTuple()
+
+x = @MVector [1,2,3]
+@test ArrayInterfaceCore.ismutable(x) == true
+@test ArrayInterfaceCore.ismutable(view(x, 1:2)) == true
+@test @inferred(ArrayInterfaceCore.device(typeof(x))) === ArrayInterfaceCore.CPUPointer()
+
+A = @SMatrix(randn(5, 5))
+@test ArrayInterfaceCore.lu_instance(A) isa typeof(lu(A))
+A = @MMatrix(randn(5, 5))
+@test ArrayInterfaceCore.lu_instance(A) isa typeof(lu(A))
+
+@test isone(ArrayInterfaceCore.known_first(typeof(StaticArrays.SOneTo(7))))
+@test ArrayInterfaceCore.known_last(typeof(StaticArrays.SOneTo(7))) == 7
+@test ArrayInterfaceCore.known_length(typeof(StaticArrays.SOneTo(7))) == 7
+
+@test ArrayInterfaceCore.parent_type(SizedVector{1, Int, Vector{Int}}) <: Vector{Int}
+@test ArrayInterfaceCore.known_length(@inferred(ArrayInterfaceCore.indices(SOneTo(7)))) == 7
+
+x = view(SArray{Tuple{3,3,3}}(ones(3,3,3)), :, SOneTo(2), 2)
+@test @inferred(ArrayInterfaceCore.known_length(x)) == 6
+@test @inferred(ArrayInterfaceCore.known_length(x')) == 6
+
+v = @SVector rand(8);
+A = @MMatrix rand(7, 6);
+T = SizedArray{Tuple{5,4,3}}(zeros(5,4,3));
+@test @inferred(ArrayInterfaceCore.length(v)) === StaticInt(8)
+@test @inferred(ArrayInterfaceCore.length(A)) === StaticInt(42)
+@test @inferred(ArrayInterfaceCore.length(T)) === StaticInt(60)
+
+x = @SMatrix rand(Float32, 2, 2)
+y = @SVector rand(4)
+yr = ArrayInterfaceCore.restructure(x, y)
+@test yr isa SMatrix{2, 2}
+@test Base.size(yr) == (2,2)
+@test vec(yr) == vec(y)
+z = rand(4)
+zr = ArrayInterfaceCore.restructure(x, z)
+@test zr isa SMatrix{2, 2}
+@test Base.size(zr) == (2,2)
+@test vec(zr) == vec(z)
+
+Am = @MMatrix rand(2,10);
+@test @inferred(ArrayInterfaceCore.strides(view(Am,1,:))) === (StaticInt(2),)
+
+@test @inferred(ArrayInterfaceCore.contiguous_axis(@SArray(zeros(2,2,2)))) === ArrayInterfaceCore.StaticInt(1)
+@test @inferred(ArrayInterfaceCore.contiguous_axis_indicator(@SArray(zeros(2,2,2)))) == (true,false,false)
+@test @inferred(ArrayInterfaceCore.contiguous_batch_size(@SArray(zeros(2,2,2)))) === ArrayInterfaceCore.StaticInt(0)
+@test @inferred(ArrayInterfaceCore.stride_rank(@SArray(zeros(2,2,2)))) == (1, 2, 3)
+@test @inferred(ArrayInterfaceCore.is_column_major(@SArray(zeros(2,2,2)))) === True()
+@test @inferred(ArrayInterfaceCore.dense_dims(@SArray(zeros(2,2,2)))) == (true,true,true)
+
diff --git a/test/runtests.jl b/test/runtests.jl
