277 lines
10 KiB
Text
277 lines
10 KiB
Text
# net_test.ludic - the codec, the codes, a host taking a stranger's hello, reliable delivery in
|
|
# order, a guest's hello and its timeout, a silent guest and a slot let go - over a fake socket
|
|
import "ludic.net"
|
|
import "ludic.base"
|
|
program NetTest {
|
|
numbers float
|
|
property Pkt { ip: int = 0, port: int = 0, len: int = 0, data: []byte }
|
|
state NetTestState {
|
|
sent: []Pkt = null
|
|
inbound: []Pkt = null
|
|
from_ip: int = 0
|
|
from_port: int = 0
|
|
}
|
|
|
|
function fake_open(port: int) -> int { return 5 }
|
|
function fake_close(h: int) -> void { }
|
|
function fake_port(h: int) -> int { return 40000 }
|
|
function fake_local() -> int { return Udp.ip("10.0.0.5") }
|
|
function fake_from_ip(net_test_st: NetTestState, h: int) -> int { return net_test_st.from_ip }
|
|
function fake_from_port(net_test_st: NetTestState, h: int) -> int { return net_test_st.from_port }
|
|
function fake_send(net_test_st: mut NetTestState, h: int, ip: int, port: int, b: []byte, n: int) -> int {
|
|
let p = new Pkt
|
|
p.ip = ip
|
|
p.port = port
|
|
p.len = n
|
|
p.data = buffer(n)
|
|
nb_copy(p.data, 0, b, 0, n)
|
|
push(net_test_st.sent, p)
|
|
return n
|
|
}
|
|
function fake_recv(net_test_st: mut NetTestState, h: int, b: []byte, cap: int) -> int {
|
|
if len(net_test_st.inbound) == 0 { return 0 }
|
|
let p = net_test_st.inbound[0]
|
|
let rest = new []Pkt
|
|
for i in 1 .. len(net_test_st.inbound) { push(rest, net_test_st.inbound[i]) }
|
|
net_test_st.inbound = rest
|
|
nb_copy(b, 0, p.data, 0, p.len)
|
|
net_test_st.from_ip = p.ip
|
|
net_test_st.from_port = p.port
|
|
return p.len
|
|
}
|
|
bind NetSocket { open: fn fake_open, close: fn fake_close, send: fn fake_send, recv: fn fake_recv, from_ip: fn fake_from_ip, from_port: fn fake_from_port, port: fn fake_port, local_ip: fn fake_local }
|
|
|
|
function fresh(net_st: mut NetState, net_test_st: mut NetTestState) -> void {
|
|
net_test_st.sent = new []Pkt
|
|
net_test_st.inbound = new []Pkt
|
|
net_reset(net_st)
|
|
q_clear(net_inbox(net_st))
|
|
q_clear(net_facts(net_st))
|
|
}
|
|
|
|
# a packet from ip:port: token, pid, ack, then one message of `kind` (reliable with `id` > 0)
|
|
function arrive(net_test_st: mut NetTestState, ip: int, port: int, token: int, pid: int, ack: int, kind: int, id: int, payload: int) -> void {
|
|
let b = buffer(40)
|
|
nb_put8(b, 0, 'M')
|
|
nb_put8(b, 1, 'L')
|
|
nb_put8(b, 2, 1)
|
|
nb_put8(b, 3, 1)
|
|
nb_put32(b, 4, token)
|
|
nb_put32(b, 8, pid)
|
|
nb_put32(b, 12, ack)
|
|
nb_put32(b, 16, 1)
|
|
var o = 20
|
|
nb_put8(b, o, kind)
|
|
nb_put8(b, o + 1, 0)
|
|
o += 2
|
|
if id > 0 {
|
|
nb_put8(b, o - 1, 1)
|
|
nb_put32(b, o, id)
|
|
o += 4
|
|
}
|
|
nb_put8(b, o, 4)
|
|
nb_put8(b, o + 1, 0)
|
|
nb_put32(b, o + 2, payload)
|
|
let p = new Pkt
|
|
p.ip = ip
|
|
p.port = port
|
|
p.len = o + 6
|
|
p.data = b
|
|
push(net_test_st.inbound, p)
|
|
}
|
|
|
|
function frame(net_st: mut NetState, dt: float) -> void {
|
|
net_begin(net_st, dt)
|
|
net_update(net_st, dt)
|
|
net_end(net_st)
|
|
}
|
|
|
|
# the host with a guest let in at 10.0.0.9:5000 as pid 2
|
|
function host_with_guest(net_st: mut NetState, net_test_st: mut NetTestState) -> int {
|
|
fresh(net_st, net_test_st)
|
|
expect(net_host(net_st, 27415, 77))
|
|
arrive(net_test_st, Udp.ip("10.0.0.9"), 5000, 0, 0, 0, NET_HELLO, 1, 42)
|
|
net_begin(net_st, 0.01)
|
|
let got = q_drain(net_inbox(net_st))
|
|
expect_eq(len(got), 1)
|
|
return net_accept(net_st, got[0].slot)
|
|
}
|
|
|
|
function facts_of(net_st: NetState, what: int) -> []NetFact {
|
|
let all = q_drain(net_facts(net_st))
|
|
let out = new []NetFact
|
|
for i in 0 .. len(all) { if all[i].what == what { push(out, all[i]) } }
|
|
return out
|
|
}
|
|
|
|
test "the codec carries ints, bools, floats and text, and a short message reads bad" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
fresh(net_st, net_test_st)
|
|
nw_begin(net_st)
|
|
nw_i(net_st, -7)
|
|
nw_b(net_st, true)
|
|
nw_f(net_st, 2.5)
|
|
nw_s(net_st, "maroon")
|
|
net_read(net_st, net_written(net_st))
|
|
expect_eq(nr_i(net_st), -7)
|
|
expect(nr_b(net_st))
|
|
expect_near(nr_f(net_st), 2.5, 0.0001)
|
|
expect(nr_s(net_st) == "maroon")
|
|
expect(not nr_bad(net_st))
|
|
expect_eq(nr_i(net_st), 0)
|
|
expect(nr_bad(net_st))
|
|
}
|
|
|
|
test "a join code decodes to its address and port; an address and a room code are taken too" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
fresh(net_st, net_test_st)
|
|
let ip = Udp.ip("192.168.1.20")
|
|
let code = net_code_of(ip, 27415)
|
|
expect_eq(len(code), 11)
|
|
expect(net_parse_code(net_st, code))
|
|
expect_eq(net_code_ip(net_st), ip)
|
|
expect_eq(net_code_port(net_st), 27415)
|
|
expect(net_parse_code(net_st, Text.lower(code)))
|
|
expect(net_parse_code(net_st, "10.1.2.3:4000"))
|
|
expect_eq(net_code_port(net_st), 4000)
|
|
expect(net_parse_code(net_st, "10.1.2.3"))
|
|
expect_eq(net_code_port(net_st), 27415)
|
|
expect(not net_parse_code(net_st, "HELLO"))
|
|
expect(net_is_room("abcdef"))
|
|
expect(not net_is_room("ABCDE1"))
|
|
}
|
|
|
|
test "a host takes a stranger only with a hello, and hands out pids from 2" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
let pid = host_with_guest(net_st, net_test_st)
|
|
expect_eq(pid, 2)
|
|
expect(net_hosting(net_st))
|
|
expect_eq(net_my_pid(net_st), 1)
|
|
arrive(net_test_st, Udp.ip("10.0.0.10"), 6000, 0, 0, 0, 9, 1, 1)
|
|
net_begin(net_st, 0.01)
|
|
expect_eq(q_len(net_inbox(net_st)), 0)
|
|
arrive(net_test_st, Udp.ip("10.0.0.11"), 6000, 0, 0, 0, NET_HELLO, 1, 1)
|
|
net_begin(net_st, 0.01)
|
|
let got = q_drain(net_inbox(net_st))
|
|
expect_eq(net_accept(net_st, got[0].slot), 3)
|
|
}
|
|
|
|
test "a message's payload reads back as it was written" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
host_with_guest(net_st, net_test_st)
|
|
arrive(net_test_st, Udp.ip("10.0.0.9"), 5000, 77, 2, 0, 9, 2, 1234)
|
|
net_begin(net_st, 0.01)
|
|
let got = q_drain(net_inbox(net_st))
|
|
expect_eq(len(got), 1)
|
|
expect_eq(got[0].kind, 9)
|
|
expect_eq(got[0].from, 2)
|
|
net_read(net_st, got[0])
|
|
expect_eq(nr_i(net_st), 1234)
|
|
expect(not nr_bad(net_st))
|
|
nr_i(net_st)
|
|
expect(nr_bad(net_st))
|
|
}
|
|
|
|
test "a reliable message that arrives early is dropped and taken in order" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
let slot = np_of_pid(net_st, host_with_guest(net_st, net_test_st))
|
|
arrive(net_test_st, Udp.ip("10.0.0.9"), 5000, 77, 2, 0, 9, 3, 30)
|
|
net_begin(net_st, 0.01)
|
|
expect_eq(q_len(net_inbox(net_st)), 0)
|
|
arrive(net_test_st, Udp.ip("10.0.0.9"), 5000, 77, 2, 0, 9, 2, 20)
|
|
arrive(net_test_st, Udp.ip("10.0.0.9"), 5000, 77, 2, 0, 9, 3, 30)
|
|
net_begin(net_st, 0.01)
|
|
let got = q_drain(net_inbox(net_st))
|
|
expect_eq(len(got), 2)
|
|
net_read(net_st, got[1])
|
|
expect_eq(nr_i(net_st), 30)
|
|
expect_eq(got[1].slot, slot)
|
|
}
|
|
|
|
test "a reliable message goes again until it is taken" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
let slot = np_of_pid(net_st, host_with_guest(net_st, net_test_st))
|
|
net_end(net_st)
|
|
net_test_st.sent = new []Pkt
|
|
nw_begin(net_st)
|
|
nw_i(net_st, 5)
|
|
np_queue(net_st, slot, 9, true)
|
|
frame(net_st, 0.01)
|
|
expect_eq(len(net_test_st.sent), 1)
|
|
frame(net_st, 0.1)
|
|
expect_eq(len(net_test_st.sent), 1)
|
|
frame(net_st, 0.2)
|
|
expect_eq(len(net_test_st.sent), 2)
|
|
arrive(net_test_st, Udp.ip("10.0.0.9"), 5000, 77, 2, 1, 9, 0, 0)
|
|
frame(net_st, 0.3)
|
|
let n = len(net_test_st.sent)
|
|
frame(net_st, 0.3)
|
|
expect_eq(len(net_test_st.sent), n)
|
|
}
|
|
|
|
test "an unreliable message half a second old is dropped" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
let slot = np_of_pid(net_st, host_with_guest(net_st, net_test_st))
|
|
net_end(net_st)
|
|
net_test_st.sent = new []Pkt
|
|
nw_begin(net_st)
|
|
np_queue(net_st, slot, 9, false)
|
|
net_begin(net_st, 0.6)
|
|
net_end(net_st)
|
|
expect_eq(len(net_test_st.sent), 0)
|
|
}
|
|
|
|
test "a guest sends its hello until nobody has answered for too long" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
fresh(net_st, net_test_st)
|
|
nw_begin(net_st)
|
|
nw_s(net_st, "v1")
|
|
net_hello_set(net_st)
|
|
expect(net_join(net_st, Udp.ip("10.0.0.1"), 27415))
|
|
expect(net_joining(net_st))
|
|
frame(net_st, 0.1)
|
|
expect_eq(len(net_test_st.sent), 1)
|
|
expect_eq(nb_get8(net_test_st.sent[0].data, 20), NET_HELLO)
|
|
for i in 0 .. 110 { frame(net_st, 0.1) }
|
|
expect_eq(net_state(net_st), NET_LOST)
|
|
let down = facts_of(net_st, NET_DOWN)
|
|
expect_eq(len(down), 1)
|
|
expect_eq(down[0].why, NET_WHY_NO_ANSWER)
|
|
net_fresh(net_st)
|
|
expect_eq(net_state(net_st), NET_IDLE)
|
|
}
|
|
|
|
test "a welcome makes the guest that pid in that session" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
fresh(net_st, net_test_st)
|
|
nw_begin(net_st)
|
|
net_hello_set(net_st)
|
|
net_join(net_st, Udp.ip("10.0.0.1"), 27415)
|
|
net_joined_as(net_st, 99, 4)
|
|
expect(net_live(net_st))
|
|
expect_eq(net_my_pid(net_st), 4)
|
|
expect_eq(net_token(net_st), 99)
|
|
}
|
|
|
|
test "a guest silent for the timeout is gone" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
let pid = host_with_guest(net_st, net_test_st)
|
|
let slot = np_of_pid(net_st, pid)
|
|
for i in 0 .. 105 { frame(net_st, 0.1) }
|
|
let gone = facts_of(net_st, NET_GONE)
|
|
expect_eq(len(gone), 1)
|
|
expect_eq(gone[0].pid, pid)
|
|
expect_eq(gone[0].slot, slot)
|
|
expect(not net_peer_on(net_st, slot))
|
|
}
|
|
|
|
test "a slot is let go once it has taken its last message" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
let slot = np_of_pid(net_st, host_with_guest(net_st, net_test_st))
|
|
nw_begin(net_st)
|
|
np_queue(net_st, slot, 9, true)
|
|
net_close_when_sent(net_st, slot, 20.0)
|
|
frame(net_st, 0.01)
|
|
expect(net_peer_on(net_st, slot))
|
|
arrive(net_test_st, Udp.ip("10.0.0.9"), 5000, 77, 2, 1, 9, 0, 0)
|
|
frame(net_st, 0.01)
|
|
expect(not net_peer_on(net_st, slot))
|
|
expect_eq(len(facts_of(net_st, NET_CLOSED)), 1)
|
|
}
|
|
|
|
test "with no matchmaker, a room code is refused" (net_st: mut NetState, net_test_st: mut NetTestState) {
|
|
fresh(net_st, net_test_st)
|
|
expect(not net_room_on(net_st))
|
|
expect(not net_room_join(net_st, "ABCDEF"))
|
|
expect_eq(net_why(net_st), NET_WHY_NO_MATCHMAKER)
|
|
}
|
|
}
|