dymokomi/luce-std
Source of release 0.7.2
0.7.2 / tests / net_readiness / main.lucb
import sync
import c
import io
import memory
from luce_std import net
import thread
import platform
extern func reference_begin(kind: i32)
extern func reference_end() -> i32
extern func reference_cancel_callback(callback: func(void*) -> unit, context: void*)
extern func reference_delay()
func cancel_now(context: void*):
let cancellation = (sync.Cancellation*)context
cancellation.request()
func cancel_later(context: void*):
reference_delay()
cancel_now(context)
func no_events(ready: net.Readiness) -> bool:
return not ready.readable and not ready.writable and not ready.hangup and not ready.failure and not ready.invalid
pub func main(arguments: c.str[]) -> i32!:
if platform.windows:
print("skip: reference.c drives poll and the clock through dlsym")
return 0
var packet = try net.Datagram.bind(net.SocketAddress.loopback(0))
defer packet.destroy()
try packet.set_nonblocking(true)
let fd = packet.descriptor() else trap("datagram descriptor")
var poller = try net.Poller.create(2)
defer poller.destroy()
assert(poller.capacity() == 2)
try poller.watch(0, fd)
assert((try poller.wait(try net.Deadline.after(0))) == 0)
assert(no_events(try poller.readiness(0)) and no_events(try poller.readiness(1)))
reference_begin(1)
let interrupted_deadline = try net.Deadline.after(100000000)
assert((try poller.wait(interrupted_deadline)) == 1)
assert((try poller.readiness(0)).readable and not (try poller.readiness(0)).failure)
assert(reference_end() == 2)
reference_begin(2)
assert((try poller.wait(try net.Deadline.after(100000000))) == 0)
assert(no_events(try poller.readiness(0)) and reference_end() == 2)
reference_begin(3)
var rejected = false
_ = poller.wait(net.Deadline.at(1)) catch failure:
assert(failure.code == net.failed)
rejected = true
recover 0
assert(rejected and no_events(try poller.readiness(0)) and reference_end() == 0)
var cancellation: sync.Cancellation
reference_cancel_callback(cancel_now, &cancellation)
reference_begin(4)
rejected = false
_ = poller.wait(cancellation = &cancellation) catch failure:
assert(failure.code == net.cancelled)
rejected = true
recover 0
assert(rejected and cancellation.is_requested() and no_events(try poller.readiness(0)))
assert(reference_end() == 1)
reference_begin(5)
rejected = false
_ = poller.wait() catch failure:
assert(failure.code == net.failed)
rejected = true
recover 0
assert(rejected and no_events(try poller.readiness(0)) and reference_end() == 1)
var sender = try net.Datagram.bind(net.SocketAddress.loopback(0))
defer sender.destroy()
try sender.send_to("ready".bytes, try packet.address())
let ready = try packet.wait(deadline = try net.Deadline.after(1000000000))
assert(ready.readable and not ready.invalid)
rejected = false
poller.watch(1, fd) catch failure:
assert(failure.code == net.invalid_options)
rejected = true
assert(rejected and no_events(try poller.readiness(1)))
let sender_fd = sender.descriptor() else trap("sender descriptor")
try poller.watch(1, sender_fd, net.WaitInterest.write)
assert((try poller.wait(net.Deadline.at(0))) == 2)
assert((try poller.readiness(0)).readable and (try poller.readiness(1)).writable)
var data: u8[8]
let (count, peer) = try packet.receive_from(data)
assert(count == 5 and (str)data[..<count] == "ready")
_ = peer
rejected = false
_ = packet.wait(deadline = net.Deadline.at(0)) catch failure:
assert(failure.code == net.timed_out)
rejected = true
recover net.Readiness()
assert(rejected)
try poller.disable(1)
packet.destroy()
assert((try poller.wait(net.Deadline.at(0))) == 1)
assert((try poller.readiness(0)).invalid)
try poller.disable(0)
var concurrent: sync.Cancellation
let worker = try thread.spawn(cancel_later, &concurrent)
rejected = false
_ = poller.wait(cancellation = &concurrent) catch failure:
assert(failure.code == net.cancelled)
rejected = true
recover 0
try worker.join()
assert(rejected and concurrent.is_requested())
var listener = try net.Listener.bind(net.SocketAddress.loopback(0))
defer listener.destroy()
var client = try net.Connection.connect(try listener.address())
defer client.destroy()
assert((try listener.wait(deadline = try net.Deadline.after(1000000000))).readable)
var server = try listener.accept(true)
defer server.destroy()
assert((try client.wait(net.WaitInterest.write, try net.Deadline.after(1000000000))).writable)
try io.write_all(&client, "tail".bytes)
try client.shutdown(net.ShutdownDirection.write)
assert((try server.wait(deadline = try net.Deadline.after(1000000000))).readable)
try io.read_exact(&server, data[..<4])
assert((str)data[..<4] == "tail")
_ = try server.wait(deadline = try net.Deadline.after(1000000000))
assert((try server.read(data)) == 0)
rejected = false
_ = net.Deadline.after(18446744073709551615) catch failure:
assert(failure.code == net.invalid_options)
rejected = true
recover net.Deadline()
assert(rejected)
rejected = false
poller.watch(2, fd) catch failure:
assert(failure.code == net.invalid_options)
rejected = true
assert(rejected)
# The retained allocator owns exactly the original extent after context changes.
var storage: u64[8]
var owner = memory.FixedBuffer.over(u8[]((u8*)&storage[0], 64))
var owned: net.Poller
with owner:
owned = try net.Poller.create(8)
owned.destroy()
owned.destroy()
assert(owner.allocate(64, 4) != none)
var empty: u8[]
var refusing = memory.FixedBuffer.over(empty)
rejected = false
with refusing:
var unavailable = net.Poller.create(1) catch failure:
assert(failure.code == memory.exhausted)
rejected = true
recover net.Poller()
unavailable.destroy()
assert(rejected)
with refusing:
assert((try poller.wait(net.Deadline.at(0))) == 0)
poller.destroy()
rejected = false
_ = poller.wait() catch failure:
assert(failure.code == net.closed)
rejected = true
recover 0
assert(rejected)
print("ok readiness deadlines and cancellation")
return 0