clock.swift

// RUN: %target-typecheck-verify-swift -strict-concurrency=complete -disable-availability-checking -parse-as-library
// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking -parse-as-library)

// REQUIRES: concurrency
// REQUIRES: executable_test
// REQUIRES: concurrency_runtime

// Test requires _swift_task_enterThreadLocalContext which is not available 
// in the back deployment runtime.
// UNSUPPORTED: back_deployment_runtime
// UNSUPPORTED: back_deploy_concurrency

import _Concurrency
import StdlibUnittest

@MainActorvartests=TestSuite("Time")

@mainstructMain{
staticfunc main()async{
 tests.test("ContinuousClock sleep")
.skip(.always("failed despite increased timeout (rdar://94451729)"))
.code{
letclock=ContinuousClock()
letelapsed=await clock.measure{
try!await clock.sleep(until:.now +.milliseconds(100))
}
 // give a reasonable range of expected elapsed time
expectGT(elapsed,.milliseconds(90))
expectLT(elapsed,.milliseconds(1000))
}

 tests.test("ContinuousClock sleep with tolerance")
.skip(.always("failed despite increased timeout (rdar://94451729)"))
.code{
letclock=ContinuousClock()
letelapsed=await clock.measure{
try!await clock.sleep(until:.now +.milliseconds(100), tolerance:.milliseconds(100))
}
 // give a reasonable range of expected elapsed time
expectGT(elapsed,.milliseconds(90))
expectLT(elapsed,.milliseconds(2000))
}

 tests.test("ContinuousClock sleep longer")
.skip(.always("failed despite increased timeout (rdar://94451729)"))
.code{
letelapsed=awaitContinuousClock().measure{
try!awaitTask.sleep(until:.now +.seconds(1), clock:.continuous)
}
expectGT(elapsed,.seconds(1)-.milliseconds(90))
expectLT(elapsed,.seconds(1)+.milliseconds(1000))
}

 tests.test("SuspendingClock sleep")
.skip(.always("failed despite increased timeout (rdar://94451729)"))
.code{
letclock=SuspendingClock()
letelapsed=await clock.measure{
try!await clock.sleep(until:.now +.milliseconds(100))
}
 // give a reasonable range of expected elapsed time
expectGT(elapsed,.milliseconds(90))
expectLT(elapsed,.milliseconds(1000))
}

 tests.test("SuspendingClock sleep with tolerance")
.skip(.always("failed despite increased timeout (rdar://94451729)"))
.code{
letclock=SuspendingClock()
letelapsed=await clock.measure{
try!await clock.sleep(until:.now +.milliseconds(100), tolerance:.milliseconds(100))
}
 // give a reasonable range of expected elapsed time
expectGT(elapsed,.milliseconds(90))
expectLT(elapsed,.milliseconds(2000))
}

 tests.test("SuspendingClock sleep longer")
.skip(.always("failed despite increased timeout (rdar://94451729)"))
.code{
letelapsed=awaitSuspendingClock().measure{
try!awaitTask.sleep(until:.now +.seconds(1), clock:.suspending)
}
expectGT(elapsed,.seconds(1)-.milliseconds(90))
expectLT(elapsed,.seconds(1)+.milliseconds(1000))
}

 tests.test("duration addition"){
letd1=Duration.milliseconds(500)
letd2=Duration.milliseconds(500)
letd3=Duration.milliseconds(-500)
letsum= d1 + d2
expectEqual(sum,.seconds(1))
letcomps= sum.components
expectEqual(comps.seconds,1)
expectEqual(comps.attoseconds,0)
letadjusted= sum + d3
expectEqual(adjusted,.milliseconds(500))
}

 tests.test("duration subtraction"){
letd1=Duration.nanoseconds(500)
letd2= d1 -.nanoseconds(100)
expectEqual(d2,.nanoseconds(400))
letd3= d1 -.nanoseconds(500)
expectEqual(d3,.nanoseconds(0))
letd4= d1 -.nanoseconds(600)
expectEqual(d4,.nanoseconds(-100))
}

 tests.test("duration division"){
letd1=Duration.seconds(1)
lethalfSecond= d1 /2
expectEqual(halfSecond,.milliseconds(500))
}

 tests.test("duration multiplication"){
letd1=Duration.seconds(1)
lettwoSeconds= d1 *2
expectEqual(twoSeconds,.seconds(2))
}

 tests.test("Duration components/whole second increments"){
foriin0..<1_000_000{
letd=Duration.seconds(i)
letcomps= d.components
expectEqual(comps.seconds,Int64(i))
expectEqual(comps.attoseconds,0)
}
}

 tests.test("Duration components/1ms increments"){
foriin0..<1_000_000{
letd=Duration.milliseconds(i)
letcomps= d.components
expectEqual(comps.seconds,Int64(i /1000))
expectEqual(comps.attoseconds,Int64(i %1000)*1_000_000_000_000_000)
}
}

 tests.test("Duration components/100µs increments"){
foriin0..<1_000_000{
letms=100* i
letd=Duration.microseconds(ms)
letcomps= d.components
expectEqual(comps.seconds,Int64(ms /1_000_000))
expectEqual(comps.attoseconds,Int64(ms %1_000_000)*1_000_000_000_000)
}
}

 tests.test("Duration components/200ns increments"){
foriin0..<1_000_000{
letns=200* i
letd=Duration.nanoseconds(ns)
letcomps= d.components
expectEqual(comps.seconds,Int64(ns /1_000_000_000))
expectEqual(comps.attoseconds,Int64(ns %1_000_000_000)*1_000_000_000)
}
}

awaitrunAllTestsAsync()
}
}