Skip to content

Commit 9be2c9e

Browse files
IanButterworthIanButterworth
committed
coverage: mark tests that fail on coverage jobs as broken, for cleaner logs
1 parent 2431550 commit 9be2c9e

22 files changed

+394
-350
lines changed

‎Compiler/test/AbstractInterpreter.jl‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,8 @@ include("setup_Compiler.jl")
66
include("irutils.jl")
77
include("newinterp.jl")
88

9+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
10+
911
# interpreter that performs abstract interpretation only
1012
# (semi-concrete interpretation should be disabled automatically)
1113
@newinterp AbsIntOnlyInterp1
@@ -158,8 +160,8 @@ gpu_factorial3(x::Int) = myfactorial(x, raise_on_gpu3)
158160
let effects = Base.infer_effects(gpu_factorial3, (Int,); interp=MTOverlayInterp())
159161
# check if `@consistent_overlay` together works with `@assume_effects`
160162
# N.B. the overlaid `raise_on_gpu3` is not :foldable otherwise since `error_on_gpu` is (intetionally) undefined.
161-
@test Compiler.is_consistent_overlay(effects)
162-
@test Compiler.is_foldable(effects)
163+
@test Compiler.is_consistent_overlay(effects) broken=coverage_enabled
164+
@test Compiler.is_foldable(effects) broken=coverage_enabled
163165
end
164166
@test Base.infer_return_type(; interp=MTOverlayInterp()) do
165167
Val(gpu_factorial2(3))

‎Compiler/test/effects.jl‎

Lines changed: 222 additions & 220 deletions
Large diffs are not rendered by default.

‎Compiler/test/inference.jl‎

Lines changed: 34 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,8 @@ using Test
77
include("setup_Compiler.jl")
88
include("irutils.jl")
99

10+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
11+
1012
# tests for Compiler correctness and precision
1113
using .Compiler: Conditional, ⊑
1214
isdispatchelem(@nospecialize x) = !isa(x, Type) || Compiler.isdispatchelem(x)
@@ -5187,19 +5189,19 @@ end
51875189
invoke_concretized1(a::Int) = a > 0 ? :int : nothing
51885190
invoke_concretized1(a::Integer) = a > 0 ? "integer" : nothing
51895191
# check if `invoke(invoke_concretized1, Tuple{Integer}, ::Int)` is foldable
5190-
@test Base.infer_effects((Int,)) do a
5192+
@test (Base.infer_effects((Int,)) do a
51915193
@invoke invoke_concretized1(a::Integer)
5192-
end |> Compiler.is_foldable
5194+
end |> Compiler.is_foldable) broken=coverage_enabled
51935195
@test Base.return_types() do
51945196
@invoke invoke_concretized1(42::Integer)
51955197
end |> only === String
51965198

51975199
invoke_concretized2(a::Int) = a > 0 ? :int : nothing
51985200
invoke_concretized2(a::Integer) = a > 0 ? :integer : nothing
51995201
# check if `invoke(invoke_concretized2, Tuple{Integer}, ::Int)` is foldable
5200-
@test Base.infer_effects((Int,)) do a
5202+
@test (Base.infer_effects((Int,)) do a
52015203
@invoke invoke_concretized2(a::Integer)
5202-
end |> Compiler.is_foldable
5204+
end |> Compiler.is_foldable) broken=coverage_enabled
52035205
@test let
52045206
Base.Experimental.@force_compile
52055207
@invoke invoke_concretized2(42::Integer)
@@ -5298,7 +5300,7 @@ type_level_recurse_entry() = Val{type_level_recurse1(1)}()
52985300
f_no_bail_effects_any(x::Any) = x
52995301
f_no_bail_effects_any(x::NamedTuple{(:x,), Tuple{Any}}) = getfield(x, 1)
53005302
g_no_bail_effects_any(x::Any) = f_no_bail_effects_any(x)
5301-
@test Compiler.is_foldable_nothrow(Base.infer_effects(g_no_bail_effects_any, Tuple{Any}))
5303+
@test Compiler.is_foldable_nothrow(Base.infer_effects(g_no_bail_effects_any, Tuple{Any})) broken=coverage_enabled
53025304

53035305
# issue #48374
53045306
@test (() -> Union{<:Nothing})() == Nothing
@@ -6132,65 +6134,65 @@ end == Val{true}
61326134
end == Val
61336135

61346136
# 2. getfield modeling for partial struct
6135-
@test Base.infer_effects((Any,Any); optimize=false) do a, b
6137+
@test (Base.infer_effects((Any,Any); optimize=false) do a, b
61366138
getfield(PartiallyInitialized1(a, b), :b)
6137-
end |> Compiler.is_nothrow
6139+
end |> Compiler.is_nothrow) broken=coverage_enabled
61386140
@test Base.infer_effects((Any,Any,Symbol,); optimize=false) do a, b, f
61396141
getfield(PartiallyInitialized1(a, b), f, #=boundscheck=#false)
61406142
end |> !Compiler.is_nothrow
6141-
@test Base.infer_effects((Any,Any,Any); optimize=false) do a, b, c
6143+
@test (Base.infer_effects((Any,Any,Any); optimize=false) do a, b, c
61426144
getfield(PartiallyInitialized1(a, b, c), :c)
6143-
end |> Compiler.is_nothrow
6144-
@test Base.infer_effects((Any,Any,Any,Symbol); optimize=false) do a, b, c, f
6145+
end |> Compiler.is_nothrow) broken=coverage_enabled
6146+
@test (Base.infer_effects((Any,Any,Any,Symbol); optimize=false) do a, b, c, f
61456147
getfield(PartiallyInitialized1(a, b, c), f, #=boundscheck=#false)
6146-
end |> Compiler.is_nothrow
6147-
@test Base.infer_effects((Any,Any); optimize=false) do a, b
6148+
end |> Compiler.is_nothrow) broken=coverage_enabled
6149+
@test (Base.infer_effects((Any,Any); optimize=false) do a, b
61486150
getfield(PartiallyInitialized2(a, b), :b)
6149-
end |> Compiler.is_nothrow
6151+
end |> Compiler.is_nothrow) broken=coverage_enabled
61506152
@test Base.infer_effects((Any,Any,Symbol,); optimize=false) do a, b, f
61516153
getfield(PartiallyInitialized2(a, b), f, #=boundscheck=#false)
61526154
end |> !Compiler.is_nothrow
6153-
@test Base.infer_effects((Any,Any,Any); optimize=false) do a, b, c
6155+
@test (Base.infer_effects((Any,Any,Any); optimize=false) do a, b, c
61546156
getfield(PartiallyInitialized2(a, b, c), :c)
6155-
end |> Compiler.is_nothrow
6156-
@test Base.infer_effects((Any,Any,Any,Symbol); optimize=false) do a, b, c, f
6157+
end |> Compiler.is_nothrow) broken=coverage_enabled
6158+
@test (Base.infer_effects((Any,Any,Any,Symbol); optimize=false) do a, b, c, f
61576159
getfield(PartiallyInitialized2(a, b, c), f, #=boundscheck=#false)
6158-
end |> Compiler.is_nothrow
6160+
end |> Compiler.is_nothrow) broken=coverage_enabled
61596161

61606162
# isdefined-Conditionals
6161-
@test Base.infer_effects((Base.RefValue{Any},)) do x
6163+
@test (Base.infer_effects((Base.RefValue{Any},)) do x
61626164
if isdefined(x, :x)
61636165
return getfield(x, :x)
61646166
end
6165-
end |> Compiler.is_nothrow
6166-
@test Base.infer_effects((Base.RefValue{Any},)) do x
6167+
end |> Compiler.is_nothrow) broken=coverage_enabled
6168+
@test (Base.infer_effects((Base.RefValue{Any},)) do x
61676169
if isassigned(x)
61686170
return x[]
61696171
end
6170-
end |> Compiler.is_nothrow
6172+
end |> Compiler.is_nothrow) broken=coverage_enabled
61716173
@test Base.infer_effects((Any,Any); optimize=false) do a, c
61726174
x = PartiallyInitialized2(a)
61736175
x.c = c
61746176
if isdefined(x, :c)
61756177
return x.b
61766178
end
61776179
end |> !Compiler.is_nothrow
6178-
@test Base.infer_effects((PartiallyInitialized2,); optimize=false) do x
6180+
@test (Base.infer_effects((PartiallyInitialized2,); optimize=false) do x
61796181
if isdefined(x, :b)
61806182
if isdefined(x, :c)
61816183
return x.c
61826184
end
61836185
return x.b
61846186
end
61856187
return nothing
6186-
end |> Compiler.is_nothrow
6187-
@test Base.infer_effects((Bool,Int,); optimize=false) do c, b
6188+
end |> Compiler.is_nothrow) broken=coverage_enabled
6189+
@test (Base.infer_effects((Bool,Int,); optimize=false) do c, b
61886190
x = c ? PartiallyInitialized1(true) : PartiallyInitialized1(true, b)
61896191
if isdefined(x, :b)
61906192
return Val(x.a), x.b
61916193
end
61926194
return nothing
6193-
end |> Compiler.is_nothrow
6195+
end |> Compiler.is_nothrow) broken=coverage_enabled
61946196

61956197
# refine `undef` information from `@isdefined` check
61966198
function isdefined_nothrow(c, x)
@@ -6203,7 +6205,7 @@ function isdefined_nothrow(c, x)
62036205
end
62046206
return zero(Int)
62056207
end
6206-
@test Compiler.is_nothrow(Base.infer_effects(isdefined_nothrow, (Bool,Int)))
6208+
@test Compiler.is_nothrow(Base.infer_effects(isdefined_nothrow, (Bool,Int))) broken=coverage_enabled
62076209
@test !any(first(only(code_typed(isdefined_nothrow, (Bool,Int)))).code) do @nospecialize x
62086210
Meta.isexpr(x, :throw_undef_if_not)
62096211
end
@@ -6251,9 +6253,9 @@ end == TypeError
62516253
# nothrow modeling for `invoke` calls
62526254
f_invoke_nothrow(::Number) = :number
62536255
f_invoke_nothrow(::Int) = :int
6254-
@test Base.infer_effects((Int,)) do x
6256+
@test (Base.infer_effects((Int,)) do x
62556257
@invoke f_invoke_nothrow(x::Number)
6256-
end |> Compiler.is_nothrow
6258+
end |> Compiler.is_nothrow) broken=coverage_enabled
62576259
@test Base.infer_effects((Char,)) do x
62586260
@invoke f_invoke_nothrow(x::Number)
62596261
end |> !Compiler.is_nothrow
@@ -6392,16 +6394,16 @@ end
63926394

63936395
global global_decl_defined
63946396
global_decl_defined = 42
6395-
@test Base.infer_effects(; interp=AssumeBindingsStaticInterp()) do
6397+
@test (Base.infer_effects(; interp=AssumeBindingsStaticInterp()) do
63966398
global global_decl_defined
63976399
return global_decl_defined
6398-
end |> Compiler.is_nothrow
6400+
end |> Compiler.is_nothrow) broken=coverage_enabled
63996401
global global_decl_defined2::Int
64006402
global_decl_defined2 = 42
6401-
@test Base.infer_effects(; interp=AssumeBindingsStaticInterp()) do
6403+
@test (Base.infer_effects(; interp=AssumeBindingsStaticInterp()) do
64026404
global global_decl_defined2
64036405
return global_decl_defined2
6404-
end |> Compiler.is_nothrow
6406+
end |> Compiler.is_nothrow) broken=coverage_enabled
64056407

64066408
@eval get_exception() = $(Expr(:the_exception))
64076409
@test Base.infer_return_type() do

‎Compiler/test/irpasses.jl‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,8 @@ using Core.IR
77
include("setup_Compiler.jl")
88
include("irutils.jl")
99

10+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
11+
1012
# domsort
1113
# =======
1214

@@ -1179,7 +1181,7 @@ let ci = code_typed(foo_cfg_empty, Tuple{Bool}, optimize=true)[1][1]
11791181
@test isa(ir.stmts[length(ir.stmts)][:stmt], ReturnNode)
11801182
end
11811183

1182-
@test Compiler.is_effect_free(Base.infer_effects(getfield, (Complex{Int}, Symbol)))
1184+
@test Compiler.is_effect_free(Base.infer_effects(getfield, (Complex{Int}, Symbol))) broken=coverage_enabled
11831185

11841186
# We consider a potential deprecatio warning an effect, so for completely unknown getglobal,
11851187
# we taint the effect_free bit.

‎test/abstractarray.jl‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,8 @@ using Random, LinearAlgebra
44

55
include(joinpath(@__DIR__,"../Compiler/test/irutils.jl"))
66

7+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
8+
79
isdefined(Main, :InfiniteArrays) || @eval Main include("testhelpers/InfiniteArrays.jl")
810
using .Main.InfiniteArrays
911

@@ -2339,12 +2341,12 @@ end
23392341
for El ∈ (Float32, Real, Any)
23402342
for Arr ∈ (Memory{El}, Array{El, 0}, Vector{El}, Matrix{El}, Array{El, 3})
23412343
effects = Base.infer_effects(iterate, Tuple{Arr, Int})
2342-
@test Base.Compiler.is_effect_free(effects)
2343-
@test Base.Compiler.is_terminates(effects)
2344-
@test Base.Compiler.is_notaskstate(effects)
2345-
@test Base.Compiler.is_noub(effects)
2346-
@test Base.Compiler.is_nonoverlayed(effects)
2347-
@test Base.Compiler.is_nortcall(effects)
2344+
@test Base.Compiler.is_effect_free(effects) broken=coverage_enabled
2345+
@test Base.Compiler.is_terminates(effects) broken=coverage_enabled
2346+
@test Base.Compiler.is_notaskstate(effects) broken=coverage_enabled
2347+
@test Base.Compiler.is_noub(effects) broken=coverage_enabled
2348+
@test Base.Compiler.is_nonoverlayed(effects) broken=coverage_enabled
2349+
@test Base.Compiler.is_nortcall(effects) broken=coverage_enabled
23482350
end
23492351
end
23502352
end

‎test/arrayops.jl‎

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,8 @@ isdefined(@__MODULE__, :T24Linear) || include("testhelpers/arrayindexingtypes.jl
99
using Random, LinearAlgebra
1010
using Dates
1111

12+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
13+
1214
@testset "basics" begin
1315
@test length([1, 2, 3]) == 3
1416
@test count(!iszero, [1, 2, 3]) == 3
@@ -104,11 +106,11 @@ end
104106
for Arr ∈ (Array{<:Any, 0}, Vector, Matrix, Array{<:Any, 3})
105107
for Shape ∈ (Tuple{Int}, Tuple{Int, Int})
106108
effects = Base.infer_effects(reshape, Tuple{Arr{Float32}, Shape})
107-
@test Base.Compiler.is_effect_free(effects)
108-
@test Base.Compiler.is_terminates(effects)
109-
@test Base.Compiler.is_notaskstate(effects)
110-
@test Base.Compiler.is_noub(effects)
111-
@test Base.Compiler.is_nortcall(effects)
109+
@test Base.Compiler.is_effect_free(effects) broken=coverage_enabled
110+
@test Base.Compiler.is_terminates(effects) broken=coverage_enabled
111+
@test Base.Compiler.is_notaskstate(effects) broken=coverage_enabled
112+
@test Base.Compiler.is_noub(effects) broken=coverage_enabled
113+
@test Base.Compiler.is_nortcall(effects) broken=coverage_enabled
112114
end
113115
end
114116
end

‎test/broadcast.jl‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,8 @@
22

33
using Test, Random
44

5+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
6+
57
module TestBroadcastInternals
68

79
using Base.Broadcast: check_broadcast_axes, check_broadcast_shape, newindex, _bcs
@@ -1200,8 +1202,8 @@ end
12001202

12011203
# test that `Broadcast` definition is defined as total and eligible for concrete evaluation
12021204
import Base.Broadcast: BroadcastStyle, DefaultArrayStyle
1203-
@test Base.infer_effects(BroadcastStyle, (DefaultArrayStyle{1},DefaultArrayStyle{2},)) |>
1204-
Core.Compiler.is_foldable
1205+
@test (Base.infer_effects(BroadcastStyle, (DefaultArrayStyle{1},DefaultArrayStyle{2},)) |>
1206+
Core.Compiler.is_foldable) broken=coverage_enabled
12051207

12061208
f51129(v, x) = (1 .- (v ./ x) .^ 2)
12071209
@test @inferred(f51129([13.0], 6.5)) == [-3.0]

‎test/combinatorics.jl‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,8 @@ using Random: randcycle
55
isdefined(Main, :ImmutableArrays) || @eval Main include("testhelpers/ImmutableArrays.jl")
66
using .Main.ImmutableArrays
77

8+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
9+
810
@testset "binomial" begin
911
@test binomial(5,-1) == 0
1012
@test binomial(5,10) == 0
@@ -80,7 +82,7 @@ end
8082
for T = Base.uniontypes(Union{Base.Checked.SignedInt,Base.Checked.UnsignedInt})
8183
@testset let T = T
8284
@test factorial(T(7)) == 5040
83-
@test Core.Compiler.is_foldable(Base.infer_effects(factorial, (T,)))
85+
@test Core.Compiler.is_foldable(Base.infer_effects(factorial, (T,))) broken=coverage_enabled
8486
end
8587
end
8688
@test factorial(0) == 1

‎test/core.jl‎

Lines changed: 21 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,8 @@ using Random, InteractiveUtils
66

77
const Bottom = Union{}
88

9+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
10+
911
# For curmod_*
1012
include("testenv.jl")
1113

@@ -8194,7 +8196,7 @@ foo46503(@nospecialize(a), b::Union{Nothing, Float64}) = rand() + 10
81948196
@test 10 <= foo46503(1, nothing) <= 11
81958197

81968198
@testset "effect override on Symbol(::String)" begin
8197-
@test Core.Compiler.is_foldable(Base.infer_effects(Symbol, (String,)))
8199+
@test Core.Compiler.is_foldable(Base.infer_effects(Symbol, (String,))) broken=coverage_enabled
81988200
end
81998201

82008202
@testset "error message for getfield with bad integer type" begin
@@ -8287,25 +8289,25 @@ struct ModTParamUnionAll{A, B}; end
82878289

82888290
# effects for objectid
82898291
for T in (Int, String, Symbol, Module)
8290-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (T,)))
8291-
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (T,)))
8292-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Some{T},)))
8293-
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (Some{T},)))
8294-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Some{Some{T}},)))
8295-
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (Some{Some{T}},)))
8296-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{T},)))
8297-
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (Tuple{T},)))
8298-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{T,T},)))
8299-
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (Tuple{T,T},)))
8300-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Ref{T},)))
8301-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{Ref{T}},)))
8302-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{Vector{T}},)))
8303-
end
8304-
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (DataType,)))
8292+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (T,))) broken=coverage_enabled
8293+
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (T,))) broken=coverage_enabled
8294+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Some{T},))) broken=coverage_enabled
8295+
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (Some{T},))) broken=coverage_enabled
8296+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Some{Some{T}},))) broken=coverage_enabled
8297+
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (Some{Some{T}},))) broken=coverage_enabled
8298+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{T},))) broken=coverage_enabled
8299+
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (Tuple{T},))) broken=coverage_enabled
8300+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{T,T},))) broken=coverage_enabled
8301+
@test Core.Compiler.is_foldable(Base.infer_effects(hash, (Tuple{T,T},))) broken=coverage_enabled
8302+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Ref{T},))) broken=coverage_enabled
8303+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{Ref{T}},))) broken=coverage_enabled
8304+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (Tuple{Vector{T}},))) broken=coverage_enabled
8305+
end
8306+
@test Core.Compiler.is_foldable(Base.infer_effects(objectid, (DataType,))) broken=coverage_enabled
83058307

83068308
# donotdelete should not taint consistency of the containing function
83078309
f_donotdete(x) = (Core.Compiler.donotdelete(x); 1)
8308-
@test Core.Compiler.is_consistent(Base.infer_effects(f_donotdete, (Tuple{Float64},)))
8310+
@test Core.Compiler.is_consistent(Base.infer_effects(f_donotdete, (Tuple{Float64},))) broken=coverage_enabled
83098311

83108312
# Test conditional UndefRefError (#50250)
83118313
struct Foo50250
@@ -8338,8 +8340,8 @@ let u = Union{Type{Union{}}, Type{Any}}, ab = bar50293(u)
83388340
end
83398341

83408342
# `SimpleVector`-operations should be concrete-eval eligible
8341-
@test Core.Compiler.is_foldable(Base.infer_effects(length, (Core.SimpleVector,)))
8342-
@test Core.Compiler.is_foldable(Base.infer_effects(getindex, (Core.SimpleVector,Int)))
8343+
@test Core.Compiler.is_foldable(Base.infer_effects(length, (Core.SimpleVector,))) broken=coverage_enabled
8344+
@test Core.Compiler.is_foldable(Base.infer_effects(getindex, (Core.SimpleVector,Int))) broken=coverage_enabled
83438345

83448346
# Test that a the lowering of nothrow globalref
83458347
module WellKnownGlobal

‎test/dict.jl‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,8 @@
22

33
using Random
44

5+
const coverage_enabled = (Base.JLOptions().code_coverage != 0)
6+
57
@testset "Pair" begin
68
p = Pair(10,20)
79
@test p == (10=>20)
@@ -1523,7 +1525,7 @@ end
15231525
for T in (Int, Float64, String, Symbol)
15241526
@testset let T=T
15251527
@test !Core.Compiler.is_consistent(Base.infer_effects(getindex, (Dict{T,Any}, T)))
1526-
@test Core.Compiler.is_effect_free(Base.infer_effects(getindex, (Dict{T,Any}, T)))
1528+
@test Core.Compiler.is_effect_free(Base.infer_effects(getindex, (Dict{T,Any}, T))) broken=coverage_enabled
15271529
@test !Core.Compiler.is_nothrow(Base.infer_effects(getindex, (Dict{T,Any}, T)))
15281530
@test Core.Compiler.is_terminates(Base.infer_effects(getindex, (Dict{T,Any}, T)))
15291531
end

0 commit comments

Comments
 (0)