tnet/netfd_linux_test.go at main · trpc-group/tnet · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
//
//
// Tencent is pleased to support the open source community by making tRPC available.
//
// Copyright (C) 2023 Tencent.
// All rights reserved.
//
// If you have downloaded a copy of the tRPC source code from Tencent,
// please note that tRPC source code is licensed under the  Apache 2.0 License,
// A copy of the Apache 2.0 License is included in this file.
//
//

//go:build linux
// +build linux

package tnet

import (
	"net"
	"testing"

	"github.com/stretchr/testify/assert"
	"trpc.group/trpc-go/tnet/internal/buffer"
	"trpc.group/trpc-go/tnet/internal/cache/systype"
)

func Test_netFD_FillToBuffer(t *testing.T) {
	// Use fixed udp buffer size, 65536 in default.
	t.Run("FixedUDPBufferSize", func(t *testing.T) {
		rawConn, err := rawListenUDP("udp4")
		assert.Nil(t, err)
		defer rawConn.Close()
		serverAddr := rawConn.LocalAddr()
		nfd, err := rawToNetFD(rawConn)
		assert.Nil(t, err)

		p := []byte{3, 2, 1}
		client, err := newUDPClient("udp4")
		assert.Nil(t, err)
		defer client.Close()
		clientAddr := client.LocalAddr()
		client.WriteTo(p, serverAddr.String())

		b := buffer.New()
		err = nfd.FillToBuffer(b)
		assert.Nil(t, err)

		block, _ := b.ReadBlock()
		s, addr, err := getUDPDataAndAddr(block)
		assert.Nil(t, err)
		assert.Equal(t, p, s)
		assert.Equal(t, clientAddr, addr)
	})
	// Use exact UDP buffer size based on the packet.
	t.Run("ExactUDPBufferSize", func(t *testing.T) {
		lns, err := listenUDP("udp", "127.0.0.1:", false)
		assert.Nil(t, err)
		assert.Equal(t, 1, len(lns))
		ln := lns[0]
		defer ln.Close()
		ln.SetExactUDPBufferSizeEnabled(true)
		serverAddr := ln.LocalAddr()
		udpConn, ok := ln.(*udpconn)
		assert.True(t, ok)

		p := []byte{6, 5, 4}
		client, err := newUDPClient("udp4")
		assert.Nil(t, err)
		defer client.Close()
		clientAddr := client.LocalAddr()
		client.WriteTo(p, serverAddr.String())

		b := buffer.New()
		err = udpConn.nfd.FillToBuffer(b)
		assert.Nil(t, err)

		block, _ := b.ReadBlock()
		s, addr, err := getUDPDataAndAddr(block)
		assert.Nil(t, err)
		assert.Equal(t, p, s)
		assert.Equal(t, clientAddr, addr)
	})
}

func Test_netFD_err(t *testing.T) {
	rawConn, err := rawListenUDP("udp4")
	assert.Nil(t, err)
	defer rawConn.Close()
	nfd, err := rawToNetFD(rawConn)
	assert.Nil(t, err)
	t.Run("writeTo err", func(t *testing.T) {
		_, err = nfd.WriteTo(helloWorld, nil)
		assert.NotNil(t, err)

		clientAddr := "127.0.0.1:0"
		udpAddr, _ := net.ResolveUDPAddr("udp", clientAddr)
		p := make([]byte, defaultUDPBufferSize+1)
		_, err = nfd.WriteTo(p, udpAddr)
		assert.NotNil(t, err)
	})
	t.Run("syscallMMsg err", func(t *testing.T) {
		_, err = nfd.syscallMMsg(-1, nil)
		assert.NotNil(t, err)
	})
	t.Run("syscallMsg err", func(t *testing.T) {
		_, err = nfd.syscallMsg(-1, nil, 0)
		assert.NotNil(t, err)
	})
}

func Test_buildMMsgs_err(t *testing.T) {
	err := buildMMsgs([]systype.MMsghdr{{}}, [][]byte{make([]byte, 0)})
	assert.NotNil(t, err)
}

func Test_buildMsg_err(t *testing.T) {
	err := buildMsg(&systype.Msghdr{}, make([]byte, 0))
	assert.NotNil(t, err)
}