Esempio n. 1
0
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
}
Esempio n. 2
0
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
}
Esempio n. 3
0
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
}