...
Run Format

Source file src/net/interface_unix_test.go

Documentation: net

  // Copyright 2013 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.
  
  // +build darwin dragonfly freebsd linux netbsd openbsd
  
  package net
  
  import (
  	"fmt"
  	"os"
  	"os/exec"
  	"runtime"
  	"testing"
  	"time"
  )
  
  type testInterface struct {
  	name         string
  	local        string
  	remote       string
  	setupCmds    []*exec.Cmd
  	teardownCmds []*exec.Cmd
  }
  
  func (ti *testInterface) setup() error {
  	for _, cmd := range ti.setupCmds {
  		if out, err := cmd.CombinedOutput(); err != nil {
  			return fmt.Errorf("args=%v out=%q err=%v", cmd.Args, string(out), err)
  		}
  	}
  	return nil
  }
  
  func (ti *testInterface) teardown() error {
  	for _, cmd := range ti.teardownCmds {
  		if out, err := cmd.CombinedOutput(); err != nil {
  			return fmt.Errorf("args=%v out=%q err=%v ", cmd.Args, string(out), err)
  		}
  	}
  	return nil
  }
  
  func TestPointToPointInterface(t *testing.T) {
  	if testing.Short() {
  		t.Skip("avoid external network")
  	}
  	if runtime.GOOS == "darwin" {
  		t.Skipf("not supported on %s", runtime.GOOS)
  	}
  	if os.Getuid() != 0 {
  		t.Skip("must be root")
  	}
  
  	// We suppose that using IPv4 link-local addresses doesn't
  	// harm anyone.
  	local, remote := "169.254.0.1", "169.254.0.254"
  	ip := ParseIP(remote)
  	for i := 0; i < 3; i++ {
  		ti := &testInterface{local: local, remote: remote}
  		if err := ti.setPointToPoint(5963 + i); err != nil {
  			t.Skipf("test requires external command: %v", err)
  		}
  		if err := ti.setup(); err != nil {
  			t.Fatal(err)
  		} else {
  			time.Sleep(3 * time.Millisecond)
  		}
  		ift, err := Interfaces()
  		if err != nil {
  			ti.teardown()
  			t.Fatal(err)
  		}
  		for _, ifi := range ift {
  			if ti.name != ifi.Name {
  				continue
  			}
  			ifat, err := ifi.Addrs()
  			if err != nil {
  				ti.teardown()
  				t.Fatal(err)
  			}
  			for _, ifa := range ifat {
  				if ip.Equal(ifa.(*IPNet).IP) {
  					ti.teardown()
  					t.Fatalf("got %v", ifa)
  				}
  			}
  		}
  		if err := ti.teardown(); err != nil {
  			t.Fatal(err)
  		} else {
  			time.Sleep(3 * time.Millisecond)
  		}
  	}
  }
  
  func TestInterfaceArrivalAndDeparture(t *testing.T) {
  	if testing.Short() {
  		t.Skip("avoid external network")
  	}
  	if os.Getuid() != 0 {
  		t.Skip("must be root")
  	}
  
  	// We suppose that using IPv4 link-local addresses and the
  	// dot1Q ID for Token Ring and FDDI doesn't harm anyone.
  	local, remote := "169.254.0.1", "169.254.0.254"
  	ip := ParseIP(remote)
  	for _, vid := range []int{1002, 1003, 1004, 1005} {
  		ift1, err := Interfaces()
  		if err != nil {
  			t.Fatal(err)
  		}
  		ti := &testInterface{local: local, remote: remote}
  		if err := ti.setBroadcast(vid); err != nil {
  			t.Skipf("test requires external command: %v", err)
  		}
  		if err := ti.setup(); err != nil {
  			t.Fatal(err)
  		} else {
  			time.Sleep(3 * time.Millisecond)
  		}
  		ift2, err := Interfaces()
  		if err != nil {
  			ti.teardown()
  			t.Fatal(err)
  		}
  		if len(ift2) <= len(ift1) {
  			for _, ifi := range ift1 {
  				t.Logf("before: %v", ifi)
  			}
  			for _, ifi := range ift2 {
  				t.Logf("after: %v", ifi)
  			}
  			ti.teardown()
  			t.Fatalf("got %v; want gt %v", len(ift2), len(ift1))
  		}
  		for _, ifi := range ift2 {
  			if ti.name != ifi.Name {
  				continue
  			}
  			ifat, err := ifi.Addrs()
  			if err != nil {
  				ti.teardown()
  				t.Fatal(err)
  			}
  			for _, ifa := range ifat {
  				if ip.Equal(ifa.(*IPNet).IP) {
  					ti.teardown()
  					t.Fatalf("got %v", ifa)
  				}
  			}
  		}
  		if err := ti.teardown(); err != nil {
  			t.Fatal(err)
  		} else {
  			time.Sleep(3 * time.Millisecond)
  		}
  		ift3, err := Interfaces()
  		if err != nil {
  			t.Fatal(err)
  		}
  		if len(ift3) >= len(ift2) {
  			for _, ifi := range ift2 {
  				t.Logf("before: %v", ifi)
  			}
  			for _, ifi := range ift3 {
  				t.Logf("after: %v", ifi)
  			}
  			t.Fatalf("got %v; want lt %v", len(ift3), len(ift2))
  		}
  	}
  }
  

View as plain text