func TestCodec(t *testing.T) {
// Transport
f := trace.NewFrame()
// Carrier
sx := sandbox.NewRandomUnreliableTransport(f.Refine("sandbox"), 3, 3, time.Second/4, time.Second/4)
// Chain
hx := chain.NewTransport(f.Refine("chain"), sx)
// Faithful
fx := faithful.NewTransport(f.Refine("faithful"), hx)
// Codec
cx := NewTransport(fx, GobCodec{})
// Sync
y := make(chan int)
// Accepter
go func() {
l := cx.Listen(sandbox.Addr("@"))
for i := 0; i < testN; i++ {
y <- 1
conn := l.Accept()
msg := &testMsg{}
if err := conn.Read(msg); err != nil {
t.Fatalf("read (%s)", err)
failNow()
}
if msg.Carry != i {
t.Fatalf("check")
failNow()
}
f.Printf("READ %d/%d CLOSING", i+1, testN)
conn.Close()
f.Printf("READ %d/%d √", i+1, testN)
}
y <- 1
}()
// Dialer
for i := 0; i < testN; i++ {
<-y
conn := cx.Dial(sandbox.Addr("@"))
if err := conn.Write(&testMsg{i}); err != nil {
t.Fatalf("write (%s)", err)
failNow()
}
f.Printf("WRITE %d/%d CLOSING", i+1, testN)
if err := conn.Close(); err != nil {
t.Fatalf("close (%s)", err)
failNow()
}
f.Printf("WRITE %d/%d √", i+1, testN)
}
<-y
}
func testConn(t *testing.T, mode testMode) {
f := trace.NewFrame("testConn")
f.Bind(&f)
fsx := f.Refine("sandbox")
fsx.Bind(&fsx)
var x *sandbox.Transport
if mode.Random {
x = sandbox.NewRandomUnreliableTransport(fsx, mode.NOK, mode.NDrop, exp, exp)
} else {
x = sandbox.NewUnreliableTransport(fsx, mode.NOK, mode.NDrop, exp, exp)
}
ready := make(chan int, 3)
// Accept side
go func() {
ax := NewTransport(f.Refine("faithful:a"), chain.NewTransport(f.Refine("chain:a"), x))
l := ax.Listen(sandbox.Addr("@"))
ready <- 1
c := l.Accept()
switch mode.Kind {
case testDWAR:
testRead(f, t, c, ready)
case testDRAW:
testWrite(f, t, c, ready)
}
}()
// Dial side
dx := NewTransport(f.Refine("faithful:d"), chain.NewTransport(f.Refine("chain:d"), x))
<-ready
c := dx.Dial(sandbox.Addr("@"))
setabrt(func() {
dbg := c.Debug().(*sandbox.DebugInfo)
dbg.Out.Abort()
})
switch mode.Kind {
case testDWAR:
testWrite(f, t, c, ready)
case testDRAW:
testRead(f, t, c, ready)
}
_, _ = <-ready, <-ready // One from testRead and one from testWrite
}
func testConn(t *testing.T, mode connMode) {
// Transport
frame := trace.NewFrame()
var x Carrier
if mode.Random {
x = sandbox.NewRandomUnreliableTransport(frame.Refine("sandbox"), mode.NOK, mode.NDrop, 0, 0)
} else {
x = sandbox.NewUnreliableTransport(frame.Refine("sandbox"), mode.NOK, mode.NDrop, 0, 0)
}
// Signalling
ready := make(chan int, 2)
feedfwd := make(chan byte, mode.NWrite()+1)
// Accepter endpoint
go func() {
defer func() {
ready <- 1 // SYNC: Notify that accepter-side logic is done
}()
l := NewListener(frame.Refine("chain", "listener"), x, sandbox.Addr(""))
ready <- 1 // SYNC: Notify that listener is accepting
switch mode.Kind {
case testDWAR:
testRead(t, l.Accept(), feedfwd)
case testDRAW:
testWrite(t, l.Accept(), mode, feedfwd)
default:
panic("u")
}
}()
// Dialer endpoint
<-ready // SYNC: Wait for listener to start accepting
d := NewDialer(frame.Refine("chain", "dialer"), x)
conn := d.Dial(sandbox.Addr(""))
switch mode.Kind {
case testDWAR:
testWrite(t, conn, mode, feedfwd)
case testDRAW:
testRead(t, conn, feedfwd)
default:
panic("u")
}
<-ready // SYNC: Wait for accepter goroutine to complete
}