Black Lives Matter. Support the Equal Justice Initiative.

Source file src/net/server_test.go

Documentation: net

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  //go:build !js
     6  // +build !js
     7  
     8  package net
     9  
    10  import (
    11  	"os"
    12  	"testing"
    13  )
    14  
    15  var tcpServerTests = []struct {
    16  	snet, saddr string // server endpoint
    17  	tnet, taddr string // target endpoint for client
    18  }{
    19  	{snet: "tcp", saddr: ":0", tnet: "tcp", taddr: "127.0.0.1"},
    20  	{snet: "tcp", saddr: "0.0.0.0:0", tnet: "tcp", taddr: "127.0.0.1"},
    21  	{snet: "tcp", saddr: "[::ffff:0.0.0.0]:0", tnet: "tcp", taddr: "127.0.0.1"},
    22  	{snet: "tcp", saddr: "[::]:0", tnet: "tcp", taddr: "::1"},
    23  
    24  	{snet: "tcp", saddr: ":0", tnet: "tcp", taddr: "::1"},
    25  	{snet: "tcp", saddr: "0.0.0.0:0", tnet: "tcp", taddr: "::1"},
    26  	{snet: "tcp", saddr: "[::ffff:0.0.0.0]:0", tnet: "tcp", taddr: "::1"},
    27  	{snet: "tcp", saddr: "[::]:0", tnet: "tcp", taddr: "127.0.0.1"},
    28  
    29  	{snet: "tcp", saddr: ":0", tnet: "tcp4", taddr: "127.0.0.1"},
    30  	{snet: "tcp", saddr: "0.0.0.0:0", tnet: "tcp4", taddr: "127.0.0.1"},
    31  	{snet: "tcp", saddr: "[::ffff:0.0.0.0]:0", tnet: "tcp4", taddr: "127.0.0.1"},
    32  	{snet: "tcp", saddr: "[::]:0", tnet: "tcp6", taddr: "::1"},
    33  
    34  	{snet: "tcp", saddr: ":0", tnet: "tcp6", taddr: "::1"},
    35  	{snet: "tcp", saddr: "0.0.0.0:0", tnet: "tcp6", taddr: "::1"},
    36  	{snet: "tcp", saddr: "[::ffff:0.0.0.0]:0", tnet: "tcp6", taddr: "::1"},
    37  	{snet: "tcp", saddr: "[::]:0", tnet: "tcp4", taddr: "127.0.0.1"},
    38  
    39  	{snet: "tcp", saddr: "127.0.0.1:0", tnet: "tcp", taddr: "127.0.0.1"},
    40  	{snet: "tcp", saddr: "[::ffff:127.0.0.1]:0", tnet: "tcp", taddr: "127.0.0.1"},
    41  	{snet: "tcp", saddr: "[::1]:0", tnet: "tcp", taddr: "::1"},
    42  
    43  	{snet: "tcp4", saddr: ":0", tnet: "tcp4", taddr: "127.0.0.1"},
    44  	{snet: "tcp4", saddr: "0.0.0.0:0", tnet: "tcp4", taddr: "127.0.0.1"},
    45  	{snet: "tcp4", saddr: "[::ffff:0.0.0.0]:0", tnet: "tcp4", taddr: "127.0.0.1"},
    46  
    47  	{snet: "tcp4", saddr: "127.0.0.1:0", tnet: "tcp4", taddr: "127.0.0.1"},
    48  
    49  	{snet: "tcp6", saddr: ":0", tnet: "tcp6", taddr: "::1"},
    50  	{snet: "tcp6", saddr: "[::]:0", tnet: "tcp6", taddr: "::1"},
    51  
    52  	{snet: "tcp6", saddr: "[::1]:0", tnet: "tcp6", taddr: "::1"},
    53  }
    54  
    55  // TestTCPServer tests concurrent accept-read-write servers.
    56  func TestTCPServer(t *testing.T) {
    57  	const N = 3
    58  
    59  	for i, tt := range tcpServerTests {
    60  		t.Run(tt.snet+" "+tt.saddr+"<-"+tt.taddr, func(t *testing.T) {
    61  			if !testableListenArgs(tt.snet, tt.saddr, tt.taddr) {
    62  				t.Skip("not testable")
    63  			}
    64  
    65  			ln, err := Listen(tt.snet, tt.saddr)
    66  			if err != nil {
    67  				if perr := parseDialError(err); perr != nil {
    68  					t.Error(perr)
    69  				}
    70  				t.Fatal(err)
    71  			}
    72  
    73  			var lss []*localServer
    74  			var tpchs []chan error
    75  			defer func() {
    76  				for _, ls := range lss {
    77  					ls.teardown()
    78  				}
    79  			}()
    80  			for i := 0; i < N; i++ {
    81  				ls, err := (&streamListener{Listener: ln}).newLocalServer()
    82  				if err != nil {
    83  					t.Fatal(err)
    84  				}
    85  				lss = append(lss, ls)
    86  				tpchs = append(tpchs, make(chan error, 1))
    87  			}
    88  			for i := 0; i < N; i++ {
    89  				ch := tpchs[i]
    90  				handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }
    91  				if err := lss[i].buildup(handler); err != nil {
    92  					t.Fatal(err)
    93  				}
    94  			}
    95  
    96  			var trchs []chan error
    97  			for i := 0; i < N; i++ {
    98  				_, port, err := SplitHostPort(lss[i].Listener.Addr().String())
    99  				if err != nil {
   100  					t.Fatal(err)
   101  				}
   102  				d := Dialer{Timeout: someTimeout}
   103  				c, err := d.Dial(tt.tnet, JoinHostPort(tt.taddr, port))
   104  				if err != nil {
   105  					if perr := parseDialError(err); perr != nil {
   106  						t.Error(perr)
   107  					}
   108  					t.Fatal(err)
   109  				}
   110  				defer c.Close()
   111  				trchs = append(trchs, make(chan error, 1))
   112  				go transceiver(c, []byte("TCP SERVER TEST"), trchs[i])
   113  			}
   114  
   115  			for _, ch := range trchs {
   116  				for err := range ch {
   117  					t.Errorf("#%d: %v", i, err)
   118  				}
   119  			}
   120  			for _, ch := range tpchs {
   121  				for err := range ch {
   122  					t.Errorf("#%d: %v", i, err)
   123  				}
   124  			}
   125  		})
   126  	}
   127  }
   128  
   129  var unixAndUnixpacketServerTests = []struct {
   130  	network, address string
   131  }{
   132  	{"unix", testUnixAddr()},
   133  	{"unix", "@nettest/go/unix"},
   134  
   135  	{"unixpacket", testUnixAddr()},
   136  	{"unixpacket", "@nettest/go/unixpacket"},
   137  }
   138  
   139  // TestUnixAndUnixpacketServer tests concurrent accept-read-write
   140  // servers
   141  func TestUnixAndUnixpacketServer(t *testing.T) {
   142  	const N = 3
   143  
   144  	for i, tt := range unixAndUnixpacketServerTests {
   145  		if !testableListenArgs(tt.network, tt.address, "") {
   146  			t.Logf("skipping %s test", tt.network+" "+tt.address)
   147  			continue
   148  		}
   149  
   150  		ln, err := Listen(tt.network, tt.address)
   151  		if err != nil {
   152  			if perr := parseDialError(err); perr != nil {
   153  				t.Error(perr)
   154  			}
   155  			t.Fatal(err)
   156  		}
   157  
   158  		var lss []*localServer
   159  		var tpchs []chan error
   160  		defer func() {
   161  			for _, ls := range lss {
   162  				ls.teardown()
   163  			}
   164  		}()
   165  		for i := 0; i < N; i++ {
   166  			ls, err := (&streamListener{Listener: ln}).newLocalServer()
   167  			if err != nil {
   168  				t.Fatal(err)
   169  			}
   170  			lss = append(lss, ls)
   171  			tpchs = append(tpchs, make(chan error, 1))
   172  		}
   173  		for i := 0; i < N; i++ {
   174  			ch := tpchs[i]
   175  			handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }
   176  			if err := lss[i].buildup(handler); err != nil {
   177  				t.Fatal(err)
   178  			}
   179  		}
   180  
   181  		var trchs []chan error
   182  		for i := 0; i < N; i++ {
   183  			d := Dialer{Timeout: someTimeout}
   184  			c, err := d.Dial(lss[i].Listener.Addr().Network(), lss[i].Listener.Addr().String())
   185  			if err != nil {
   186  				if perr := parseDialError(err); perr != nil {
   187  					t.Error(perr)
   188  				}
   189  				t.Fatal(err)
   190  			}
   191  			defer os.Remove(c.LocalAddr().String())
   192  			defer c.Close()
   193  			trchs = append(trchs, make(chan error, 1))
   194  			go transceiver(c, []byte("UNIX AND UNIXPACKET SERVER TEST"), trchs[i])
   195  		}
   196  
   197  		for _, ch := range trchs {
   198  			for err := range ch {
   199  				t.Errorf("#%d: %v", i, err)
   200  			}
   201  		}
   202  		for _, ch := range tpchs {
   203  			for err := range ch {
   204  				t.Errorf("#%d: %v", i, err)
   205  			}
   206  		}
   207  	}
   208  }
   209  
   210  var udpServerTests = []struct {
   211  	snet, saddr string // server endpoint
   212  	tnet, taddr string // target endpoint for client
   213  	dial        bool   // test with Dial
   214  }{
   215  	{snet: "udp", saddr: ":0", tnet: "udp", taddr: "127.0.0.1"},
   216  	{snet: "udp", saddr: "0.0.0.0:0", tnet: "udp", taddr: "127.0.0.1"},
   217  	{snet: "udp", saddr: "[::ffff:0.0.0.0]:0", tnet: "udp", taddr: "127.0.0.1"},
   218  	{snet: "udp", saddr: "[::]:0", tnet: "udp", taddr: "::1"},
   219  
   220  	{snet: "udp", saddr: ":0", tnet: "udp", taddr: "::1"},
   221  	{snet: "udp", saddr: "0.0.0.0:0", tnet: "udp", taddr: "::1"},
   222  	{snet: "udp", saddr: "[::ffff:0.0.0.0]:0", tnet: "udp", taddr: "::1"},
   223  	{snet: "udp", saddr: "[::]:0", tnet: "udp", taddr: "127.0.0.1"},
   224  
   225  	{snet: "udp", saddr: ":0", tnet: "udp4", taddr: "127.0.0.1"},
   226  	{snet: "udp", saddr: "0.0.0.0:0", tnet: "udp4", taddr: "127.0.0.1"},
   227  	{snet: "udp", saddr: "[::ffff:0.0.0.0]:0", tnet: "udp4", taddr: "127.0.0.1"},
   228  	{snet: "udp", saddr: "[::]:0", tnet: "udp6", taddr: "::1"},
   229  
   230  	{snet: "udp", saddr: ":0", tnet: "udp6", taddr: "::1"},
   231  	{snet: "udp", saddr: "0.0.0.0:0", tnet: "udp6", taddr: "::1"},
   232  	{snet: "udp", saddr: "[::ffff:0.0.0.0]:0", tnet: "udp6", taddr: "::1"},
   233  	{snet: "udp", saddr: "[::]:0", tnet: "udp4", taddr: "127.0.0.1"},
   234  
   235  	{snet: "udp", saddr: "127.0.0.1:0", tnet: "udp", taddr: "127.0.0.1"},
   236  	{snet: "udp", saddr: "[::ffff:127.0.0.1]:0", tnet: "udp", taddr: "127.0.0.1"},
   237  	{snet: "udp", saddr: "[::1]:0", tnet: "udp", taddr: "::1"},
   238  
   239  	{snet: "udp4", saddr: ":0", tnet: "udp4", taddr: "127.0.0.1"},
   240  	{snet: "udp4", saddr: "0.0.0.0:0", tnet: "udp4", taddr: "127.0.0.1"},
   241  	{snet: "udp4", saddr: "[::ffff:0.0.0.0]:0", tnet: "udp4", taddr: "127.0.0.1"},
   242  
   243  	{snet: "udp4", saddr: "127.0.0.1:0", tnet: "udp4", taddr: "127.0.0.1"},
   244  
   245  	{snet: "udp6", saddr: ":0", tnet: "udp6", taddr: "::1"},
   246  	{snet: "udp6", saddr: "[::]:0", tnet: "udp6", taddr: "::1"},
   247  
   248  	{snet: "udp6", saddr: "[::1]:0", tnet: "udp6", taddr: "::1"},
   249  
   250  	{snet: "udp", saddr: "127.0.0.1:0", tnet: "udp", taddr: "127.0.0.1", dial: true},
   251  
   252  	{snet: "udp", saddr: "[::1]:0", tnet: "udp", taddr: "::1", dial: true},
   253  }
   254  
   255  func TestUDPServer(t *testing.T) {
   256  	for i, tt := range udpServerTests {
   257  		if !testableListenArgs(tt.snet, tt.saddr, tt.taddr) {
   258  			t.Logf("skipping %s test", tt.snet+" "+tt.saddr+"<-"+tt.taddr)
   259  			continue
   260  		}
   261  
   262  		c1, err := ListenPacket(tt.snet, tt.saddr)
   263  		if err != nil {
   264  			if perr := parseDialError(err); perr != nil {
   265  				t.Error(perr)
   266  			}
   267  			t.Fatal(err)
   268  		}
   269  
   270  		ls, err := (&packetListener{PacketConn: c1}).newLocalServer()
   271  		if err != nil {
   272  			t.Fatal(err)
   273  		}
   274  		defer ls.teardown()
   275  		tpch := make(chan error, 1)
   276  		handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, tpch) }
   277  		if err := ls.buildup(handler); err != nil {
   278  			t.Fatal(err)
   279  		}
   280  
   281  		trch := make(chan error, 1)
   282  		_, port, err := SplitHostPort(ls.PacketConn.LocalAddr().String())
   283  		if err != nil {
   284  			t.Fatal(err)
   285  		}
   286  		if tt.dial {
   287  			d := Dialer{Timeout: someTimeout}
   288  			c2, err := d.Dial(tt.tnet, JoinHostPort(tt.taddr, port))
   289  			if err != nil {
   290  				if perr := parseDialError(err); perr != nil {
   291  					t.Error(perr)
   292  				}
   293  				t.Fatal(err)
   294  			}
   295  			defer c2.Close()
   296  			go transceiver(c2, []byte("UDP SERVER TEST"), trch)
   297  		} else {
   298  			c2, err := ListenPacket(tt.tnet, JoinHostPort(tt.taddr, "0"))
   299  			if err != nil {
   300  				if perr := parseDialError(err); perr != nil {
   301  					t.Error(perr)
   302  				}
   303  				t.Fatal(err)
   304  			}
   305  			defer c2.Close()
   306  			dst, err := ResolveUDPAddr(tt.tnet, JoinHostPort(tt.taddr, port))
   307  			if err != nil {
   308  				t.Fatal(err)
   309  			}
   310  			go packetTransceiver(c2, []byte("UDP SERVER TEST"), dst, trch)
   311  		}
   312  
   313  		for err := range trch {
   314  			t.Errorf("#%d: %v", i, err)
   315  		}
   316  		for err := range tpch {
   317  			t.Errorf("#%d: %v", i, err)
   318  		}
   319  	}
   320  }
   321  
   322  var unixgramServerTests = []struct {
   323  	saddr string // server endpoint
   324  	caddr string // client endpoint
   325  	dial  bool   // test with Dial
   326  }{
   327  	{saddr: testUnixAddr(), caddr: testUnixAddr()},
   328  	{saddr: testUnixAddr(), caddr: testUnixAddr(), dial: true},
   329  
   330  	{saddr: "@nettest/go/unixgram/server", caddr: "@nettest/go/unixgram/client"},
   331  }
   332  
   333  func TestUnixgramServer(t *testing.T) {
   334  	for i, tt := range unixgramServerTests {
   335  		if !testableListenArgs("unixgram", tt.saddr, "") {
   336  			t.Logf("skipping %s test", "unixgram "+tt.saddr+"<-"+tt.caddr)
   337  			continue
   338  		}
   339  
   340  		c1, err := ListenPacket("unixgram", tt.saddr)
   341  		if err != nil {
   342  			if perr := parseDialError(err); perr != nil {
   343  				t.Error(perr)
   344  			}
   345  			t.Fatal(err)
   346  		}
   347  
   348  		ls, err := (&packetListener{PacketConn: c1}).newLocalServer()
   349  		if err != nil {
   350  			t.Fatal(err)
   351  		}
   352  		defer ls.teardown()
   353  		tpch := make(chan error, 1)
   354  		handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, tpch) }
   355  		if err := ls.buildup(handler); err != nil {
   356  			t.Fatal(err)
   357  		}
   358  
   359  		trch := make(chan error, 1)
   360  		if tt.dial {
   361  			d := Dialer{Timeout: someTimeout, LocalAddr: &UnixAddr{Net: "unixgram", Name: tt.caddr}}
   362  			c2, err := d.Dial("unixgram", ls.PacketConn.LocalAddr().String())
   363  			if err != nil {
   364  				if perr := parseDialError(err); perr != nil {
   365  					t.Error(perr)
   366  				}
   367  				t.Fatal(err)
   368  			}
   369  			defer os.Remove(c2.LocalAddr().String())
   370  			defer c2.Close()
   371  			go transceiver(c2, []byte(c2.LocalAddr().String()), trch)
   372  		} else {
   373  			c2, err := ListenPacket("unixgram", tt.caddr)
   374  			if err != nil {
   375  				if perr := parseDialError(err); perr != nil {
   376  					t.Error(perr)
   377  				}
   378  				t.Fatal(err)
   379  			}
   380  			defer os.Remove(c2.LocalAddr().String())
   381  			defer c2.Close()
   382  			go packetTransceiver(c2, []byte("UNIXGRAM SERVER TEST"), ls.PacketConn.LocalAddr(), trch)
   383  		}
   384  
   385  		for err := range trch {
   386  			t.Errorf("#%d: %v", i, err)
   387  		}
   388  		for err := range tpch {
   389  			t.Errorf("#%d: %v", i, err)
   390  		}
   391  	}
   392  }
   393  

View as plain text