server_test.go

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