deduplicate

Author: nsajko

test/no_invalidations.jl

@@ -51,60 +51,30 @@ function test_expr(f, supertype::Type = Integer)
 end
 
 @testset "no invalidations test set" begin
+    int_types = (Bool, Int8, UInt8, Int16, UInt16, Int, UInt, BigInt)
     @testset "construction of old int types from new type" begin
-        @test test_expr(n -> :(Base.Bool(::$n) = false))
-        @test test_expr(n -> :(Base.Int8(::$n) = Int8(0))) broken=true
-        @test test_expr(n -> :(Base.UInt8(::$n) = UInt8(0))) broken=true
-        @test test_expr(n -> :(Base.Int16(::$n) = Int16(0)))
-        @test test_expr(n -> :(Base.UInt16(::$n) = UInt16(0))) broken=true
-        @test test_expr(n -> :(Base.Int(::$n) = 0)) broken=true
-        @test test_expr(n -> :(Base.UInt(::$n) = 0x0)) broken=true
+        broken = (Int8, UInt8, UInt16, Int, UInt)
+        @testset "T: $T" for T ∈ int_types
+            @test test_expr(n -> :(Base.$T(::$n) = $T(0))) broken=(T ∈ broken)
+        end
     end
     @testset "arithmetic between old int types and new int type" begin
-        @test test_expr(n -> :(Base.:(+)(::$n, m::Bool) = m))
-        @test test_expr(n -> :(Base.:(+)(m::Bool, ::$n) = m))
-        @test test_expr(n -> :(Base.:(+)(::$n, m::Int8) = m))
-        @test test_expr(n -> :(Base.:(+)(m::Int8, ::$n) = m))
-        @test test_expr(n -> :(Base.:(+)(::$n, m::UInt8) = m))
-        @test test_expr(n -> :(Base.:(+)(m::UInt8, ::$n) = m))
-        @test test_expr(n -> :(Base.:(+)(::$n, m::Int16) = m))
-        @test test_expr(n -> :(Base.:(+)(m::Int16, ::$n) = m))
-        @test test_expr(n -> :(Base.:(+)(::$n, m::UInt16) = m))
-        @test test_expr(n -> :(Base.:(+)(m::UInt16, ::$n) = m))
-        @test test_expr(n -> :(Base.:(+)(::$n, m::Int) = m))
-        @test test_expr(n -> :(Base.:(+)(m::Int, ::$n) = m)) broken=true
-        @test test_expr(n -> :(Base.:(+)(::$n, m::UInt) = m))
-        @test test_expr(n -> :(Base.:(+)(m::UInt, ::$n) = m))
+        broken = (Int,)
+        @testset "T: $T" for T ∈ int_types
+            @test (
+                test_expr(n -> :(Base.:(+)(::$n, m::$T) = m)) &&
+                test_expr(n -> :(Base.:(+)(m::$T, ::$n) = m))
+            ) broken=(T ∈ broken)
+        end
     end
     @testset "promotion between old int types and new int type" begin
-        @test (
-            test_expr(n -> :(Base.promote_rule(::Type{Bool}, ::Type{$n}) = Bool)) &&
-            test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{Bool}) = Bool))
-        ) broken=true
-        @test (
-            test_expr(n -> :(Base.promote_rule(::Type{Int8}, ::Type{$n}) = Int8)) &&
-            test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{Int8}) = Int8))
-        )
-        @test (
-            test_expr(n -> :(Base.promote_rule(::Type{UInt8}, ::Type{$n}) = UInt8)) &&
-            test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{UInt8}) = UInt8))
-        ) broken=true
-        @test (
-            test_expr(n -> :(Base.promote_rule(::Type{Int16}, ::Type{$n}) = Int16)) &&
-            test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{Int16}) = Int16))
-        )
-        @test (
-            test_expr(n -> :(Base.promote_rule(::Type{UInt16}, ::Type{$n}) = UInt16)) &&
-            test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{UInt16}) = UInt16))
-        )
-        @test (
-            test_expr(n -> :(Base.promote_rule(::Type{Int}, ::Type{$n}) = Int)) &&
-            test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{Int}) = Int))
-        ) broken=true
-        @test (
-            test_expr(n -> :(Base.promote_rule(::Type{UInt}, ::Type{$n}) = UInt)) &&
-            test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{UInt}) = UInt))
-        )
+        broken = (Bool, UInt8, Int)
+        @testset "T: $T" for T ∈ int_types
+            @test (
+                test_expr(n -> :(Base.promote_rule(::Type{$T}, ::Type{$n}) = $T)) &&
+                test_expr(n -> :(Base.promote_rule(::Type{$n}, ::Type{$T}) = $T))
+            ) broken=(T ∈ broken)
+        end
     end
     @testset "unary functions" begin
         @test test_expr(n -> :(Base.zero(::$n) = $n())) broken=true