| // Copyright 2023 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| //go:build go1.21 |
| |
| package quic |
| |
| import ( |
| "bytes" |
| "context" |
| "io" |
| "net" |
| "net/netip" |
| "testing" |
| ) |
| |
| func TestConnect(t *testing.T) { |
| newLocalConnPair(t, &Config{}, &Config{}) |
| } |
| |
| func TestStreamTransfer(t *testing.T) { |
| ctx := context.Background() |
| cli, srv := newLocalConnPair(t, &Config{}, &Config{}) |
| data := makeTestData(1 << 20) |
| |
| srvdone := make(chan struct{}) |
| go func() { |
| defer close(srvdone) |
| s, err := srv.AcceptStream(ctx) |
| if err != nil { |
| t.Errorf("AcceptStream: %v", err) |
| return |
| } |
| b, err := io.ReadAll(s) |
| if err != nil { |
| t.Errorf("io.ReadAll(s): %v", err) |
| return |
| } |
| if !bytes.Equal(b, data) { |
| t.Errorf("read data mismatch (got %v bytes, want %v", len(b), len(data)) |
| } |
| if err := s.Close(); err != nil { |
| t.Errorf("s.Close() = %v", err) |
| } |
| }() |
| |
| s, err := cli.NewStream(ctx) |
| if err != nil { |
| t.Fatalf("NewStream: %v", err) |
| } |
| n, err := io.Copy(s, bytes.NewBuffer(data)) |
| if n != int64(len(data)) || err != nil { |
| t.Fatalf("io.Copy(s, data) = %v, %v; want %v, nil", n, err, len(data)) |
| } |
| if err := s.Close(); err != nil { |
| t.Fatalf("s.Close() = %v", err) |
| } |
| } |
| |
| func newLocalConnPair(t *testing.T, conf1, conf2 *Config) (clientConn, serverConn *Conn) { |
| t.Helper() |
| ctx := context.Background() |
| l1 := newLocalListener(t, serverSide, conf1) |
| l2 := newLocalListener(t, clientSide, conf2) |
| c2, err := l2.Dial(ctx, "udp", l1.LocalAddr().String()) |
| if err != nil { |
| t.Fatal(err) |
| } |
| c1, err := l1.Accept(ctx) |
| if err != nil { |
| t.Fatal(err) |
| } |
| return c2, c1 |
| } |
| |
| func newLocalListener(t *testing.T, side connSide, conf *Config) *Listener { |
| t.Helper() |
| if conf.TLSConfig == nil { |
| conf.TLSConfig = newTestTLSConfig(side) |
| } |
| l, err := Listen("udp", "127.0.0.1:0", conf) |
| if err != nil { |
| t.Fatal(err) |
| } |
| t.Cleanup(func() { |
| l.Close(context.Background()) |
| }) |
| return l |
| } |
| |
| type testListener struct { |
| t *testing.T |
| l *Listener |
| recvc chan *datagram |
| idlec chan struct{} |
| sentDatagrams [][]byte |
| } |
| |
| func newTestListener(t *testing.T, config *Config, testHooks connTestHooks) *testListener { |
| tl := &testListener{ |
| t: t, |
| recvc: make(chan *datagram), |
| idlec: make(chan struct{}), |
| } |
| tl.l = newListener((*testListenerUDPConn)(tl), config, testHooks) |
| t.Cleanup(tl.cleanup) |
| return tl |
| } |
| |
| func (tl *testListener) cleanup() { |
| tl.l.Close(canceledContext()) |
| } |
| |
| func (tl *testListener) wait() { |
| tl.idlec <- struct{}{} |
| } |
| |
| func (tl *testListener) write(d *datagram) { |
| tl.recvc <- d |
| tl.wait() |
| } |
| |
| func (tl *testListener) read() []byte { |
| tl.wait() |
| if len(tl.sentDatagrams) == 0 { |
| return nil |
| } |
| d := tl.sentDatagrams[0] |
| tl.sentDatagrams = tl.sentDatagrams[1:] |
| return d |
| } |
| |
| // testListenerUDPConn implements UDPConn. |
| type testListenerUDPConn testListener |
| |
| func (tl *testListenerUDPConn) Close() error { |
| close(tl.recvc) |
| return nil |
| } |
| |
| func (tl *testListenerUDPConn) LocalAddr() net.Addr { |
| return net.UDPAddrFromAddrPort(netip.MustParseAddrPort("127.0.0.1:443")) |
| } |
| |
| func (tl *testListenerUDPConn) ReadMsgUDPAddrPort(b, control []byte) (n, controln, flags int, _ netip.AddrPort, _ error) { |
| for { |
| select { |
| case d, ok := <-tl.recvc: |
| if !ok { |
| return 0, 0, 0, netip.AddrPort{}, io.EOF |
| } |
| n = copy(b, d.b) |
| return n, 0, 0, d.addr, nil |
| case <-tl.idlec: |
| } |
| } |
| } |
| |
| func (tl *testListenerUDPConn) WriteToUDPAddrPort(b []byte, addr netip.AddrPort) (int, error) { |
| tl.sentDatagrams = append(tl.sentDatagrams, append([]byte(nil), b...)) |
| return len(b), nil |
| } |