update code and tests to limit false global sharing

ref #19324

Author: vtjnash

base/multimedia.jl

@@ -154,7 +154,7 @@ for mime in ["application/atom+xml", "application/ecmascript",
              "application/x-latex", "application/xhtml+xml", "application/xml",
              "application/xml-dtd", "image/svg+xml", "model/vrml",
              "model/x3d+vrml", "model/x3d+xml"]
-    istextmime(::MIME{Symbol(mime)}) = true
+    global istextmime(::MIME{Symbol(mime)}) = true
 end
 
 ###########################################################################

base/nullable.jl

@@ -388,6 +388,7 @@ all(f::typeof(hasvalue), t::Tuple{}) = true
 
 # Note this list does not include sqrt since it can raise a DomainError
 for op in (+, -, abs, abs2)
+    global null_safe_op
     null_safe_op(::typeof(op), ::NullSafeTypes) = true
     null_safe_op(::typeof(op), ::Type{Complex{S}}) where {S} = null_safe_op(op, S)
     null_safe_op(::typeof(op), ::Type{Rational{S}}) where {S} = null_safe_op(op, S)
@@ -404,11 +405,13 @@ null_safe_op(::typeof(!), ::Type{Bool}) = true
 for op in (+, -, *, /, &, |, <<, >>, >>>,
            scalarmin, scalarmax)
     # to fix ambiguities
+    global null_safe_op
     null_safe_op(::typeof(op), ::NullSafeFloats, ::NullSafeFloats) = true
     null_safe_op(::typeof(op), ::NullSafeSignedInts, ::NullSafeSignedInts) = true
     null_safe_op(::typeof(op), ::NullSafeUnsignedInts, ::NullSafeUnsignedInts) = true
 end
 for op in (+, -, *, /)
+    global null_safe_op
     null_safe_op(::typeof(op), ::Type{Complex{S}}, ::Type{T}) where {S,T} =
         null_safe_op(op, T, S)
     null_safe_op(::typeof(op), ::Type{Rational{S}}, ::Type{T}) where {S,T} =

base/test.jl

@@ -1010,7 +1010,7 @@ function testset_forloop(args, testloop)
     end
     quote
         arr = Array{Any,1}(0)
-        first_iteration = true
+        local first_iteration = true
         local ts
         try
             $(Expr(:for, Expr(:block, [esc(v) for v in loopvars]...), blk))

test/abstractarray.jl

@@ -158,7 +158,7 @@ end
             @test ind2sub((0:3,3:5,-101:-100), l) == (i-1, j+2, k-102)
         end
 
-        A = reshape(collect(1:9), (3,3))
+        local A = reshape(collect(1:9), (3,3))
         @test ind2sub(size(A), 6) == (3,2)
         @test sub2ind(size(A), 3, 2) == 6
         @test ind2sub(A, 6) == (3,2)

test/arrayops.jl

@@ -585,30 +585,34 @@ end
 
 # unique across dim
 
-# All rows and columns unique
-A = ones(10, 10)
-A[diagind(A)] = shuffle!([1:10;])
-@test unique(A, 1) == A
-@test unique(A, 2) == A
-
-# 10 repeats of each row
-B = A[shuffle!(repmat(1:10, 10)), :]
-C = unique(B, 1)
-@test sortrows(C) == sortrows(A)
-@test unique(B, 2) == B
-@test unique(B.', 2).' == C
-
-# Along third dimension
-D = cat(3, B, B)
-@test unique(D, 1) == cat(3, C, C)
-@test unique(D, 3) == cat(3, B)
-
 # With hash collisions
 struct HashCollision
     x::Float64
 end
 Base.hash(::HashCollision, h::UInt) = h
-@test map(x->x.x, unique(map(HashCollision, B), 1)) == C
+
+# All rows and columns unique
+let A, B, C, D
+    A = ones(10, 10)
+    A[diagind(A)] = shuffle!([1:10;])
+    @test unique(A, 1) == A
+    @test unique(A, 2) == A
+
+    # 10 repeats of each row
+    B = A[shuffle!(repmat(1:10, 10)), :]
+    C = unique(B, 1)
+    @test sortrows(C) == sortrows(A)
+    @test unique(B, 2) == B
+    @test unique(B.', 2).' == C
+
+    # Along third dimension
+    D = cat(3, B, B)
+    @test unique(D, 1) == cat(3, C, C)
+    @test unique(D, 3) == cat(3, B)
+
+    # With hash collisions
+    @test map(x -> x.x, unique(map(HashCollision, B), 1)) == C
+end
 
 @testset "large matrices transpose" begin
     for i = 1 : 3
@@ -956,7 +960,7 @@ end
 end
 
 @testset "mapslices" begin
-    local a,h,i
+    local a, b, c, m, h, s
     a = rand(5,5)
     s = mapslices(sort, a, [1])
     S = mapslices(sort, a, [2])
@@ -1124,7 +1128,9 @@ end
     for idx in Any[1, 2, 5, 9, 10, 1:0, 2:1, 1:1, 2:2, 1:2, 2:4, 9:8, 10:9, 9:9, 10:10,
                    8:9, 9:10, 6:9, 7:10]
         for repl in Any[[], [11], [11,22], [11,22,33,44,55]]
-            a = [1:10;]; acopy = copy(a)
+            local a
+            a = [1:10;]
+            acopy = copy(a)
             @test splice!(a, idx, repl) == acopy[idx]
             @test a == [acopy[1:(first(idx)-1)]; repl; acopy[(last(idx)+1):end]]
         end
@@ -1266,9 +1272,10 @@ end
 end
 
 # issue 4228
-A = [[i i; i i] for i=1:2]
-@test cumsum(A) == Any[[1 1; 1 1], [3 3; 3 3]]
-@test cumprod(A) == Any[[1 1; 1 1], [4 4; 4 4]]
+let A = [[i i; i i] for i=1:2]
+    @test cumsum(A) == Any[[1 1; 1 1], [3 3; 3 3]]
+    @test cumprod(A) == Any[[1 1; 1 1], [4 4; 4 4]]
+end
 
 @testset "prepend/append" begin
     # PR #4627
@@ -1293,9 +1300,10 @@ A = [[i i; i i] for i=1:2]
     @test prepend!([1,2], OffsetArray([9,8], (-3,))) == [9,8,1,2]
 end
 
-A = [1,2]
-s = Set([1,2,3])
-@test sort(append!(A, s)) == [1,1,2,2,3]
+let A = [1,2]
+    s = Set([1,2,3])
+    @test sort(append!(A, s)) == [1,1,2,2,3]
+end
 
 @testset "cases where shared arrays can/can't be grown" begin
     A = [1 3;2 4]
@@ -1332,8 +1340,10 @@ end
 
 # issue #6645 (32-bit)
 let x = Float64[]
-    for i=1:5; push!(x, 1.0); end
-    @test dot(zeros(5),x) == 0.0
+    for i = 1:5
+        push!(x, 1.0)
+    end
+    @test dot(zeros(5), x) == 0.0
 end
 
 # issue #6977
@@ -1346,10 +1356,12 @@ end
 @test map(join, ["z", "я"]) == ["z", "я"]
 
 # Handle block matrices
-A = [randn(2,2) for i = 1:2, j = 1:2]
-@test issymmetric(A.'A)
-A = [complex.(randn(2,2), randn(2,2)) for i = 1:2, j = 1:2]
-@test ishermitian(A'A)
+let A = [randn(2, 2) for i = 1:2, j = 1:2]
+    @test issymmetric(A.'A)
+end
+let A = [complex.(randn(2, 2), randn(2, 2)) for i = 1:2, j = 1:2]
+    @test ishermitian(A'A)
+end
 
 # issue #7197
 function i7197()
@@ -1794,25 +1806,30 @@ for (a,s) in zip(A, S)
     @test a == s
 end
 
-C = copy(B)
-@test A == C
-@test B == C
+let C = copy(B)
+    @test A == C
+    @test B == C
+end
 
 @test vec(A) == vec(B) == vec(S)
 @test minimum(A) == minimum(B) == minimum(S)
 @test maximum(A) == maximum(B) == maximum(S)
 
-a, ai = findmin(A)
-b, bi = findmin(B)
-s, si = findmin(S)
-@test a == b == s
-@test ai == bi == si
+let
+    a, ai = findmin(A)
+    b, bi = findmin(B)
+    s, si = findmin(S)
+    @test a == b == s
+    @test ai == bi == si
+end
 
-a, ai = findmax(A)
-b, bi = findmax(B)
-s, si = findmax(S)
-@test a == b == s
-@test ai == bi == si
+let
+    a, ai = findmax(A)
+    b, bi = findmax(B)
+    s, si = findmax(S)
+    @test a == b == s
+    @test ai == bi == si
+end
 
 for X in (A, B, S)
     @test findmin(X) == findmin(Dict(pairs(X)))
@@ -1970,6 +1987,7 @@ end
 end
 
 @testset "sign, conj, ~" begin
+    local A, B, C
     A = [-10,0,3]
     B = [-10.0,0.0,3.0]
     C = [1,im,0]
@@ -1991,7 +2009,7 @@ end
 end
 
 @testset "issue #16247" begin
-    A = zeros(3,3)
+    local A = zeros(3,3)
     @test size(A[:,0x1:0x2]) == (3, 2)
     @test size(A[:,UInt(1):UInt(2)]) == (3,2)
     @test size(similar(A, UInt(3), 0x3)) == size(similar(A, (UInt(3), 0x3))) == (3,3)
@@ -2007,11 +2025,12 @@ for op in (:+, :*, :÷, :%, :<<, :>>, :-, :/, :\, ://, :^)
     @eval import Base.$(op)
     @eval $(op)(::Foo, ::Foo) = Foo()
 end
-A = fill(Foo(), 10, 10)
-@test typeof(A+A) == Matrix{Foo}
-@test typeof(A-A) == Matrix{Foo}
-for op in (:.+, :.*, :.÷, :.%, :.<<, :.>>, :.-, :./, :.\, :.//, :.^)
-    @eval @test typeof($(op)(A,A)) == Matrix{Foo}
+let A = fill(Foo(), 10, 10)
+    @test isa(A + A, Matrix{Foo})
+    @test isa(A - A, Matrix{Foo})
+    for op in (:+, :*, :÷, :%, :<<, :>>, :-, :/, :\, ://, :^)
+        @test isa(broadcast(eval(op), A, A), Matrix{Foo})
+    end
 end
 
 end # module AutoRetType

test/backtrace.jl

@@ -6,7 +6,7 @@ for l in bt
     lkup = ccall(:jl_lookup_code_address, Any, (Ptr{Void}, Cint), l, true)
     if lkup[1][1] == :backtrace
         @test lkup[1][5] == false # fromC
-        have_backtrace = true
+        global have_backtrace = true
         break
     end
 end
@@ -115,10 +115,10 @@ hasbt = hasbt2 = false
 for sfs in lkup
     for sf in sfs
         if sf.func == :bt
-            hasbt = true
+            global hasbt = true
         end
         if sf.func == :bt2
-            hasbt2 = true
+            global hasbt2 = true
         end
     end
 end
@@ -138,10 +138,10 @@ hasme = hasbtmacro = false
 for sfs in lkup
     for sf in sfs
         if sf.func == Symbol("macro expansion")
-            hasme = true
+            global hasme = true
         end
         if sf.func == :btmacro
-            hasbtmacro = true
+            global hasbtmacro = true
         end
     end
 end

test/bigint.jl

@@ -250,21 +250,22 @@ function bigfib(n)
 end
 @test [bigfib(n) for n=0:10] == [0,1,1,2,3,5,8,13,21,34,55]
 
-n = bigfib(1000001)
-@test ndigits(n) == 208988
-@test mod(n,big(10)^15) == 359244926937501
-@test div(n,big(10)^208973) == 316047687386689
-
-s = string(n)
-@test length(s) == 208988
-@test endswith(s, "359244926937501")
-@test startswith(s, "316047687386689")
+let s, n = bigfib(1000001)
+    @test ndigits(n) == 208988
+    @test mod(n,big(10)^15) == 359244926937501
+    @test div(n,big(10)^208973) == 316047687386689
+
+    s = string(n)
+    @test length(s) == 208988
+    @test endswith(s, "359244926937501")
+    @test startswith(s, "316047687386689")
+end
 
 # serialization (#5133)
-let n = parse(BigInt,"359334085968622831041960188598043661065388726959079837")
+let n = parse(BigInt, "359334085968622831041960188598043661065388726959079837"),
     b = IOBuffer()
-    serialize(b,n)
-    seek(b,0)
+    serialize(b, n)
+    seek(b, 0)
     @test deserialize(b) == n
 end