Depenancy upgrades and movign to dep. (#8630)

17 files changed, 8 insertions, 2402 deletions

diff --git a/vendor/golang.org/x/net/ipv6/bpf_test.go b/vendor/golang.org/x/net/ipv6/bpf_test.go
deleted file mode 100644
index 8253e1f42..000000000
--- a/vendor/golang.org/x/net/ipv6/bpf_test.go
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2016 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.
-
-package ipv6_test
-
-import (
-	"net"
-	"runtime"
-	"testing"
-	"time"
-
-	"golang.org/x/net/bpf"
-	"golang.org/x/net/ipv6"
-)
-
-func TestBPF(t *testing.T) {
-	if runtime.GOOS != "linux" {
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	l, err := net.ListenPacket("udp6", "[::1]:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-
-	p := ipv6.NewPacketConn(l)
-
-	// This filter accepts UDP packets whose first payload byte is
-	// even.
-	prog, err := bpf.Assemble([]bpf.Instruction{
-		// Load the first byte of the payload (skipping UDP header).
-		bpf.LoadAbsolute{Off: 8, Size: 1},
-		// Select LSB of the byte.
-		bpf.ALUOpConstant{Op: bpf.ALUOpAnd, Val: 1},
-		// Byte is even?
-		bpf.JumpIf{Cond: bpf.JumpEqual, Val: 0, SkipFalse: 1},
-		// Accept.
-		bpf.RetConstant{Val: 4096},
-		// Ignore.
-		bpf.RetConstant{Val: 0},
-	})
-	if err != nil {
-		t.Fatalf("compiling BPF: %s", err)
-	}
-
-	if err = p.SetBPF(prog); err != nil {
-		t.Fatalf("attaching filter to Conn: %s", err)
-	}
-
-	s, err := net.Dial("udp6", l.LocalAddr().String())
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer s.Close()
-	go func() {
-		for i := byte(0); i < 10; i++ {
-			s.Write([]byte{i})
-		}
-	}()
-
-	l.SetDeadline(time.Now().Add(2 * time.Second))
-	seen := make([]bool, 5)
-	for {
-		var b [512]byte
-		n, _, err := l.ReadFrom(b[:])
-		if err != nil {
-			t.Fatalf("reading from listener: %s", err)
-		}
-		if n != 1 {
-			t.Fatalf("unexpected packet length, want 1, got %d", n)
-		}
-		if b[0] >= 10 {
-			t.Fatalf("unexpected byte, want 0-9, got %d", b[0])
-		}
-		if b[0]%2 != 0 {
-			t.Fatalf("got odd byte %d, wanted only even bytes", b[0])
-		}
-		seen[b[0]/2] = true
-
-		seenAll := true
-		for _, v := range seen {
-			if !v {
-				seenAll = false
-				break
-			}
-		}
-		if seenAll {
-			break
-		}
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/control_test.go b/vendor/golang.org/x/net/ipv6/control_test.go
deleted file mode 100644
index c186ca99f..000000000
--- a/vendor/golang.org/x/net/ipv6/control_test.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2017 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.
-
-package ipv6_test
-
-import (
-	"testing"
-
-	"golang.org/x/net/ipv6"
-)
-
-func TestControlMessageParseWithFuzz(t *testing.T) {
-	var cm ipv6.ControlMessage
-	for _, fuzz := range []string{
-		"\f\x00\x00\x00)\x00\x00\x00.\x00\x00\x00",
-		"\f\x00\x00\x00)\x00\x00\x00,\x00\x00\x00",
-	} {
-		cm.Parse([]byte(fuzz))
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/example_test.go b/vendor/golang.org/x/net/ipv6/example_test.go
deleted file mode 100644
index e761aa2a1..000000000
--- a/vendor/golang.org/x/net/ipv6/example_test.go
+++ /dev/null
@@ -1,216 +0,0 @@
-// Copyright 2014 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.
-
-package ipv6_test
-
-import (
-	"fmt"
-	"log"
-	"net"
-	"os"
-	"time"
-
-	"golang.org/x/net/icmp"
-	"golang.org/x/net/ipv6"
-)
-
-func ExampleConn_markingTCP() {
-	ln, err := net.Listen("tcp", "[::]:1024")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer ln.Close()
-
-	for {
-		c, err := ln.Accept()
-		if err != nil {
-			log.Fatal(err)
-		}
-		go func(c net.Conn) {
-			defer c.Close()
-			if c.RemoteAddr().(*net.TCPAddr).IP.To16() != nil && c.RemoteAddr().(*net.TCPAddr).IP.To4() == nil {
-				p := ipv6.NewConn(c)
-				if err := p.SetTrafficClass(0x28); err != nil { // DSCP AF11
-					log.Fatal(err)
-				}
-				if err := p.SetHopLimit(128); err != nil {
-					log.Fatal(err)
-				}
-			}
-			if _, err := c.Write([]byte("HELLO-R-U-THERE-ACK")); err != nil {
-				log.Fatal(err)
-			}
-		}(c)
-	}
-}
-
-func ExamplePacketConn_servingOneShotMulticastDNS() {
-	c, err := net.ListenPacket("udp6", "[::]:5353") // mDNS over UDP
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-
-	en0, err := net.InterfaceByName("en0")
-	if err != nil {
-		log.Fatal(err)
-	}
-	mDNSLinkLocal := net.UDPAddr{IP: net.ParseIP("ff02::fb")}
-	if err := p.JoinGroup(en0, &mDNSLinkLocal); err != nil {
-		log.Fatal(err)
-	}
-	defer p.LeaveGroup(en0, &mDNSLinkLocal)
-	if err := p.SetControlMessage(ipv6.FlagDst|ipv6.FlagInterface, true); err != nil {
-		log.Fatal(err)
-	}
-
-	var wcm ipv6.ControlMessage
-	b := make([]byte, 1500)
-	for {
-		_, rcm, peer, err := p.ReadFrom(b)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if !rcm.Dst.IsMulticast() || !rcm.Dst.Equal(mDNSLinkLocal.IP) {
-			continue
-		}
-		wcm.IfIndex = rcm.IfIndex
-		answers := []byte("FAKE-MDNS-ANSWERS") // fake mDNS answers, you need to implement this
-		if _, err := p.WriteTo(answers, &wcm, peer); err != nil {
-			log.Fatal(err)
-		}
-	}
-}
-
-func ExamplePacketConn_tracingIPPacketRoute() {
-	// Tracing an IP packet route to www.google.com.
-
-	const host = "www.google.com"
-	ips, err := net.LookupIP(host)
-	if err != nil {
-		log.Fatal(err)
-	}
-	var dst net.IPAddr
-	for _, ip := range ips {
-		if ip.To16() != nil && ip.To4() == nil {
-			dst.IP = ip
-			fmt.Printf("using %v for tracing an IP packet route to %s\n", dst.IP, host)
-			break
-		}
-	}
-	if dst.IP == nil {
-		log.Fatal("no AAAA record found")
-	}
-
-	c, err := net.ListenPacket("ip6:58", "::") // ICMP for IPv6
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-
-	if err := p.SetControlMessage(ipv6.FlagHopLimit|ipv6.FlagSrc|ipv6.FlagDst|ipv6.FlagInterface, true); err != nil {
-		log.Fatal(err)
-	}
-	wm := icmp.Message{
-		Type: ipv6.ICMPTypeEchoRequest, Code: 0,
-		Body: &icmp.Echo{
-			ID:   os.Getpid() & 0xffff,
-			Data: []byte("HELLO-R-U-THERE"),
-		},
-	}
-	var f ipv6.ICMPFilter
-	f.SetAll(true)
-	f.Accept(ipv6.ICMPTypeTimeExceeded)
-	f.Accept(ipv6.ICMPTypeEchoReply)
-	if err := p.SetICMPFilter(&f); err != nil {
-		log.Fatal(err)
-	}
-
-	var wcm ipv6.ControlMessage
-	rb := make([]byte, 1500)
-	for i := 1; i <= 64; i++ { // up to 64 hops
-		wm.Body.(*icmp.Echo).Seq = i
-		wb, err := wm.Marshal(nil)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		// In the real world usually there are several
-		// multiple traffic-engineered paths for each hop.
-		// You may need to probe a few times to each hop.
-		begin := time.Now()
-		wcm.HopLimit = i
-		if _, err := p.WriteTo(wb, &wcm, &dst); err != nil {
-			log.Fatal(err)
-		}
-		if err := p.SetReadDeadline(time.Now().Add(3 * time.Second)); err != nil {
-			log.Fatal(err)
-		}
-		n, rcm, peer, err := p.ReadFrom(rb)
-		if err != nil {
-			if err, ok := err.(net.Error); ok && err.Timeout() {
-				fmt.Printf("%v\t*\n", i)
-				continue
-			}
-			log.Fatal(err)
-		}
-		rm, err := icmp.ParseMessage(58, rb[:n])
-		if err != nil {
-			log.Fatal(err)
-		}
-		rtt := time.Since(begin)
-
-		// In the real world you need to determine whether the
-		// received message is yours using ControlMessage.Src,
-		// ControlMesage.Dst, icmp.Echo.ID and icmp.Echo.Seq.
-		switch rm.Type {
-		case ipv6.ICMPTypeTimeExceeded:
-			names, _ := net.LookupAddr(peer.String())
-			fmt.Printf("%d\t%v %+v %v\n\t%+v\n", i, peer, names, rtt, rcm)
-		case ipv6.ICMPTypeEchoReply:
-			names, _ := net.LookupAddr(peer.String())
-			fmt.Printf("%d\t%v %+v %v\n\t%+v\n", i, peer, names, rtt, rcm)
-			return
-		}
-	}
-}
-
-func ExamplePacketConn_advertisingOSPFHello() {
-	c, err := net.ListenPacket("ip6:89", "::") // OSPF for IPv6
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-
-	en0, err := net.InterfaceByName("en0")
-	if err != nil {
-		log.Fatal(err)
-	}
-	allSPFRouters := net.IPAddr{IP: net.ParseIP("ff02::5")}
-	if err := p.JoinGroup(en0, &allSPFRouters); err != nil {
-		log.Fatal(err)
-	}
-	defer p.LeaveGroup(en0, &allSPFRouters)
-
-	hello := make([]byte, 24) // fake hello data, you need to implement this
-	ospf := make([]byte, 16)  // fake ospf header, you need to implement this
-	ospf[0] = 3               // version 3
-	ospf[1] = 1               // hello packet
-	ospf = append(ospf, hello...)
-	if err := p.SetChecksum(true, 12); err != nil {
-		log.Fatal(err)
-	}
-
-	cm := ipv6.ControlMessage{
-		TrafficClass: 0xc0, // DSCP CS6
-		HopLimit:     1,
-		IfIndex:      en0.Index,
-	}
-	if _, err := p.WriteTo(ospf, &cm, &allSPFRouters); err != nil {
-		log.Fatal(err)
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/gen.go b/vendor/golang.org/x/net/ipv6/gen.go
index 47b7e9f0a..5885664fb 100644
--- a/vendor/golang.org/x/net/ipv6/gen.go
+++ b/vendor/golang.org/x/net/ipv6/gen.go
@@ -80,7 +80,7 @@ var registries = []struct {
 func geniana() error {
 	var bb bytes.Buffer
 	fmt.Fprintf(&bb, "// go generate gen.go\n")
-	fmt.Fprintf(&bb, "// GENERATED BY THE COMMAND ABOVE; DO NOT EDIT\n\n")
+	fmt.Fprintf(&bb, "// Code generated by the command above; DO NOT EDIT.\n\n")
 	fmt.Fprintf(&bb, "package ipv6\n\n")
 	for _, r := range registries {
 		resp, err := http.Get(r.url)
diff --git a/vendor/golang.org/x/net/ipv6/header_test.go b/vendor/golang.org/x/net/ipv6/header_test.go
deleted file mode 100644
index ca11dc23d..000000000
--- a/vendor/golang.org/x/net/ipv6/header_test.go
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2014 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.
-
-package ipv6_test
-
-import (
-	"net"
-	"reflect"
-	"strings"
-	"testing"
-
-	"golang.org/x/net/internal/iana"
-	"golang.org/x/net/ipv6"
-)
-
-var (
-	wireHeaderFromKernel = [ipv6.HeaderLen]byte{
-		0x69, 0x8b, 0xee, 0xf1,
-		0xca, 0xfe, 0x2c, 0x01,
-		0x20, 0x01, 0x0d, 0xb8,
-		0x00, 0x01, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01,
-		0x20, 0x01, 0x0d, 0xb8,
-		0x00, 0x02, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01,
-	}
-
-	testHeader = &ipv6.Header{
-		Version:      ipv6.Version,
-		TrafficClass: iana.DiffServAF43,
-		FlowLabel:    0xbeef1,
-		PayloadLen:   0xcafe,
-		NextHeader:   iana.ProtocolIPv6Frag,
-		HopLimit:     1,
-		Src:          net.ParseIP("2001:db8:1::1"),
-		Dst:          net.ParseIP("2001:db8:2::1"),
-	}
-)
-
-func TestParseHeader(t *testing.T) {
-	h, err := ipv6.ParseHeader(wireHeaderFromKernel[:])
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(h, testHeader) {
-		t.Fatalf("got %#v; want %#v", h, testHeader)
-	}
-	s := h.String()
-	if strings.Contains(s, ",") {
-		t.Fatalf("should be space-separated values: %s", s)
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/iana.go b/vendor/golang.org/x/net/ipv6/iana.go
index 3c6214fb6..32db1aa94 100644
--- a/vendor/golang.org/x/net/ipv6/iana.go
+++ b/vendor/golang.org/x/net/ipv6/iana.go
@@ -1,9 +1,9 @@
 // go generate gen.go
-// GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
+// Code generated by the command above; DO NOT EDIT.
 
 package ipv6
 
-// Internet Control Message Protocol version 6 (ICMPv6) Parameters, Updated: 2015-07-07
+// Internet Control Message Protocol version 6 (ICMPv6) Parameters, Updated: 2018-03-09
 const (
 	ICMPTypeDestinationUnreachable                ICMPType = 1   // Destination Unreachable
 	ICMPTypePacketTooBig                          ICMPType = 2   // Packet Too Big
@@ -40,9 +40,11 @@ const (
 	ICMPTypeDuplicateAddressRequest               ICMPType = 157 // Duplicate Address Request
 	ICMPTypeDuplicateAddressConfirmation          ICMPType = 158 // Duplicate Address Confirmation
 	ICMPTypeMPLControl                            ICMPType = 159 // MPL Control Message
+	ICMPTypeExtendedEchoRequest                   ICMPType = 160 // Extended Echo Request
+	ICMPTypeExtendedEchoReply                     ICMPType = 161 // Extended Echo Reply
 )
 
-// Internet Control Message Protocol version 6 (ICMPv6) Parameters, Updated: 2015-07-07
+// Internet Control Message Protocol version 6 (ICMPv6) Parameters, Updated: 2018-03-09
 var icmpTypes = map[ICMPType]string{
 	1:   "destination unreachable",
 	2:   "packet too big",
@@ -79,4 +81,6 @@ var icmpTypes = map[ICMPType]string{
 	157: "duplicate address request",
 	158: "duplicate address confirmation",
 	159: "mpl control message",
+	160: "extended echo request",
+	161: "extended echo reply",
 }
diff --git a/vendor/golang.org/x/net/ipv6/icmp_test.go b/vendor/golang.org/x/net/ipv6/icmp_test.go
deleted file mode 100644
index d8e9675dc..000000000
--- a/vendor/golang.org/x/net/ipv6/icmp_test.go
+++ /dev/null
@@ -1,96 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"net"
-	"reflect"
-	"runtime"
-	"testing"
-
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-var icmpStringTests = []struct {
-	in  ipv6.ICMPType
-	out string
-}{
-	{ipv6.ICMPTypeDestinationUnreachable, "destination unreachable"},
-
-	{256, "<nil>"},
-}
-
-func TestICMPString(t *testing.T) {
-	for _, tt := range icmpStringTests {
-		s := tt.in.String()
-		if s != tt.out {
-			t.Errorf("got %s; want %s", s, tt.out)
-		}
-	}
-}
-
-func TestICMPFilter(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-
-	var f ipv6.ICMPFilter
-	for _, toggle := range []bool{false, true} {
-		f.SetAll(toggle)
-		for _, typ := range []ipv6.ICMPType{
-			ipv6.ICMPTypeDestinationUnreachable,
-			ipv6.ICMPTypeEchoReply,
-			ipv6.ICMPTypeNeighborSolicitation,
-			ipv6.ICMPTypeDuplicateAddressConfirmation,
-		} {
-			f.Accept(typ)
-			if f.WillBlock(typ) {
-				t.Errorf("ipv6.ICMPFilter.Set(%v, false) failed", typ)
-			}
-			f.Block(typ)
-			if !f.WillBlock(typ) {
-				t.Errorf("ipv6.ICMPFilter.Set(%v, true) failed", typ)
-			}
-		}
-	}
-}
-
-func TestSetICMPFilter(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if m, ok := nettest.SupportsRawIPSocket(); !ok {
-		t.Skip(m)
-	}
-
-	c, err := net.ListenPacket("ip6:ipv6-icmp", "::1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	p := ipv6.NewPacketConn(c)
-
-	var f ipv6.ICMPFilter
-	f.SetAll(true)
-	f.Accept(ipv6.ICMPTypeEchoRequest)
-	f.Accept(ipv6.ICMPTypeEchoReply)
-	if err := p.SetICMPFilter(&f); err != nil {
-		t.Fatal(err)
-	}
-	kf, err := p.ICMPFilter()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(kf, &f) {
-		t.Fatalf("got %#v; want %#v", kf, f)
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/mocktransponder_test.go b/vendor/golang.org/x/net/ipv6/mocktransponder_test.go
deleted file mode 100644
index 6efe56c68..000000000
--- a/vendor/golang.org/x/net/ipv6/mocktransponder_test.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"net"
-	"testing"
-)
-
-func connector(t *testing.T, network, addr string, done chan<- bool) {
-	defer func() { done <- true }()
-
-	c, err := net.Dial(network, addr)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	c.Close()
-}
-
-func acceptor(t *testing.T, ln net.Listener, done chan<- bool) {
-	defer func() { done <- true }()
-
-	c, err := ln.Accept()
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	c.Close()
-}
diff --git a/vendor/golang.org/x/net/ipv6/multicast_test.go b/vendor/golang.org/x/net/ipv6/multicast_test.go
deleted file mode 100644
index 69a21cd38..000000000
--- a/vendor/golang.org/x/net/ipv6/multicast_test.go
+++ /dev/null
@@ -1,264 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"bytes"
-	"net"
-	"os"
-	"runtime"
-	"testing"
-	"time"
-
-	"golang.org/x/net/icmp"
-	"golang.org/x/net/internal/iana"
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-var packetConnReadWriteMulticastUDPTests = []struct {
-	addr     string
-	grp, src *net.UDPAddr
-}{
-	{"[ff02::]:0", &net.UDPAddr{IP: net.ParseIP("ff02::114")}, nil}, // see RFC 4727
-
-	{"[ff30::8000:0]:0", &net.UDPAddr{IP: net.ParseIP("ff30::8000:1")}, &net.UDPAddr{IP: net.IPv6loopback}}, // see RFC 5771
-}
-
-func TestPacketConnReadWriteMulticastUDP(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if !nettest.SupportsIPv6MulticastDeliveryOnLoopback() {
-		t.Skipf("multicast delivery doesn't work correctly on %s", runtime.GOOS)
-	}
-	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagMulticast|net.FlagLoopback)
-	if ifi == nil {
-		t.Skipf("not available on %s", runtime.GOOS)
-	}
-
-	for _, tt := range packetConnReadWriteMulticastUDPTests {
-		c, err := net.ListenPacket("udp6", tt.addr)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer c.Close()
-
-		grp := *tt.grp
-		grp.Port = c.LocalAddr().(*net.UDPAddr).Port
-		p := ipv6.NewPacketConn(c)
-		defer p.Close()
-		if tt.src == nil {
-			if err := p.JoinGroup(ifi, &grp); err != nil {
-				t.Fatal(err)
-			}
-			defer p.LeaveGroup(ifi, &grp)
-		} else {
-			if err := p.JoinSourceSpecificGroup(ifi, &grp, tt.src); err != nil {
-				switch runtime.GOOS {
-				case "freebsd", "linux":
-				default: // platforms that don't support MLDv2 fail here
-					t.Logf("not supported on %s", runtime.GOOS)
-					continue
-				}
-				t.Fatal(err)
-			}
-			defer p.LeaveSourceSpecificGroup(ifi, &grp, tt.src)
-		}
-		if err := p.SetMulticastInterface(ifi); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := p.MulticastInterface(); err != nil {
-			t.Fatal(err)
-		}
-		if err := p.SetMulticastLoopback(true); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := p.MulticastLoopback(); err != nil {
-			t.Fatal(err)
-		}
-
-		cm := ipv6.ControlMessage{
-			TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-			Src:          net.IPv6loopback,
-			IfIndex:      ifi.Index,
-		}
-		cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-		wb := []byte("HELLO-R-U-THERE")
-
-		for i, toggle := range []bool{true, false, true} {
-			if err := p.SetControlMessage(cf, toggle); err != nil {
-				if nettest.ProtocolNotSupported(err) {
-					t.Logf("not supported on %s", runtime.GOOS)
-					continue
-				}
-				t.Fatal(err)
-			}
-			if err := p.SetDeadline(time.Now().Add(200 * time.Millisecond)); err != nil {
-				t.Fatal(err)
-			}
-			cm.HopLimit = i + 1
-			if n, err := p.WriteTo(wb, &cm, &grp); err != nil {
-				t.Fatal(err)
-			} else if n != len(wb) {
-				t.Fatal(err)
-			}
-			rb := make([]byte, 128)
-			if n, _, _, err := p.ReadFrom(rb); err != nil {
-				t.Fatal(err)
-			} else if !bytes.Equal(rb[:n], wb) {
-				t.Fatalf("got %v; want %v", rb[:n], wb)
-			}
-		}
-	}
-}
-
-var packetConnReadWriteMulticastICMPTests = []struct {
-	grp, src *net.IPAddr
-}{
-	{&net.IPAddr{IP: net.ParseIP("ff02::114")}, nil}, // see RFC 4727
-
-	{&net.IPAddr{IP: net.ParseIP("ff30::8000:1")}, &net.IPAddr{IP: net.IPv6loopback}}, // see RFC 5771
-}
-
-func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if !nettest.SupportsIPv6MulticastDeliveryOnLoopback() {
-		t.Skipf("multicast delivery doesn't work correctly on %s", runtime.GOOS)
-	}
-	if m, ok := nettest.SupportsRawIPSocket(); !ok {
-		t.Skip(m)
-	}
-	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagMulticast|net.FlagLoopback)
-	if ifi == nil {
-		t.Skipf("not available on %s", runtime.GOOS)
-	}
-
-	for _, tt := range packetConnReadWriteMulticastICMPTests {
-		c, err := net.ListenPacket("ip6:ipv6-icmp", "::")
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer c.Close()
-
-		pshicmp := icmp.IPv6PseudoHeader(c.LocalAddr().(*net.IPAddr).IP, tt.grp.IP)
-		p := ipv6.NewPacketConn(c)
-		defer p.Close()
-		if tt.src == nil {
-			if err := p.JoinGroup(ifi, tt.grp); err != nil {
-				t.Fatal(err)
-			}
-			defer p.LeaveGroup(ifi, tt.grp)
-		} else {
-			if err := p.JoinSourceSpecificGroup(ifi, tt.grp, tt.src); err != nil {
-				switch runtime.GOOS {
-				case "freebsd", "linux":
-				default: // platforms that don't support MLDv2 fail here
-					t.Logf("not supported on %s", runtime.GOOS)
-					continue
-				}
-				t.Fatal(err)
-			}
-			defer p.LeaveSourceSpecificGroup(ifi, tt.grp, tt.src)
-		}
-		if err := p.SetMulticastInterface(ifi); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := p.MulticastInterface(); err != nil {
-			t.Fatal(err)
-		}
-		if err := p.SetMulticastLoopback(true); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := p.MulticastLoopback(); err != nil {
-			t.Fatal(err)
-		}
-
-		cm := ipv6.ControlMessage{
-			TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-			Src:          net.IPv6loopback,
-			IfIndex:      ifi.Index,
-		}
-		cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-
-		var f ipv6.ICMPFilter
-		f.SetAll(true)
-		f.Accept(ipv6.ICMPTypeEchoReply)
-		if err := p.SetICMPFilter(&f); err != nil {
-			t.Fatal(err)
-		}
-
-		var psh []byte
-		for i, toggle := range []bool{true, false, true} {
-			if toggle {
-				psh = nil
-				if err := p.SetChecksum(true, 2); err != nil {
-					// Solaris never allows to
-					// modify ICMP properties.
-					if runtime.GOOS != "solaris" {
-						t.Fatal(err)
-					}
-				}
-			} else {
-				psh = pshicmp
-				// Some platforms never allow to
-				// disable the kernel checksum
-				// processing.
-				p.SetChecksum(false, -1)
-			}
-			wb, err := (&icmp.Message{
-				Type: ipv6.ICMPTypeEchoRequest, Code: 0,
-				Body: &icmp.Echo{
-					ID: os.Getpid() & 0xffff, Seq: i + 1,
-					Data: []byte("HELLO-R-U-THERE"),
-				},
-			}).Marshal(psh)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if err := p.SetControlMessage(cf, toggle); err != nil {
-				if nettest.ProtocolNotSupported(err) {
-					t.Logf("not supported on %s", runtime.GOOS)
-					continue
-				}
-				t.Fatal(err)
-			}
-			if err := p.SetDeadline(time.Now().Add(200 * time.Millisecond)); err != nil {
-				t.Fatal(err)
-			}
-			cm.HopLimit = i + 1
-			if n, err := p.WriteTo(wb, &cm, tt.grp); err != nil {
-				t.Fatal(err)
-			} else if n != len(wb) {
-				t.Fatalf("got %v; want %v", n, len(wb))
-			}
-			rb := make([]byte, 128)
-			if n, _, _, err := p.ReadFrom(rb); err != nil {
-				switch runtime.GOOS {
-				case "darwin": // older darwin kernels have some limitation on receiving icmp packet through raw socket
-					t.Logf("not supported on %s", runtime.GOOS)
-					continue
-				}
-				t.Fatal(err)
-			} else {
-				if m, err := icmp.ParseMessage(iana.ProtocolIPv6ICMP, rb[:n]); err != nil {
-					t.Fatal(err)
-				} else if m.Type != ipv6.ICMPTypeEchoReply || m.Code != 0 {
-					t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0)
-				}
-			}
-		}
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/multicastlistener_test.go b/vendor/golang.org/x/net/ipv6/multicastlistener_test.go
deleted file mode 100644
index b27713e2f..000000000
--- a/vendor/golang.org/x/net/ipv6/multicastlistener_test.go
+++ /dev/null
@@ -1,261 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"net"
-	"runtime"
-	"testing"
-
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-var udpMultipleGroupListenerTests = []net.Addr{
-	&net.UDPAddr{IP: net.ParseIP("ff02::114")}, // see RFC 4727
-	&net.UDPAddr{IP: net.ParseIP("ff02::1:114")},
-	&net.UDPAddr{IP: net.ParseIP("ff02::2:114")},
-}
-
-func TestUDPSinglePacketConnWithMultipleGroupListeners(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	for _, gaddr := range udpMultipleGroupListenerTests {
-		c, err := net.ListenPacket("udp6", "[::]:0") // wildcard address with non-reusable port
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer c.Close()
-
-		p := ipv6.NewPacketConn(c)
-		var mift []*net.Interface
-
-		ift, err := net.Interfaces()
-		if err != nil {
-			t.Fatal(err)
-		}
-		for i, ifi := range ift {
-			if _, ok := nettest.IsMulticastCapable("ip6", &ifi); !ok {
-				continue
-			}
-			if err := p.JoinGroup(&ifi, gaddr); err != nil {
-				t.Fatal(err)
-			}
-			mift = append(mift, &ift[i])
-		}
-		for _, ifi := range mift {
-			if err := p.LeaveGroup(ifi, gaddr); err != nil {
-				t.Fatal(err)
-			}
-		}
-	}
-}
-
-func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	for _, gaddr := range udpMultipleGroupListenerTests {
-		c1, err := net.ListenPacket("udp6", "[ff02::]:0") // wildcard address with reusable port
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer c1.Close()
-		_, port, err := net.SplitHostPort(c1.LocalAddr().String())
-		if err != nil {
-			t.Fatal(err)
-		}
-		c2, err := net.ListenPacket("udp6", net.JoinHostPort("ff02::", port)) // wildcard address with reusable port
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer c2.Close()
-
-		var ps [2]*ipv6.PacketConn
-		ps[0] = ipv6.NewPacketConn(c1)
-		ps[1] = ipv6.NewPacketConn(c2)
-		var mift []*net.Interface
-
-		ift, err := net.Interfaces()
-		if err != nil {
-			t.Fatal(err)
-		}
-		for i, ifi := range ift {
-			if _, ok := nettest.IsMulticastCapable("ip6", &ifi); !ok {
-				continue
-			}
-			for _, p := range ps {
-				if err := p.JoinGroup(&ifi, gaddr); err != nil {
-					t.Fatal(err)
-				}
-			}
-			mift = append(mift, &ift[i])
-		}
-		for _, ifi := range mift {
-			for _, p := range ps {
-				if err := p.LeaveGroup(ifi, gaddr); err != nil {
-					t.Fatal(err)
-				}
-			}
-		}
-	}
-}
-
-func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
-	type ml struct {
-		c   *ipv6.PacketConn
-		ifi *net.Interface
-	}
-	var mlt []*ml
-
-	ift, err := net.Interfaces()
-	if err != nil {
-		t.Fatal(err)
-	}
-	port := "0"
-	for i, ifi := range ift {
-		ip, ok := nettest.IsMulticastCapable("ip6", &ifi)
-		if !ok {
-			continue
-		}
-		c, err := net.ListenPacket("udp6", net.JoinHostPort(ip.String()+"%"+ifi.Name, port)) // unicast address with non-reusable port
-		if err != nil {
-			// The listen may fail when the serivce is
-			// already in use, but it's fine because the
-			// purpose of this is not to test the
-			// bookkeeping of IP control block inside the
-			// kernel.
-			t.Log(err)
-			continue
-		}
-		defer c.Close()
-		if port == "0" {
-			_, port, err = net.SplitHostPort(c.LocalAddr().String())
-			if err != nil {
-				t.Fatal(err)
-			}
-		}
-		p := ipv6.NewPacketConn(c)
-		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatal(err)
-		}
-		mlt = append(mlt, &ml{p, &ift[i]})
-	}
-	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
-
-func TestIPSinglePacketConnWithSingleGroupListener(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if m, ok := nettest.SupportsRawIPSocket(); !ok {
-		t.Skip(m)
-	}
-
-	c, err := net.ListenPacket("ip6:ipv6-icmp", "::") // wildcard address
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	p := ipv6.NewPacketConn(c)
-	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
-	var mift []*net.Interface
-
-	ift, err := net.Interfaces()
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, ifi := range ift {
-		if _, ok := nettest.IsMulticastCapable("ip6", &ifi); !ok {
-			continue
-		}
-		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatal(err)
-		}
-		mift = append(mift, &ift[i])
-	}
-	for _, ifi := range mift {
-		if err := p.LeaveGroup(ifi, &gaddr); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
-
-func TestIPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
-	switch runtime.GOOS {
-	case "darwin", "dragonfly", "openbsd": // platforms that return fe80::1%lo0: bind: can't assign requested address
-		t.Skipf("not supported on %s", runtime.GOOS)
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if m, ok := nettest.SupportsRawIPSocket(); !ok {
-		t.Skip(m)
-	}
-
-	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
-	type ml struct {
-		c   *ipv6.PacketConn
-		ifi *net.Interface
-	}
-	var mlt []*ml
-
-	ift, err := net.Interfaces()
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, ifi := range ift {
-		ip, ok := nettest.IsMulticastCapable("ip6", &ifi)
-		if !ok {
-			continue
-		}
-		c, err := net.ListenPacket("ip6:ipv6-icmp", ip.String()+"%"+ifi.Name) // unicast address
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatal(err)
-		}
-		mlt = append(mlt, &ml{p, &ift[i]})
-	}
-	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/multicastsockopt_test.go b/vendor/golang.org/x/net/ipv6/multicastsockopt_test.go
deleted file mode 100644
index 9e6b902d7..000000000
--- a/vendor/golang.org/x/net/ipv6/multicastsockopt_test.go
+++ /dev/null
@@ -1,157 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"net"
-	"runtime"
-	"testing"
-
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-var packetConnMulticastSocketOptionTests = []struct {
-	net, proto, addr string
-	grp, src         net.Addr
-}{
-	{"udp6", "", "[ff02::]:0", &net.UDPAddr{IP: net.ParseIP("ff02::114")}, nil}, // see RFC 4727
-	{"ip6", ":ipv6-icmp", "::", &net.IPAddr{IP: net.ParseIP("ff02::115")}, nil}, // see RFC 4727
-
-	{"udp6", "", "[ff30::8000:0]:0", &net.UDPAddr{IP: net.ParseIP("ff30::8000:1")}, &net.UDPAddr{IP: net.IPv6loopback}}, // see RFC 5771
-	{"ip6", ":ipv6-icmp", "::", &net.IPAddr{IP: net.ParseIP("ff30::8000:2")}, &net.IPAddr{IP: net.IPv6loopback}},        // see RFC 5771
-}
-
-func TestPacketConnMulticastSocketOptions(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagMulticast|net.FlagLoopback)
-	if ifi == nil {
-		t.Skipf("not available on %s", runtime.GOOS)
-	}
-
-	m, ok := nettest.SupportsRawIPSocket()
-	for _, tt := range packetConnMulticastSocketOptionTests {
-		if tt.net == "ip6" && !ok {
-			t.Log(m)
-			continue
-		}
-		c, err := net.ListenPacket(tt.net+tt.proto, tt.addr)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		defer p.Close()
-
-		if tt.src == nil {
-			testMulticastSocketOptions(t, p, ifi, tt.grp)
-		} else {
-			testSourceSpecificMulticastSocketOptions(t, p, ifi, tt.grp, tt.src)
-		}
-	}
-}
-
-type testIPv6MulticastConn interface {
-	MulticastHopLimit() (int, error)
-	SetMulticastHopLimit(ttl int) error
-	MulticastLoopback() (bool, error)
-	SetMulticastLoopback(bool) error
-	JoinGroup(*net.Interface, net.Addr) error
-	LeaveGroup(*net.Interface, net.Addr) error
-	JoinSourceSpecificGroup(*net.Interface, net.Addr, net.Addr) error
-	LeaveSourceSpecificGroup(*net.Interface, net.Addr, net.Addr) error
-	ExcludeSourceSpecificGroup(*net.Interface, net.Addr, net.Addr) error
-	IncludeSourceSpecificGroup(*net.Interface, net.Addr, net.Addr) error
-}
-
-func testMulticastSocketOptions(t *testing.T, c testIPv6MulticastConn, ifi *net.Interface, grp net.Addr) {
-	const hoplim = 255
-	if err := c.SetMulticastHopLimit(hoplim); err != nil {
-		t.Error(err)
-		return
-	}
-	if v, err := c.MulticastHopLimit(); err != nil {
-		t.Error(err)
-		return
-	} else if v != hoplim {
-		t.Errorf("got %v; want %v", v, hoplim)
-		return
-	}
-
-	for _, toggle := range []bool{true, false} {
-		if err := c.SetMulticastLoopback(toggle); err != nil {
-			t.Error(err)
-			return
-		}
-		if v, err := c.MulticastLoopback(); err != nil {
-			t.Error(err)
-			return
-		} else if v != toggle {
-			t.Errorf("got %v; want %v", v, toggle)
-			return
-		}
-	}
-
-	if err := c.JoinGroup(ifi, grp); err != nil {
-		t.Error(err)
-		return
-	}
-	if err := c.LeaveGroup(ifi, grp); err != nil {
-		t.Error(err)
-		return
-	}
-}
-
-func testSourceSpecificMulticastSocketOptions(t *testing.T, c testIPv6MulticastConn, ifi *net.Interface, grp, src net.Addr) {
-	// MCAST_JOIN_GROUP -> MCAST_BLOCK_SOURCE -> MCAST_UNBLOCK_SOURCE -> MCAST_LEAVE_GROUP
-	if err := c.JoinGroup(ifi, grp); err != nil {
-		t.Error(err)
-		return
-	}
-	if err := c.ExcludeSourceSpecificGroup(ifi, grp, src); err != nil {
-		switch runtime.GOOS {
-		case "freebsd", "linux":
-		default: // platforms that don't support MLDv2 fail here
-			t.Logf("not supported on %s", runtime.GOOS)
-			return
-		}
-		t.Error(err)
-		return
-	}
-	if err := c.IncludeSourceSpecificGroup(ifi, grp, src); err != nil {
-		t.Error(err)
-		return
-	}
-	if err := c.LeaveGroup(ifi, grp); err != nil {
-		t.Error(err)
-		return
-	}
-
-	// MCAST_JOIN_SOURCE_GROUP -> MCAST_LEAVE_SOURCE_GROUP
-	if err := c.JoinSourceSpecificGroup(ifi, grp, src); err != nil {
-		t.Error(err)
-		return
-	}
-	if err := c.LeaveSourceSpecificGroup(ifi, grp, src); err != nil {
-		t.Error(err)
-		return
-	}
-
-	// MCAST_JOIN_SOURCE_GROUP -> MCAST_LEAVE_GROUP
-	if err := c.JoinSourceSpecificGroup(ifi, grp, src); err != nil {
-		t.Error(err)
-		return
-	}
-	if err := c.LeaveGroup(ifi, grp); err != nil {
-		t.Error(err)
-		return
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/readwrite_go1_8_test.go b/vendor/golang.org/x/net/ipv6/readwrite_go1_8_test.go
deleted file mode 100644
index c11d92ae9..000000000
--- a/vendor/golang.org/x/net/ipv6/readwrite_go1_8_test.go
+++ /dev/null
@@ -1,242 +0,0 @@
-// 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 !go1.9
-
-package ipv6_test
-
-import (
-	"bytes"
-	"fmt"
-	"net"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-
-	"golang.org/x/net/internal/iana"
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-func BenchmarkPacketConnReadWriteUnicast(b *testing.B) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		b.Skipf("not supported on %s", runtime.GOOS)
-	}
-
-	payload := []byte("HELLO-R-U-THERE")
-	iph := []byte{
-		0x69, 0x8b, 0xee, 0xf1, 0xca, 0xfe, 0xff, 0x01,
-		0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-		0x20, 0x01, 0x0d, 0xb8, 0x00, 0x02, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	}
-	greh := []byte{0x00, 0x00, 0x86, 0xdd, 0x00, 0x00, 0x00, 0x00}
-	datagram := append(greh, append(iph, payload...)...)
-	bb := make([]byte, 128)
-	cm := ipv6.ControlMessage{
-		TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-		HopLimit:     1,
-		Src:          net.IPv6loopback,
-	}
-	if ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback); ifi != nil {
-		cm.IfIndex = ifi.Index
-	}
-
-	b.Run("UDP", func(b *testing.B) {
-		c, err := nettest.NewLocalPacketListener("udp6")
-		if err != nil {
-			b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		dst := c.LocalAddr()
-		cf := ipv6.FlagHopLimit | ipv6.FlagInterface
-		if err := p.SetControlMessage(cf, true); err != nil {
-			b.Fatal(err)
-		}
-		b.Run("Net", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := c.WriteTo(payload, dst); err != nil {
-					b.Fatal(err)
-				}
-				if _, _, err := c.ReadFrom(bb); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-		b.Run("ToFrom", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := p.WriteTo(payload, &cm, dst); err != nil {
-					b.Fatal(err)
-				}
-				if _, _, _, err := p.ReadFrom(bb); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-	})
-	b.Run("IP", func(b *testing.B) {
-		switch runtime.GOOS {
-		case "netbsd":
-			b.Skip("need to configure gre on netbsd")
-		case "openbsd":
-			b.Skip("net.inet.gre.allow=0 by default on openbsd")
-		}
-
-		c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolGRE), "::1")
-		if err != nil {
-			b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		dst := c.LocalAddr()
-		cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-		if err := p.SetControlMessage(cf, true); err != nil {
-			b.Fatal(err)
-		}
-		b.Run("Net", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := c.WriteTo(datagram, dst); err != nil {
-					b.Fatal(err)
-				}
-				if _, _, err := c.ReadFrom(bb); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-		b.Run("ToFrom", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := p.WriteTo(datagram, &cm, dst); err != nil {
-					b.Fatal(err)
-				}
-				if _, _, _, err := p.ReadFrom(bb); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-	})
-}
-
-func TestPacketConnConcurrentReadWriteUnicast(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-
-	payload := []byte("HELLO-R-U-THERE")
-	iph := []byte{
-		0x69, 0x8b, 0xee, 0xf1, 0xca, 0xfe, 0xff, 0x01,
-		0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-		0x20, 0x01, 0x0d, 0xb8, 0x00, 0x02, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	}
-	greh := []byte{0x00, 0x00, 0x86, 0xdd, 0x00, 0x00, 0x00, 0x00}
-	datagram := append(greh, append(iph, payload...)...)
-
-	t.Run("UDP", func(t *testing.T) {
-		c, err := nettest.NewLocalPacketListener("udp6")
-		if err != nil {
-			t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		t.Run("ToFrom", func(t *testing.T) {
-			testPacketConnConcurrentReadWriteUnicast(t, p, payload, c.LocalAddr())
-		})
-	})
-	t.Run("IP", func(t *testing.T) {
-		switch runtime.GOOS {
-		case "netbsd":
-			t.Skip("need to configure gre on netbsd")
-		case "openbsd":
-			t.Skip("net.inet.gre.allow=0 by default on openbsd")
-		}
-
-		c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolGRE), "::1")
-		if err != nil {
-			t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		t.Run("ToFrom", func(t *testing.T) {
-			testPacketConnConcurrentReadWriteUnicast(t, p, datagram, c.LocalAddr())
-		})
-	})
-}
-
-func testPacketConnConcurrentReadWriteUnicast(t *testing.T, p *ipv6.PacketConn, data []byte, dst net.Addr) {
-	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-
-	if err := p.SetControlMessage(cf, true); err != nil { // probe before test
-		if nettest.ProtocolNotSupported(err) {
-			t.Skipf("not supported on %s", runtime.GOOS)
-		}
-		t.Fatal(err)
-	}
-
-	var wg sync.WaitGroup
-	reader := func() {
-		defer wg.Done()
-		b := make([]byte, 128)
-		n, cm, _, err := p.ReadFrom(b)
-		if err != nil {
-			t.Error(err)
-			return
-		}
-		if !bytes.Equal(b[:n], data) {
-			t.Errorf("got %#v; want %#v", b[:n], data)
-			return
-		}
-		s := cm.String()
-		if strings.Contains(s, ",") {
-			t.Errorf("should be space-separated values: %s", s)
-			return
-		}
-	}
-	writer := func(toggle bool) {
-		defer wg.Done()
-		cm := ipv6.ControlMessage{
-			TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-			HopLimit:     1,
-			Src:          net.IPv6loopback,
-		}
-		if ifi != nil {
-			cm.IfIndex = ifi.Index
-		}
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Error(err)
-			return
-		}
-		n, err := p.WriteTo(data, &cm, dst)
-		if err != nil {
-			t.Error(err)
-			return
-		}
-		if n != len(data) {
-			t.Errorf("got %d; want %d", n, len(data))
-			return
-		}
-	}
-
-	const N = 10
-	wg.Add(N)
-	for i := 0; i < N; i++ {
-		go reader()
-	}
-	wg.Add(2 * N)
-	for i := 0; i < 2*N; i++ {
-		go writer(i%2 != 0)
-
-	}
-	wg.Add(N)
-	for i := 0; i < N; i++ {
-		go reader()
-	}
-	wg.Wait()
-}
diff --git a/vendor/golang.org/x/net/ipv6/readwrite_go1_9_test.go b/vendor/golang.org/x/net/ipv6/readwrite_go1_9_test.go
deleted file mode 100644
index e2fd73370..000000000
--- a/vendor/golang.org/x/net/ipv6/readwrite_go1_9_test.go
+++ /dev/null
@@ -1,373 +0,0 @@
-// Copyright 2017 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 go1.9
-
-package ipv6_test
-
-import (
-	"bytes"
-	"fmt"
-	"net"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-
-	"golang.org/x/net/internal/iana"
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-func BenchmarkPacketConnReadWriteUnicast(b *testing.B) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		b.Skipf("not supported on %s", runtime.GOOS)
-	}
-
-	payload := []byte("HELLO-R-U-THERE")
-	iph := []byte{
-		0x69, 0x8b, 0xee, 0xf1, 0xca, 0xfe, 0xff, 0x01,
-		0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-		0x20, 0x01, 0x0d, 0xb8, 0x00, 0x02, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	}
-	greh := []byte{0x00, 0x00, 0x86, 0xdd, 0x00, 0x00, 0x00, 0x00}
-	datagram := append(greh, append(iph, payload...)...)
-	bb := make([]byte, 128)
-	cm := ipv6.ControlMessage{
-		TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-		HopLimit:     1,
-		Src:          net.IPv6loopback,
-	}
-	if ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback); ifi != nil {
-		cm.IfIndex = ifi.Index
-	}
-
-	b.Run("UDP", func(b *testing.B) {
-		c, err := nettest.NewLocalPacketListener("udp6")
-		if err != nil {
-			b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		dst := c.LocalAddr()
-		cf := ipv6.FlagHopLimit | ipv6.FlagInterface
-		if err := p.SetControlMessage(cf, true); err != nil {
-			b.Fatal(err)
-		}
-		wms := []ipv6.Message{
-			{
-				Buffers: [][]byte{payload},
-				Addr:    dst,
-				OOB:     cm.Marshal(),
-			},
-		}
-		rms := []ipv6.Message{
-			{
-				Buffers: [][]byte{bb},
-				OOB:     ipv6.NewControlMessage(cf),
-			},
-		}
-		b.Run("Net", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := c.WriteTo(payload, dst); err != nil {
-					b.Fatal(err)
-				}
-				if _, _, err := c.ReadFrom(bb); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-		b.Run("ToFrom", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := p.WriteTo(payload, &cm, dst); err != nil {
-					b.Fatal(err)
-				}
-				if _, _, _, err := p.ReadFrom(bb); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-		b.Run("Batch", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := p.WriteBatch(wms, 0); err != nil {
-					b.Fatal(err)
-				}
-				if _, err := p.ReadBatch(rms, 0); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-	})
-	b.Run("IP", func(b *testing.B) {
-		switch runtime.GOOS {
-		case "netbsd":
-			b.Skip("need to configure gre on netbsd")
-		case "openbsd":
-			b.Skip("net.inet.gre.allow=0 by default on openbsd")
-		}
-
-		c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolGRE), "::1")
-		if err != nil {
-			b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		dst := c.LocalAddr()
-		cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-		if err := p.SetControlMessage(cf, true); err != nil {
-			b.Fatal(err)
-		}
-		wms := []ipv6.Message{
-			{
-				Buffers: [][]byte{datagram},
-				Addr:    dst,
-				OOB:     cm.Marshal(),
-			},
-		}
-		rms := []ipv6.Message{
-			{
-				Buffers: [][]byte{bb},
-				OOB:     ipv6.NewControlMessage(cf),
-			},
-		}
-		b.Run("Net", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := c.WriteTo(datagram, dst); err != nil {
-					b.Fatal(err)
-				}
-				if _, _, err := c.ReadFrom(bb); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-		b.Run("ToFrom", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := p.WriteTo(datagram, &cm, dst); err != nil {
-					b.Fatal(err)
-				}
-				if _, _, _, err := p.ReadFrom(bb); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-		b.Run("Batch", func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				if _, err := p.WriteBatch(wms, 0); err != nil {
-					b.Fatal(err)
-				}
-				if _, err := p.ReadBatch(rms, 0); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-	})
-}
-
-func TestPacketConnConcurrentReadWriteUnicast(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-
-	payload := []byte("HELLO-R-U-THERE")
-	iph := []byte{
-		0x69, 0x8b, 0xee, 0xf1, 0xca, 0xfe, 0xff, 0x01,
-		0x20, 0x01, 0x0d, 0xb8, 0x00, 0x01, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-		0x20, 0x01, 0x0d, 0xb8, 0x00, 0x02, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-	}
-	greh := []byte{0x00, 0x00, 0x86, 0xdd, 0x00, 0x00, 0x00, 0x00}
-	datagram := append(greh, append(iph, payload...)...)
-
-	t.Run("UDP", func(t *testing.T) {
-		c, err := nettest.NewLocalPacketListener("udp6")
-		if err != nil {
-			t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		t.Run("ToFrom", func(t *testing.T) {
-			testPacketConnConcurrentReadWriteUnicast(t, p, payload, c.LocalAddr(), false)
-		})
-		t.Run("Batch", func(t *testing.T) {
-			testPacketConnConcurrentReadWriteUnicast(t, p, payload, c.LocalAddr(), true)
-		})
-	})
-	t.Run("IP", func(t *testing.T) {
-		switch runtime.GOOS {
-		case "netbsd":
-			t.Skip("need to configure gre on netbsd")
-		case "openbsd":
-			t.Skip("net.inet.gre.allow=0 by default on openbsd")
-		}
-
-		c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolGRE), "::1")
-		if err != nil {
-			t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		t.Run("ToFrom", func(t *testing.T) {
-			testPacketConnConcurrentReadWriteUnicast(t, p, datagram, c.LocalAddr(), false)
-		})
-		t.Run("Batch", func(t *testing.T) {
-			testPacketConnConcurrentReadWriteUnicast(t, p, datagram, c.LocalAddr(), true)
-		})
-	})
-}
-
-func testPacketConnConcurrentReadWriteUnicast(t *testing.T, p *ipv6.PacketConn, data []byte, dst net.Addr, batch bool) {
-	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-
-	if err := p.SetControlMessage(cf, true); err != nil { // probe before test
-		if nettest.ProtocolNotSupported(err) {
-			t.Skipf("not supported on %s", runtime.GOOS)
-		}
-		t.Fatal(err)
-	}
-
-	var wg sync.WaitGroup
-	reader := func() {
-		defer wg.Done()
-		b := make([]byte, 128)
-		n, cm, _, err := p.ReadFrom(b)
-		if err != nil {
-			t.Error(err)
-			return
-		}
-		if !bytes.Equal(b[:n], data) {
-			t.Errorf("got %#v; want %#v", b[:n], data)
-			return
-		}
-		s := cm.String()
-		if strings.Contains(s, ",") {
-			t.Errorf("should be space-separated values: %s", s)
-			return
-		}
-	}
-	batchReader := func() {
-		defer wg.Done()
-		ms := []ipv6.Message{
-			{
-				Buffers: [][]byte{make([]byte, 128)},
-				OOB:     ipv6.NewControlMessage(cf),
-			},
-		}
-		n, err := p.ReadBatch(ms, 0)
-		if err != nil {
-			t.Error(err)
-			return
-		}
-		if n != len(ms) {
-			t.Errorf("got %d; want %d", n, len(ms))
-			return
-		}
-		var cm ipv6.ControlMessage
-		if err := cm.Parse(ms[0].OOB[:ms[0].NN]); err != nil {
-			t.Error(err)
-			return
-		}
-		b := ms[0].Buffers[0][:ms[0].N]
-		if !bytes.Equal(b, data) {
-			t.Errorf("got %#v; want %#v", b, data)
-			return
-		}
-		s := cm.String()
-		if strings.Contains(s, ",") {
-			t.Errorf("should be space-separated values: %s", s)
-			return
-		}
-	}
-	writer := func(toggle bool) {
-		defer wg.Done()
-		cm := ipv6.ControlMessage{
-			TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-			HopLimit:     1,
-			Src:          net.IPv6loopback,
-		}
-		if ifi != nil {
-			cm.IfIndex = ifi.Index
-		}
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Error(err)
-			return
-		}
-		n, err := p.WriteTo(data, &cm, dst)
-		if err != nil {
-			t.Error(err)
-			return
-		}
-		if n != len(data) {
-			t.Errorf("got %d; want %d", n, len(data))
-			return
-		}
-	}
-	batchWriter := func(toggle bool) {
-		defer wg.Done()
-		cm := ipv6.ControlMessage{
-			TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-			HopLimit:     1,
-			Src:          net.IPv6loopback,
-		}
-		if ifi != nil {
-			cm.IfIndex = ifi.Index
-		}
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Error(err)
-			return
-		}
-		ms := []ipv6.Message{
-			{
-				Buffers: [][]byte{data},
-				OOB:     cm.Marshal(),
-				Addr:    dst,
-			},
-		}
-		n, err := p.WriteBatch(ms, 0)
-		if err != nil {
-			t.Error(err)
-			return
-		}
-		if n != len(ms) {
-			t.Errorf("got %d; want %d", n, len(ms))
-			return
-		}
-		if ms[0].N != len(data) {
-			t.Errorf("got %d; want %d", ms[0].N, len(data))
-			return
-		}
-	}
-
-	const N = 10
-	wg.Add(N)
-	for i := 0; i < N; i++ {
-		if batch {
-			go batchReader()
-		} else {
-			go reader()
-		}
-	}
-	wg.Add(2 * N)
-	for i := 0; i < 2*N; i++ {
-		if batch {
-			go batchWriter(i%2 != 0)
-		} else {
-			go writer(i%2 != 0)
-		}
-	}
-	wg.Add(N)
-	for i := 0; i < N; i++ {
-		if batch {
-			go batchReader()
-		} else {
-			go reader()
-		}
-	}
-	wg.Wait()
-}
diff --git a/vendor/golang.org/x/net/ipv6/readwrite_test.go b/vendor/golang.org/x/net/ipv6/readwrite_test.go
deleted file mode 100644
index 206b915ce..000000000
--- a/vendor/golang.org/x/net/ipv6/readwrite_test.go
+++ /dev/null
@@ -1,148 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"bytes"
-	"net"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-
-	"golang.org/x/net/internal/iana"
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-func BenchmarkReadWriteUnicast(b *testing.B) {
-	c, err := nettest.NewLocalPacketListener("udp6")
-	if err != nil {
-		b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err)
-	}
-	defer c.Close()
-
-	dst := c.LocalAddr()
-	wb, rb := []byte("HELLO-R-U-THERE"), make([]byte, 128)
-
-	b.Run("NetUDP", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			if _, err := c.WriteTo(wb, dst); err != nil {
-				b.Fatal(err)
-			}
-			if _, _, err := c.ReadFrom(rb); err != nil {
-				b.Fatal(err)
-			}
-		}
-	})
-	b.Run("IPv6UDP", func(b *testing.B) {
-		p := ipv6.NewPacketConn(c)
-		cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-		if err := p.SetControlMessage(cf, true); err != nil {
-			b.Fatal(err)
-		}
-		cm := ipv6.ControlMessage{
-			TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-			HopLimit:     1,
-		}
-		ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
-		if ifi != nil {
-			cm.IfIndex = ifi.Index
-		}
-
-		for i := 0; i < b.N; i++ {
-			if _, err := p.WriteTo(wb, &cm, dst); err != nil {
-				b.Fatal(err)
-			}
-			if _, _, _, err := p.ReadFrom(rb); err != nil {
-				b.Fatal(err)
-			}
-		}
-	})
-}
-
-func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	c, err := nettest.NewLocalPacketListener("udp6")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-	defer p.Close()
-
-	dst := c.LocalAddr()
-	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-	wb := []byte("HELLO-R-U-THERE")
-
-	if err := p.SetControlMessage(cf, true); err != nil { // probe before test
-		if nettest.ProtocolNotSupported(err) {
-			t.Skipf("not supported on %s", runtime.GOOS)
-		}
-		t.Fatal(err)
-	}
-
-	var wg sync.WaitGroup
-	reader := func() {
-		defer wg.Done()
-		rb := make([]byte, 128)
-		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Error(err)
-			return
-		} else if !bytes.Equal(rb[:n], wb) {
-			t.Errorf("got %v; want %v", rb[:n], wb)
-			return
-		} else {
-			s := cm.String()
-			if strings.Contains(s, ",") {
-				t.Errorf("should be space-separated values: %s", s)
-			}
-		}
-	}
-	writer := func(toggle bool) {
-		defer wg.Done()
-		cm := ipv6.ControlMessage{
-			TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-			Src:          net.IPv6loopback,
-		}
-		if ifi != nil {
-			cm.IfIndex = ifi.Index
-		}
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Error(err)
-			return
-		}
-		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Error(err)
-			return
-		} else if n != len(wb) {
-			t.Errorf("got %d; want %d", n, len(wb))
-			return
-		}
-	}
-
-	const N = 10
-	wg.Add(N)
-	for i := 0; i < N; i++ {
-		go reader()
-	}
-	wg.Add(2 * N)
-	for i := 0; i < 2*N; i++ {
-		go writer(i%2 != 0)
-	}
-	wg.Add(N)
-	for i := 0; i < N; i++ {
-		go reader()
-	}
-	wg.Wait()
-}
diff --git a/vendor/golang.org/x/net/ipv6/sockopt_test.go b/vendor/golang.org/x/net/ipv6/sockopt_test.go
deleted file mode 100644
index 774338dbf..000000000
--- a/vendor/golang.org/x/net/ipv6/sockopt_test.go
+++ /dev/null
@@ -1,133 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"fmt"
-	"net"
-	"runtime"
-	"testing"
-
-	"golang.org/x/net/internal/iana"
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-var supportsIPv6 bool = nettest.SupportsIPv6()
-
-func TestConnInitiatorPathMTU(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	ln, err := net.Listen("tcp6", "[::1]:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer ln.Close()
-
-	done := make(chan bool)
-	go acceptor(t, ln, done)
-
-	c, err := net.Dial("tcp6", ln.Addr().String())
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
-		switch runtime.GOOS {
-		case "darwin": // older darwin kernels don't support IPV6_PATHMTU option
-			t.Logf("not supported on %s", runtime.GOOS)
-		default:
-			t.Fatal(err)
-		}
-	} else {
-		t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
-	}
-
-	<-done
-}
-
-func TestConnResponderPathMTU(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	ln, err := net.Listen("tcp6", "[::1]:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer ln.Close()
-
-	done := make(chan bool)
-	go connector(t, "tcp6", ln.Addr().String(), done)
-
-	c, err := ln.Accept()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
-		switch runtime.GOOS {
-		case "darwin": // older darwin kernels don't support IPV6_PATHMTU option
-			t.Logf("not supported on %s", runtime.GOOS)
-		default:
-			t.Fatal(err)
-		}
-	} else {
-		t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
-	}
-
-	<-done
-}
-
-func TestPacketConnChecksum(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if m, ok := nettest.SupportsRawIPSocket(); !ok {
-		t.Skip(m)
-	}
-
-	c, err := net.ListenPacket(fmt.Sprintf("ip6:%d", iana.ProtocolOSPFIGP), "::") // OSPF for IPv6
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	p := ipv6.NewPacketConn(c)
-	offset := 12 // see RFC 5340
-
-	for _, toggle := range []bool{false, true} {
-		if err := p.SetChecksum(toggle, offset); err != nil {
-			if toggle {
-				t.Fatalf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err)
-			} else {
-				// Some platforms never allow to disable the kernel
-				// checksum processing.
-				t.Logf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err)
-			}
-		}
-		if on, offset, err := p.Checksum(); err != nil {
-			t.Fatal(err)
-		} else {
-			t.Logf("kernel checksum processing enabled=%v, offset=%v", on, offset)
-		}
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/unicast_test.go b/vendor/golang.org/x/net/ipv6/unicast_test.go
deleted file mode 100644
index a0b7d9550..000000000
--- a/vendor/golang.org/x/net/ipv6/unicast_test.go
+++ /dev/null
@@ -1,184 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"bytes"
-	"net"
-	"os"
-	"runtime"
-	"testing"
-	"time"
-
-	"golang.org/x/net/icmp"
-	"golang.org/x/net/internal/iana"
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	c, err := nettest.NewLocalPacketListener("udp6")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-	defer p.Close()
-
-	dst := c.LocalAddr()
-	cm := ipv6.ControlMessage{
-		TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-		Src:          net.IPv6loopback,
-	}
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
-	if ifi != nil {
-		cm.IfIndex = ifi.Index
-	}
-	wb := []byte("HELLO-R-U-THERE")
-
-	for i, toggle := range []bool{true, false, true} {
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			if nettest.ProtocolNotSupported(err) {
-				t.Logf("not supported on %s", runtime.GOOS)
-				continue
-			}
-			t.Fatal(err)
-		}
-		cm.HopLimit = i + 1
-		if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatal(err)
-		}
-		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Fatal(err)
-		} else if n != len(wb) {
-			t.Fatalf("got %v; want %v", n, len(wb))
-		}
-		rb := make([]byte, 128)
-		if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatal(err)
-		}
-		if n, _, _, err := p.ReadFrom(rb); err != nil {
-			t.Fatal(err)
-		} else if !bytes.Equal(rb[:n], wb) {
-			t.Fatalf("got %v; want %v", rb[:n], wb)
-		}
-	}
-}
-
-func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if m, ok := nettest.SupportsRawIPSocket(); !ok {
-		t.Skip(m)
-	}
-
-	c, err := net.ListenPacket("ip6:ipv6-icmp", "::1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-	defer p.Close()
-
-	dst, err := net.ResolveIPAddr("ip6", "::1")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	pshicmp := icmp.IPv6PseudoHeader(c.LocalAddr().(*net.IPAddr).IP, dst.IP)
-	cm := ipv6.ControlMessage{
-		TrafficClass: iana.DiffServAF11 | iana.CongestionExperienced,
-		Src:          net.IPv6loopback,
-	}
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-	ifi := nettest.RoutedInterface("ip6", net.FlagUp|net.FlagLoopback)
-	if ifi != nil {
-		cm.IfIndex = ifi.Index
-	}
-
-	var f ipv6.ICMPFilter
-	f.SetAll(true)
-	f.Accept(ipv6.ICMPTypeEchoReply)
-	if err := p.SetICMPFilter(&f); err != nil {
-		t.Fatal(err)
-	}
-
-	var psh []byte
-	for i, toggle := range []bool{true, false, true} {
-		if toggle {
-			psh = nil
-			if err := p.SetChecksum(true, 2); err != nil {
-				// Solaris never allows to modify
-				// ICMP properties.
-				if runtime.GOOS != "solaris" {
-					t.Fatal(err)
-				}
-			}
-		} else {
-			psh = pshicmp
-			// Some platforms never allow to disable the
-			// kernel checksum processing.
-			p.SetChecksum(false, -1)
-		}
-		wb, err := (&icmp.Message{
-			Type: ipv6.ICMPTypeEchoRequest, Code: 0,
-			Body: &icmp.Echo{
-				ID: os.Getpid() & 0xffff, Seq: i + 1,
-				Data: []byte("HELLO-R-U-THERE"),
-			},
-		}).Marshal(psh)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			if nettest.ProtocolNotSupported(err) {
-				t.Logf("not supported on %s", runtime.GOOS)
-				continue
-			}
-			t.Fatal(err)
-		}
-		cm.HopLimit = i + 1
-		if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatal(err)
-		}
-		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Fatal(err)
-		} else if n != len(wb) {
-			t.Fatalf("got %v; want %v", n, len(wb))
-		}
-		rb := make([]byte, 128)
-		if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatal(err)
-		}
-		if n, _, _, err := p.ReadFrom(rb); err != nil {
-			switch runtime.GOOS {
-			case "darwin": // older darwin kernels have some limitation on receiving icmp packet through raw socket
-				t.Logf("not supported on %s", runtime.GOOS)
-				continue
-			}
-			t.Fatal(err)
-		} else {
-			if m, err := icmp.ParseMessage(iana.ProtocolIPv6ICMP, rb[:n]); err != nil {
-				t.Fatal(err)
-			} else if m.Type != ipv6.ICMPTypeEchoReply || m.Code != 0 {
-				t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0)
-			}
-		}
-	}
-}
diff --git a/vendor/golang.org/x/net/ipv6/unicastsockopt_test.go b/vendor/golang.org/x/net/ipv6/unicastsockopt_test.go
deleted file mode 100644
index e175dccf5..000000000
--- a/vendor/golang.org/x/net/ipv6/unicastsockopt_test.go
+++ /dev/null
@@ -1,120 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"net"
-	"runtime"
-	"testing"
-
-	"golang.org/x/net/internal/iana"
-	"golang.org/x/net/internal/nettest"
-	"golang.org/x/net/ipv6"
-)
-
-func TestConnUnicastSocketOptions(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	ln, err := net.Listen("tcp6", "[::1]:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer ln.Close()
-
-	errc := make(chan error, 1)
-	go func() {
-		c, err := ln.Accept()
-		if err != nil {
-			errc <- err
-			return
-		}
-		errc <- c.Close()
-	}()
-
-	c, err := net.Dial("tcp6", ln.Addr().String())
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	testUnicastSocketOptions(t, ipv6.NewConn(c))
-
-	if err := <-errc; err != nil {
-		t.Errorf("server: %v", err)
-	}
-}
-
-var packetConnUnicastSocketOptionTests = []struct {
-	net, proto, addr string
-}{
-	{"udp6", "", "[::1]:0"},
-	{"ip6", ":ipv6-icmp", "::1"},
-}
-
-func TestPacketConnUnicastSocketOptions(t *testing.T) {
-	switch runtime.GOOS {
-	case "nacl", "plan9", "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	m, ok := nettest.SupportsRawIPSocket()
-	for _, tt := range packetConnUnicastSocketOptionTests {
-		if tt.net == "ip6" && !ok {
-			t.Log(m)
-			continue
-		}
-		c, err := net.ListenPacket(tt.net+tt.proto, tt.addr)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer c.Close()
-
-		testUnicastSocketOptions(t, ipv6.NewPacketConn(c))
-	}
-}
-
-type testIPv6UnicastConn interface {
-	TrafficClass() (int, error)
-	SetTrafficClass(int) error
-	HopLimit() (int, error)
-	SetHopLimit(int) error
-}
-
-func testUnicastSocketOptions(t *testing.T, c testIPv6UnicastConn) {
-	tclass := iana.DiffServCS0 | iana.NotECNTransport
-	if err := c.SetTrafficClass(tclass); err != nil {
-		switch runtime.GOOS {
-		case "darwin": // older darwin kernels don't support IPV6_TCLASS option
-			t.Logf("not supported on %s", runtime.GOOS)
-			goto next
-		}
-		t.Fatal(err)
-	}
-	if v, err := c.TrafficClass(); err != nil {
-		t.Fatal(err)
-	} else if v != tclass {
-		t.Fatalf("got %v; want %v", v, tclass)
-	}
-
-next:
-	hoplim := 255
-	if err := c.SetHopLimit(hoplim); err != nil {
-		t.Fatal(err)
-	}
-	if v, err := c.HopLimit(); err != nil {
-		t.Fatal(err)
-	} else if v != hoplim {
-		t.Fatalf("got %v; want %v", v, hoplim)
-	}
-}