Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-std

Source of release 0.7.1

0.7.1 / tests / net / event_loop.lucb

## The pieces of `net` an event loop drives: a connection begun without waiting
## (`Connection.start_connect`, completed by `finish_connect` after write readiness), its
## failure when nothing listens, and host name resolution off the caller's thread
## (`Lookup`): a numeric address answered at once, a name answered on a thread that signals
## a watched descriptor, a failed name, and a lookup abandoned while it runs.

## Waits up to five seconds for `descriptor` to be ready for `interest` through a poller.
## The wait ends as soon as it is ready; the margin is for Windows, which reports a refused
## loopback connect only after retrying the SYN (about two seconds after start_connect).
func wait_ready(descriptor: platform.SocketDescriptor, interest: WaitInterest) -> Readiness:
    var poller = Poller.create(1) else trap("a poller")
    defer poller.destroy()
    poller.watch(0, descriptor, interest) else trap("the descriptor is watched")
    let deadline = Deadline.after(5000000000) else trap("a deadline")
    let count = poller.wait(deadline) else trap("the wait")
    assert(count == 1)
    return poller.readiness(0) else trap("the slot's readiness")

test "start_connect begins a connection without waiting; finish_connect completes it after write readiness":
    var listener = Listener.bind(SocketAddress.loopback(0)) else trap("a listener")
    defer listener.destroy()
    let address = listener.address() else trap("its address")
    var connection = Connection.start_connect(address) else trap("the connect starts")
    defer connection.destroy()
    assert(connection.is_nonblocking() else false)
    let ready = wait_ready(connection.descriptor() else trap("a descriptor"), WaitInterest.write)
    assert(ready.writable)
    assert(connection.finish_connect() else false)
    # Completed: asking again answers true at once.
    assert(connection.finish_connect() else false)
    var accepted = listener.accept() else trap("the connection is accepted")
    defer accepted.destroy()
    let hello: u8[5] = ['h', 'e', 'l', 'l', 'o']
    assert((connection.write(hello) else 0) == 5)
    var buffer: u8[8]
    assert((accepted.read(buffer) else 0) == 5)
    # Nothing to read on the nonblocking side: would_block, not a wait.
    var refused = false
    _ = connection.read(buffer) catch failure:
        assert(failure.code == io.would_block)
        refused = true
        recover 0
    assert(refused)

test "finish_connect reports a refused connection":
    var listener = Listener.bind(SocketAddress.loopback(0)) else trap("a listener")
    let address = listener.address() else trap("its address")
    listener.destroy()
    var connection = Connection.start_connect(address) catch failure:
        # Some hosts refuse a loopback connection at once.
        assert(failure.code == connection_refused)
        return
    defer connection.destroy()
    var outcome: ErrorCode? = none
    for _ in 0..<100:
        let done = connection.finish_connect() catch failure:
            outcome = failure.code
            break
        assert(not done)
        _ = wait_ready(connection.descriptor() else trap("a descriptor"), WaitInterest.write)
    assert(outcome == connection_refused)

test "Lookup answers a numeric address at once, without a thread":
    var lookup_here = Lookup.start("127.0.0.1", 8080) else trap("the lookup_here starts")
    defer lookup_here.destroy()
    assert(lookup_here.descriptor() == none and lookup_here.finished())
    var addresses = lookup_here.take() else trap("the answer")
    defer addresses.destroy()
    assert(addresses.view().length == 1 and addresses.view()[0].port == 8080)
    assert(addresses.view()[0].ip.equals(IpAddress.parse("127.0.0.1") else trap("parses")))
    var again = false
    _ = lookup_here.take() catch failure:
        assert(failure.code == closed)
        again = true
        recover ResolvedAddresses()
    assert(again)

test "Lookup resolves a name on its own thread and signals its descriptor":
    var lookup_here = Lookup.start("localhost", 80) else trap("the lookup_here starts")
    defer lookup_here.destroy()
    let descriptor = lookup_here.descriptor() else trap("a name is resolved on a thread")
    let ready = wait_ready(descriptor, WaitInterest.read)
    assert(ready.readable and lookup_here.finished())
    var addresses = lookup_here.take() else trap("localhost resolves")
    defer addresses.destroy()
    assert(addresses.view().length >= 1)
    for address in addresses.view():
        assert(address.port == 80)

test "Lookup reports a name that does not resolve, and may be abandoned while it runs":
    var failed_here = Lookup.start("no-such-host.invalid", 80) else trap("the lookup starts")
    defer failed_here.destroy()
    var reported = false
    _ = failed_here.take() catch failure:
        assert(failure.code == unknown_host or failure.code == resolution_temporary or failure.code == failed)
        reported = true
        recover ResolvedAddresses()
    assert(reported)
    # Abandoned at once: the threads finish on their own and release their state.
    for _ in 0..<8:
        var abandoned = Lookup.start("localhost", 443) else trap("the lookup starts")
        abandoned.destroy()
    thread.sleep(50)