Package evaluation of ExtendableSparse on Julia 1.13.0-DEV.692 (1ea959a8b1*) started at 2025-06-03T13:25:30.262 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 8.1s ################################################################################ # Installation # Installing ExtendableSparse... Resolving package versions... Updating `~/.julia/environments/v1.13/Project.toml` [95c220a8] + ExtendableSparse v1.7.1 Updating `~/.julia/environments/v1.13/Manifest.toml` [ffbed154] + DocStringExtensions v0.9.4 [95c220a8] + ExtendableSparse v1.7.1 [88f59080] + ILUZero v0.2.0 [6fe1bfb0] + OffsetArrays v1.17.0 [aea7be01] + PrecompileTools v1.3.2 [21216c6a] + Preferences v1.4.3 [e56a9233] + Sparspak v0.3.11 [90137ffa] + StaticArrays v1.9.13 [1e83bf80] + StaticArraysCore v1.4.3 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.12.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.12.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [9e88b42a] + Serialization v1.11.0 [2f01184e] + SparseArrays v1.12.0 [f489334b] + StyledStrings v1.11.0 [4607b0f0] + SuiteSparse [fa267f1f] + TOML v1.0.3 [8dfed614] + Test v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1 [4536629a] + OpenBLAS_jll v0.3.29+0 [bea87d4a] + SuiteSparse_jll v7.10.1+0 [8e850b90] + libblastrampoline_jll v5.12.0+0 Installation completed after 3.55s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 484.03s ################################################################################ # Testing # Testing ExtendableSparse Status `/tmp/jl_nCzdN1/Project.toml` [4f76b812] AMGCLWrap v2.1.0 [2169fc97] AlgebraicMultigrid v1.0.0 [4c88cf16] Aqua v0.8.13 [6e4b80f9] BenchmarkTools v1.6.0 [ae650224] ChunkSplitters v3.1.2 [ffbed154] DocStringExtensions v0.9.4 [7d51a73a] ExplicitImports v1.11.2 [cfc395e8] ExtendableGrids v1.13.1 [95c220a8] ExtendableSparse v1.7.1 [f6369f11] ForwardDiff v1.0.1 [88f59080] ILUZero v0.2.0 [40713840] IncompleteLU v0.2.1 [42fd0dbc] IterativeSolvers v0.9.4 [7ed4a6bd] LinearSolve v3.16.0 [2679e427] Metis v1.5.0 [bdf0d083] MultiFloats v2.3.0 [67456a42] OhMyThreads v0.8.3 [46dd5b70] Pardiso v1.0.1 [f2c3362d] RecursiveFactorization v0.2.23 [e56a9233] Sparspak v0.3.11 [90137ffa] StaticArrays v1.9.13 [37e2e46d] LinearAlgebra v1.12.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [2f01184e] SparseArrays v1.12.0 [4607b0f0] SuiteSparse [8dfed614] Test v1.11.0 Status `/tmp/jl_nCzdN1/Manifest.toml` [47edcb42] ADTypes v1.14.0 [4f76b812] AMGCLWrap v2.1.0 [1520ce14] AbstractTrees v0.4.5 [7d9f7c33] Accessors v0.1.42 [79e6a3ab] Adapt v4.3.0 [2169fc97] AlgebraicMultigrid v1.0.0 [66dad0bd] AliasTables v1.1.3 [4c88cf16] Aqua v0.8.13 [ec485272] ArnoldiMethod v0.4.0 [4fba245c] ArrayInterface v7.19.0 [4c555306] ArrayLayouts v1.11.1 [198e06fe] BangBang v0.4.4 [6e4b80f9] BenchmarkTools v1.6.0 ⌅ [e2ed5e7c] Bijections v0.1.10 [62783981] BitTwiddlingConvenienceFunctions v0.1.6 [fa961155] CEnum v0.5.0 [2a0fbf3d] CPUSummary v0.2.6 [d360d2e6] ChainRulesCore v1.25.1 [ae650224] ChunkSplitters v3.1.2 [fb6a15b2] CloseOpenIntervals v0.1.13 [944b1d66] CodecZlib v0.7.8 [38540f10] CommonSolve v0.2.4 [bbf7d656] CommonSubexpressions v0.3.1 [f70d9fcc] CommonWorldInvalidations v1.0.0 [34da2185] Compat v4.16.0 [534720e6] CompositeStructs v0.1.5 [a33af91c] CompositionsBase v0.1.2 [2569d6c7] ConcreteStructs v0.2.3 [187b0558] ConstructionBase v1.5.8 [adafc99b] CpuId v0.3.1 [a8cc5b0e] Crayons v4.1.1 [9a962f9c] DataAPI v1.16.0 [864edb3b] DataStructures v0.18.22 [e2d170a0] DataValueInterfaces v1.0.0 [163ba53b] DiffResults v1.1.0 [b552c78f] DiffRules v1.15.1 [ffbed154] DocStringExtensions v0.9.4 [fdbdab4c] ElasticArrays v1.2.12 [4e289a0a] EnumX v1.0.5 [7d51a73a] ExplicitImports v1.11.2 [e2ba6199] ExprTools v0.1.10 [55351af7] ExproniconLite v0.10.14 [cfc395e8] ExtendableGrids v1.13.1 [95c220a8] ExtendableSparse v1.7.1 [1a297f60] FillArrays v1.13.0 [f6369f11] ForwardDiff v1.0.1 [069b7b12] FunctionWrappers v1.1.3 [77dc65aa] FunctionWrappersWrappers v0.1.3 [46192b85] GPUArraysCore v0.2.0 [86223c79] Graphs v1.12.1 [076d061b] HashArrayMappedTries v0.2.0 [3e5b6fbb] HostCPUFeatures v0.1.17 [88f59080] ILUZero v0.2.0 [615f187c] IfElse v0.1.1 [40713840] IncompleteLU v0.2.1 [d25df0c9] Inflate v0.1.5 [22cec73e] InitialValues v0.3.1 [3587e190] InverseFunctions v0.1.17 [92d709cd] IrrationalConstants v0.2.4 [42fd0dbc] IterativeSolvers v0.9.4 [82899510] IteratorInterfaceExtensions v1.0.0 [692b3bcd] JLLWrappers v1.7.0 [682c06a0] JSON v0.21.4 [0f8b85d8] JSON3 v1.14.3 [ae98c720] Jieko v0.2.1 ⌅ [70703baa] JuliaSyntax v0.4.10 [ba0b0d4f] Krylov v0.10.1 [b964fa9f] LaTeXStrings v1.4.0 [10f19ff3] LayoutPointers v0.1.17 [5078a376] LazyArrays v2.6.1 [9c8b4983] LightXML v0.9.1 [7ed4a6bd] LinearSolve v3.16.0 [2ab3a3ac] LogExpFunctions v0.3.29 [bdcacae8] LoopVectorization v0.12.172 [1914dd2f] MacroTools v0.5.16 [d125e4d3] ManualMemory v0.1.8 [2679e427] Metis v1.5.0 [e1d29d7a] Missings v1.2.0 [2e0e35c7] Moshi v0.3.5 [bdf0d083] MultiFloats v2.3.0 [77ba4419] NaNMath v1.1.3 [6fe1bfb0] OffsetArrays v1.17.0 [67456a42] OhMyThreads v0.8.3 [bac558e1] OrderedCollections v1.8.1 [46dd5b70] Pardiso v1.0.1 [69de0a69] Parsers v2.8.3 [f517fe37] Polyester v0.7.18 [1d0040c9] PolyesterWeave v0.2.2 [aea7be01] PrecompileTools v1.3.2 [21216c6a] Preferences v1.4.3 [08abe8d2] PrettyTables v2.4.0 [43287f4e] PtrArrays v1.3.0 [3cdcf5f2] RecipesBase v1.3.4 [731186ca] RecursiveArrayTools v3.33.0 [f2c3362d] RecursiveFactorization v0.2.23 [189a3867] Reexport v1.2.2 [ae029012] Requires v1.3.1 [7e49a35a] RuntimeGeneratedFunctions v0.5.15 [fdea26ae] SIMD v3.7.1 [94e857df] SIMDTypes v0.1.0 [476501e8] SLEEFPirates v0.6.43 [0bca4576] SciMLBase v2.96.0 [c0aeaf25] SciMLOperators v1.3.0 [53ae85a6] SciMLStructures v1.7.0 [7e506255] ScopedValues v1.3.0 [efcf1570] Setfield v1.1.2 [699a6c99] SimpleTraits v0.9.4 [a2af1166] SortingAlgorithms v1.2.1 [a0a7dd2c] SparseMatricesCSR v0.6.9 [e56a9233] Sparspak v0.3.11 [276daf66] SpecialFunctions v2.5.1 [91464d47] StableTasks v0.1.7 [aedffcd0] Static v1.2.0 [0d7ed370] StaticArrayInterface v1.8.0 [90137ffa] StaticArrays v1.9.13 [1e83bf80] StaticArraysCore v1.4.3 [10745b16] Statistics v1.11.1 [82ae8749] StatsAPI v1.7.1 [2913bbd2] StatsBase v0.34.5 [7792a7ef] StrideArraysCore v0.5.7 [892a3eda] StringManipulation v0.4.1 [856f2bd8] StructTypes v1.11.0 [2efcf032] SymbolicIndexingInterface v0.3.40 [3783bdb8] TableTraits v1.0.1 [bd369af6] Tables v1.12.0 [ed4db957] TaskLocalValues v0.1.2 [8290d209] ThreadingUtilities v0.5.4 [3bb67fe8] TranscodingStreams v0.11.3 [d5829a12] TriangularSolve v0.2.1 [3a884ed6] UnPack v1.0.2 [4004b06d] VTKBase v1.0.1 [3d5dd08c] VectorizationBase v0.21.71 [64499a7a] WriteVTK v1.21.2 [e3ba5bb7] AMGCL_C_jll v0.3.0+0 [1d5cc7b8] IntelOpenMP_jll v2025.0.4+0 [1d63c593] LLVMOpenMP_jll v18.1.8+0 [94ce4f54] Libiconv_jll v1.18.0+0 [d00139f3] METIS_jll v5.1.3+0 [856f044c] MKL_jll v2025.0.1+1 [efe28fd5] OpenSpecFun_jll v0.5.6+0 ⌅ [02c8fc9c] XML2_jll v2.13.6+1 ⌅ [28df3c45] boost_jll v1.79.0+3 [1317d2d5] oneTBB_jll v2022.0.0+0 [0dad84c5] ArgTools v1.1.2 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [8ba89e20] Distributed v1.11.0 [f43a241f] Downloads v1.7.0 [7b1f6079] FileWatching v1.11.0 [9fa8497b] Future v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.12.0 [4af54fe1] LazyArtifacts v1.11.0 [b27032c2] LibCURL v0.6.4 [76f85450] LibGit2 v1.11.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.12.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [a63ad114] Mmap v1.11.0 [ca575930] NetworkOptions v1.3.0 [44cfe95a] Pkg v1.13.0 [de0858da] Printf v1.11.0 [9abbd945] Profile v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v0.7.0 [9e88b42a] Serialization v1.11.0 [1a1011a3] SharedArrays v1.11.0 [6462fe0b] Sockets v1.11.0 [2f01184e] SparseArrays v1.12.0 [f489334b] StyledStrings v1.11.0 [4607b0f0] SuiteSparse [fa267f1f] TOML v1.0.3 [a4e569a6] Tar v1.10.0 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.3.0+1 [deac9b47] LibCURL_jll v8.12.1+1 [e37daf67] LibGit2_jll v1.9.0+0 [29816b5a] LibSSH2_jll v1.11.3+1 [14a3606d] MozillaCACerts_jll v2025.5.20 [4536629a] OpenBLAS_jll v0.3.29+0 [05823500] OpenLibm_jll v0.8.5+0 [458c3c95] OpenSSL_jll v3.5.0+0 [bea87d4a] SuiteSparse_jll v7.10.1+0 [83775a58] Zlib_jll v1.3.1+2 [8e850b90] libblastrampoline_jll v5.12.0+0 [8e850ede] nghttp2_jll v1.65.0+0 [3f19e933] p7zip_jll v17.5.0+2 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... Test Summary: | Pass Total Time ExplicitImports | 2 2 1m08.9s Precompiling packages... 5956.7 ms ✓ StatsBase 21930.8 ms ✓ ExtendableGrids 2 dependencies successfully precompiled in 28 seconds. 60 already precompiled. Precompiling packages... 6805.6 ms ✓ Metis → MetisGraphs 5077.3 ms ✓ ExtendableGrids → ExtendableGridsMetisExt 2 dependencies successfully precompiled in 12 seconds. 65 already precompiled. Precompiling packages... 18588.9 ms ✓ TriangularSolve Info Given RecursiveFactorization was explicitly requested, output will be shown live  WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _generic_lufact!(Any, Base.Val{Pivot}, Any, Any) where {Pivot} at /home/pkgeval/.julia/packages/RecursiveFactorization/zhyWn/src/lu.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _turbo_!(Base.Val{var"#UNROLL#"}, Base.Val{var"#OPS#"}, Base.Val{var"#ARF#"}, Base.Val{var"#AM#"}, Base.Val{var"#LPSYM#"}, Base.Val{Tuple{var"#LB#", var"#V#"}}, Vararg{Any, var"#num#vargs#"}) where {var"#UNROLL#", var"#OPS#", var"#ARF#", var"#AM#", var"#LPSYM#", var"#LB#", var"#V#", var"#num#vargs#"} at /home/pkgeval/.julia/packages/LoopVectorization/ImqiY/src/reconstruct_loopset.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _ldiv_L!(Any, Any, Base.Val{UNIT}, Type{Args}, Vararg{Any, K}) where {UNIT, Args, K} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_remainder!(Any, Any, Any, Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}) where {W, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W!(Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}, Static.StaticInt{R}) where {W, UNIT, R} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in BdivU_small_kern!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Int64, VectorizationBase.AbstractMask{W, U} where U<:Union{UInt128, UInt16, UInt32, UInt64, UInt8}, Base.Val{UNIT}) where {T, UNIT, W} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W!(Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}) where {W, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W_u!(Any, Any, Any, Any, Static.StaticInt{W}, Static.StaticInt{U}, Base.Val{UNIT}) where {W, U, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in BdivU_small_kern_u!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Int64, Static.StaticInt{U}, Base.Val{UNIT}, Static.StaticInt{W}) where {T, U, UNIT, W} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in rdiv_block_MandN!(LayoutPointers.AbstractStridedPointer{T, var"#s41", XC, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s41"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s41"}} where R where B where var"#s41", LayoutPointers.AbstractStridedPointer{T, var"#s39", XA, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s39"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s39"}} where R where B where var"#s39", LayoutPointers.AbstractStridedPointer{T, var"#s6", XU, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s6"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s6"}} where R where B where var"#s6", Any, Any, Base.Val{UNIT}) where {T, UNIT, XC, XA, XU} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in rdiv_block_N!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, Any, Any, Any, Base.Val{UNIT}, Any) where {T, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in reckernel!(AbstractArray{T, 2}, Base.Val{Pivot}, Any, Any, Any, Any, Any, Any) where {T, Pivot} at /home/pkgeval/.julia/packages/RecursiveFactorization/zhyWn/src/lu.jl 47704.8 ms ✓ RecursiveFactorization 2 dependencies successfully precompiled in 67 seconds. 40 already precompiled. 2 dependencies had output during precompilation: ┌ RecursiveFactorization │ [Output was shown above] └ ┌ TriangularSolve │ WARNING: llvmcall with integer pointers is deprecated. │ Use actual pointers instead, replacing i32 or i64 with i8* or ptr │ in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl └ WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl Precompiling packages... Info Given SpecialFunctionsExt was explicitly requested, output will be shown live  WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl 6133.9 ms ✓ LoopVectorization → SpecialFunctionsExt 1 dependency successfully precompiled in 6 seconds. 44 already precompiled. 1 dependency had output during precompilation: ┌ LoopVectorization → SpecialFunctionsExt │ [Output was shown above] └ WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _generic_lufact!(Any, Base.Val{Pivot}, Any, Any) where {Pivot} at /home/pkgeval/.julia/packages/RecursiveFactorization/zhyWn/src/lu.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _turbo_!(Base.Val{var"#UNROLL#"}, Base.Val{var"#OPS#"}, Base.Val{var"#ARF#"}, Base.Val{var"#AM#"}, Base.Val{var"#LPSYM#"}, Base.Val{Tuple{var"#LB#", var"#V#"}}, Vararg{Any, var"#num#vargs#"}) where {var"#UNROLL#", var"#OPS#", var"#ARF#", var"#AM#", var"#LPSYM#", var"#LB#", var"#V#", var"#num#vargs#"} at /home/pkgeval/.julia/packages/LoopVectorization/ImqiY/src/reconstruct_loopset.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in _ldiv_L!(Any, Any, Base.Val{UNIT}, Type{Args}, Vararg{Any, K}) where {UNIT, Args, K} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_remainder!(Any, Any, Any, Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}) where {W, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W!(Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}, Static.StaticInt{R}) where {W, UNIT, R} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in BdivU_small_kern!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Int64, VectorizationBase.AbstractMask{W, U} where U<:Union{UInt128, UInt16, UInt32, UInt64, UInt8}, Base.Val{UNIT}) where {T, UNIT, W} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W!(Any, Any, Any, Any, Static.StaticInt{W}, Base.Val{UNIT}) where {W, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in ldiv_solve_W_u!(Any, Any, Any, Any, Static.StaticInt{W}, Static.StaticInt{U}, Base.Val{UNIT}) where {W, U, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in BdivU_small_kern_u!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Int64, Static.StaticInt{U}, Base.Val{UNIT}, Static.StaticInt{W}) where {T, U, UNIT, W} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in rdiv_block_MandN!(LayoutPointers.AbstractStridedPointer{T, var"#s41", XC, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s41"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s41"}} where R where B where var"#s41", LayoutPointers.AbstractStridedPointer{T, var"#s39", XA, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s39"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s39"}} where R where B where var"#s39", LayoutPointers.AbstractStridedPointer{T, var"#s6", XU, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s6"}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, var"#s6"}} where R where B where var"#s6", Any, Any, Base.Val{UNIT}) where {T, UNIT, XC, XA, XU} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in rdiv_block_N!(LayoutPointers.AbstractStridedPointer{T, N, C, B, R, X, O} where O<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where X<:Tuple{Vararg{Union{Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Static.StaticInt{N} where N}, N}} where R where B where C where N, Any, Any, Any, Any, Base.Val{UNIT}, Any) where {T, UNIT} at /home/pkgeval/.julia/packages/TriangularSolve/rwyRY/src/TriangularSolve.jl WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in reckernel!(AbstractArray{T, 2}, Base.Val{Pivot}, Any, Any, Any, Any, Any, Any) where {T, Pivot} at /home/pkgeval/.julia/packages/RecursiveFactorization/zhyWn/src/lu.jl num_partitions_per_color(pgrid) = [2, 4, 4] num_partitions_per_color(pgrid) = [4, 4, 4, 3] num_partitions_per_color(pgrid) = [6, 6, 6, 2] num_partitions_per_color(pgrid) = [2, 4, 4] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... num_partitions_per_color(pgrid) = [4, 4, 4, 3] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... num_partitions_per_color(pgrid) = [6, 6, 6, 2] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.3322676295501878e-15 [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.3322676295501878e-15 [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.3322676295501878e-15 num_partitions_per_color(pgrid) = [3, 3, 4] num_partitions_per_color(pgrid) = [4, 4, 6, 1] num_partitions_per_color(pgrid) = [7, 5, 5, 3] num_partitions_per_color(pgrid) = [3, 3, 4] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... num_partitions_per_color(pgrid) = [4, 4, 6, 1] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... num_partitions_per_color(pgrid) = [7, 5, 5, 3] [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.0547118733938987e-15 [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.3322676295501878e-15 [ Info: Check if every node belongs to one of the cell partitions... [ Info: Check if no node belongs to two cell partitions of the same color at once... [ Info: Check if no node belongs to two node partitions of the same color at once... [ Info: Check if no node is a neighbor of nodes from two node partitions of the same color... diff = 1.1102230246251565e-15 Test Summary: | Pass Total Time Parallel | 36 36 4m27.3s Test Summary: | Pass Total Time Constructors | 23 23 6.6s WARNING: Method definition rand(Random.AbstractRNG, Random.SamplerType{ForwardDiff.Dual{T, V, N}}) where {T, V, N} in module test_constructors at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/test_constructors.jl:11 overwritten in module test_copymethods at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/test_copymethods.jl:10. ┌ Warning: timing test failed. │ If this occurs just once or twice, it is probably due to CPU noise. │ So we nevertheless count this as passing. └ @ Main.test_copymethods ~/.julia/packages/ExtendableSparse/pjofE/test/test_copymethods.jl:26 Test Summary: | Total Time Copy-Methods | 0 4.6s Test Summary: | Pass Total Time Updates | 18 18 7.1s Test Summary: | Pass Total Time Assembly | 19 19 4.2s Float64 (1000,1,1): CSC 3.8913 EXT 0.4585 LNK 0.1760 Float64 (100,100,1): CSC 677.8410 EXT 9.2805 LNK 3.7074 Float64 (20,20,20): CSC 569.5093 EXT 10.9371 LNK 4.7798 MultiFloat{Float64, 2} (1000,1,1): CSC 4.2326 EXT 0.5397 LNK 0.2242 MultiFloat{Float64, 2} (100,100,1): CSC 618.8108 EXT 10.5845 LNK 4.7839 MultiFloat{Float64, 2} (20,20,20): CSC 569.3152 EXT 13.0364 LNK 6.1716 ForwardDiff.Dual{Float64, Float64, 1} (1000,1,1): CSC 3.7345 EXT 0.5052 LNK 0.1762 ForwardDiff.Dual{Float64, Float64, 1} (100,100,1): CSC 630.0641 EXT 10.0270 LNK 4.2534 ForwardDiff.Dual{Float64, Float64, 1} (20,20,20): CSC 550.7045 EXT 11.4128 LNK 4.9237 Test Summary: | Pass Total Time Construction timings | 9 9 2m16.0s Test Summary: | Pass Total Time Operations | 25 25 17.3s Test Summary: | Pass Total Time fdrand | 36 36 59.7s [ Info: Float32: [ Info: Float64: [ Info: MultiFloat{Float64, 1}: [ Info: MultiFloat{Float64, 2}: [ Info: ForwardDiff.Dual{Float64, Float64, 1}: [ Info: ForwardDiff.Dual{Float64, Float64, 2}: Test Summary: | Pass Total Time Backslash | 18 18 1m52.5s Test Summary: | Pass Total Time Dirichlet | 6 6 1.7s Precompiling packages... 6063.3 ms ✓ RecursiveArrayTools 3592.5 ms ✓ RecursiveArrayTools → RecursiveArrayToolsSparseArraysExt 26770.2 ms ✓ SciMLBase 4619.7 ms ✓ SciMLBase → SciMLBaseChainRulesCoreExt Info Given LinearSolve was explicitly requested, output will be shown live  WARNING: Detected access to binding `LinearSolve.defaultalg_symbol` in a world prior to its definition world.  Julia 1.12 has introduced more strict world age semantics for global bindings.  !!! This code may malfunction under Revise.  !!! This code will error in future versions of Julia. Hint: Add an appropriate `invokelatest` around the access to this binding. To make this warning an error, and hence obtain a stack trace, use `julia --depwarn=error`. 20832.3 ms ✓ LinearSolve 11214.4 ms ✓ LinearSolve → LinearSolveSparseArraysExt 6 dependencies successfully precompiled in 74 seconds. 103 already precompiled. 1 dependency had output during precompilation: ┌ LinearSolve │ [Output was shown above] └ Precompiling packages... 3748.0 ms ✓ RecursiveArrayTools → RecursiveArrayToolsForwardDiffExt 1 dependency successfully precompiled in 4 seconds. 58 already precompiled. Precompiling packages... Info Given ForwardDiffExt was explicitly requested, output will be shown live  WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl 6753.9 ms ✓ LoopVectorization → ForwardDiffExt 1 dependency successfully precompiled in 7 seconds. 57 already precompiled. 1 dependency had output during precompilation: ┌ LoopVectorization → ForwardDiffExt │ [Output was shown above] └ Precompiling packages... 22500.0 ms ✓ LinearSolve → LinearSolveSparspakExt 7369.9 ms ✓ ExtendableSparse → ExtendableSparseLinearSolveExt 2 dependencies successfully precompiled in 30 seconds. 125 already precompiled. Precompiling packages... Info Given LinearSolveRecursiveFactorizationExt was explicitly requested, output will be shown live  WARNING: llvmcall with integer pointers is deprecated. Use actual pointers instead, replacing i32 or i64 with i8* or ptr in initialize_task(Any) at /home/pkgeval/.julia/packages/ThreadingUtilities/AsFET/src/ThreadingUtilities.jl 9076.9 ms ✓ LinearSolve → LinearSolveRecursiveFactorizationExt 1 dependency successfully precompiled in 10 seconds. 133 already precompiled. 1 dependency had output during precompilation: ┌ LinearSolve → LinearSolveRecursiveFactorizationExt │ [Output was shown above] └ Precompiling packages... 6644.1 ms ✓ AMGCLWrap → AMGCLWrapLinearSolveExt 1 dependency successfully precompiled in 7 seconds. 120 already precompiled. Precompiling packages... 2374.1 ms ✓ ExtendableSparse → ExtendableSparseIncompleteLUExt 1 dependency successfully precompiled in 3 seconds. 25 already precompiled. Precompiling packages... 7409.9 ms ✓ AlgebraicMultigrid 1 dependency successfully precompiled in 8 seconds. 109 already precompiled. Precompiling packages... 7662.7 ms ✓ ExtendableSparse → ExtendableSparseAlgebraicMultigridExt 1 dependency successfully precompiled in 8 seconds. 128 already precompiled. Precompiling packages... 6374.2 ms ✓ ExtendableSparse → ExtendableSparsePardisoExt 1 dependency successfully precompiled in 7 seconds. 46 already precompiled. Precompiling packages... 10662.0 ms ✓ LinearSolve → LinearSolvePardisoExt 1 dependency successfully precompiled in 11 seconds. 110 already precompiled. Factorizations: Error During Test at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:78 Test threw exception Expression: test_ls2(Float64, 25, 40, 1, linsolver = factorization) ArgumentError: pattern of the matrix changed Stacktrace: [1] umferror(status::Int32) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:125 [2] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:639 [inlined] [3] macro expansion @ ./lock.jl:376 [inlined] [4] umfpack_numeric!(U::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}; reuse_numeric::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:630 [5] umfpack_numeric! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:629 [inlined] [6] lu!(F::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}; check::Bool, reuse_symbolic::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:493 [7] lu! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:489 [inlined] [8] lu!(F::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, S::SparseMatrixCSC{Float64, Int64}; check::Bool, reuse_symbolic::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:486 [9] lu! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:460 [inlined] [10] solve!(cache::LinearSolve.LinearCache{ExtendableSparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.UMFPACKFactorization, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SciMLOperators.IdentityOperator, SciMLOperators.IdentityOperator, Float64, Bool, LinearSolve.LinearSolveAdjoint{Missing}}, alg::LinearSolve.UMFPACKFactorization; kwargs::@Kwargs{}) @ LinearSolveSparseArraysExt ~/.julia/packages/LinearSolve/r8pCv/ext/LinearSolveSparseArraysExt.jl:153 [11] solve! @ ~/.julia/packages/LinearSolve/r8pCv/ext/LinearSolveSparseArraysExt.jl:139 [inlined] [12] #solve!#11 @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:299 [inlined] [13] solve! @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:298 [inlined] [14] #solve#10 @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:295 [inlined] [15] solve(::SciMLBase.LinearProblem{Nothing, true, ExtendableSparseMatrixCSC{Float64, Int64}, Vector{Float64}, SciMLBase.NullParameters, @Kwargs{}}, ::LinearSolve.UMFPACKFactorization) @ LinearSolve ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:293 [16] test_ls2(T::Type, k::Int64, l::Int64, m::Int64; linsolver::LinearSolve.UMFPACKFactorization) @ Main.test_linearsolve ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:32 [17] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:373 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:727 [inlined] [19] macro expansion @ ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:78 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1833 [inlined] [21] top-level scope @ ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:71 Factorizations: Error During Test at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:79 Test threw exception Expression: test_ls2(Float64, 100, 1, 1, linsolver = factorization) ArgumentError: pattern of the matrix changed Stacktrace: [1] umferror(status::Int32) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:125 [2] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:639 [inlined] [3] macro expansion @ ./lock.jl:376 [inlined] [4] umfpack_numeric!(U::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}; reuse_numeric::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:630 [5] umfpack_numeric! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:629 [inlined] [6] lu!(F::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}; check::Bool, reuse_symbolic::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:493 [7] lu! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:489 [inlined] [8] lu!(F::SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, S::SparseMatrixCSC{Float64, Int64}; check::Bool, reuse_symbolic::Bool, q::Nothing) @ SparseArrays.UMFPACK /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:486 [9] lu! @ /opt/julia/share/julia/stdlib/v1.13/SparseArrays/src/solvers/umfpack.jl:460 [inlined] [10] solve!(cache::LinearSolve.LinearCache{ExtendableSparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.UMFPACKFactorization, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SciMLOperators.IdentityOperator, SciMLOperators.IdentityOperator, Float64, Bool, LinearSolve.LinearSolveAdjoint{Missing}}, alg::LinearSolve.UMFPACKFactorization; kwargs::@Kwargs{}) @ LinearSolveSparseArraysExt ~/.julia/packages/LinearSolve/r8pCv/ext/LinearSolveSparseArraysExt.jl:153 [11] solve! @ ~/.julia/packages/LinearSolve/r8pCv/ext/LinearSolveSparseArraysExt.jl:139 [inlined] [12] #solve!#11 @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:299 [inlined] [13] solve! @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:298 [inlined] [14] #solve#10 @ ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:295 [inlined] [15] solve(::SciMLBase.LinearProblem{Nothing, true, ExtendableSparseMatrixCSC{Float64, Int64}, Vector{Float64}, SciMLBase.NullParameters, @Kwargs{}}, ::LinearSolve.UMFPACKFactorization) @ LinearSolve ~/.julia/packages/LinearSolve/r8pCv/src/common.jl:293 [16] test_ls2(T::Type, k::Int64, l::Int64, m::Int64; linsolver::LinearSolve.UMFPACKFactorization) @ Main.test_linearsolve ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:32 [17] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:373 [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:727 [inlined] [19] macro expansion @ ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:79 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.13/Test/src/Test.jl:1833 [inlined] [21] top-level scope @ ~/.julia/packages/ExtendableSparse/pjofE/test/test_linearsolve.jl:71 Test Summary: | Pass Error Total Time LinearSolve | 119 2 121 5m39.7s Sparspak | 30 30 47.8s Factorizations | 22 2 24 18.6s iterations | 54 54 31.5s block preconditioning | 13 13 58.6s RNG of the outermost testset: Random.Xoshiro(0x28b35b4f7d4068f6, 0x7690aca11342f5bb, 0xcd7f6cf72d2717f8, 0xe81d5b9ffd37ca8c, 0xe8b0036685534bd3) ERROR: LoadError: Some tests did not pass: 119 passed, 0 failed, 2 errored, 0 broken. in expression starting at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/alltests.jl:81 in expression starting at /home/pkgeval/.julia/packages/ExtendableSparse/pjofE/test/runtests.jl:2 Testing failed after 1052.45s ERROR: LoadError: Package ExtendableSparse errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Operations.jl:2421 [3] test @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/Operations.jl:2276 [inlined] [4] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:498 [5] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:164 [6] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:152 [7] test @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:152 [inlined] [8] #test#81 @ /opt/julia/share/julia/stdlib/v1.13/Pkg/src/API.jl:151 [inlined] [9] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:219 [10] include(mod::Module, _path::String) @ Base ./Base.jl:309 [11] exec_options(opts::Base.JLOptions) @ Base ./client.jl:324 [12] _start() @ Base ./client.jl:557 in expression starting at /PkgEval.jl/scripts/evaluate.jl:210 PkgEval failed after 1570.57s: package tests unexpectedly errored