fix invalid input for .., capture warnings in tests

Author: lucaferranti

src/intervals/intervals.jl

@@ -25,7 +25,8 @@ struct Interval{T<:Real} <: AbstractInterval{T}
                 new(a, b)
 
             else
-                throw(ArgumentError("Interval of form [$a, $b] not allowed. Must have a ≤ b to construct interval(a, b)."))
+                @warn "Invalid input, empty interval is returned"
+                return new(T(Inf), T(-Inf))
             end
 
         end
@@ -82,13 +83,7 @@ function is_valid_interval(a::Real, b::Real)
         return false
     end
 
-    if a > b
-        if isinf(a) && isinf(b)
-            return true  # empty interval = [∞,-∞]
-        else
-            return false
-        end
-    end
+    a > b && return false
 
     if a == Inf || b == -Inf
         return false
@@ -138,21 +133,32 @@ include("complex.jl")
 # Syntax for intervals
 
 function ..(a::T, b::S) where {T, S}
-    interval(atomic(Interval{T}, a).lo, atomic(Interval{S}, b).hi)
+    if !is_valid_interval(a, b)
+        @warn "Invalid input, empty interval is returned"
+        return emptyinterval(promote_type(T, S, Float64))
+    end
+    Interval(atomic(Interval{T}, a).lo, atomic(Interval{S}, b).hi)
 end
 
 function ..(a::T, b::Irrational{S}) where {T, S}
+    if !is_valid_interval(a, b)
+        @warn "Invalid input, empty interval is returned"
+        return emptyinterval(promote_type(T, Irrational{S}, Float64))
+    end
     R = promote_type(T, Irrational{S})
-    interval(atomic(Interval{R}, a).lo, R(b, RoundUp))
+    Interval(atomic(Interval{R}, a).lo, R(b, RoundUp))
 end
 
 function ..(a::Irrational{T}, b::S) where {T, S}
+    if !is_valid_interval(a, b)
+        @warn "Invalid input, empty interval is returned"
+        return emptyinterval(promote_type(Irrational{T}, S, Float64))
+    end
     R = promote_type(Irrational{T}, S)
-    return interval(R(a, RoundDown), atomic(Interval{R}, b).hi)
+    return Interval(R(a, RoundDown), atomic(Interval{R}, b).hi)
 end
 
 function ..(a::Irrational{T}, b::Irrational{S}) where {T, S}
-    R = promote_type(Irrational{T}, Irrational{S})
     return interval(a, b)
 end
 

test/interval_tests/consistency.jl

@@ -380,10 +380,10 @@ setprecision(Interval, Float64)
         @test interval(1, 2) == Interval(1, 2)
 
         @test inf(Interval(3, 2)) == 3
-        @test isempty(interval(3, 2))
+        @test_logs (:warn,) @test isempty(interval(3, 2))
 
         @test sup(Interval(Inf, Inf)) == Inf
-        @test isempty(interval(Inf, Inf))
+        @test_logs (:warn,) @test isempty(interval(Inf, Inf))
 
     end
 

test/interval_tests/construction.jl

@@ -69,20 +69,20 @@ const eeuler = Base.MathConstants.e
 
     # Disallowed conversions with a > b
 
-    @test isempty(interval(2, 1))
-    @test isempty(interval(big(2), big(1)))
-    @test isempty(interval(BigInt(1), 1//10))
-    @test isempty(interval(1, 0.1))
-    @test isempty(interval(big(1), big(0.1)))
-
-    @test isempty(@interval(2, 1))
-    @test isempty(@interval(big(2), big(1)))
-    @test isempty(@interval(big(1), 1//10))
-    @test isempty(@interval(1, 0.1))
-    @test isempty(@interval(big(1), big(0.1)))
-    @test isempty(interval(Inf))
-    @test isempty(interval(-Inf, -Inf))
-    @test isempty(interval(Inf, Inf))
+    @test_logs (:warn,) @test isempty(interval(2, 1))
+    @test_logs (:warn,) @test isempty(interval(big(2), big(1)))
+    @test_logs (:warn,) @test isempty(interval(BigInt(1), 1//10))
+    @test_logs (:warn,) @test isempty(interval(1, 0.1))
+    @test_logs (:warn,) @test isempty(interval(big(1), big(0.1)))
+
+    @test_logs (:warn,) @test isempty(@interval(2, 1))
+    @test_logs (:warn,) @test isempty(@interval(big(2), big(1)))
+    @test_logs (:warn,) @test isempty(@interval(big(1), 1//10))
+    @test_logs (:warn,) @test isempty(@interval(1, 0.1))
+    @test_logs (:warn,) @test isempty(@interval(big(1), big(0.1)))
+    @test_logs (:warn,) @test isempty(interval(Inf))
+    @test_logs (:warn,) @test isempty(interval(-Inf, -Inf))
+    @test_logs (:warn,) @test isempty(interval(Inf, Inf))
 
     # Conversion to Interval without type
     @test convert(Interval, 1) == Interval(1.0)
@@ -237,10 +237,10 @@ end
     a = big(0.1)..2
     @test typeof(a) == Interval{BigFloat}
 
-    @test isempty(2..1)
-    @test isempty(π..1)
-    @test isempty(π..eeuler)
-    @test isempty(4..π)
+    @test_logs (:warn, ) @test isempty(2..1)
+    @test_logs (:warn, ) @test isempty(π..1)
+    @test_logs (:warn, ) @test isempty(π..eeuler)
+    @test_logs (:warn, ) @test isempty(4..π)
     @test 1..π == Interval(1, π)
 end
 
@@ -293,9 +293,9 @@ end
 
 # issue 192:
 @testset "Disallow NaN in an interval" begin
-    @test isempty(interval(NaN, 2))
-    @test isempty(interval(Inf, NaN))
-    @test isempty(interval(NaN, NaN))
+    @test_logs (:warn, ) @test isempty(interval(NaN, 2))
+    @test_logs (:warn, ) @test isempty(interval(Inf, NaN))
+    @test_logs (:warn, ) @test isempty(interval(NaN, NaN))
 end
 
 # issue 206:
@@ -343,7 +343,7 @@ end
 end
 
 @testset "a..b with a > b" begin
-    @test isempty(3..2)
+    @test_logs (:warn,) @test isempty(3..2)
 end
 
 @testset "Hashing of Intervals" begin
@@ -375,7 +375,7 @@ import IntervalArithmetic: force_interval
     @test force_interval(4, Inf) == Interval(4, Inf)
     @test force_interval(Inf, 4) == Interval(4, Inf)
     @test force_interval(Inf, -Inf) == Interval(-Inf, Inf)
-    @test isempty(force_interval(NaN, 3))
+    @test_logs (:warn,) @test isempty(force_interval(NaN, 3))
 end
 
 @testset "Zero interval" begin

test/interval_tests/numeric.jl

@@ -115,7 +115,7 @@ end
     @test Interval(1,2) ^ -3 == Interval(1/8, 1.0)
     @test Interval(0,3) ^ -3 == @interval(1/27, Inf)
     @test Interval(-1,2) ^ -3 == entireinterval()
-    @test isempty(interval(-1, -2) ^ -3)  # wrong way round
+    @test_logs (:warn, ) @test isempty(interval(-1, -2) ^ -3)
     @test Interval(-3,2) ^ (3//1) == Interval(-27, 8)
     @test Interval(0.0) ^ 1.1 == Interval(0, 0)
     @test Interval(0.0) ^ 0.0 == emptyinterval()