lzhr/v2fly
1
0
Fork 0
mirror of https://github.com/v2fly/v2ray-core.git synced 2026-04-23 14:09:11 -04:00
Code Issues Releases Wiki Activity

fully migrate to new assertion lib

Browse Source
This commit is contained in:
Darien Raymond
2017-10-24 16:15:35 +02:00
parent 4a0ca30d08
commit 74cf833758
70 changed files with 974 additions and 942 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
testing/scenarios/dns_test.go
View File

@@ -14,18 +14,18 @@ import (
"v2ray.com/core/proxy/blackhole"
"v2ray.com/core/proxy/freedom"
"v2ray.com/core/proxy/socks"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
"v2ray.com/core/testing/servers/tcp"
)
func TestResolveIP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
serverPort := pickPort()
@@ -81,24 +81,24 @@ func TestResolveIP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
{
noAuthDialer, err := xproxy.SOCKS5("tcp", net.TCPDestination(net.LocalHostIP, serverPort).NetAddr(), nil, xproxy.Direct)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := noAuthDialer.Dial("tcp", fmt.Sprintf("google.com:%d", dest.Port))
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
CloseAllServers(servers)

38
testing/scenarios/dokodemo_test.go
View File

@@ -15,19 +15,19 @@ import (
"v2ray.com/core/proxy/vmess"
"v2ray.com/core/proxy/vmess/inbound"
"v2ray.com/core/proxy/vmess/outbound"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
"v2ray.com/core/testing/servers/tcp"
"v2ray.com/core/testing/servers/udp"
)
func TestDokodemoTCP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -109,38 +109,38 @@ func TestDokodemoTCP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
for port := clientPort; port <= clientPort+clientPortRange; port++ {
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(port),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
CloseAllServers(servers)
}
func TestDokodemoUDP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
udpServer := udp.Server{
MsgProcessor: xor,
}
dest, err := udpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer udpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -210,25 +210,25 @@ func TestDokodemoUDP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
for port := clientPort; port <= clientPort+clientPortRange; port++ {
conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(port),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
CloseAllServers(servers)

138
testing/scenarios/feature_test.go
View File

@@ -24,21 +24,21 @@ import (
"v2ray.com/core/proxy/vmess"
"v2ray.com/core/proxy/vmess/inbound"
"v2ray.com/core/proxy/vmess/outbound"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
"v2ray.com/core/testing/servers/tcp"
"v2ray.com/core/testing/servers/udp"
"v2ray.com/core/transport/internet"
)
func TestPassiveConnection(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
SendFirst: []byte("send first"),
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
serverPort := pickPort()
@@ -66,49 +66,49 @@ func TestPassiveConnection(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(serverPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
{
response := make([]byte, 1024)
nBytes, err := conn.Read(response)
assert.Error(err).IsNil()
assert.String(string(response[:nBytes])).Equals("send first")
assert(err, IsNil)
assert(string(response[:nBytes]), Equals, "send first")
}
payload := "dokodemo request."
{
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
}
{
response := make([]byte, 1024)
nBytes, err := conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
}
assert.Error(conn.Close()).IsNil()
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestProxy(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
serverUserID := protocol.NewID(uuid.New())
@@ -227,36 +227,36 @@ func TestProxy(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, proxyConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestProxyOverKCP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
serverUserID := protocol.NewID(uuid.New())
@@ -386,43 +386,43 @@ func TestProxyOverKCP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, proxyConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestBlackhole(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
tcpServer2 := tcp.Server{
MsgProcessor: xor,
}
dest2, err := tcpServer2.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer2.Close()
serverPort := pickPort()
@@ -479,41 +479,41 @@ func TestBlackhole(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(serverPort2),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
{
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
}
{
response := make([]byte, 1024)
_, err := conn.Read(response)
assert.Error(err).IsNotNil()
assert(err, IsNotNil)
}
assert.Error(conn.Close()).IsNil()
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestForward(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
serverPort := pickPort()
@@ -549,37 +549,37 @@ func TestForward(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
{
noAuthDialer, err := xproxy.SOCKS5("tcp", net.TCPDestination(net.LocalHostIP, serverPort).NetAddr(), nil, xproxy.Direct)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := noAuthDialer.Dial("tcp", "google.com:80")
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
CloseAllServers(servers)
}
func TestUDPConnection(t *testing.T) {
assert := assert.On(t)
assert := With(t)
udpServer := udp.Server{
MsgProcessor: xor,
}
dest, err := udpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer udpServer.Close()
clientPort := pickPort()
@@ -607,28 +607,28 @@ func TestUDPConnection(t *testing.T) {
}
servers, err := InitializeServerConfigs(clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
{
conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
for i := 0; i < 5; i++ {
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
}
assert.Error(conn.Close()).IsNil()
assert(conn.Close(), IsNil)
}
time.Sleep(20 * time.Second)
@@ -638,25 +638,25 @@ func TestUDPConnection(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
CloseAllServers(servers)
}
func TestDomainSniffing(t *testing.T) {
assert := assert.On(t)
assert := With(t)
sniffingPort := pickPort()
httpPort := pickPort()
@@ -725,7 +725,7 @@ func TestDomainSniffing(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
{
transport := &http.Transport{
@@ -739,10 +739,10 @@ func TestDomainSniffing(t *testing.T) {
}
resp, err := client.Get("https://www.github.com/")
assert.Error(err).IsNil()
assert.Int(resp.StatusCode).Equals(200)
assert(err, IsNil)
assert(resp.StatusCode, Equals, 200)
assert.Error(resp.Write(ioutil.Discard)).IsNil()
assert(resp.Write(ioutil.Discard), IsNil)
}
CloseAllServers(servers)

16
testing/scenarios/http_test.go
View File

@@ -12,12 +12,12 @@ import (
"v2ray.com/core/common/serial"
"v2ray.com/core/proxy/freedom"
v2http "v2ray.com/core/proxy/http"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
v2httptest "v2ray.com/core/testing/servers/http"
)
func TestHttpConformance(t *testing.T) {
assert := assert.On(t)
assert := With(t)
httpServerPort := pickPort()
httpServer := &v2httptest.Server{
@@ -25,7 +25,7 @@ func TestHttpConformance(t *testing.T) {
PathHandler: make(map[string]http.HandlerFunc),
}
_, err := httpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer httpServer.Close()
serverPort := pickPort()
@@ -47,7 +47,7 @@ func TestHttpConformance(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
{
transport := &http.Transport{
@@ -61,12 +61,12 @@ func TestHttpConformance(t *testing.T) {
}
resp, err := client.Get("http://127.0.0.1:" + httpServerPort.String())
assert.Error(err).IsNil()
assert.Int(resp.StatusCode).Equals(200)
assert(err, IsNil)
assert(resp.StatusCode, Equals, 200)
content, err := ioutil.ReadAll(resp.Body)
assert.Error(err).IsNil()
assert.String(string(content)).Equals("Home")
assert(err, IsNil)
assert(string(content), Equals, "Home")
}

50
testing/scenarios/shadowsocks_test.go
View File

@@ -15,19 +15,19 @@ import (
"v2ray.com/core/proxy/dokodemo"
"v2ray.com/core/proxy/freedom"
"v2ray.com/core/proxy/shadowsocks"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
"v2ray.com/core/testing/servers/tcp"
"v2ray.com/core/testing/servers/udp"
)
func TestShadowsocksAES256TCP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
account := serial.ToTypedMessage(&shadowsocks.Account{
@@ -108,7 +108,7 @@ func TestShadowsocksAES256TCP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
var wg sync.WaitGroup
wg.Add(10)
@@ -118,18 +118,18 @@ func TestShadowsocksAES256TCP(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 10240*1024)
rand.Read(payload)
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, 10240*1024)
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -139,13 +139,13 @@ func TestShadowsocksAES256TCP(t *testing.T) {
}
func TestShadowsocksAES128UDP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
udpServer := udp.Server{
MsgProcessor: xor,
}
dest, err := udpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer udpServer.Close()
account := serial.ToTypedMessage(&shadowsocks.Account{
@@ -227,7 +227,7 @@ func TestShadowsocksAES128UDP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
var wg sync.WaitGroup
wg.Add(10)
@@ -237,18 +237,18 @@ func TestShadowsocksAES128UDP(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 1024)
rand.Read(payload)
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*5, 1024)
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -258,13 +258,13 @@ func TestShadowsocksAES128UDP(t *testing.T) {
}
func TestShadowsocksChacha20TCP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
account := serial.ToTypedMessage(&shadowsocks.Account{
@@ -345,7 +345,7 @@ func TestShadowsocksChacha20TCP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
var wg sync.WaitGroup
wg.Add(10)
@@ -355,18 +355,18 @@ func TestShadowsocksChacha20TCP(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 10240*1024)
rand.Read(payload)
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, 10240*1024)
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
wg.Done()
}()
}

96
testing/scenarios/socks_test.go
View File

@@ -13,19 +13,19 @@ import (
"v2ray.com/core/proxy/dokodemo"
"v2ray.com/core/proxy/freedom"
"v2ray.com/core/proxy/socks"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
"v2ray.com/core/testing/servers/tcp"
"v2ray.com/core/testing/servers/udp"
)
func TestSocksBridgeTCP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
serverPort := pickPort()
@@ -93,36 +93,36 @@ func TestSocksBridgeTCP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestSocksBridageUDP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
udpServer := udp.Server{
MsgProcessor: xor,
}
dest, err := udpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer udpServer.Close()
serverPort := pickPort()
@@ -190,36 +190,36 @@ func TestSocksBridageUDP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialUDP("udp", nil, &net.UDPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestSocksConformance(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
authPort := pickPort()
@@ -263,76 +263,76 @@ func TestSocksConformance(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
{
noAuthDialer, err := xproxy.SOCKS5("tcp", net.TCPDestination(net.LocalHostIP, noAuthPort).NetAddr(), nil, xproxy.Direct)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := noAuthDialer.Dial("tcp", dest.NetAddr())
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
{
authDialer, err := xproxy.SOCKS5("tcp", net.TCPDestination(net.LocalHostIP, authPort).NetAddr(), &xproxy.Auth{User: "Test Account", Password: "Test Password"}, xproxy.Direct)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := authDialer.Dial("tcp", dest.NetAddr())
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
{
dialer := socks4.DialSocksProxy(socks4.SOCKS4, net.TCPDestination(net.LocalHostIP, noAuthPort).NetAddr())
conn, err := dialer("tcp", dest.NetAddr())
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
{
dialer := socks4.DialSocksProxy(socks4.SOCKS4A, net.TCPDestination(net.LocalHostIP, noAuthPort).NetAddr())
conn, err := dialer("tcp", net.TCPDestination(net.LocalHostDomain, tcpServer.Port).NetAddr())
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "test payload"
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
CloseAllServers(servers)

50
testing/scenarios/tls_test.go
View File

@@ -16,7 +16,7 @@ import (
"v2ray.com/core/proxy/vmess"
"v2ray.com/core/proxy/vmess/inbound"
"v2ray.com/core/proxy/vmess/outbound"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
"v2ray.com/core/testing/servers/tcp"
tlsgen "v2ray.com/core/testing/tls"
"v2ray.com/core/transport/internet"
@@ -25,13 +25,13 @@ import (
)
func TestSimpleTLSConnection(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -118,34 +118,34 @@ func TestSimpleTLSConnection(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*2, len(payload))
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestTLSOverKCP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -234,34 +234,34 @@ func TestTLSOverKCP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*2, len(payload))
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestTLSOverWebSocket(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -356,23 +356,23 @@ func TestTLSOverWebSocket(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 10240*1024)
rand.Read(payload)
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, len(payload))
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}

18
testing/scenarios/transport_test.go
View File

@@ -15,7 +15,7 @@ import (
"v2ray.com/core/proxy/vmess"
"v2ray.com/core/proxy/vmess/inbound"
"v2ray.com/core/proxy/vmess/outbound"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
"v2ray.com/core/testing/servers/tcp"
"v2ray.com/core/transport/internet"
"v2ray.com/core/transport/internet/headers/http"
@@ -23,13 +23,13 @@ import (
)
func TestHttpConnectionHeader(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -120,22 +120,22 @@ func TestHttpConnectionHeader(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*2, len(payload))
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}

170
testing/scenarios/vmess_test.go
View File

@@ -18,20 +18,20 @@ import (
"v2ray.com/core/proxy/vmess"
"v2ray.com/core/proxy/vmess/inbound"
"v2ray.com/core/proxy/vmess/outbound"
"v2ray.com/core/testing/assert"
. "v2ray.com/ext/assert"
"v2ray.com/core/testing/servers/tcp"
"v2ray.com/core/testing/servers/udp"
"v2ray.com/core/transport/internet"
)
func TestVMessDynamicPort(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -135,38 +135,38 @@ func TestVMessDynamicPort(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
for i := 0; i < 10; i++ {
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := make([]byte, 1024)
nBytes, err = conn.Read(response)
assert.Error(err).IsNil()
assert.Bytes(response[:nBytes]).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(err, IsNil)
assert(response[:nBytes], Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
}
CloseAllServers(servers)
}
func TestVMessGCM(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -252,7 +252,7 @@ func TestVMessGCM(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
var wg sync.WaitGroup
wg.Add(10)
@@ -262,18 +262,18 @@ func TestVMessGCM(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 10240*1024)
rand.Read(payload)
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, 10240*1024)
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -283,13 +283,13 @@ func TestVMessGCM(t *testing.T) {
}
func TestVMessGCMUDP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
udpServer := udp.Server{
MsgProcessor: xor,
}
dest, err := udpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer udpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -375,7 +375,7 @@ func TestVMessGCMUDP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
var wg sync.WaitGroup
wg.Add(10)
@@ -385,28 +385,28 @@ func TestVMessGCMUDP(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 1024)
rand.Read(payload)
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
payload1 := make([]byte, 1024)
rand.Read(payload1)
nBytes, err = conn.Write([]byte(payload1))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload1))
assert(err, IsNil)
assert(nBytes, Equals, len(payload1))
response := readFrom(conn, time.Second*5, 1024)
assert.Bytes(response).Equals(xor([]byte(payload)))
assert(response, Equals, xor([]byte(payload)))
response = readFrom(conn, time.Second*5, 1024)
assert.Bytes(response).Equals(xor([]byte(payload1)))
assert(response, Equals, xor([]byte(payload1)))
assert.Error(conn.Close()).IsNil()
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -416,13 +416,13 @@ func TestVMessGCMUDP(t *testing.T) {
}
func TestVMessChacha20(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -508,7 +508,7 @@ func TestVMessChacha20(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
var wg sync.WaitGroup
wg.Add(10)
@@ -518,18 +518,18 @@ func TestVMessChacha20(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 10240*1024)
rand.Read(payload)
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, 10240*1024)
assert.Bytes(response).Equals(xor([]byte(payload)))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor([]byte(payload)))
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -539,13 +539,13 @@ func TestVMessChacha20(t *testing.T) {
}
func TestVMessNone(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -631,7 +631,7 @@ func TestVMessNone(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
var wg sync.WaitGroup
wg.Add(10)
@@ -641,18 +641,18 @@ func TestVMessNone(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 1024*1024)
rand.Read(payload)
nBytes, err := conn.Write(payload)
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, 1024*1024)
assert.Bytes(response).Equals(xor(payload))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor(payload))
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -662,13 +662,13 @@ func TestVMessNone(t *testing.T) {
}
func TestVMessKCP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -762,7 +762,7 @@ func TestVMessKCP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
@@ -772,18 +772,18 @@ func TestVMessKCP(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 10240*1024)
rand.Read(payload)
nBytes, err := conn.Write(payload)
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Minute, 10240*1024)
assert.Bytes(response).Equals(xor(payload))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor(payload))
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -794,14 +794,14 @@ func TestVMessKCP(t *testing.T) {
func TestVMessIPv6(t *testing.T) {
t.SkipNow() // No IPv6 on travis-ci.
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
Listen: net.LocalHostIPv6,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -887,36 +887,36 @@ func TestVMessIPv6(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: net.LocalHostIPv6.IP(),
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 1024)
rand.Read(payload)
nBytes, err := conn.Write(payload)
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, 1024)
assert.Bytes(response).Equals(xor(payload))
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xor(payload))
assert(conn.Close(), IsNil)
CloseAllServers(servers)
}
func TestVMessGCMMux(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -1008,7 +1008,7 @@ func TestVMessGCMMux(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
for range "abcd" {
var wg sync.WaitGroup
@@ -1020,7 +1020,7 @@ func TestVMessGCMMux(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 10240)
rand.Read(payload)
@@ -1028,12 +1028,12 @@ func TestVMessGCMMux(t *testing.T) {
xorpayload := xor(payload)
nBytes, err := conn.Write(payload)
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, 10240)
assert.Bytes(response).Equals(xorpayload)
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xorpayload)
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -1045,20 +1045,20 @@ func TestVMessGCMMux(t *testing.T) {
}
func TestVMessGCMMuxUDP(t *testing.T) {
assert := assert.On(t)
assert := With(t)
tcpServer := tcp.Server{
MsgProcessor: xor,
}
dest, err := tcpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer tcpServer.Close()
udpServer := udp.Server{
MsgProcessor: xor,
}
udpDest, err := udpServer.Start()
assert.Error(err).IsNil()
assert(err, IsNil)
defer udpServer.Close()
userID := protocol.NewID(uuid.New())
@@ -1164,7 +1164,7 @@ func TestVMessGCMMuxUDP(t *testing.T) {
}
servers, err := InitializeServerConfigs(serverConfig, clientConfig)
assert.Error(err).IsNil()
assert(err, IsNil)
for range "abcd" {
var wg sync.WaitGroup
@@ -1176,7 +1176,7 @@ func TestVMessGCMMuxUDP(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
payload := make([]byte, 10240)
rand.Read(payload)
@@ -1184,12 +1184,12 @@ func TestVMessGCMMuxUDP(t *testing.T) {
xorpayload := xor(payload)
nBytes, err := conn.Write(payload)
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
response := readFrom(conn, time.Second*20, 10240)
assert.Bytes(response).Equals(xorpayload)
assert.Error(conn.Close()).IsNil()
assert(response, Equals, xorpayload)
assert(conn.Close(), IsNil)
wg.Done()
}()
}
@@ -1199,7 +1199,7 @@ func TestVMessGCMMuxUDP(t *testing.T) {
IP: []byte{127, 0, 0, 1},
Port: int(clientUDPPort),
})
assert.Error(err).IsNil()
assert(err, IsNil)
conn.SetDeadline(time.Now().Add(time.Second * 10))
@@ -1210,20 +1210,20 @@ func TestVMessGCMMuxUDP(t *testing.T) {
for j := 0; j < 2; j++ {
nBytes, _, err := conn.WriteMsgUDP(payload, nil, nil)
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
assert(err, IsNil)
assert(nBytes, Equals, len(payload))
}
response := make([]byte, 1024)
oob := make([]byte, 16)
for j := 0; j < 2; j++ {
nBytes, _, _, _, err := conn.ReadMsgUDP(response, oob)
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(1024)
assert.Bytes(response).Equals(xorpayload)
assert(err, IsNil)
assert(nBytes, Equals, 1024)
assert(response, Equals, xorpayload)
}
assert.Error(conn.Close()).IsNil()
assert(conn.Close(), IsNil)
wg.Done()
}()
}