libgo/go/net/interface_test.go

   1 // Copyright 2011 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         "bytes"
   9         "testing"
  10 )
  11
  12 func sameInterface(i, j *Interface) bool {
  13         if i == nil || j == nil {
  14                 return false
  15         }
  16         if i.Index == j.Index && i.Name == j.Name && bytes.Equal(i.HardwareAddr, j.HardwareAddr) {
  17                 return true
  18         }
  19         return false
  20 }
  21
  22 func TestInterfaces(t *testing.T) {
  23         ift, err := Interfaces()
  24         if err != nil {
  25                 t.Fatalf("Interfaces failed: %v", err)
  26         }
  27         t.Logf("table: len/cap = %v/%v", len(ift), cap(ift))
  28
  29         for _, ifi := range ift {
  30                 ifxi, err := InterfaceByIndex(ifi.Index)
  31                 if err != nil {
  32                         t.Fatalf("InterfaceByIndex(%q) failed: %v", ifi.Index, err)
  33                 }
  34                 if !sameInterface(ifxi, &ifi) {
  35                         t.Fatalf("InterfaceByIndex(%q) = %v, want %v", ifi.Index, *ifxi, ifi)
  36                 }
  37                 ifxn, err := InterfaceByName(ifi.Name)
  38                 if err != nil {
  39                         t.Fatalf("InterfaceByName(%q) failed: %v", ifi.Name, err)
  40                 }
  41                 if !sameInterface(ifxn, &ifi) {
  42                         t.Fatalf("InterfaceByName(%q) = %v, want %v", ifi.Name, *ifxn, ifi)
  43                 }
  44                 t.Logf("%q: flags %q, ifindex %v, mtu %v", ifi.Name, ifi.Flags.String(), ifi.Index, ifi.MTU)
  45                 t.Logf("\thardware address %q", ifi.HardwareAddr.String())
  46                 testInterfaceAddrs(t, &ifi)
  47                 testInterfaceMulticastAddrs(t, &ifi)
  48         }
  49 }
  50
  51 func TestInterfaceAddrs(t *testing.T) {
  52         ifat, err := InterfaceAddrs()
  53         if err != nil {
  54                 t.Fatalf("InterfaceAddrs failed: %v", err)
  55         }
  56         t.Logf("table: len/cap = %v/%v", len(ifat), cap(ifat))
  57         testAddrs(t, ifat)
  58 }
  59
  60 func testInterfaceAddrs(t *testing.T, ifi *Interface) {
  61         ifat, err := ifi.Addrs()
  62         if err != nil {
  63                 t.Fatalf("Interface.Addrs failed: %v", err)
  64         }
  65         testAddrs(t, ifat)
  66 }
  67
  68 func testInterfaceMulticastAddrs(t *testing.T, ifi *Interface) {
  69         ifmat, err := ifi.MulticastAddrs()
  70         if err != nil {
  71                 t.Fatalf("Interface.MulticastAddrs failed: %v", err)
  72         }
  73         testMulticastAddrs(t, ifmat)
  74 }
  75
  76 func testAddrs(t *testing.T, ifat []Addr) {
  77         for _, ifa := range ifat {
  78                 switch v := ifa.(type) {
  79                 case *IPAddr, *IPNet:
  80                         if v == nil {
  81                                 t.Errorf("\tunexpected value: %v", ifa)
  82                         } else {
  83                                 t.Logf("\tinterface address %q", ifa.String())
  84                         }
  85                 default:
  86                         t.Errorf("\tunexpected type: %T", ifa)
  87                 }
  88         }
  89 }
  90
  91 func testMulticastAddrs(t *testing.T, ifmat []Addr) {
  92         for _, ifma := range ifmat {
  93                 switch v := ifma.(type) {
  94                 case *IPAddr:
  95                         if v == nil {
  96                                 t.Errorf("\tunexpected value: %v", ifma)
  97                         } else {
  98                                 t.Logf("\tjoined group address %q", ifma.String())
  99                         }
 100                 default:
 101                         t.Errorf("\tunexpected type: %T", ifma)
 102                 }
 103         }
 104 }