types.jl: sleep with Date.Period types

Supports sleep(Dates.Second(10))
		 sleep(Dates.Milliesecond(10))

Closes #19736

Author: Shade5

base/dates/types.jl

@@ -241,3 +241,8 @@ Base.isless(x::Date,y::Date) = isless(value(x),value(y))
 Base.isless(x::DateTime,y::DateTime) = isless(value(x),value(y))
 Base.isless(x::TimeType,y::TimeType) = isless(promote(x,y)...)
 ==(x::TimeType,y::TimeType) = ===(promote(x,y)...)
+
+import Base: sleep,Timer,timedwait
+sleep(time::Period) = sleep(toms(time) / 1000)
+Timer(time::Period, repeat::Period=Second(0)) = Timer(toms(time) / 1000,toms(repeat) / 1000)
+timedwait(testcb::Function, time::Period) = timedwait(testcb, toms(time) / 1000)

test/channels.jl

@@ -103,3 +103,30 @@ end
     end
     @test isready(rr1)
 end
+
+@sync begin
+    rr1 = Channel(1)
+    rr2 = Channel(1)
+    rr3 = Channel(1)
+
+    callback2() = all(map(isready, [rr1, rr2, rr3]))
+    # precompile functions which will be tested for execution time
+    @test !callback2()
+    @test timedwait(callback2, 0.0) === :timed_out
+
+    @async begin sleep(0.5); put!(rr1, :ok) end
+    @async begin sleep(1.0); put!(rr2, :ok) end
+    @async begin sleep(2.0); put!(rr3, :ok) end
+
+    tic()
+    timedwait(callback2, Dates.Second(1))
+    et=toq()
+    # assuming that 0.5 seconds is a good enough buffer on a typical modern CPU
+    try
+        @assert (et >= 1.0) && (et <= 1.5)
+        @assert !isready(rr3)
+    catch
+        warn("timedwait-Period tests delayed. et=$et, isready(rr3)=$(isready(rr3))")
+    end
+    @test isready(rr1)
+end

test/threads.jl

@@ -347,37 +347,38 @@ for T in (Int32, Int64, Float32, Float64)
     @test varmax[] === T(maximum(1:nloops))
     @test varmin[] === T(0)
 end
-
-let async = Base.AsyncCondition(), t
-    c = Condition()
-    task = schedule(Task(function()
-        notify(c)
-        wait(c)
-        t = Timer(0.06)
-        wait(t)
-        ccall(:uv_async_send, Void, (Ptr{Void},), async)
-        ccall(:uv_async_send, Void, (Ptr{Void},), async)
+for period in (0.06, Dates.Millisecond(60))
+    let async = Base.AsyncCondition(), t
+        c = Condition()
+        task = schedule(Task(function()
+            notify(c)
+            wait(c)
+            t = Timer(period)
+            wait(t)
+            ccall(:uv_async_send, Void, (Ptr{Void},), async)
+            ccall(:uv_async_send, Void, (Ptr{Void},), async)
+            wait(c)
+            sleep(period)
+            ccall(:uv_async_send, Void, (Ptr{Void},), async)
+            ccall(:uv_async_send, Void, (Ptr{Void},), async)
+        end))
         wait(c)
-        sleep(0.06)
-        ccall(:uv_async_send, Void, (Ptr{Void},), async)
-        ccall(:uv_async_send, Void, (Ptr{Void},), async)
-    end))
-    wait(c)
-    notify(c)
-    delay1 = @elapsed wait(async)
-    notify(c)
-    delay2 = @elapsed wait(async)
-    @test istaskdone(task)
-    @test delay1 > 0.05
-    @test delay2 > 0.05
-    @test isopen(async)
-    @test !isopen(t)
-    close(t)
-    close(async)
-    @test_throws EOFError wait(async)
-    @test !isopen(async)
-    @test_throws EOFError wait(t)
-    @test_throws EOFError wait(async)
+        notify(c)
+        delay1 = @elapsed wait(async)
+        notify(c)
+        delay2 = @elapsed wait(async)
+        @test istaskdone(task)
+        @test delay1 > 0.05
+        @test delay2 > 0.05
+        @test isopen(async)
+        @test !isopen(t)
+        close(t)
+        close(async)
+        @test_throws EOFError wait(async)
+        @test !isopen(async)
+        @test_throws EOFError wait(t)
+        @test_throws EOFError wait(async)
+    end
 end
 
 # Compare the two ways of checking if threading is enabled.