Function TestClientRun

ptp/simpleclient/client_test.go:150–279

(t *testing.T)

}

func TestClientRun(t *testing.T) {
	cfg := &Config{
		Address:  "blah",
		Iface:    "ethBlah",
		Timeout:  5 * time.Second,
		Duration: 5 * time.Second,
	}
	// we simply append samples to the array to match what we collected in the end
	history := []*MeasurementResult{}
	c := New(cfg, func(m *MeasurementResult) {
		history = append(history, m)
	})

	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	genConn := NewMockUDPConn(ctrl)
	c.genConn = genConn
	// handle whatever client is sending over genConn
	genConn.EXPECT().WriteTo(gomock.Any(), gomock.Any()).DoAndReturn(func(b []byte, _ net.Addr) (int, error) {
		r := bytes.NewReader(b)
		h := &ptp.Header{}
		err := binary.Read(r, binary.BigEndian, h)
		require.Nil(t, err, "reading header")
		require.Equal(t, ptp.MessageSignaling, h.SdoIDAndMsgType.MsgType(), "only expect signaling msgs over genConn")
		signaling := &ptp.Signaling{}
		err = ptp.FromBytes(b, signaling)
		require.Nil(t, err, "reading signaling msg")
		require.Equal(t, 1, len(signaling.TLVs), "expect only 1 TLV in signaling msg")
		tlv := signaling.TLVs[0]
		// we only expect SIGNALING messages where client asks for unicast grants.
		// for each such request we grant it.
		switch v := tlv.(type) {
		case *ptp.RequestUnicastTransmissionTLV:
			msgType := v.MsgTypeAndReserved.MsgType()
			switch msgType {
			case ptp.MessageAnnounce:
				grantAnnounce := grantUnicastPkt(0, c.clockID, c.cfg.Duration, ptp.MessageAnnounce)
				grantAnnounceBytes, err := ptp.Bytes(grantAnnounce)
				require.Nil(t, err)
				c.inChan <- &inPacket{
					data: grantAnnounceBytes,
					ts:   time.Now(),
				}
				return 20, nil
			case ptp.MessageSync:
				grantSync := grantUnicastPkt(1, c.clockID, c.cfg.Duration, ptp.MessageSync)
				grantSyncBytes, err := ptp.Bytes(grantSync)
				require.Nil(t, err)
				c.inChan <- &inPacket{
					data: grantSyncBytes,
					ts:   time.Now(),
				}
				return 20, nil
			case ptp.MessageDelayResp:
				grantDelayResp := grantUnicastPkt(2, c.clockID, c.cfg.Duration, ptp.MessageDelayResp)
				grantDelayRespBytes, err := ptp.Bytes(grantDelayResp)
				require.Nil(t, err)