github.com/hongwozai/go-src-1.4.3@v0.0.0-20191127132709-dc3fce3dbccb/src/net/interface_unix_test.go (about)

     1  // Copyright 2013 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  // +build darwin dragonfly freebsd linux netbsd openbsd
     6  
     7  package net
     8  
     9  import (
    10  	"os"
    11  	"os/exec"
    12  	"runtime"
    13  	"testing"
    14  	"time"
    15  )
    16  
    17  type testInterface struct {
    18  	name         string
    19  	local        string
    20  	remote       string
    21  	setupCmds    []*exec.Cmd
    22  	teardownCmds []*exec.Cmd
    23  }
    24  
    25  func (ti *testInterface) setup() error {
    26  	for _, cmd := range ti.setupCmds {
    27  		if err := cmd.Run(); err != nil {
    28  			return err
    29  		}
    30  	}
    31  	return nil
    32  }
    33  
    34  func (ti *testInterface) teardown() error {
    35  	for _, cmd := range ti.teardownCmds {
    36  		if err := cmd.Run(); err != nil {
    37  			return err
    38  		}
    39  	}
    40  	return nil
    41  }
    42  
    43  func TestPointToPointInterface(t *testing.T) {
    44  	if testing.Short() {
    45  		t.Skip("skipping test in short mode")
    46  	}
    47  	switch {
    48  	case runtime.GOOS == "darwin":
    49  		t.Skipf("skipping read test on %q", runtime.GOOS)
    50  	}
    51  	if os.Getuid() != 0 {
    52  		t.Skip("skipping test; must be root")
    53  	}
    54  
    55  	local, remote := "169.254.0.1", "169.254.0.254"
    56  	ip := ParseIP(remote)
    57  	for i := 0; i < 3; i++ {
    58  		ti := &testInterface{}
    59  		if err := ti.setPointToPoint(5963+i, local, remote); err != nil {
    60  			t.Skipf("test requries external command: %v", err)
    61  		}
    62  		if err := ti.setup(); err != nil {
    63  			t.Fatalf("testInterface.setup failed: %v", err)
    64  		} else {
    65  			time.Sleep(3 * time.Millisecond)
    66  		}
    67  		ift, err := Interfaces()
    68  		if err != nil {
    69  			ti.teardown()
    70  			t.Fatalf("Interfaces failed: %v", err)
    71  		}
    72  		for _, ifi := range ift {
    73  			if ti.name == ifi.Name {
    74  				ifat, err := ifi.Addrs()
    75  				if err != nil {
    76  					ti.teardown()
    77  					t.Fatalf("Interface.Addrs failed: %v", err)
    78  				}
    79  				for _, ifa := range ifat {
    80  					if ip.Equal(ifa.(*IPNet).IP) {
    81  						ti.teardown()
    82  						t.Fatalf("got %v; want %v", ip, local)
    83  					}
    84  				}
    85  			}
    86  		}
    87  		if err := ti.teardown(); err != nil {
    88  			t.Fatalf("testInterface.teardown failed: %v", err)
    89  		} else {
    90  			time.Sleep(3 * time.Millisecond)
    91  		}
    92  	}
    93  }
    94  
    95  func TestInterfaceArrivalAndDeparture(t *testing.T) {
    96  	if testing.Short() {
    97  		t.Skip("skipping test in short mode")
    98  	}
    99  	if os.Getuid() != 0 {
   100  		t.Skip("skipping test; must be root")
   101  	}
   102  
   103  	for i := 0; i < 3; i++ {
   104  		ift1, err := Interfaces()
   105  		if err != nil {
   106  			t.Fatalf("Interfaces failed: %v", err)
   107  		}
   108  		ti := &testInterface{}
   109  		if err := ti.setBroadcast(5682 + i); err != nil {
   110  			t.Skipf("test requires external command: %v", err)
   111  		}
   112  		if err := ti.setup(); err != nil {
   113  			t.Fatalf("testInterface.setup failed: %v", err)
   114  		} else {
   115  			time.Sleep(3 * time.Millisecond)
   116  		}
   117  		ift2, err := Interfaces()
   118  		if err != nil {
   119  			ti.teardown()
   120  			t.Fatalf("Interfaces failed: %v", err)
   121  		}
   122  		if len(ift2) <= len(ift1) {
   123  			for _, ifi := range ift1 {
   124  				t.Logf("before: %v", ifi)
   125  			}
   126  			for _, ifi := range ift2 {
   127  				t.Logf("after: %v", ifi)
   128  			}
   129  			ti.teardown()
   130  			t.Fatalf("got %v; want gt %v", len(ift2), len(ift1))
   131  		}
   132  		if err := ti.teardown(); err != nil {
   133  			t.Fatalf("testInterface.teardown failed: %v", err)
   134  		} else {
   135  			time.Sleep(3 * time.Millisecond)
   136  		}
   137  		ift3, err := Interfaces()
   138  		if err != nil {
   139  			t.Fatalf("Interfaces failed: %v", err)
   140  		}
   141  		if len(ift3) >= len(ift2) {
   142  			for _, ifi := range ift2 {
   143  				t.Logf("before: %v", ifi)
   144  			}
   145  			for _, ifi := range ift3 {
   146  				t.Logf("after: %v", ifi)
   147  			}
   148  			t.Fatalf("got %v; want lt %v", len(ift3), len(ift2))
   149  		}
   150  	}
   151  }