Update dep and deps

Gopkg.lock

@@ -2,142 +2,185 @@
 
 
 [[projects]]
+  digest = "1:b16fbfbcc20645cb419f78325bb2e85ec729b338e996a228124d68931a6f2a37"
   name = "github.com/BurntSushi/toml"
   packages = ["."]
+  pruneopts = "UT"
   revision = "b26d9c308763d68093482582cea63d69be07a0f0"
   version = "v0.3.0"
 
 [[projects]]
+  digest = "1:e626376fab8608a972d47e91b3c1bbbddaecaf1d42b82be6dcc52d10a7557893"
   name = "github.com/VividCortex/ewma"
   packages = ["."]
+  pruneopts = "UT"
   revision = "b24eb346a94c3ba12c1da1e564dbac1b498a77ce"
   version = "v1.1.1"
 
 [[projects]]
   branch = "master"
+  digest = "1:6d6d9309d10d5dffaaf3a56c4b2570dec62152f978ac3566b13bdfafd63f32fb"
   name = "github.com/aead/chacha20"
   packages = ["chacha"]
-  revision = "e2538746bfea853aaa589feb8ec46bd46ee78f86"
+  pruneopts = "UT"
+  revision = "8b13a72661dae6e9e5dea04f344f0dc95ea29547"
 
 [[projects]]
   branch = "master"
+  digest = "1:82df2686fe2e0cc2894fbec00098fe2efeacbda08af8087a86d9eeea58699d49"
   name = "github.com/aead/poly1305"
   packages = ["."]
-  revision = "969857f48f7ae439b6d2449ed1dcd9aaabc49c67"
+  pruneopts = "UT"
+  revision = "3fee0db0b63511234f7230da50b72414f6258f10"
 
 [[projects]]
   branch = "master"
+  digest = "1:47ea4fbe2ab4aeb9808502c51e657041c2e49b36b83fc1c1a349135cdf16342f"
   name = "github.com/agl/ed25519"
   packages = [
     ".",
-    "edwards25519"
+    "edwards25519",
   ]
+  pruneopts = "UT"
   revision = "5312a61534124124185d41f09206b9fef1d88403"
 
 [[projects]]
+  digest = "1:9ddcd6732e302feb09865d8bfbebd55c295d95915ee0a530fd22b51851d852e4"
   name = "github.com/coreos/go-systemd"
   packages = [
     "activation",
-    "daemon"
+    "daemon",
   ]
+  pruneopts = "UT"
   revision = "39ca1b05acc7ad1220e09f133283b8859a8b71ab"
   version = "v17"
 
 [[projects]]
   branch = "master"
+  digest = "1:b78a58e00a1b951af4803ddfefbbcae14c7cacce3940ebad359c9d5582bf74a0"
   name = "github.com/dchest/safefile"
   packages = ["."]
+  pruneopts = "UT"
   revision = "855e8d98f1852d48dde521e0522408d1fe7e836a"
 
 [[projects]]
   branch = "master"
+  digest = "1:c183111eaf02a9e6bb39c213bdfb5472b16f1955dd4c9dab82db83f114c64a63"
   name = "github.com/facebookgo/atomicfile"
   packages = ["."]
+  pruneopts = "UT"
   revision = "2de1f203e7d5e386a6833233882782932729f27e"
 
 [[projects]]
   branch = "master"
+  digest = "1:b0b75ab0829ae3769f1f221486da0c40c8dc0680fb93d072b5df5a39d56c996c"
   name = "github.com/facebookgo/pidfile"
   packages = ["."]
+  pruneopts = "UT"
   revision = "f242e2999868dcd267a2b86e49ce1f9cf9e15b16"
 
 [[projects]]
   branch = "master"
+  digest = "1:2394f5a25132b3868eff44599cc28d44bdd0330806e34c495d754dd052df612b"
   name = "github.com/hashicorp/go-immutable-radix"
   packages = ["."]
+  pruneopts = "UT"
   revision = "7f3cd4390caab3250a57f30efdb2a65dd7649ecf"
 
 [[projects]]
   branch = "master"
+  digest = "1:4d9d876a856ada3b553062ac8e50331a9a539e12893c0c4a50d8ae2af4242685"
   name = "github.com/hashicorp/go-syslog"
   packages = ["."]
+  pruneopts = "UT"
   revision = "326bf4a7f709d263f964a6a96558676b103f3534"
 
 [[projects]]
   branch = "master"
+  digest = "1:cf296baa185baae04a9a7004efee8511d08e2f5f51d4cbe5375da89722d681db"
   name = "github.com/hashicorp/golang-lru"
   packages = [
     ".",
-    "simplelru"
+    "simplelru",
   ]
+  pruneopts = "UT"
   revision = "0fb14efe8c47ae851c0034ed7a448854d3d34cf3"
 
 [[projects]]
   branch = "master"
+  digest = "1:d7b8c19830aedc4fec0c843fd3ada94eeb47f7c4f43149f90e6e9623627480d7"
   name = "github.com/jedisct1/dlog"
   packages = ["."]
+  pruneopts = "UT"
   revision = "f81e5af176e59fc11674b2777fe465fc506c27fe"
 
 [[projects]]
   branch = "master"
+  digest = "1:6874350bad25169257ca2ccfe929d852d0f866b841908632d3b94b1a100178df"
   name = "github.com/jedisct1/go-clocksmith"
   packages = ["."]
+  pruneopts = "UT"
   revision = "c35da9bed550558a4797c74e34957071214342e7"
 
 [[projects]]
   branch = "master"
+  digest = "1:2c8c475bb86fe1b4cdb134c3b4649385daafcd37fa56b970957d98814db7b3ea"
   name = "github.com/jedisct1/go-dnsstamps"
   packages = ["."]
+  pruneopts = "UT"
   revision = "1e4999280f861b465e03e21e4f84d838f2f02b38"
 
 [[projects]]
   branch = "master"
+  digest = "1:d1d9e8794639828c2953fae54ef5f25eb0dbc42032f9a8700ebabbc42d70130d"
   name = "github.com/jedisct1/go-minisign"
   packages = ["."]
+  pruneopts = "UT"
   revision = "f4dbde220b4f73d450949b9ba27fa941faa05a78"
 
 [[projects]]
   branch = "master"
+  digest = "1:9eb6e583742b094222b15794641e0e5fac69078147b82f4a5c971bb0b8938671"
   name = "github.com/jedisct1/xsecretbox"
   packages = ["."]
+  pruneopts = "UT"
   revision = "7a679c0bcd9a5bbfe097fb7d48497bc06d17be76"
 
 [[projects]]
+  digest = "1:9d85ab479918f5d22a449601d35ff4e94115e31db534e22b8431e2c7b152bc4d"
   name = "github.com/k-sone/critbitgo"
   packages = ["."]
+  pruneopts = "UT"
   revision = "658116ef1e826b72c603cfe2091b12503f9bca43"
   version = "v1.2.0"
 
 [[projects]]
   branch = "master"
+  digest = "1:caf6db28595425c0e0f2301a00257d11712f65c1878e12cffc42f6b9a9cf3f23"
   name = "github.com/kardianos/osext"
   packages = ["."]
+  pruneopts = "UT"
   revision = "ae77be60afb1dcacde03767a8c37337fad28ac14"
 
 [[projects]]
   branch = "master"
+  digest = "1:2c4470d47613daac5ff660ff9b67a6f8dca489845bb867186e3fcda742a3e53f"
   name = "github.com/kardianos/service"
   packages = ["."]
+  pruneopts = "UT"
   revision = "615a14ed75099c9eaac6949e22ac2341bf9d3197"
 
 [[projects]]
+  digest = "1:463e4140189f8194f9121ca1c7fe3b8e9e9a2ab3d949b43c835c21034927dc62"
   name = "github.com/miekg/dns"
   packages = ["."]
+  pruneopts = "UT"
   revision = "5a2b9fab83ff0f8bfc99684bd5f43a37abe560f1"
   version = "v1.0.8"
 
 [[projects]]
   branch = "master"
+  digest = "1:fb92a63e4dcf1d88c58efdbc028d0b91bcaeddd8633758056beb376f13531147"
   name = "golang.org/x/crypto"
   packages = [
     "curve25519",
@@ -147,12 +190,14 @@
     "nacl/box",
     "nacl/secretbox",
     "poly1305",
-    "salsa20/salsa"
+    "salsa20/salsa",
   ]
-  revision = "a49355c7e3f8fe157a85be2f77e6e269a0f89602"
+  pruneopts = "UT"
+  revision = "de0752318171da717af4ce24d0a2e8626afaeb11"
 
 [[projects]]
   branch = "master"
+  digest = "1:b6a4877dbd8d954aebfe3c6e4b8f674f0564aaf7ac2bb99ea1d9e190410f46c4"
   name = "golang.org/x/net"
   packages = [
     "bpf",
@@ -165,12 +210,14 @@
     "internal/socks",
     "ipv4",
     "ipv6",
-    "proxy"
+    "proxy",
   ]
-  revision = "32a936f46389aa10549d60bd7833e54b01685d09"
+  pruneopts = "UT"
+  revision = "f9ce57c11b242f0f1599cf25c89d8cb02c45295a"
 
 [[projects]]
   branch = "master"
+  digest = "1:86c7b355731b7a7eb6cb38f1af9c7e025412c081ba76bffed9ba5381802d275a"
   name = "golang.org/x/sys"
   packages = [
     "cpu",
@@ -179,11 +226,13 @@
     "windows/registry",
     "windows/svc",
     "windows/svc/eventlog",
-    "windows/svc/mgr"
+    "windows/svc/mgr",
   ]
-  revision = "3c6ecd8f22c6f40fbeec94c000a069d7d87c7624"
+  pruneopts = "UT"
+  revision = "904bdc257025c7b3f43c19360ad3ab85783fad78"
 
 [[projects]]
+  digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
   name = "golang.org/x/text"
   packages = [
     "collate",
@@ -199,20 +248,50 @@
     "unicode/bidi",
     "unicode/cldr",
     "unicode/norm",
-    "unicode/rangetable"
+    "unicode/rangetable",
   ]
+  pruneopts = "UT"
   revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
   version = "v0.3.0"
 
 [[projects]]
+  digest = "1:c805e517269b0ba4c21ded5836019ed7d16953d4026cb7d00041d039c7906be9"
   name = "gopkg.in/natefinch/lumberjack.v2"
   packages = ["."]
+  pruneopts = "UT"
   revision = "a96e63847dc3c67d17befa69c303767e2f84e54f"
   version = "v2.1"
 
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "2e3662737bdfec3295cf1f397f5584d97fbfd99973ab0351fafe66049bfa79bb"
+  input-imports = [
+    "github.com/BurntSushi/toml",
+    "github.com/VividCortex/ewma",
+    "github.com/agl/ed25519",
+    "github.com/coreos/go-systemd/activation",
+    "github.com/coreos/go-systemd/daemon",
+    "github.com/dchest/safefile",
+    "github.com/facebookgo/pidfile",
+    "github.com/hashicorp/go-immutable-radix",
+    "github.com/hashicorp/golang-lru",
+    "github.com/jedisct1/dlog",
+    "github.com/jedisct1/go-clocksmith",
+    "github.com/jedisct1/go-dnsstamps",
+    "github.com/jedisct1/go-minisign",
+    "github.com/jedisct1/xsecretbox",
+    "github.com/k-sone/critbitgo",
+    "github.com/kardianos/service",
+    "github.com/miekg/dns",
+    "golang.org/x/crypto/curve25519",
+    "golang.org/x/crypto/ed25519",
+    "golang.org/x/crypto/nacl/box",
+    "golang.org/x/crypto/nacl/secretbox",
+    "golang.org/x/net/http2",
+    "golang.org/x/net/proxy",
+    "golang.org/x/sys/unix",
+    "golang.org/x/sys/windows/svc/mgr",
+    "gopkg.in/natefinch/lumberjack.v2",
+  ]
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -1,3 +1,7 @@
+[prune]
+  go-tests = true
+  unused-packages = true
+
 [[constraint]]
   name = "github.com/BurntSushi/toml"
   version = "0.3.0"

vendor/github.com/BurntSushi/toml/cmd/toml-test-decoder/COPYING

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

vendor/github.com/BurntSushi/toml/cmd/toml-test-encoder/COPYING

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

vendor/github.com/BurntSushi/toml/cmd/tomlv/COPYING

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

vendor/github.com/BurntSushi/toml/encode_test.go

@@ -1,615 +0,0 @@
-package toml
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"net"
-	"testing"
-	"time"
-)
-
-func TestEncodeRoundTrip(t *testing.T) {
-	type Config struct {
-		Age        int
-		Cats       []string
-		Pi         float64
-		Perfection []int
-		DOB        time.Time
-		Ipaddress  net.IP
-	}
-
-	var inputs = Config{
-		13,
-		[]string{"one", "two", "three"},
-		3.145,
-		[]int{11, 2, 3, 4},
-		time.Now(),
-		net.ParseIP("192.168.59.254"),
-	}
-
-	var firstBuffer bytes.Buffer
-	e := NewEncoder(&firstBuffer)
-	err := e.Encode(inputs)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var outputs Config
-	if _, err := Decode(firstBuffer.String(), &outputs); err != nil {
-		t.Logf("Could not decode:\n-----\n%s\n-----\n",
-			firstBuffer.String())
-		t.Fatal(err)
-	}
-
-	// could test each value individually, but I'm lazy
-	var secondBuffer bytes.Buffer
-	e2 := NewEncoder(&secondBuffer)
-	err = e2.Encode(outputs)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if firstBuffer.String() != secondBuffer.String() {
-		t.Error(
-			firstBuffer.String(),
-			"\n\n is not identical to\n\n",
-			secondBuffer.String())
-	}
-}
-
-// XXX(burntsushi)
-// I think these tests probably should be removed. They are good, but they
-// ought to be obsolete by toml-test.
-func TestEncode(t *testing.T) {
-	type Embedded struct {
-		Int int `toml:"_int"`
-	}
-	type NonStruct int
-
-	date := time.Date(2014, 5, 11, 20, 30, 40, 0, time.FixedZone("IST", 3600))
-	dateStr := "2014-05-11T19:30:40Z"
-
-	tests := map[string]struct {
-		input      interface{}
-		wantOutput string
-		wantError  error
-	}{
-		"bool field": {
-			input: struct {
-				BoolTrue  bool
-				BoolFalse bool
-			}{true, false},
-			wantOutput: "BoolTrue = true\nBoolFalse = false\n",
-		},
-		"int fields": {
-			input: struct {
-				Int   int
-				Int8  int8
-				Int16 int16
-				Int32 int32
-				Int64 int64
-			}{1, 2, 3, 4, 5},
-			wantOutput: "Int = 1\nInt8 = 2\nInt16 = 3\nInt32 = 4\nInt64 = 5\n",
-		},
-		"uint fields": {
-			input: struct {
-				Uint   uint
-				Uint8  uint8
-				Uint16 uint16
-				Uint32 uint32
-				Uint64 uint64
-			}{1, 2, 3, 4, 5},
-			wantOutput: "Uint = 1\nUint8 = 2\nUint16 = 3\nUint32 = 4" +
-				"\nUint64 = 5\n",
-		},
-		"float fields": {
-			input: struct {
-				Float32 float32
-				Float64 float64
-			}{1.5, 2.5},
-			wantOutput: "Float32 = 1.5\nFloat64 = 2.5\n",
-		},
-		"string field": {
-			input:      struct{ String string }{"foo"},
-			wantOutput: "String = \"foo\"\n",
-		},
-		"string field and unexported field": {
-			input: struct {
-				String     string
-				unexported int
-			}{"foo", 0},
-			wantOutput: "String = \"foo\"\n",
-		},
-		"datetime field in UTC": {
-			input:      struct{ Date time.Time }{date},
-			wantOutput: fmt.Sprintf("Date = %s\n", dateStr),
-		},
-		"datetime field as primitive": {
-			// Using a map here to fail if isStructOrMap() returns true for
-			// time.Time.
-			input: map[string]interface{}{
-				"Date": date,
-				"Int":  1,
-			},
-			wantOutput: fmt.Sprintf("Date = %s\nInt = 1\n", dateStr),
-		},
-		"array fields": {
-			input: struct {
-				IntArray0 [0]int
-				IntArray3 [3]int
-			}{[0]int{}, [3]int{1, 2, 3}},
-			wantOutput: "IntArray0 = []\nIntArray3 = [1, 2, 3]\n",
-		},
-		"slice fields": {
-			input: struct{ IntSliceNil, IntSlice0, IntSlice3 []int }{
-				nil, []int{}, []int{1, 2, 3},
-			},
-			wantOutput: "IntSlice0 = []\nIntSlice3 = [1, 2, 3]\n",
-		},
-		"datetime slices": {
-			input: struct{ DatetimeSlice []time.Time }{
-				[]time.Time{date, date},
-			},
-			wantOutput: fmt.Sprintf("DatetimeSlice = [%s, %s]\n",
-				dateStr, dateStr),
-		},
-		"nested arrays and slices": {
-			input: struct {
-				SliceOfArrays         [][2]int
-				ArrayOfSlices         [2][]int
-				SliceOfArraysOfSlices [][2][]int
-				ArrayOfSlicesOfArrays [2][][2]int
-				SliceOfMixedArrays    [][2]interface{}
-				ArrayOfMixedSlices    [2][]interface{}
-			}{
-				[][2]int{{1, 2}, {3, 4}},
-				[2][]int{{1, 2}, {3, 4}},
-				[][2][]int{
-					{
-						{1, 2}, {3, 4},
-					},
-					{
-						{5, 6}, {7, 8},
-					},
-				},
-				[2][][2]int{
-					{
-						{1, 2}, {3, 4},
-					},
-					{
-						{5, 6}, {7, 8},
-					},
-				},
-				[][2]interface{}{
-					{1, 2}, {"a", "b"},
-				},
-				[2][]interface{}{
-					{1, 2}, {"a", "b"},
-				},
-			},
-			wantOutput: `SliceOfArrays = [[1, 2], [3, 4]]
-ArrayOfSlices = [[1, 2], [3, 4]]
-SliceOfArraysOfSlices = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
-ArrayOfSlicesOfArrays = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
-SliceOfMixedArrays = [[1, 2], ["a", "b"]]
-ArrayOfMixedSlices = [[1, 2], ["a", "b"]]
-`,
-		},
-		"empty slice": {
-			input:      struct{ Empty []interface{} }{[]interface{}{}},
-			wantOutput: "Empty = []\n",
-		},
-		"(error) slice with element type mismatch (string and integer)": {
-			input:     struct{ Mixed []interface{} }{[]interface{}{1, "a"}},
-			wantError: errArrayMixedElementTypes,
-		},
-		"(error) slice with element type mismatch (integer and float)": {
-			input:     struct{ Mixed []interface{} }{[]interface{}{1, 2.5}},
-			wantError: errArrayMixedElementTypes,
-		},
-		"slice with elems of differing Go types, same TOML types": {
-			input: struct {
-				MixedInts   []interface{}
-				MixedFloats []interface{}
-			}{
-				[]interface{}{
-					int(1), int8(2), int16(3), int32(4), int64(5),
-					uint(1), uint8(2), uint16(3), uint32(4), uint64(5),
-				},
-				[]interface{}{float32(1.5), float64(2.5)},
-			},
-			wantOutput: "MixedInts = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n" +
-				"MixedFloats = [1.5, 2.5]\n",
-		},
-		"(error) slice w/ element type mismatch (one is nested array)": {
-			input: struct{ Mixed []interface{} }{
-				[]interface{}{1, []interface{}{2}},
-			},
-			wantError: errArrayMixedElementTypes,
-		},
-		"(error) slice with 1 nil element": {
-			input:     struct{ NilElement1 []interface{} }{[]interface{}{nil}},
-			wantError: errArrayNilElement,
-		},
-		"(error) slice with 1 nil element (and other non-nil elements)": {
-			input: struct{ NilElement []interface{} }{
-				[]interface{}{1, nil},
-			},
-			wantError: errArrayNilElement,
-		},
-		"simple map": {
-			input:      map[string]int{"a": 1, "b": 2},
-			wantOutput: "a = 1\nb = 2\n",
-		},
-		"map with interface{} value type": {
-			input:      map[string]interface{}{"a": 1, "b": "c"},
-			wantOutput: "a = 1\nb = \"c\"\n",
-		},
-		"map with interface{} value type, some of which are structs": {
-			input: map[string]interface{}{
-				"a": struct{ Int int }{2},
-				"b": 1,
-			},
-			wantOutput: "b = 1\n\n[a]\n  Int = 2\n",
-		},
-		"nested map": {
-			input: map[string]map[string]int{
-				"a": {"b": 1},
-				"c": {"d": 2},
-			},
-			wantOutput: "[a]\n  b = 1\n\n[c]\n  d = 2\n",
-		},
-		"nested struct": {
-			input: struct{ Struct struct{ Int int } }{
-				struct{ Int int }{1},
-			},
-			wantOutput: "[Struct]\n  Int = 1\n",
-		},
-		"nested struct and non-struct field": {
-			input: struct {
-				Struct struct{ Int int }
-				Bool   bool
-			}{struct{ Int int }{1}, true},
-			wantOutput: "Bool = true\n\n[Struct]\n  Int = 1\n",
-		},
-		"2 nested structs": {
-			input: struct{ Struct1, Struct2 struct{ Int int } }{
-				struct{ Int int }{1}, struct{ Int int }{2},
-			},
-			wantOutput: "[Struct1]\n  Int = 1\n\n[Struct2]\n  Int = 2\n",
-		},
-		"deeply nested structs": {
-			input: struct {
-				Struct1, Struct2 struct{ Struct3 *struct{ Int int } }
-			}{
-				struct{ Struct3 *struct{ Int int } }{&struct{ Int int }{1}},
-				struct{ Struct3 *struct{ Int int } }{nil},
-			},
-			wantOutput: "[Struct1]\n  [Struct1.Struct3]\n    Int = 1" +
-				"\n\n[Struct2]\n",
-		},
-		"nested struct with nil struct elem": {
-			input: struct {
-				Struct struct{ Inner *struct{ Int int } }
-			}{
-				struct{ Inner *struct{ Int int } }{nil},
-			},
-			wantOutput: "[Struct]\n",
-		},
-		"nested struct with no fields": {
-			input: struct {
-				Struct struct{ Inner struct{} }
-			}{
-				struct{ Inner struct{} }{struct{}{}},
-			},
-			wantOutput: "[Struct]\n  [Struct.Inner]\n",
-		},
-		"struct with tags": {
-			input: struct {
-				Struct struct {
-					Int int `toml:"_int"`
-				} `toml:"_struct"`
-				Bool bool `toml:"_bool"`
-			}{
-				struct {
-					Int int `toml:"_int"`
-				}{1}, true,
-			},
-			wantOutput: "_bool = true\n\n[_struct]\n  _int = 1\n",
-		},
-		"embedded struct": {
-			input:      struct{ Embedded }{Embedded{1}},
-			wantOutput: "_int = 1\n",
-		},
-		"embedded *struct": {
-			input:      struct{ *Embedded }{&Embedded{1}},
-			wantOutput: "_int = 1\n",
-		},
-		"nested embedded struct": {
-			input: struct {
-				Struct struct{ Embedded } `toml:"_struct"`
-			}{struct{ Embedded }{Embedded{1}}},
-			wantOutput: "[_struct]\n  _int = 1\n",
-		},
-		"nested embedded *struct": {
-			input: struct {
-				Struct struct{ *Embedded } `toml:"_struct"`
-			}{struct{ *Embedded }{&Embedded{1}}},
-			wantOutput: "[_struct]\n  _int = 1\n",
-		},
-		"embedded non-struct": {
-			input:      struct{ NonStruct }{5},
-			wantOutput: "NonStruct = 5\n",
-		},
-		"array of tables": {
-			input: struct {
-				Structs []*struct{ Int int } `toml:"struct"`
-			}{
-				[]*struct{ Int int }{{1}, {3}},
-			},
-			wantOutput: "[[struct]]\n  Int = 1\n\n[[struct]]\n  Int = 3\n",
-		},
-		"array of tables order": {
-			input: map[string]interface{}{
-				"map": map[string]interface{}{
-					"zero": 5,
-					"arr": []map[string]int{
-						{
-							"friend": 5,
-						},
-					},
-				},
-			},
-			wantOutput: "[map]\n  zero = 5\n\n  [[map.arr]]\n    friend = 5\n",
-		},
-		"(error) top-level slice": {
-			input:     []struct{ Int int }{{1}, {2}, {3}},
-			wantError: errNoKey,
-		},
-		"(error) slice of slice": {
-			input: struct {
-				Slices [][]struct{ Int int }
-			}{
-				[][]struct{ Int int }{{{1}}, {{2}}, {{3}}},
-			},
-			wantError: errArrayNoTable,
-		},
-		"(error) map no string key": {
-			input:     map[int]string{1: ""},
-			wantError: errNonString,
-		},
-		"(error) empty key name": {
-			input:     map[string]int{"": 1},
-			wantError: errAnything,
-		},
-		"(error) empty map name": {
-			input: map[string]interface{}{
-				"": map[string]int{"v": 1},
-			},
-			wantError: errAnything,
-		},
-	}
-	for label, test := range tests {
-		encodeExpected(t, label, test.input, test.wantOutput, test.wantError)
-	}
-}
-
-func TestEncodeNestedTableArrays(t *testing.T) {
-	type song struct {
-		Name string `toml:"name"`
-	}
-	type album struct {
-		Name  string `toml:"name"`
-		Songs []song `toml:"songs"`
-	}
-	type springsteen struct {
-		Albums []album `toml:"albums"`
-	}
-	value := springsteen{
-		[]album{
-			{"Born to Run",
-				[]song{{"Jungleland"}, {"Meeting Across the River"}}},
-			{"Born in the USA",
-				[]song{{"Glory Days"}, {"Dancing in the Dark"}}},
-		},
-	}
-	expected := `[[albums]]
-  name = "Born to Run"
-
-  [[albums.songs]]
-    name = "Jungleland"
-
-  [[albums.songs]]
-    name = "Meeting Across the River"
-
-[[albums]]
-  name = "Born in the USA"
-
-  [[albums.songs]]
-    name = "Glory Days"
-
-  [[albums.songs]]
-    name = "Dancing in the Dark"
-`
-	encodeExpected(t, "nested table arrays", value, expected, nil)
-}
-
-func TestEncodeArrayHashWithNormalHashOrder(t *testing.T) {
-	type Alpha struct {
-		V int
-	}
-	type Beta struct {
-		V int
-	}
-	type Conf struct {
-		V int
-		A Alpha
-		B []Beta
-	}
-
-	val := Conf{
-		V: 1,
-		A: Alpha{2},
-		B: []Beta{{3}},
-	}
-	expected := "V = 1\n\n[A]\n  V = 2\n\n[[B]]\n  V = 3\n"
-	encodeExpected(t, "array hash with normal hash order", val, expected, nil)
-}
-
-func TestEncodeWithOmitEmpty(t *testing.T) {
-	type simple struct {
-		Bool   bool              `toml:"bool,omitempty"`
-		String string            `toml:"string,omitempty"`
-		Array  [0]byte           `toml:"array,omitempty"`
-		Slice  []int             `toml:"slice,omitempty"`
-		Map    map[string]string `toml:"map,omitempty"`
-	}
-
-	var v simple
-	encodeExpected(t, "fields with omitempty are omitted when empty", v, "", nil)
-	v = simple{
-		Bool:   true,
-		String: " ",
-		Slice:  []int{2, 3, 4},
-		Map:    map[string]string{"foo": "bar"},
-	}
-	expected := `bool = true
-string = " "
-slice = [2, 3, 4]
-
-[map]
-  foo = "bar"
-`
-	encodeExpected(t, "fields with omitempty are not omitted when non-empty",
-		v, expected, nil)
-}
-
-func TestEncodeWithOmitZero(t *testing.T) {
-	type simple struct {
-		Number   int     `toml:"number,omitzero"`
-		Real     float64 `toml:"real,omitzero"`
-		Unsigned uint    `toml:"unsigned,omitzero"`
-	}
-
-	value := simple{0, 0.0, uint(0)}
-	expected := ""
-
-	encodeExpected(t, "simple with omitzero, all zero", value, expected, nil)
-
-	value.Number = 10
-	value.Real = 20
-	value.Unsigned = 5
-	expected = `number = 10
-real = 20.0
-unsigned = 5
-`
-	encodeExpected(t, "simple with omitzero, non-zero", value, expected, nil)
-}
-
-func TestEncodeOmitemptyWithEmptyName(t *testing.T) {
-	type simple struct {
-		S []int `toml:",omitempty"`
-	}
-	v := simple{[]int{1, 2, 3}}
-	expected := "S = [1, 2, 3]\n"
-	encodeExpected(t, "simple with omitempty, no name, non-empty field",
-		v, expected, nil)
-}
-
-func TestEncodeAnonymousStruct(t *testing.T) {
-	type Inner struct{ N int }
-	type Outer0 struct{ Inner }
-	type Outer1 struct {
-		Inner `toml:"inner"`
-	}
-
-	v0 := Outer0{Inner{3}}
-	expected := "N = 3\n"
-	encodeExpected(t, "embedded anonymous untagged struct", v0, expected, nil)
-
-	v1 := Outer1{Inner{3}}
-	expected = "[inner]\n  N = 3\n"
-	encodeExpected(t, "embedded anonymous tagged struct", v1, expected, nil)
-}
-
-func TestEncodeAnonymousStructPointerField(t *testing.T) {
-	type Inner struct{ N int }
-	type Outer0 struct{ *Inner }
-	type Outer1 struct {
-		*Inner `toml:"inner"`
-	}
-
-	v0 := Outer0{}
-	expected := ""
-	encodeExpected(t, "nil anonymous untagged struct pointer field", v0, expected, nil)
-
-	v0 = Outer0{&Inner{3}}
-	expected = "N = 3\n"
-	encodeExpected(t, "non-nil anonymous untagged struct pointer field", v0, expected, nil)
-
-	v1 := Outer1{}
-	expected = ""
-	encodeExpected(t, "nil anonymous tagged struct pointer field", v1, expected, nil)
-
-	v1 = Outer1{&Inner{3}}
-	expected = "[inner]\n  N = 3\n"
-	encodeExpected(t, "non-nil anonymous tagged struct pointer field", v1, expected, nil)
-}
-
-func TestEncodeIgnoredFields(t *testing.T) {
-	type simple struct {
-		Number int `toml:"-"`
-	}
-	value := simple{}
-	expected := ""
-	encodeExpected(t, "ignored field", value, expected, nil)
-}
-
-func encodeExpected(
-	t *testing.T, label string, val interface{}, wantStr string, wantErr error,
-) {
-	var buf bytes.Buffer
-	enc := NewEncoder(&buf)
-	err := enc.Encode(val)
-	if err != wantErr {
-		if wantErr != nil {
-			if wantErr == errAnything && err != nil {
-				return
-			}
-			t.Errorf("%s: want Encode error %v, got %v", label, wantErr, err)
-		} else {
-			t.Errorf("%s: Encode failed: %s", label, err)
-		}
-	}
-	if err != nil {
-		return
-	}
-	if got := buf.String(); wantStr != got {
-		t.Errorf("%s: want\n-----\n%q\n-----\nbut got\n-----\n%q\n-----\n",
-			label, wantStr, got)
-	}
-}
-
-func ExampleEncoder_Encode() {
-	date, _ := time.Parse(time.RFC822, "14 Mar 10 18:00 UTC")
-	var config = map[string]interface{}{
-		"date":   date,
-		"counts": []int{1, 1, 2, 3, 5, 8},
-		"hash": map[string]string{
-			"key1": "val1",
-			"key2": "val2",
-		},
-	}
-	buf := new(bytes.Buffer)
-	if err := NewEncoder(buf).Encode(config); err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println(buf.String())
-
-	// Output:
-	// counts = [1, 1, 2, 3, 5, 8]
-	// date = 2010-03-14T18:00:00Z
-	//
-	// [hash]
-	//   key1 = "val1"
-	//   key2 = "val2"
-}

vendor/github.com/VividCortex/ewma/ewma_test.go

@@ -1,103 +0,0 @@
-package ewma
-
-// Copyright (c) 2013 VividCortex, Inc. All rights reserved.
-// Please see the LICENSE file for applicable license terms.
-
-import (
-	"math"
-	"testing"
-)
-
-const testMargin = 0.00000001
-
-var samples = [100]float64{
-	4599, 5711, 4746, 4621, 5037, 4218, 4925, 4281, 5207, 5203, 5594, 5149,
-	4948, 4994, 6056, 4417, 4973, 4714, 4964, 5280, 5074, 4913, 4119, 4522,
-	4631, 4341, 4909, 4750, 4663, 5167, 3683, 4964, 5151, 4892, 4171, 5097,
-	3546, 4144, 4551, 6557, 4234, 5026, 5220, 4144, 5547, 4747, 4732, 5327,
-	5442, 4176, 4907, 3570, 4684, 4161, 5206, 4952, 4317, 4819, 4668, 4603,
-	4885, 4645, 4401, 4362, 5035, 3954, 4738, 4545, 5433, 6326, 5927, 4983,
-	5364, 4598, 5071, 5231, 5250, 4621, 4269, 3953, 3308, 3623, 5264, 5322,
-	5395, 4753, 4936, 5315, 5243, 5060, 4989, 4921, 4480, 3426, 3687, 4220,
-	3197, 5139, 6101, 5279,
-}
-
-func withinMargin(a, b float64) bool {
-	return math.Abs(a-b) <= testMargin
-}
-
-func TestSimpleEWMA(t *testing.T) {
-	var e SimpleEWMA
-	for _, f := range samples {
-		e.Add(f)
-	}
-	if !withinMargin(e.Value(), 4734.500946466118) {
-		t.Errorf("e.Value() is %v, wanted %v", e.Value(), 4734.500946466118)
-	}
-	e.Set(1.0)
-	if e.Value() != 1.0 {
-		t.Errorf("e.Value() is %d", e.Value())
-	}
-}
-
-func TestVariableEWMA(t *testing.T) {
-	e := NewMovingAverage(30)
-	for _, f := range samples {
-		e.Add(f)
-	}
-	if !withinMargin(e.Value(), 4734.500946466118) {
-		t.Errorf("e.Value() is %v, wanted %v", e.Value(), 4734.500946466118)
-	}
-	e.Set(1.0)
-	if e.Value() != 1.0 {
-		t.Errorf("e.Value() is %d", e.Value())
-	}
-}
-
-func TestVariableEWMA2(t *testing.T) {
-	e := NewMovingAverage(5)
-	for _, f := range samples {
-		e.Add(f)
-	}
-	if !withinMargin(e.Value(), 5015.397367486725) {
-		t.Errorf("e.Value() is %v, wanted %v", e.Value(), 5015.397367486725)
-	}
-}
-
-func TestVariableEWMAWarmup(t *testing.T) {
-	e := NewMovingAverage(5)
-	for i, f := range samples {
-		e.Add(f)
-
-		// all values returned during warmup should be 0.0
-		if uint8(i) < WARMUP_SAMPLES {
-			if e.Value() != 0.0 {
-				t.Errorf("e.Value() is %v, expected %v", e.Value(), 0.0)
-			}
-		}
-	}
-	e = NewMovingAverage(5)
-	e.Set(5)
-	e.Add(1)
-	if e.Value() >= 5 {
-		t.Errorf("e.Value() is %d, expected it to decay towards 0", e.Value())
-	}
-}
-
-func TestVariableEWMAWarmup2(t *testing.T) {
-	e := NewMovingAverage(5)
-	testSamples := [12]float64{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10000, 1}
-	for i, f := range testSamples {
-		e.Add(f)
-
-		// all values returned during warmup should be 0.0
-		if uint8(i) < WARMUP_SAMPLES {
-			if e.Value() != 0.0 {
-				t.Errorf("e.Value() is %v, expected %v", e.Value(), 0.0)
-			}
-		}
-	}
-	if val := e.Value(); val == 1.0 {
-		t.Errorf("e.Value() is expected to be greater than %v", 1.0)
-	}
-}

vendor/github.com/aead/chacha20/.gitignore

@@ -1,25 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-.vscode
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
-*.prof

vendor/github.com/aead/chacha20/.travis.yml

@@ -1,25 +0,0 @@
-language: go
-
-go:
-  - "1.8.x"
-  - "1.9.x"
-  - "1.10.x"
-
-env:
-   - TRAVIS_GOARCH=amd64
-   - TRAVIS_GOARCH=386 
- 
-before_install:
-- export GOARCH=$TRAVIS_GOARCH
-
-branches:
-  only:
-  - master
-
-before_script:
-- go get -u github.com/klauspost/asmfmt/cmd/asmfmt
-
-script:
-- diff -au <(gofmt -d .) <(printf "")
-- diff -au <(asmfmt -d .) <(printf "")
-- go test -v ./...

vendor/github.com/aead/chacha20/README.md

@@ -1,82 +0,0 @@
-[![Godoc Reference](https://godoc.org/github.com/aead/chacha20?status.svg)](https://godoc.org/github.com/aead/chacha20)
-[![Build Status](https://travis-ci.org/aead/chacha20.svg?branch=master)](https://travis-ci.org/aead/chacha20)
-[![Go Report Card](https://goreportcard.com/badge/aead/chacha20)](https://goreportcard.com/report/aead/chacha20)
-
-## The ChaCha20 stream cipher
-
-ChaCha is a stream cipher family created by Daniel J. Bernstein.  
-The most common ChaCha variant is ChaCha20 (20 rounds). ChaCha20 is
-standardized in [RFC 7539](https://tools.ietf.org/html/rfc7539 "RFC 7539").
-
-This package provides implementations of three ChaCha versions:
-- ChaCha20 with a 64 bit nonce (can en/decrypt up to 2^64 * 64 bytes for one key-nonce combination)  
-- ChaCha20 with a 96 bit nonce (can en/decrypt up to 2^32 * 64 bytes ~ 256 GB for one key-nonce combination)  
-- XChaCha20 with a 192 bit nonce (can en/decrypt up to 2^64 * 64 bytes for one key-nonce combination)  
-
-Furthermore the chacha sub package implements ChaCha20/12 and ChaCha20/8.
-These versions use 12 or 8 rounds instead of 20.
-But it's recommended to use ChaCha20 (with 20 rounds) - it will be fast enough for almost all purposes. 
-
-### Installation 
-Install in your GOPATH: `go get -u github.com/aead/chacha20`
-
-### Requirements
-All go versions >= 1.8.7 are supported.
-The code may also work on Go 1.7 but this is not tested.
-
-### Performance
-
-#### AMD64
-Hardware: Intel i7-6500U 2.50GHz x 2  
-System: Linux Ubuntu 16.04 - kernel: 4.4.0-62-generic  
-Go version: 1.8.0  
-```
-AVX2
-name                        speed              cpb
-ChaCha20_64-4                573MB/s ± 0%      4.16
-ChaCha20_1K-4               2.19GB/s ± 0%      1.06
-XChaCha20_64-4               261MB/s ± 0%      9.13
-XChaCha20_1K-4              1.69GB/s ± 4%      1.37
-XORKeyStream64-4             474MB/s ± 2%      5.02
-XORKeyStream1K-4            2.09GB/s ± 1%      1.11
-XChaCha20_XORKeyStream64-4   262MB/s ± 0%      9.09
-XChaCha20_XORKeyStream1K-4  1.71GB/s ± 1%      1.36
-
-SSSE3
-name                        speed              cpb
-ChaCha20_64-4                583MB/s ± 0%      4.08
-ChaCha20_1K-4               1.15GB/s ± 1%      2.02
-XChaCha20_64-4               267MB/s ± 0%      8.92
-XChaCha20_1K-4               984MB/s ± 5%      2.42
-XORKeyStream64-4             492MB/s ± 1%      4.84
-XORKeyStream1K-4            1.10GB/s ± 5%      2.11
-XChaCha20_XORKeyStream64-4   266MB/s ± 0%      8.96
-XChaCha20_XORKeyStream1K-4  1.00GB/s ± 2%      2.32
-```
-#### 386
-Hardware: Intel i7-6500U 2.50GHz x 2  
-System: Linux Ubuntu 16.04 - kernel: 4.4.0-62-generic  
-Go version: 1.8.0  
-```
-SSSE3
-name                        speed              cpb
-ChaCha20_64-4               570MB/s ± 0%       4.18
-ChaCha20_1K-4               650MB/s ± 0%       3.66
-XChaCha20_64-4              223MB/s ± 0%      10.69
-XChaCha20_1K-4              584MB/s ± 1%       4.08
-XORKeyStream64-4            392MB/s ± 1%       6.08
-XORKeyStream1K-4            629MB/s ± 1%       3.79
-XChaCha20_XORKeyStream64-4  222MB/s ± 0%      10.73
-XChaCha20_XORKeyStream1K-4  585MB/s ± 0%       4.07
-
-SSE2
-name                        speed              cpb
-ChaCha20_64-4               509MB/s ± 0%       4.68
-ChaCha20_1K-4               553MB/s ± 2%       4.31
-XChaCha20_64-4              201MB/s ± 0%      11.86
-XChaCha20_1K-4              498MB/s ± 4%       4.78
-XORKeyStream64-4            359MB/s ± 1%       6.64
-XORKeyStream1K-4            545MB/s ± 0%       4.37
-XChaCha20_XORKeyStream64-4  201MB/s ± 1%      11.86
-XChaCha20_XORKeyStream1K-4  507MB/s ± 0%       4.70
-```

vendor/github.com/aead/chacha20/chacha/chacha.go

@@ -9,6 +9,7 @@ package chacha // import "github.com/aead/chacha20/chacha"
 import (
 	"encoding/binary"
 	"errors"
+	"math"
 )
 
 const (
@@ -162,6 +163,21 @@ func (c *Cipher) XORKeyStream(dst, src []byte) {
 		c.off = 0
 	}
 
+	// check for counter overflow
+	blocksToXOR := len(src) / 64
+	if len(src)%64 != 0 {
+		blocksToXOR++
+	}
+	var overflow bool
+	if c.noncesize == INonceSize {
+		overflow = binary.LittleEndian.Uint32(c.state[48:]) > math.MaxUint32-uint32(blocksToXOR)
+	} else {
+		overflow = binary.LittleEndian.Uint64(c.state[48:]) > math.MaxUint64-uint64(blocksToXOR)
+	}
+	if overflow {
+		panic("chacha20/chacha: counter overflow")
+	}
+
 	c.off += xorKeyStream(dst, src, &(c.block), &(c.state), c.rounds)
 }
 

vendor/github.com/aead/chacha20/chacha/chacha_amd64.go

@@ -12,7 +12,7 @@ func init() {
 	useSSE2 = cpu.X86.HasSSE2
 	useSSSE3 = cpu.X86.HasSSSE3
 	useAVX = cpu.X86.HasAVX
-	useAVX2 = cpu.X86.HasAVX2 && false // disable until #16 is fixed
+	useAVX2 = cpu.X86.HasAVX2
 }
 
 // This function is implemented in chacha_amd64.s

vendor/github.com/aead/chacha20/chacha/chacha_test.go

@@ -1,397 +0,0 @@
-// Copyright (c) 2016 Andreas Auernhammer. All rights reserved.
-// Use of this source code is governed by a license that can be
-// found in the LICENSE file.
-
-package chacha
-
-import (
-	"bytes"
-	"encoding/hex"
-	"testing"
-)
-
-func toHex(bits []byte) string {
-	return hex.EncodeToString(bits)
-}
-
-func fromHex(bits string) []byte {
-	b, err := hex.DecodeString(bits)
-	if err != nil {
-		panic(err)
-	}
-	return b
-}
-
-func TestHChaCha20(t *testing.T) {
-	defer func(sse2, ssse3, avx, avx2 bool) {
-		useSSE2, useSSSE3, useAVX, useAVX2 = sse2, ssse3, avx, avx2
-	}(useSSE2, useSSSE3, useAVX, useAVX2)
-
-	if useAVX2 {
-		t.Log("AVX2 version")
-		testHChaCha20(t)
-		useAVX2 = false
-	}
-	if useAVX {
-		t.Log("AVX version")
-		testHChaCha20(t)
-		useAVX = false
-	}
-	if useSSSE3 {
-		t.Log("SSSE3 version")
-		testHChaCha20(t)
-		useSSSE3 = false
-	}
-	if useSSE2 {
-		t.Log("SSE2 version")
-		testHChaCha20(t)
-		useSSE2 = false
-	}
-	t.Log("generic version")
-	testHChaCha20(t)
-}
-
-func TestVectors(t *testing.T) {
-	defer func(sse2, ssse3, avx, avx2 bool) {
-		useSSE2, useSSSE3, useAVX, useAVX2 = sse2, ssse3, avx, avx2
-	}(useSSE2, useSSSE3, useAVX, useAVX2)
-
-	if useAVX2 {
-		t.Log("AVX2 version")
-		testVectors(t)
-		useAVX2 = false
-	}
-	if useAVX {
-		t.Log("AVX version")
-		testVectors(t)
-		useAVX = false
-	}
-	if useSSSE3 {
-		t.Log("SSSE3 version")
-		testVectors(t)
-		useSSSE3 = false
-	}
-	if useSSE2 {
-		t.Log("SSE2 version")
-		testVectors(t)
-		useSSE2 = false
-	}
-	t.Log("generic version")
-	testVectors(t)
-}
-
-func TestIncremental(t *testing.T) {
-	defer func(sse2, ssse3, avx, avx2 bool) {
-		useSSE2, useSSSE3, useAVX, useAVX2 = sse2, ssse3, avx, avx2
-	}(useSSE2, useSSSE3, useAVX, useAVX2)
-
-	if useAVX2 {
-		t.Log("AVX2 version")
-		testIncremental(t, 5, 2049)
-		useAVX2 = false
-	}
-	if useAVX {
-		t.Log("AVX version")
-		testIncremental(t, 5, 2049)
-		useAVX = false
-	}
-	if useSSSE3 {
-		t.Log("SSSE3 version")
-		testIncremental(t, 5, 2049)
-		useSSSE3 = false
-	}
-	if useSSE2 {
-		t.Log("SSE2 version")
-		testIncremental(t, 5, 2049)
-	}
-}
-
-func testHChaCha20(t *testing.T) {
-	for i, v := range hChaCha20Vectors {
-		var key [32]byte
-		var nonce [16]byte
-		copy(key[:], v.key)
-		copy(nonce[:], v.nonce)
-
-		hChaCha20(&key, &nonce, &key)
-		if !bytes.Equal(key[:], v.keystream) {
-			t.Errorf("Test %d: keystream mismatch:\n \t got:  %s\n \t want: %s", i, toHex(key[:]), toHex(v.keystream))
-		}
-	}
-}
-
-func testVectors(t *testing.T) {
-	for i, v := range vectors {
-		if len(v.plaintext) == 0 {
-			v.plaintext = make([]byte, len(v.ciphertext))
-		}
-
-		dst := make([]byte, len(v.ciphertext))
-
-		XORKeyStream(dst, v.plaintext, v.nonce, v.key, v.rounds)
-		if !bytes.Equal(dst, v.ciphertext) {
-			t.Errorf("Test %d: ciphertext mismatch:\n \t got:  %s\n \t want: %s", i, toHex(dst), toHex(v.ciphertext))
-		}
-
-		c, err := NewCipher(v.nonce, v.key, v.rounds)
-		if err != nil {
-			t.Fatal(err)
-		}
-		c.XORKeyStream(dst[:1], v.plaintext[:1])
-		c.XORKeyStream(dst[1:], v.plaintext[1:])
-		if !bytes.Equal(dst, v.ciphertext) {
-			t.Errorf("Test %d: ciphertext mismatch:\n \t got:  %s\n \t want: %s", i, toHex(dst), toHex(v.ciphertext))
-		}
-	}
-}
-
-func testIncremental(t *testing.T, iter int, size int) {
-	sse2, ssse3, avx, avx2 := useSSE2, useSSSE3, useAVX, useAVX2
-	msg, ref, stream := make([]byte, size), make([]byte, size), make([]byte, size)
-
-	for i := 0; i < iter; i++ {
-		var key [32]byte
-		var nonce []byte
-		switch i % 3 {
-		case 0:
-			nonce = make([]byte, 8)
-		case 1:
-			nonce = make([]byte, 12)
-		case 2:
-			nonce = make([]byte, 24)
-		}
-
-		for j := range key {
-			key[j] = byte(len(nonce) + i)
-		}
-		for j := range nonce {
-			nonce[j] = byte(i)
-		}
-
-		for j := 0; j <= len(msg); j++ {
-			useSSE2, useSSSE3, useAVX, useAVX2 = false, false, false, false
-			XORKeyStream(ref[:j], msg[:j], nonce, key[:], 20)
-
-			useSSE2, useSSSE3, useAVX, useAVX2 = sse2, ssse3, avx, avx2
-			XORKeyStream(stream[:j], msg[:j], nonce, key[:], 20)
-
-			if !bytes.Equal(ref[:j], stream[:j]) {
-				t.Fatalf("Iteration %d failed:\n Message length: %d\n\n got:  %s\nwant: %s", i, j, toHex(stream[:j]), toHex(ref[:j]))
-			}
-
-			useSSE2, useSSSE3, useAVX, useAVX2 = false, false, false, false
-			c, _ := NewCipher(nonce, key[:], 20)
-			c.XORKeyStream(stream[:j], msg[:j])
-
-			useSSE2, useSSSE3, useAVX, useAVX2 = sse2, ssse3, avx, avx2
-			c, _ = NewCipher(nonce, key[:], 20)
-			c.XORKeyStream(stream[:j], msg[:j])
-
-			if !bytes.Equal(ref[:j], stream[:j]) {
-				t.Fatalf("Iteration %d failed:\n Message length: %d\n\n got:  %s\nwant: %s", i, j, toHex(stream[:j]), toHex(ref[:j]))
-			}
-		}
-		copy(msg, stream)
-	}
-}
-
-var hChaCha20Vectors = []struct {
-	key, nonce, keystream []byte
-}{
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000000000000000000000000000"),
-		fromHex("1140704c328d1d5d0e30086cdf209dbd6a43b8f41518a11cc387b669b2ee6586"),
-	},
-	{
-		fromHex("8000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000000000000000000000000000"),
-		fromHex("7d266a7fd808cae4c02a0a70dcbfbcc250dae65ce3eae7fc210f54cc8f77df86"),
-	},
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
-		fromHex("000000000000000000000000000000000000000000000002"),
-		fromHex("e0c77ff931bb9163a5460c02ac281c2b53d792b1c43fea817e9ad275ae546963"),
-	},
-	{
-		fromHex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
-		fromHex("000102030405060708090a0b0c0d0e0f1011121314151617"),
-		fromHex("51e3ff45a895675c4b33b46c64f4a9ace110d34df6a2ceab486372bacbd3eff6"),
-	},
-}
-
-var vectors = []struct {
-	key, nonce, plaintext, ciphertext []byte
-	rounds                            int
-}{
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000"),
-		nil,
-		fromHex("76b8e0ada0f13d90405d6ae55386bd28bdd219b8a08ded1aa836efcc8b770dc7da41597c5157488d7724e03fb8d84a376a43b8f41518a11cc387b669b2ee6586"),
-		20,
-	},
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
-		fromHex("000000000000000000000002"),
-		fromHex("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" +
-			"416e79207375626d697373696f6e20746f20746865204945544620696e74656e6465642062792074686520436f6e7472696275746f7220666f72207075626c69" +
-			"636174696f6e20617320616c6c206f722070617274206f6620616e204945544620496e7465726e65742d4472616674206f722052464320616e6420616e792073" +
-			"746174656d656e74206d6164652077697468696e2074686520636f6e74657874206f6620616e204945544620616374697669747920697320636f6e7369646572" +
-			"656420616e20224945544620436f6e747269627574696f6e222e20537563682073746174656d656e747320696e636c756465206f72616c2073746174656d656e" +
-			"747320696e20494554462073657373696f6e732c2061732077656c6c206173207772697474656e20616e6420656c656374726f6e696320636f6d6d756e696361" +
-			"74696f6e73206d61646520617420616e792074696d65206f7220706c6163652c207768696368206172652061646472657373656420746f"),
-		fromHex("ecfa254f845f647473d3cb140da9e87606cb33066c447b87bc2666dde3fbb739a371c9ec7abcb4cfa9211f7d90f64c2d07f89e5cf9b93e330a6e4c08af5ba6d5" +
-			"a3fbf07df3fa2fde4f376ca23e82737041605d9f4f4f57bd8cff2c1d4b7955ec2a97948bd3722915c8f3d337f7d370050e9e96d647b7c39f56e031ca5eb6250d" +
-			"4042e02785ececfa4b4bb5e8ead0440e20b6e8db09d881a7c6132f420e52795042bdfa7773d8a9051447b3291ce1411c680465552aa6c405b7764d5e87bea85a" +
-			"d00f8449ed8f72d0d662ab052691ca66424bc86d2df80ea41f43abf937d3259dc4b2d0dfb48a6c9139ddd7f76966e928e635553ba76c5c879d7b35d49eb2e62b" +
-			"0871cdac638939e25e8a1e0ef9d5280fa8ca328b351c3c765989cbcf3daa8b6ccc3aaf9f3979c92b3720fc88dc95ed84a1be059c6499b9fda236e7e818b04b0b" +
-			"c39c1e876b193bfe5569753f88128cc08aaa9b63d1a16f80ef2554d7189c411f5869ca52c5b83fa36ff216b9c1d30062bebcfd2dc5bce0911934fda79a86f6e6" +
-			"98ced759c3ff9b6477338f3da4f9cd8514ea9982ccafb341b2384dd902f3d1ab7ac61dd29c6f21ba5b862f3730e37cfdc4fd806c22f221"),
-		20,
-	},
-	{
-		fromHex("8000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000"),
-		nil,
-		fromHex("e29edae0466dea17f2576ce95025dd2db2d34fc81b5153f1b70a87f315a35286"),
-		20,
-	},
-	{
-		fromHex("8000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000"),
-		nil,
-		fromHex("e29edae0466dea17f2576ce95025dd2db2d34fc81b5153f1b70a87f315a35286fb56db91e8dbf0a93faaa25777aad63450dae65ce3eae7fc210f54cc8f77df8662f8" +
-			"955228b2358d61d8c5ccf63a6c40203be5fb4541c39c52861de70b8a1416ddd3fe9a818bae8f0e8ff2288cede0459fbb00032fd85fef972fcb586c228d"),
-		20,
-	},
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("0000000000000000"),
-		nil,
-		fromHex("76b8e0ada0f13d90405d6ae55386bd28bdd219b8a08ded1aa836efcc8b770dc7da41597c5157488d7724e03fb8d84a376a43b8f41518a11cc387b669b2ee65869f07" +
-			"e7be5551387a98ba977c732d080dcb0f29a048e3656912c6533e32ee7aed29b721769ce64e43d57133b074d839d531ed1f28510afb45ace10a1f4b794d6f2d09a0e663266ce1ae7ed1081968a0758e7" +
-			"18e997bd362c6b0c34634a9a0b35d012737681f7b5d0f281e3afde458bc1e73d2d313c9cf94c05ff3716240a248f21320a058d7b3566bd520daaa3ed2bf0ac5b8b120fb852773c3639734b45c91a42d" +
-			"d4cb83f8840d2eedb158131062ac3f1f2cf8ff6dcd1856e86a1e6c3167167ee5a688742b47c5adfb59d4df76fd1db1e51ee03b1ca9f82aca173edb8b7293474ebe980f904d10c916442b4783a0e9848" +
-			"60cb6c957b39c38ed8f51cffaa68a4de01025a39c504546b9dc1406a7eb28151e5150d7b204baa719d4f091021217db5cf1b5c84c4fa71a879610a1a695ac527c5b56774a6b8a21aae88685868e094c" +
-			"f29ef4090af7a90cc07e8817aa528763797d3c332b67ca4bc110642c2151ec47ee84cb8c42d85f10e2a8cb18c3b7335f26e8c39a12b1bcc1707177b7613873"),
-		20,
-	},
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("0100000000000000"),
-		nil,
-		fromHex("ef3fdfd6c61578fbf5cf35bd3dd33b8009631634d21e42ac33960bd138e50d32111e4caf237ee53ca8ad6426194a88545ddc497a0b466e7d6bbdb0041b2f586b5305" +
-			"e5e44aff19b235936144675efbe4409eb7e8e5f1430f5f5836aeb49bb5328b017c4b9dc11f8a03863fa803dc71d5726b2b6b31aa32708afe5af1d6b690584d58792b271e5fdb92c486051c48b79a4d4" +
-			"8a109bb2d0477956e74c25e93c3c2db34bf779470464a033b8394517a5cf3576a6618c8551a456628b253ef0117c90cd46d8177a2a06d16e20e05c05f889bf87e95d6ee8a03807d1cd53d586872b125" +
-			"9d0647da7b7aae80af9b3aad41ad5a8141d2e156c9dd52a3bd2ae165bd7d6a2a4e2cf6938b8b390828ff20dc8fd60e2cd17fe368e35b467a70654ba93cfa62760a9d2f26da7818d4d863808e1add5ff" +
-			"db76d41efd524ded4246e03caa008950c91dedfc9a8e68173fe481c4d3d3c215fdf3af22aeab0097b835a84faabbbce094c6181a193ffeda067271ff7c10cce76542241116283842e31e922430211dc" +
-			"b38e556158fc2daaec367b705b75f782f8bc2c2c5e33a375390c3052f7e3446feb105fb47820f1d2539811c5b49bb76dc15f2d20a7e2c200b573db9f653ed7"),
-		20,
-	},
-	{
-		fromHex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
-		fromHex("0001020304050607"),
-		nil,
-		fromHex("f798a189f195e66982105ffb640bb7757f579da31602fc93ec01ac56f85ac3c134a4547b733b46413042c9440049176905d3be59ea1c53f15916155c2be8241a3800" +
-			"8b9a26bc35941e2444177c8ade6689de95264986d95889fb60e84629c9bd9a5acb1cc118be563eb9b3a4a472f82e09a7e778492b562ef7130e88dfe031c79db9d4f7c7a899151b9a475032b63fc3852" +
-			"45fe054e3dd5a97a5f576fe064025d3ce042c566ab2c507b138db853e3d6959660996546cc9c4a6eafdc777c040d70eaf46f76dad3979e5c5360c3317166a1c894c94a371876a94df7628fe4eaaf2cc" +
-			"b27d5aaae0ad7ad0f9d4b6ad3b54098746d4524d38407a6deb3ab78fab78c94213668bbbd394c5de93b853178addd6b97f9fa1ec3e56c00c9ddff0a44a204241175a4cab0f961ba53ede9bdf960b94f" +
-			"9829b1f3414726429b362c5b538e391520f489b7ed8d20ae3fd49e9e259e44397514d618c96c4846be3c680bdc11c71dcbbe29ccf80d62a0938fa549391e6ea57ecbe2606790ec15d2224ae307c1442" +
-			"26b7c4e8c2f97d2a1d67852d29beba110edd445197012062a393a9c92803ad3b4f31d7bc6033ccf7932cfed3f019044d25905916777286f82f9a4cc1ffe430"),
-		20,
-	},
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000"),
-		nil,
-		fromHex("9bf49a6a0755f953811fce125f2683d50429c3bb49e074147e0089a52eae155f0564f879d27ae3c02ce82834acfa8c793a629f2ca0de6919610be82f411326be0bd588" +
-			"41203e74fe86fc71338ce0173dc628ebb719bdcbcc151585214cc089b442258dcda14cf111c602b8971b8cc843e91e46ca905151c02744a6b017e69316b20cd67c4bdecc538e8be990c1b6425d68bfd3a" +
-			"6fe97693e4846351596cca8abf59fddd0b7f52dcc0c60a448cbf9511610b0a742f1e4d238a7a45cae054ec2"),
-		12,
-	},
-	{
-		fromHex("8000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000"),
-		nil,
-		fromHex("789cc357f0b6cda5395f08c8538f1226d08eb3e16ebd6b6db6cc9ca77d81d900bb9d21f6ef0b720550d161f1a80fab0468e48c086daad356edce3a3f988d8e"),
-		12,
-	},
-	{
-		fromHex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
-		fromHex("0001020304050607"),
-		nil,
-		fromHex("6898eb04f3d151985e28e882f35daf28d2a1689f79081ffb08cdc48edbbd3dcd683c764f3dd7302293928ca3d4ef4194e6e22f41a72204a14b89115d06ca29fb0b9f6e" +
-			"ba3da6793a928afe76cdf62a5d5b0898bb9bb2348612189fdb825e5aa7559c9ec79ff80d05079fad81e9bc2521b2ebcb179cebeade91f20ff3e13192d60de2ee983ec07047e7827594773c28448d89e9b" +
-			"96bb0f8665b1a56f85abebd584a446e17d5a6fb847a1dbf341ece5124ff5f80d4a57fb7edf65a2907939b2f3c9654ccbfa2e5225edc8d799bf7ce296d6c8f9234cec0bd7b91b3d2ddc27f93ff8591ddb3" +
-			"62b54fab111a7da9d5b4187661ed0e691f7aa5959fb83112427a95bbeb"),
-		12,
-	},
-	{
-		fromHex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
-		fromHex("0001020304050607"),
-		nil,
-		fromHex("40e1aaea1c843baa28b18eb728fec05dce47b0e824bf9a5d3f1bb1aad13b37fbbf0b0e146732c16380efeab70a1b6edff9acedc876b70d98b61f192290537973"),
-		8,
-	},
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000000000000000000000000000"),
-		nil,
-		fromHex("bcd02a18bf3f01d19292de30a7a8fdaca4b65e50a6002cc72cd6d2f7c91ac3d5728f83e0aad2bfcf9abd2d2db58faedd65015dd83fc09b131e271043019e8e0f789e96" +
-			"89e5208d7fd9e1f3c5b5341f48ef18a13e418998addadd97a3693a987f8e82ecd5c1433bfed1af49750c0f1ff29c4174a05b119aa3a9e8333812e0c0fea49e1ee0134a70a9d49c24e0cbd8fc3ba27e97c" +
-			"3322ad487f778f8dc6a122fa59cbe33e7"),
-		20,
-	},
-	{
-		fromHex("8000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000000000000000000000000000"),
-		nil,
-		fromHex("ccfe8a9e93431bd582f07b3eb0f4a7afc22ef39337ddd84f0d3545b318a315a32b3abb96de0fc6acde48b248fe8a80e6fa72bfcdf9d8d2656b991676476f052d937308" +
-			"0e30d8c0e217126a3c64402e1d9404ba9d6b8ce4ad5ac9693f3660638c26ea2cd1b4a8d3348c1e179ead353ee72fee558e9994c51a27195e287d00ec2f8cfef8866d1f98714f40cbe4e18cebabf3cd1fd" +
-			"3bb65506e5dce1ad09f438bffe2c96d7f2f0827c8c3f2ca59dbaa393785c6b8da7c69c8a4a63ffd113dcc93de8f52dbcfaed5e4cbcc1dc310b1352868fab7b14d930a9f7a7d47bed0eaf5b151f6dac8bd" +
-			"45510698bdc205d70b944ea5450888dd3ec753da9708bf06c0714822dda74f285c361abd0cd1071324c253dc421905edca36e8808bffef091e7dbdecebdad98cf70b7cede72e9c3c4108e5b32ffae0f42" +
-			"151a8196939d8e3b8384be1"),
-		20,
-	},
-	{
-		fromHex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
-		fromHex("000102030405060708090a0b0c0d0e0f1011121314151617"),
-		nil,
-		fromHex("e53a61cef151e81401067de33adfc02e90ab205361b49b539fda7f0e63b1bc7d68fbee56c9c20c39960e595f3ea76c979804d08cfa728e66cb5f766b840ec61f9ec20f" +
-			"7f90d28dae334426cecb52a8e84b4728a5fdd61deb7f1a3fb63dadf5595e06b6e441670964d595ae59cf21536271bae2594774fb19079b933d8fe744f4"),
-		20,
-	},
-	{
-		fromHex("FF00000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000"),
-		nil,
-		fromHex("4fe0956ef81829ff96ef093f03c15dc0eaf4e6905eff9777a5db78348915689ed64204e8fce664cb71ea4016185d15e05be4329e02fcd472707508ef62fd89565ffa632effdb" +
-			"bf08394aa437d8ff093e6cea49b61672cf294474927a8150e06cec9fdec0f5cf26f257fe335a8d7dd6d208e6df6f0a83bb1b0b5c574edc2c9a604e4310acb970815a9819c91a5137794d1ee71ede3e5d59f27e76" +
-			"84d287d704fe3945de0a9b66be3d86e66980263602aeb600efaef243b1adf4c701dbf8f57427dee71dacd703d25317ffc7a67e7881ad13f0bf096d3b0486eec71fef5e0efb5964d14eb2cea0336e34ed4444cc2b" +
-			"bdbd8ef5ba89a0a5e9e35a2e23b38d3f9136f42aefb25c2e7eae0b42c1d1ada5618c5299aedd469ce4f9353ccbae3f89110922b669b8d1b62e72aaf893b83ca264707efbefdcf22ef2333b01f18a849653b52925" +
-			"63c37314bf34289b0636a2f8c24bc97fec554a9c31ec2cb4e30ba70fa965a17561e56739be138d86a4777f866ca24ba24f70913230e1b3ea34a9a90eea1b6a3a81b93286bb582a53e78557845a654775a18efb77" +
-			"eee098d2680bc4ceb866874f31c7fadd70262cca6039833522de03cb2527dc5cfc7072db48b6011b852d705c7b24ffedf52facf352ab2512c625811db7965edc87d08f7f27e02665c9a6a42968e4c58cd86aa847" +
-			"69658153b62f208b2dcfbcb364d63e6671cf60698640"),
-		20,
-	},
-	{
-		fromHex("0120000000000000000000000000007000000000000000000000000000000DEF"),
-		fromHex("000000000000000000000000"),
-		nil,
-		fromHex("ba6bce79c4f79c815b7fec53840ff0549ff5496378aa1f6ba481a48a5b9b8dbea8b820eccbc4eca37e1050fc53510a746037d2707f81e9683ec3f495b02ad0f848d7f9bf67bc" +
-			"6299be525d1bf3bfd9953caa12cc4e1d5a6969e6fcd5d3c3e3d9f2e735cd7808755ddda7b22a3ae6040e7f8d05d62661a97d84dad694c69637aea3ae0af9f73303ffce3ae6161281d7a3c7e50a5706d766b34ddd" +
-			"eab6974fdab10b3f48fb31f26df72e54c616edf1afc019f240c059a7c003677008227f49b021bc23c9c51d6f85ad136a4aa4950d9692f7094d344d88c05868691eb620d39bd8154986c971a8c9552ff0015fd78a" +
-			"6bdd33df94b0056786a1e0ceb9cc9a38a31fbba224c1fb82bf6af376f67e94337a730301a6365d49b0dd56328e0269cbdfb5bcbccf1c7c3f4922ec1310aa2ef8136be788a55190453d3d3153b1b960a16f79365a" +
-			"0bc7d6d2d5cda9f0993dbb815ee72f83b9d2ed296598fb21d91c29d1acf4ff0a549784a1d6a4f0935ee18efbf41fdc98d81c449544e9701d92648c06e5f416833b90d15fd4c04fc720a5ec6c6fc8b3d85a66826a" +
-			"5e6817e21c4c4c0d7151b128236c41397ad4c6549e827c42269659973c153db70ffc33951b19ff21428091cea3836f72f88082508bae1839b59fa9c2556bdf373419d3cf29a8fad4d1787d829ad884f9927228fc" +
-			"0b8bb7f1a067e7bdbf06c3885154f76f5be0cde8c7c59442b72b0e3f0341afe644e7eb4c29a467288aebc893e17b446c63da7551b8b59ebdd0cbcd65bc79a969bd3397f83d149840de731df4c09a833d5bd9feda" +
-			"e1cd78a09b233b020de86ab71b9fd425adf84e502cef7c62015eade66ca91b0a90306894b53c7c5147e524d7b919ccdd0731e4eef8fe476b6eed38c91b611cd1777b9acf6eee0a11eaff16ae872db92a5d133fe7" +
-			"bed999882da283893dd1e96f530be3cd36bf38c16deed2cd77651b6e0d3628de3cb86a78f1d07f6fc79434da5f73888be617b84595acef154f66b95ade1a3e120421a9dac6eec1e5b60139da3d604a03d4a9b7a3" +
-			"0810a9c7d551aa8df08e11544486ad33000bfe410e8e6f35cb9d22806a5fcacefc6a1257d373d426243576fad9b20ad5ba84befc1a47c79d7bd2923b5776d3df86c8ed98b700d317502849ec8c02ecb8513a7a32" +
-			"e2db15e75a814f12cfc20429ae06cae2021406b4f174ce56dca65f7994a3b2722e764520a52f87d0a887fc771dbfbf381b4f750dc074fedec1a43a4df37a5a2c148f89d9630ebbd1be1858bed10207cdacae9a0a" +
-			"b92df58de53de4718f929a83474fbcf9969f1d28a5b257cacd56f0ff0bc425c93d8c91ac833c2cfefb97d82fe6236f3ec3c29e0112a6cac5abfec733db41265f8ff486e7d7fa0b3d9766357377f089056c9408d8" +
-			"2f09f18700236cc1058ea1c273e287d07d521fdbb5e28d41cc1d95999eccee"),
-		20,
-	},
-}

vendor/github.com/aead/chacha20/chacha20.go

@@ -1,41 +0,0 @@
-// Copyright (c) 2016 Andreas Auernhammer. All rights reserved.
-// Use of this source code is governed by a license that can be
-// found in the LICENSE file.
-
-// Package chacha20 implements the ChaCha20 / XChaCha20 stream chipher.
-// Notice that one specific key-nonce combination must be unique for all time.
-//
-// There are three versions of ChaCha20:
-// - ChaCha20 with a 64 bit nonce (en/decrypt up to 2^64 * 64 bytes for one key-nonce combination)
-// - ChaCha20 with a 96 bit nonce (en/decrypt up to 2^32 * 64 bytes (~256 GB) for one key-nonce combination)
-// - XChaCha20 with a 192 bit nonce (en/decrypt up to 2^64 * 64 bytes for one key-nonce combination)
-package chacha20 // import "github.com/aead/chacha20"
-
-import (
-	"crypto/cipher"
-
-	"github.com/aead/chacha20/chacha"
-)
-
-// XORKeyStream crypts bytes from src to dst using the given nonce and key.
-// The length of the nonce determinds the version of ChaCha20:
-// - 8 bytes:  ChaCha20 with a 64 bit nonce and a 2^64 * 64 byte period.
-// - 12 bytes: ChaCha20 as defined in RFC 7539 and a 2^32 * 64 byte period.
-// - 24 bytes: XChaCha20 with a 192 bit nonce and a 2^64 * 64 byte period.
-// Src and dst may be the same slice but otherwise should not overlap.
-// If len(dst) < len(src) this function panics.
-// If the nonce is neither 64, 96 nor 192 bits long, this function panics.
-func XORKeyStream(dst, src, nonce, key []byte) {
-	chacha.XORKeyStream(dst, src, nonce, key, 20)
-}
-
-// NewCipher returns a new cipher.Stream implementing a ChaCha20 version.
-// The nonce must be unique for one key for all time.
-// The length of the nonce determinds the version of ChaCha20:
-// - 8 bytes:  ChaCha20 with a 64 bit nonce and a 2^64 * 64 byte period.
-// - 12 bytes: ChaCha20 as defined in RFC 7539 and a 2^32 * 64 byte period.
-// - 24 bytes: XChaCha20 with a 192 bit nonce and a 2^64 * 64 byte period.
-// If the nonce is neither 64, 96 nor 192 bits long, a non-nil error is returned.
-func NewCipher(nonce, key []byte) (cipher.Stream, error) {
-	return chacha.NewCipher(nonce, key, 20)
-}

vendor/github.com/aead/chacha20/chacha20_test.go

@@ -1,108 +0,0 @@
-// Copyright (c) 2016 Andreas Auernhammer. All rights reserved.
-// Use of this source code is governed by a license that can be
-// found in the LICENSE file.
-
-package chacha20
-
-import (
-	"bytes"
-	"encoding/hex"
-	"testing"
-
-	"github.com/aead/chacha20/chacha"
-)
-
-func toHex(bits []byte) string {
-	return hex.EncodeToString(bits)
-}
-
-func fromHex(bits string) []byte {
-	b, err := hex.DecodeString(bits)
-	if err != nil {
-		panic(err)
-	}
-	return b
-}
-
-func TestVectors(t *testing.T) {
-	for i, v := range vectors {
-		if len(v.plaintext) == 0 {
-			v.plaintext = make([]byte, len(v.ciphertext))
-		}
-
-		dst := make([]byte, len(v.ciphertext))
-
-		XORKeyStream(dst, v.plaintext, v.nonce, v.key)
-		if !bytes.Equal(dst, v.ciphertext) {
-			t.Errorf("Test %d: ciphertext mismatch:\n \t got:  %s\n \t want: %s", i, toHex(dst), toHex(v.ciphertext))
-		}
-
-		c, err := NewCipher(v.nonce, v.key)
-		if err != nil {
-			t.Fatal(err)
-		}
-		c.XORKeyStream(dst[:1], v.plaintext[:1])
-		c.XORKeyStream(dst[1:], v.plaintext[1:])
-		if !bytes.Equal(dst, v.ciphertext) {
-			t.Errorf("Test %d: ciphertext mismatch:\n \t got:  %s\n \t want: %s", i, toHex(dst), toHex(v.ciphertext))
-		}
-	}
-}
-
-func benchmarkCipher(b *testing.B, size int, nonceSize int) {
-	var key [32]byte
-	nonce := make([]byte, nonceSize)
-	c, _ := NewCipher(nonce, key[:])
-	buf := make([]byte, size)
-
-	b.SetBytes(int64(len(buf)))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		c.XORKeyStream(buf, buf)
-	}
-}
-
-func benchmarkXORKeyStream(b *testing.B, size int, nonceSize int) {
-	var key [32]byte
-	nonce := make([]byte, nonceSize)
-	buf := make([]byte, size)
-	b.SetBytes(int64(len(buf)))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		XORKeyStream(buf, buf, nonce[:], key[:])
-	}
-}
-
-func BenchmarkChaCha20_64(b *testing.B)              { benchmarkCipher(b, 64, chacha.NonceSize) }
-func BenchmarkChaCha20_1K(b *testing.B)              { benchmarkCipher(b, 1024, chacha.NonceSize) }
-func BenchmarkXChaCha20_64(b *testing.B)             { benchmarkXORKeyStream(b, 64, chacha.XNonceSize) }
-func BenchmarkXChaCha20_1K(b *testing.B)             { benchmarkXORKeyStream(b, 1024, chacha.XNonceSize) }
-func BenchmarkXORKeyStream64(b *testing.B)           { benchmarkXORKeyStream(b, 64, chacha.NonceSize) }
-func BenchmarkXORKeyStream1K(b *testing.B)           { benchmarkXORKeyStream(b, 1024, chacha.NonceSize) }
-func BenchmarkXChaCha20_XORKeyStream64(b *testing.B) { benchmarkXORKeyStream(b, 64, chacha.XNonceSize) }
-func BenchmarkXChaCha20_XORKeyStream1K(b *testing.B) {
-	benchmarkXORKeyStream(b, 1024, chacha.XNonceSize)
-}
-
-var vectors = []struct {
-	key, nonce, plaintext, ciphertext []byte
-}{
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("0000000000000000"),
-		nil,
-		fromHex("76b8e0ada0f13d90405d6ae55386bd28bdd219b8a08ded1aa836efcc8b770dc7da41597c5157488d7724e03fb8d84a376a43b8f41518a11cc387b669b2ee6586"),
-	},
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000"),
-		nil,
-		fromHex("76b8e0ada0f13d90405d6ae55386bd28bdd219b8a08ded1aa836efcc8b770dc7da41597c5157488d7724e03fb8d84a376a43b8f41518a11cc387b669b2ee6586"),
-	},
-	{
-		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
-		fromHex("000000000000000000000000000000000000000000000000"),
-		nil,
-		fromHex("bcd02a18bf3f01d19292de30a7a8fdaca4b65e50a6002cc72cd6d2f7c91ac3d5728f83e0aad2bfcf9abd2d2db58faedd65015dd83fc09b131e271043019e8e0f"),
-	},
-}

vendor/github.com/aead/poly1305/poly1305_amd64.go

@@ -7,13 +7,11 @@
 package poly1305
 
 import (
+	"golang.org/x/sys/cpu"
 	"io"
 )
 
-var useAVX2 = supportsAVX2()
-
-//go:noescape
-func supportsAVX2() bool
+var useAVX2 = cpu.X86.HasAVX2
 
 //go:noescape
 func initialize(state *[7]uint64, key *[32]byte)

vendor/github.com/aead/poly1305/poly1305_test.go

@@ -1,157 +0,0 @@
-// Copyright (c) 2016 Andreas Auernhammer. All rights reserved.
-// Use of this source code is governed by a license that can be
-// found in the LICENSE file.
-
-package poly1305
-
-import (
-	"bytes"
-	"encoding/hex"
-	"testing"
-)
-
-func fromHex(s string) []byte {
-	b, err := hex.DecodeString(s)
-	if err != nil {
-		panic(err)
-	}
-	return b
-}
-
-var vectors = []struct {
-	msg, key, tag []byte
-}{
-	{
-		[]byte("Hello world!"),
-		[]byte("this is 32-byte key for Poly1305"),
-		[]byte{0xa6, 0xf7, 0x45, 0x00, 0x8f, 0x81, 0xc9, 0x16, 0xa2, 0x0d, 0xcc, 0x74, 0xee, 0xf2, 0xb2, 0xf0},
-	},
-	{
-		make([]byte, 32),
-		[]byte("this is 32-byte key for Poly1305"),
-		[]byte{0x49, 0xec, 0x78, 0x09, 0x0e, 0x48, 0x1e, 0xc6, 0xc2, 0x6b, 0x33, 0xb9, 0x1c, 0xcc, 0x03, 0x07},
-	},
-	{
-		make([]byte, 2007),
-		[]byte("this is 32-byte key for Poly1305"),
-		[]byte{0xda, 0x84, 0xbc, 0xab, 0x02, 0x67, 0x6c, 0x38, 0xcd, 0xb0, 0x15, 0x60, 0x42, 0x74, 0xc2, 0xaa},
-	},
-	{
-		make([]byte, 2007),
-		make([]byte, 32),
-		make([]byte, 16),
-	},
-	{
-		// This test triggers an edge-case. See https://go-review.googlesource.com/#/c/30101/.
-		[]byte{0x81, 0xd8, 0xb2, 0xe4, 0x6a, 0x25, 0x21, 0x3b, 0x58, 0xfe, 0xe4, 0x21, 0x3a, 0x2a, 0x28, 0xe9, 0x21, 0xc1, 0x2a, 0x96, 0x32, 0x51, 0x6d, 0x3b, 0x73, 0x27, 0x27, 0x27, 0xbe, 0xcf, 0x21, 0x29},
-		[]byte{0x3b, 0x3a, 0x29, 0xe9, 0x3b, 0x21, 0x3a, 0x5c, 0x5c, 0x3b, 0x3b, 0x05, 0x3a, 0x3a, 0x8c, 0x0d},
-		[]byte{0x6d, 0xc1, 0x8b, 0x8c, 0x34, 0x4c, 0xd7, 0x99, 0x27, 0x11, 0x8b, 0xbe, 0x84, 0xb7, 0xf3, 0x14},
-	},
-	// From: https://tools.ietf.org/html/rfc7539#section-2.5.2
-	{
-		fromHex("43727970746f6772617068696320466f72756d2052657365617263682047726f7570"),
-		fromHex("85d6be7857556d337f4452fe42d506a80103808afb0db2fd4abff6af4149f51b"),
-		fromHex("a8061dc1305136c6c22b8baf0c0127a9"),
-	},
-}
-
-func TestVectors(t *testing.T) {
-	var key [32]byte
-
-	for i, v := range vectors {
-		msg := v.msg
-		copy(key[:], v.key)
-
-		out := Sum(msg, key)
-		if !bytes.Equal(out[:], v.tag) {
-			t.Errorf("Test vector %d : got: %x expected: %x", i, out[:], v.tag)
-		}
-
-		h := New(key)
-		h.Write(msg)
-		tag := h.Sum(nil)
-		if !bytes.Equal(tag[:], v.tag) {
-			t.Errorf("Test vector %d : got: %x expected: %x", i, tag[:], v.tag)
-		}
-
-		var mac [16]byte
-		copy(mac[:], v.tag)
-		if !Verify(&mac, msg, key) {
-			t.Errorf("Test vector %d : Verify failed", i)
-		}
-	}
-}
-
-func TestWriteAfterSum(t *testing.T) {
-	msg := make([]byte, 64)
-	for i := range msg {
-		h := New([32]byte{})
-
-		if _, err := h.Write(msg[:i]); err != nil {
-			t.Fatalf("Iteration %d: poly1305.Hash returned unexpected error: %s", i, err)
-		}
-		h.Sum(nil)
-		if _, err := h.Write(nil); err == nil {
-			t.Fatalf("Iteration %d: poly1305.Hash returned no error for write after sum", i)
-		}
-	}
-}
-
-func TestWrite(t *testing.T) {
-	var key [32]byte
-	for i := range key {
-		key[i] = byte(i)
-	}
-
-	h := New(key)
-
-	var msg1 []byte
-	msg0 := make([]byte, 64)
-	for i := range msg0 {
-		h.Write(msg0[:i])
-		msg1 = append(msg1, msg0[:i]...)
-	}
-
-	tag0 := h.Sum(nil)
-	tag1 := Sum(msg1, key)
-
-	if !bytes.Equal(tag0[:], tag1[:]) {
-		t.Fatalf("Sum differ from poly1305.Sum\n Sum: %s \n poly1305.Sum: %s", hex.EncodeToString(tag0[:]), hex.EncodeToString(tag1[:]))
-	}
-}
-
-// Benchmarks
-
-func BenchmarkSum_64(b *testing.B)    { benchmarkSum(b, 64) }
-func BenchmarkSum_256(b *testing.B)   { benchmarkSum(b, 256) }
-func BenchmarkSum_1K(b *testing.B)    { benchmarkSum(b, 1024) }
-func BenchmarkSum_8K(b *testing.B)    { benchmarkSum(b, 8*1024) }
-func BenchmarkWrite_64(b *testing.B)  { benchmarkWrite(b, 64) }
-func BenchmarkWrite_256(b *testing.B) { benchmarkWrite(b, 256) }
-func BenchmarkWrite_1K(b *testing.B)  { benchmarkWrite(b, 1024) }
-func BenchmarkWrite_8K(b *testing.B)  { benchmarkWrite(b, 8*1024) }
-
-func benchmarkSum(b *testing.B, size int) {
-	var key [32]byte
-
-	msg := make([]byte, size)
-
-	b.SetBytes(int64(size))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Sum(msg, key)
-	}
-}
-
-func benchmarkWrite(b *testing.B, size int) {
-	var key [32]byte
-	h := New(key)
-
-	msg := make([]byte, size)
-
-	b.SetBytes(int64(size))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		h.Write(msg)
-	}
-}

vendor/github.com/agl/ed25519/ed25519_test.go

@@ -1,160 +0,0 @@
-// Copyright 2012 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 ed25519
-
-import (
-	"bufio"
-	"bytes"
-	"compress/gzip"
-	"crypto/rand"
-	"encoding/hex"
-	"io"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/agl/ed25519/edwards25519"
-)
-
-type zeroReader struct{}
-
-func (zeroReader) Read(buf []byte) (int, error) {
-	for i := range buf {
-		buf[i] = 0
-	}
-	return len(buf), nil
-}
-
-func TestUnmarshalMarshal(t *testing.T) {
-	pub, _, _ := GenerateKey(rand.Reader)
-
-	var A edwards25519.ExtendedGroupElement
-	if !A.FromBytes(pub) {
-		t.Fatalf("ExtendedGroupElement.FromBytes failed")
-	}
-
-	var pub2 [32]byte
-	A.ToBytes(&pub2)
-
-	if *pub != pub2 {
-		t.Errorf("FromBytes(%v)->ToBytes does not round-trip, got %x\n", *pub, pub2)
-	}
-}
-
-func TestSignVerify(t *testing.T) {
-	var zero zeroReader
-	public, private, _ := GenerateKey(zero)
-
-	message := []byte("test message")
-	sig := Sign(private, message)
-	if !Verify(public, message, sig) {
-		t.Errorf("valid signature rejected")
-	}
-
-	wrongMessage := []byte("wrong message")
-	if Verify(public, wrongMessage, sig) {
-		t.Errorf("signature of different message accepted")
-	}
-}
-
-func TestGolden(t *testing.T) {
-	// sign.input.gz is a selection of test cases from
-	// http://ed25519.cr.yp.to/python/sign.input
-	testDataZ, err := os.Open("testdata/sign.input.gz")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer testDataZ.Close()
-	testData, err := gzip.NewReader(testDataZ)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer testData.Close()
-
-	in := bufio.NewReaderSize(testData, 1<<12)
-	lineNo := 0
-	for {
-		lineNo++
-		lineBytes, isPrefix, err := in.ReadLine()
-		if isPrefix {
-			t.Fatal("bufio buffer too small")
-		}
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			t.Fatalf("error reading test data: %s", err)
-		}
-
-		line := string(lineBytes)
-		parts := strings.Split(line, ":")
-		if len(parts) != 5 {
-			t.Fatalf("bad number of parts on line %d", lineNo)
-		}
-
-		privBytes, _ := hex.DecodeString(parts[0])
-		pubKeyBytes, _ := hex.DecodeString(parts[1])
-		msg, _ := hex.DecodeString(parts[2])
-		sig, _ := hex.DecodeString(parts[3])
-		// The signatures in the test vectors also include the message
-		// at the end, but we just want R and S.
-		sig = sig[:SignatureSize]
-
-		if l := len(pubKeyBytes); l != PublicKeySize {
-			t.Fatalf("bad public key length on line %d: got %d bytes", lineNo, l)
-		}
-
-		var priv [PrivateKeySize]byte
-		copy(priv[:], privBytes)
-		copy(priv[32:], pubKeyBytes)
-
-		sig2 := Sign(&priv, msg)
-		if !bytes.Equal(sig, sig2[:]) {
-			t.Errorf("different signature result on line %d: %x vs %x", lineNo, sig, sig2)
-		}
-
-		var pubKey [PublicKeySize]byte
-		copy(pubKey[:], pubKeyBytes)
-		if !Verify(&pubKey, msg, sig2) {
-			t.Errorf("signature failed to verify on line %d", lineNo)
-		}
-	}
-}
-
-func BenchmarkKeyGeneration(b *testing.B) {
-	var zero zeroReader
-	for i := 0; i < b.N; i++ {
-		if _, _, err := GenerateKey(zero); err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkSigning(b *testing.B) {
-	var zero zeroReader
-	_, priv, err := GenerateKey(zero)
-	if err != nil {
-		b.Fatal(err)
-	}
-	message := []byte("Hello, world!")
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Sign(priv, message)
-	}
-}
-
-func BenchmarkVerification(b *testing.B) {
-	var zero zeroReader
-	pub, priv, err := GenerateKey(zero)
-	if err != nil {
-		b.Fatal(err)
-	}
-	message := []byte("Hello, world!")
-	signature := Sign(priv, message)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Verify(pub, message, signature)
-	}
-}

vendor/github.com/coreos/go-systemd/.travis.yml

@@ -1,29 +0,0 @@
-language: shell # We do everything inside Docker and don't want travis fiddling with steps or environment variables
-
-sudo: required
-
-services:
-  - docker
-
-env:
-  global:
-    - GOPATH=/opt
-    - BUILD_DIR=/opt/src/github.com/coreos/go-systemd
-  matrix:
-    - DOCKER_BASE=ubuntu:18.04
-    - DOCKER_BASE=debian:stretch
-
-before_install:
- - docker pull ${DOCKER_BASE}
- - docker run --privileged -e GOPATH=${GOPATH} --cidfile=/tmp/cidfile ${DOCKER_BASE} /bin/bash -c "apt-get update && apt-get install -y build-essential git golang dbus libsystemd-dev libpam-systemd systemd-container && go get github.com/coreos/pkg/dlopen && go get github.com/godbus/dbus"
- - docker commit `cat /tmp/cidfile` go-systemd/container-tests
- - rm -f /tmp/cidfile
-
-install:
- - docker run -d --cidfile=/tmp/cidfile --privileged -e GOPATH=${GOPATH} -v ${PWD}:${BUILD_DIR} go-systemd/container-tests /bin/systemd --system
-
-script:
- - docker exec `cat /tmp/cidfile` /bin/bash -c "cd ${BUILD_DIR} && ./test"
-
-after_script:
- - docker kill `cat /tmp/cidfile`

vendor/github.com/coreos/go-systemd/CONTRIBUTING.md

@@ -1,77 +0,0 @@
-# How to Contribute
-
-CoreOS projects are [Apache 2.0 licensed](LICENSE) and accept contributions via
-GitHub pull requests.  This document outlines some of the conventions on
-development workflow, commit message formatting, contact points and other
-resources to make it easier to get your contribution accepted.
-
-# Certificate of Origin
-
-By contributing to this project you agree to the Developer Certificate of
-Origin (DCO). This document was created by the Linux Kernel community and is a
-simple statement that you, as a contributor, have the legal right to make the
-contribution. See the [DCO](DCO) file for details.
-
-# Email and Chat
-
-The project currently uses the general CoreOS email list and IRC channel:
-- Email: [coreos-dev](https://groups.google.com/forum/#!forum/coreos-dev)
-- IRC: #[coreos](irc://irc.freenode.org:6667/#coreos) IRC channel on freenode.org
-
-Please avoid emailing maintainers found in the MAINTAINERS file directly. They
-are very busy and read the mailing lists.
-
-## Getting Started
-
-- Fork the repository on GitHub
-- Read the [README](README.md) for build and test instructions
-- Play with the project, submit bugs, submit patches!
-
-## Contribution Flow
-
-This is a rough outline of what a contributor's workflow looks like:
-
-- Create a topic branch from where you want to base your work (usually master).
-- Make commits of logical units.
-- Make sure your commit messages are in the proper format (see below).
-- Push your changes to a topic branch in your fork of the repository.
-- Make sure the tests pass, and add any new tests as appropriate.
-- Submit a pull request to the original repository.
-
-Thanks for your contributions!
-
-### Coding Style
-
-CoreOS projects written in Go follow a set of style guidelines that we've documented 
-[here](https://github.com/coreos/docs/tree/master/golang). Please follow them when 
-working on your contributions.
-
-### Format of the Commit Message
-
-We follow a rough convention for commit messages that is designed to answer two
-questions: what changed and why. The subject line should feature the what and
-the body of the commit should describe the why.
-
-```
-scripts: add the test-cluster command
-
-this uses tmux to setup a test cluster that you can easily kill and
-start for debugging.
-
-Fixes #38
-```
-
-The format can be described more formally as follows:
-
-```
-<subsystem>: <what changed>
-<BLANK LINE>
-<why this change was made>
-<BLANK LINE>
-<footer>
-```
-
-The first line is the subject and should be no longer than 70 characters, the
-second line is always blank, and other lines should be wrapped at 80 characters.
-This allows the message to be easier to read on GitHub as well as in various
-git tools.

vendor/github.com/coreos/go-systemd/DCO

@@ -1,36 +0,0 @@
-Developer Certificate of Origin
-Version 1.1
-
-Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-660 York Street, Suite 102,
-San Francisco, CA 94110 USA
-
-Everyone is permitted to copy and distribute verbatim copies of this
-license document, but changing it is not allowed.
-
-
-Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-(a) The contribution was created in whole or in part by me and I
-    have the right to submit it under the open source license
-    indicated in the file; or
-
-(b) The contribution is based upon previous work that, to the best
-    of my knowledge, is covered under an appropriate open source
-    license and I have the right under that license to submit that
-    work with modifications, whether created in whole or in part
-    by me, under the same open source license (unless I am
-    permitted to submit under a different license), as indicated
-    in the file; or
-
-(c) The contribution was provided directly to me by some other
-    person who certified (a), (b) or (c) and I have not modified
-    it.
-
-(d) I understand and agree that this project and the contribution
-    are public and that a record of the contribution (including all
-    personal information I submit with it, including my sign-off) is
-    maintained indefinitely and may be redistributed consistent with
-    this project or the open source license(s) involved.

vendor/github.com/coreos/go-systemd/Jenkinsfile

@@ -1,38 +0,0 @@
-matrixJob('Periodic go-systemd builder') {
-    label('master')
-    displayName('Periodic go-systemd builder (master branch)')
-
-    scm {
-        git {
-            remote {
-                url('https://github.com/coreos/go-systemd.git')
-            }
-            branch('master')
-        }
-    }
-
-    concurrentBuild()
-
-    triggers {
-        cron('@daily')
-    }
-
-    axes {
-        label('os_type', 'debian-testing', 'fedora-24', 'fedora-25')
-    }
-
-    wrappers {
-        buildNameSetter {
-            template('go-systemd master (periodic #${BUILD_NUMBER})')
-            runAtStart(true)
-            runAtEnd(true)
-        }
-        timeout {
-            absolute(25)
-        }
-    }
-
-    steps {
-        shell('./scripts/jenkins/periodic-go-systemd-builder.sh')
-    }
-}

vendor/github.com/coreos/go-systemd/README.md

@@ -1,69 +0,0 @@
-# go-systemd
-
-[![Build Status](https://travis-ci.org/coreos/go-systemd.png?branch=master)](https://travis-ci.org/coreos/go-systemd)
-[![godoc](https://godoc.org/github.com/coreos/go-systemd?status.svg)](http://godoc.org/github.com/coreos/go-systemd)
-
-Go bindings to systemd. The project has several packages:
-
-- `activation` - for writing and using socket activation from Go
-- `daemon` - for notifying systemd of service status changes
-- `dbus` - for starting/stopping/inspecting running services and units
-- `journal` - for writing to systemd's logging service, journald
-- `sdjournal` - for reading from journald by wrapping its C API
-- `login1` - for integration with the systemd logind API
-- `machine1` - for registering machines/containers with systemd
-- `unit` - for (de)serialization and comparison of unit files
-
-## Socket Activation
-
-An example HTTP server using socket activation can be quickly set up by following this README on a Linux machine running systemd:
-
-https://github.com/coreos/go-systemd/tree/master/examples/activation/httpserver
-
-## systemd Service Notification
-
-The `daemon` package is an implementation of the [sd_notify protocol](https://www.freedesktop.org/software/systemd/man/sd_notify.html#Description). It can be used to inform systemd of service start-up completion, watchdog events, and other status changes.
-
-## D-Bus
-
-The `dbus` package connects to the [systemd D-Bus API](http://www.freedesktop.org/wiki/Software/systemd/dbus/) and lets you start, stop and introspect systemd units. The API docs are here:
-
-http://godoc.org/github.com/coreos/go-systemd/dbus
-
-### Debugging
-
-Create `/etc/dbus-1/system-local.conf` that looks like this:
-
-```
-<!DOCTYPE busconfig PUBLIC
-"-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
-"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
-<busconfig>
-    <policy user="root">
-        <allow eavesdrop="true"/>
-        <allow eavesdrop="true" send_destination="*"/>
-    </policy>
-</busconfig>
-```
-
-## Journal
-
-### Writing to the Journal
-
-Using the pure-Go `journal` package you can submit journal entries directly to systemd's journal, taking advantage of features like indexed key/value pairs for each log entry.
-
-### Reading from the Journal
-
-The `sdjournal` package provides read access to the journal by wrapping around journald's native C API; consequently it requires cgo and the journal headers to be available.
-
-## logind
-
-The `login1` package provides functions to integrate with the [systemd logind API](http://www.freedesktop.org/wiki/Software/systemd/logind/).
-
-## machined
-
-The `machine1` package allows interaction with the [systemd machined D-Bus API](http://www.freedesktop.org/wiki/Software/systemd/machined/).
-
-## Units
-
-The `unit` package provides various functions for working with [systemd unit files](http://www.freedesktop.org/software/systemd/man/systemd.unit.html).

vendor/github.com/coreos/go-systemd/activation/files_test.go

@@ -1,82 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package activation
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"os/exec"
-	"testing"
-)
-
-// correctStringWritten fails the text if the correct string wasn't written
-// to the other side of the pipe.
-func correctStringWritten(t *testing.T, r *os.File, expected string) bool {
-	bytes := make([]byte, len(expected))
-	io.ReadAtLeast(r, bytes, len(expected))
-
-	if string(bytes) != expected {
-		t.Fatalf("Unexpected string %s", string(bytes))
-	}
-
-	return true
-}
-
-// TestActivation forks out a copy of activation.go example and reads back two
-// strings from the pipes that are passed in.
-func TestActivation(t *testing.T) {
-	cmd := exec.Command("go", "run", "../examples/activation/activation.go")
-
-	r1, w1, _ := os.Pipe()
-	r2, w2, _ := os.Pipe()
-	cmd.ExtraFiles = []*os.File{
-		w1,
-		w2,
-	}
-
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, "LISTEN_FDS=2", "LISTEN_FDNAMES=fd1", "FIX_LISTEN_PID=1")
-
-	err := cmd.Run()
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-
-	correctStringWritten(t, r1, "Hello world: fd1")
-	correctStringWritten(t, r2, "Goodbye world: LISTEN_FD_4")
-}
-
-func TestActivationNoFix(t *testing.T) {
-	cmd := exec.Command("go", "run", "../examples/activation/activation.go")
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, "LISTEN_FDS=2")
-
-	out, _ := cmd.CombinedOutput()
-	if !bytes.Contains(out, []byte("No files")) {
-		t.Fatalf("Child didn't error out as expected")
-	}
-}
-
-func TestActivationNoFiles(t *testing.T) {
-	cmd := exec.Command("go", "run", "../examples/activation/activation.go")
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, "LISTEN_FDS=0", "FIX_LISTEN_PID=1")
-
-	out, _ := cmd.CombinedOutput()
-	if !bytes.Contains(out, []byte("No files")) {
-		t.Fatalf("Child didn't error out as expected")
-	}
-}

vendor/github.com/coreos/go-systemd/activation/listeners_test.go

@@ -1,86 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package activation
-
-import (
-	"io"
-	"net"
-	"os"
-	"os/exec"
-	"testing"
-)
-
-// correctStringWritten fails the text if the correct string wasn't written
-// to the other side of the pipe.
-func correctStringWrittenNet(t *testing.T, r net.Conn, expected string) bool {
-	bytes := make([]byte, len(expected))
-	io.ReadAtLeast(r, bytes, len(expected))
-
-	if string(bytes) != expected {
-		t.Fatalf("Unexpected string %s", string(bytes))
-	}
-
-	return true
-}
-
-// TestActivation forks out a copy of activation.go example and reads back two
-// strings from the pipes that are passed in.
-func TestListeners(t *testing.T) {
-	cmd := exec.Command("go", "run", "../examples/activation/listen.go")
-
-	l1, err := net.Listen("tcp", ":9999")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	l2, err := net.Listen("tcp", ":1234")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-
-	t1 := l1.(*net.TCPListener)
-	t2 := l2.(*net.TCPListener)
-
-	f1, _ := t1.File()
-	f2, _ := t2.File()
-
-	cmd.ExtraFiles = []*os.File{
-		f1,
-		f2,
-	}
-
-	r1, err := net.Dial("tcp", "127.0.0.1:9999")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	r1.Write([]byte("Hi"))
-
-	r2, err := net.Dial("tcp", "127.0.0.1:1234")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	r2.Write([]byte("Hi"))
-
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, "LISTEN_FDS=2", "LISTEN_FDNAMES=fd1:fd2", "FIX_LISTEN_PID=1")
-
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		println(string(out))
-		t.Fatalf(err.Error())
-	}
-
-	correctStringWrittenNet(t, r1, "Hello world: fd1")
-	correctStringWrittenNet(t, r2, "Goodbye world: fd2")
-}

vendor/github.com/coreos/go-systemd/activation/packetconns_test.go

@@ -1,68 +0,0 @@
-// Copyright 2015 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package activation
-
-import (
-	"net"
-	"os"
-	"os/exec"
-	"testing"
-)
-
-// TestActivation forks out a copy of activation.go example and reads back two
-// strings from the pipes that are passed in.
-func TestPacketConns(t *testing.T) {
-	cmd := exec.Command("go", "run", "../examples/activation/udpconn.go")
-
-	u1, err := net.ListenUDP("udp", &net.UDPAddr{Port: 9999})
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	u2, err := net.ListenUDP("udp", &net.UDPAddr{Port: 1234})
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-
-	f1, _ := u1.File()
-	f2, _ := u2.File()
-
-	cmd.ExtraFiles = []*os.File{
-		f1,
-		f2,
-	}
-
-	r1, err := net.Dial("udp", "127.0.0.1:9999")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	r1.Write([]byte("Hi"))
-
-	r2, err := net.Dial("udp", "127.0.0.1:1234")
-	if err != nil {
-		t.Fatalf(err.Error())
-	}
-	r2.Write([]byte("Hi"))
-
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, "LISTEN_FDS=2", "LISTEN_FDNAMES=fd1:fd2", "FIX_LISTEN_PID=1")
-
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("Cmd output '%s', err: '%s'\n", out, err)
-	}
-
-	correctStringWrittenNet(t, r1, "Hello world")
-	correctStringWrittenNet(t, r2, "Goodbye world")
-}

vendor/github.com/coreos/go-systemd/code-of-conduct.md

@@ -1,61 +0,0 @@
-## CoreOS Community Code of Conduct
-
-### Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of
-fostering an open and welcoming community, we pledge to respect all people who
-contribute through reporting issues, posting feature requests, updating
-documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free
-experience for everyone, regardless of level of experience, gender, gender
-identity and expression, sexual orientation, disability, personal appearance,
-body size, race, ethnicity, age, religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing others' private information, such as physical or electronic addresses, without explicit permission
-* Other unethical or unprofessional conduct.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct. By adopting this Code of Conduct,
-project maintainers commit themselves to fairly and consistently applying these
-principles to every aspect of managing this project. Project maintainers who do
-not follow or enforce the Code of Conduct may be permanently removed from the
-project team.
-
-This code of conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting a project maintainer, Brandon Philips
-<brandon.philips@coreos.com>, and/or Rithu John <rithu.john@coreos.com>.
-
-This Code of Conduct is adapted from the Contributor Covenant
-(http://contributor-covenant.org), version 1.2.0, available at
-http://contributor-covenant.org/version/1/2/0/
-
-### CoreOS Events Code of Conduct
-
-CoreOS events are working conferences intended for professional networking and
-collaboration in the CoreOS community. Attendees are expected to behave
-according to professional standards and in accordance with their employer’s
-policies on appropriate workplace behavior.
-
-While at CoreOS events or related social networking opportunities, attendees
-should not engage in discriminatory or offensive speech or actions including
-but not limited to gender, sexuality, race, age, disability, or religion.
-Speakers should be especially aware of these concerns.
-
-CoreOS does not condone any statements by speakers contrary to these standards.
-CoreOS reserves the right to deny entrance and/or eject from an event (without
-refund) any individual found to be engaging in discriminatory or offensive
-speech or actions.
-
-Please bring any concerns to the immediate attention of designated on-site
-staff, Brandon Philips <brandon.philips@coreos.com>, and/or Rithu John <rithu.john@coreos.com>.

vendor/github.com/coreos/go-systemd/daemon/sdnotify_test.go

@@ -1,79 +0,0 @@
-// Copyright 2016 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package daemon
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net"
-	"os"
-	"testing"
-)
-
-// TestSdNotify
-func TestSdNotify(t *testing.T) {
-
-	testDir, e := ioutil.TempDir("/tmp/", "test-")
-	if e != nil {
-		panic(e)
-	}
-	defer os.RemoveAll(testDir)
-
-	notifySocket := testDir + "/notify-socket.sock"
-	laddr := net.UnixAddr{
-		Name: notifySocket,
-		Net:  "unixgram",
-	}
-	_, e = net.ListenUnixgram("unixgram", &laddr)
-	if e != nil {
-		panic(e)
-	}
-
-	tests := []struct {
-		unsetEnv  bool
-		envSocket string
-
-		wsent bool
-		werr  bool
-	}{
-		// (true, nil) - notification supported, data has been sent
-		{false, notifySocket, true, false},
-		// (false, err) - notification supported, but failure happened
-		{true, testDir + "/missing.sock", false, true},
-		// (false, nil) - notification not supported
-		{true, "", false, false},
-	}
-
-	for i, tt := range tests {
-		must(os.Unsetenv("NOTIFY_SOCKET"))
-		if tt.envSocket != "" {
-			must(os.Setenv("NOTIFY_SOCKET", tt.envSocket))
-		}
-		sent, err := SdNotify(tt.unsetEnv, fmt.Sprintf("TestSdNotify test message #%d", i))
-
-		if sent != tt.wsent {
-			t.Errorf("#%d: expected send result %t, got %t", i, tt.wsent, sent)
-		}
-		if tt.werr && err == nil {
-			t.Errorf("#%d: want non-nil err, got nil", i)
-		} else if !tt.werr && err != nil {
-			t.Errorf("#%d: want nil err, got %v", i, err)
-		}
-		if tt.unsetEnv && tt.envSocket != "" && os.Getenv("NOTIFY_SOCKET") != "" {
-			t.Errorf("#%d: environment variable not cleaned up", i)
-		}
-
-	}
-}

vendor/github.com/coreos/go-systemd/daemon/watchdog_test.go

@@ -1,85 +0,0 @@
-// Copyright 2016 CoreOS, Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package daemon
-
-import (
-	"os"
-	"strconv"
-	"testing"
-	"time"
-)
-
-func must(err error) {
-	if err != nil {
-		panic(err)
-	}
-}
-
-func TestSdWatchdogEnabled(t *testing.T) {
-	mypid := strconv.Itoa(os.Getpid())
-	tests := []struct {
-		usec     string // empty => unset
-		pid      string // empty => unset
-		unsetEnv bool   // arbitrarily set across testcases
-
-		werr   bool
-		wdelay time.Duration
-	}{
-		// Success cases
-		{"100", mypid, true, false, 100 * time.Microsecond},
-		{"50", mypid, true, false, 50 * time.Microsecond},
-		{"1", mypid, false, false, 1 * time.Microsecond},
-		{"1", "", true, false, 1 * time.Microsecond},
-
-		// No-op cases
-		{"", mypid, true, false, 0}, // WATCHDOG_USEC not set
-		{"1", "0", false, false, 0}, // WATCHDOG_PID doesn't match
-		{"", "", true, false, 0},    // Both not set
-
-		// Failure cases
-		{"-1", mypid, true, true, 0},                // Negative USEC
-		{"string", "1", false, true, 0},             // Non-integer USEC value
-		{"1", "string", true, true, 0},              // Non-integer PID value
-		{"stringa", "stringb", false, true, 0},      // E v e r y t h i n g
-		{"-10239", "-eleventythree", true, true, 0}, // i s   w r o n g
-	}
-
-	for i, tt := range tests {
-		if tt.usec != "" {
-			must(os.Setenv("WATCHDOG_USEC", tt.usec))
-		} else {
-			must(os.Unsetenv("WATCHDOG_USEC"))
-		}
-		if tt.pid != "" {
-			must(os.Setenv("WATCHDOG_PID", tt.pid))
-		} else {
-			must(os.Unsetenv("WATCHDOG_PID"))
-		}
-
-		delay, err := SdWatchdogEnabled(tt.unsetEnv)
-
-		if tt.werr && err == nil {
-			t.Errorf("#%d: want non-nil err, got nil", i)
-		} else if !tt.werr && err != nil {
-			t.Errorf("#%d: want nil err, got %v", i, err)
-		}
-		if tt.wdelay != delay {
-			t.Errorf("#%d: want delay=%d, got %d", i, tt.wdelay, delay)
-		}
-		if tt.unsetEnv && (os.Getenv("WATCHDOG_PID") != "" || os.Getenv("WATCHDOG_USEC") != "") {
-			t.Errorf("#%d: environment variables not cleaned up", i)
-		}
-	}
-}

vendor/github.com/coreos/go-systemd/test

@@ -1,88 +0,0 @@
-#!/bin/bash -e
-#
-# Run all tests
-#   ./test
-#   ./test -v
-#
-# Run tests for one package
-#   PKG=./foo ./test
-#   PKG=bar ./test
-#
-
-# Invoke ./cover for HTML output
-COVER=${COVER:-"-cover"}
-
-PROJ="go-systemd"
-ORG_PATH="github.com/coreos"
-REPO_PATH="${ORG_PATH}/${PROJ}"
-
-# As a convenience, set up a self-contained GOPATH if none set
-if [ -z "$GOPATH" ]; then
-	if [ ! -h gopath/src/${REPO_PATH} ]; then
-		mkdir -p gopath/src/${ORG_PATH}
-		ln -s ../../../.. gopath/src/${REPO_PATH} || exit 255
-	fi
-	export GOPATH=${PWD}/gopath
-	go get -u github.com/godbus/dbus
-	go get -u github.com/coreos/pkg/dlopen
-fi
-
-TESTABLE="activation daemon journal login1 unit"
-FORMATTABLE="$TESTABLE sdjournal dbus machine1"
-if [ -e "/run/systemd/system/" ]; then
-	# if we're on a systemd-system, we can test sdjournal
-	TESTABLE="${TESTABLE} sdjournal"
-	if [ "$EUID" == "0" ]; then
-		# testing actual systemd/machined behaviour requires root
-		TESTABLE="${TESTABLE} dbus machine1"
-	fi
-fi
-
-
-# user has not provided PKG override
-if [ -z "$PKG" ]; then
-	TEST=$TESTABLE
-	FMT=$FORMATTABLE
-
-# user has provided PKG override
-else
-	# strip out slashes and dots from PKG=./foo/
-	TEST=${PKG//\//}
-	TEST=${TEST//./}
-
-	# only run gofmt on packages provided by user
-	FMT="$TEST"
-fi
-
-# split TEST into an array and prepend REPO_PATH to each local package
-split=(${TEST// / })
-TEST=${split[@]/#/${REPO_PATH}/}
-
-echo "Running tests..."
-go test -v ${COVER} $@ ${TEST}
-
-echo "Checking gofmt..."
-fmtRes=$(gofmt -l $FMT)
-if [ -n "${fmtRes}" ]; then
-	echo -e "gofmt checking failed:\n${fmtRes}"
-	exit 255
-fi
-
-echo "Checking govet..."
-vetRes=$(go vet $TEST)
-if [ -n "${vetRes}" ]; then
-	echo -e "govet checking failed:\n${vetRes}"
-	exit 255
-fi
-
-echo "Checking for license header..."
-licRes=$(for file in $(find . -type f -iname '*.go' ! -path './gopath/*'); do
-		head -n3 "${file}" | grep -Eq "(Copyright|generated|GENERATED)" || echo -e "  ${file}"
-	done;)
-if [ -n "${licRes}" ]; then
-	echo -e "license header checking failed:\n${licRes}"
-	exit 255
-fi
-
-
-echo "Success"

vendor/github.com/dchest/safefile/safefile_test.go

@@ -1,155 +0,0 @@
-package safefile
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-func ensureFileContains(name, data string) error {
-	b, err := ioutil.ReadFile(name)
-	if err != nil {
-		return err
-	}
-	if string(b) != data {
-		return fmt.Errorf("wrong data in file: expected %s, got %s", data, string(b))
-	}
-	return nil
-}
-
-func tempFileName(count int) string {
-	return filepath.Join(os.TempDir(), fmt.Sprintf("safefile-test-%d-%x", count, time.Now().UnixNano()))
-}
-
-var testData = "Hello, this is a test data"
-
-func testInTempDir() error {
-	name := tempFileName(0)
-	defer os.Remove(name)
-	f, err := Create(name, 0666)
-	if err != nil {
-		return err
-	}
-	if name != f.OrigName() {
-		f.Close()
-		return fmt.Errorf("name %q differs from OrigName: %q", name, f.OrigName())
-	}
-	_, err = io.WriteString(f, testData)
-	if err != nil {
-		f.Close()
-		return err
-	}
-	err = f.Commit()
-	if err != nil {
-		f.Close()
-		return err
-	}
-	err = f.Close()
-	if err != nil {
-		return err
-	}
-	return ensureFileContains(name, testData)
-}
-
-func TestMakeTempName(t *testing.T) {
-	// Make sure temp name is random.
-	m := make(map[string]bool)
-	for i := 0; i < 100; i++ {
-		name, err := makeTempName("/tmp", "sf")
-		if err != nil {
-			t.Fatal(err)
-		}
-		if m[name] {
-			t.Fatal("repeated file name")
-		}
-		m[name] = true
-	}
-}
-
-func TestFile(t *testing.T) {
-	err := testInTempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestWriteFile(t *testing.T) {
-	name := tempFileName(1)
-	err := WriteFile(name, []byte(testData), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = ensureFileContains(name, testData)
-	if err != nil {
-		os.Remove(name)
-		t.Fatal(err)
-	}
-	os.Remove(name)
-}
-
-func TestAbandon(t *testing.T) {
-	name := tempFileName(2)
-	f, err := Create(name, 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = f.Close()
-	if err != nil {
-		t.Fatalf("Abandon failed: %s", err)
-	}
-	// Make sure temporary file doesn't exist.
-	_, err = os.Stat(f.Name())
-	if err != nil && !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-}
-
-func TestDoubleCommit(t *testing.T) {
-	name := tempFileName(3)
-	f, err := Create(name, 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = f.Commit()
-	if err != nil {
-		os.Remove(name)
-		t.Fatalf("First commit failed: %s", err)
-	}
-	err = f.Commit()
-	if err != ErrAlreadyCommitted {
-		os.Remove(name)
-		t.Fatalf("Second commit didn't fail: %s", err)
-	}
-	err = f.Close()
-	if err != nil {
-		os.Remove(name)
-		t.Fatalf("Close failed: %s", err)
-	}
-	os.Remove(name)
-}
-
-func TestOverwriting(t *testing.T) {
-	name := tempFileName(4)
-	defer os.Remove(name)
-
-	olddata := "This is old data"
-	err := ioutil.WriteFile(name, []byte(olddata), 0600)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	newdata := "This is new data"
-	err = WriteFile(name, []byte(newdata), 0600)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = ensureFileContains(name, newdata)
-	if err != nil {
-		t.Fatal(err)
-	}
-}

vendor/github.com/facebookgo/atomicfile/atomicfile_test.go

@@ -1,86 +0,0 @@
-package atomicfile_test
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"github.com/facebookgo/atomicfile"
-)
-
-func test(t *testing.T, dir, prefix string) {
-	t.Parallel()
-
-	tmpfile, err := ioutil.TempFile(dir, prefix)
-	if err != nil {
-		t.Fatal(err)
-	}
-	name := tmpfile.Name()
-
-	if err := os.Remove(name); err != nil {
-		t.Fatal(err)
-	}
-
-	defer os.Remove(name)
-	f, err := atomicfile.New(name, os.FileMode(0666))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.Write([]byte("foo"))
-	if _, err := os.Stat(name); !os.IsNotExist(err) {
-		t.Fatal("did not expect file to exist")
-	}
-	if err := f.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(name); err != nil {
-		t.Fatalf("expected file to exist: %s", err)
-	}
-}
-
-func TestCurrentDir(t *testing.T) {
-	cwd, _ := os.Getwd()
-	test(t, cwd, "atomicfile-current-dir-")
-}
-
-func TestRootTmpDir(t *testing.T) {
-	test(t, "/tmp", "atomicfile-root-tmp-dir-")
-}
-
-func TestDefaultTmpDir(t *testing.T) {
-	test(t, "", "atomicfile-default-tmp-dir-")
-}
-
-func TestAbort(t *testing.T) {
-	contents := []byte("the answer is 42")
-	t.Parallel()
-	tmpfile, err := ioutil.TempFile("", "atomicfile-abort-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	name := tmpfile.Name()
-	if _, err := tmpfile.Write(contents); err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(name)
-
-	f, err := atomicfile.New(name, os.FileMode(0666))
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.Write([]byte("foo"))
-	if err := f.Abort(); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(name); err != nil {
-		t.Fatalf("expected file to exist: %s", err)
-	}
-	actual, err := ioutil.ReadFile(name)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(contents, actual) {
-		t.Fatalf(`did not find expected "%s" instead found "%s"`, contents, actual)
-	}
-}

vendor/github.com/facebookgo/pidfile/pidfile_test.go

@@ -1,108 +0,0 @@
-package pidfile_test
-
-import (
-	"errors"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/facebookgo/pidfile"
-)
-
-// Make a temporary file, remove it, and return it's path with the hopes that
-// no one else create a file with that name.
-func tempfilename(t *testing.T) string {
-	file, err := ioutil.TempFile("", "pidfile-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = file.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = os.Remove(file.Name())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return file.Name()
-}
-
-func TestGetSetPath(t *testing.T) {
-	p := tempfilename(t)
-	defer os.Remove(p)
-	pidfile.SetPidfilePath(p)
-
-	if a := pidfile.GetPidfilePath(); a != p {
-		t.Fatalf("was expecting %s but got %s", p, a)
-	}
-}
-
-func TestSimple(t *testing.T) {
-	p := tempfilename(t)
-	defer os.Remove(p)
-	pidfile.SetPidfilePath(p)
-
-	if err := pidfile.Write(); err != nil {
-		t.Fatal(err)
-	}
-
-	pid, err := pidfile.Read()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if os.Getpid() != pid {
-		t.Fatalf("was expecting %d but got %d", os.Getpid(), pid)
-	}
-}
-
-func TestPidfileNotConfigured(t *testing.T) {
-	pidfile.SetPidfilePath("")
-
-	err := pidfile.Write()
-	if err == nil {
-		t.Fatal("was expecting an error")
-	}
-	if !pidfile.IsNotConfigured(err) {
-		t.Fatalf("was expecting IsNotConfigured error but got: %s", err)
-	}
-
-	_, err = pidfile.Read()
-	if err == nil {
-		t.Fatal("was expecting an error")
-	}
-	if !pidfile.IsNotConfigured(err) {
-		t.Fatalf("was expecting IsNotConfigured error but got: %s", err)
-	}
-}
-
-func TestNonIsConfiguredError(t *testing.T) {
-	err := errors.New("foo")
-	if pidfile.IsNotConfigured(err) {
-		t.Fatal("should be false")
-	}
-}
-
-func TestMakesDirectories(t *testing.T) {
-	dir := tempfilename(t)
-	defer os.RemoveAll(dir)
-	p := filepath.Join(dir, "pidfile")
-	pidfile.SetPidfilePath(p)
-
-	if err := pidfile.Write(); err != nil {
-		t.Fatal(err)
-	}
-
-	pid, err := pidfile.Read()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if os.Getpid() != pid {
-		t.Fatalf("was expecting %d but got %d", os.Getpid(), pid)
-	}
-}

vendor/github.com/hashicorp/golang-lru/2q_test.go

@@ -1,306 +0,0 @@
-package lru
-
-import (
-	"math/rand"
-	"testing"
-)
-
-func Benchmark2Q_Rand(b *testing.B) {
-	l, err := New2Q(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		trace[i] = rand.Int63() % 32768
-	}
-
-	b.ResetTimer()
-
-	var hit, miss int
-	for i := 0; i < 2*b.N; i++ {
-		if i%2 == 0 {
-			l.Add(trace[i], trace[i])
-		} else {
-			_, ok := l.Get(trace[i])
-			if ok {
-				hit++
-			} else {
-				miss++
-			}
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func Benchmark2Q_Freq(b *testing.B) {
-	l, err := New2Q(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		if i%2 == 0 {
-			trace[i] = rand.Int63() % 16384
-		} else {
-			trace[i] = rand.Int63() % 32768
-		}
-	}
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		l.Add(trace[i], trace[i])
-	}
-	var hit, miss int
-	for i := 0; i < b.N; i++ {
-		_, ok := l.Get(trace[i])
-		if ok {
-			hit++
-		} else {
-			miss++
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func Test2Q_RandomOps(t *testing.T) {
-	size := 128
-	l, err := New2Q(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	n := 200000
-	for i := 0; i < n; i++ {
-		key := rand.Int63() % 512
-		r := rand.Int63()
-		switch r % 3 {
-		case 0:
-			l.Add(key, key)
-		case 1:
-			l.Get(key)
-		case 2:
-			l.Remove(key)
-		}
-
-		if l.recent.Len()+l.frequent.Len() > size {
-			t.Fatalf("bad: recent: %d freq: %d",
-				l.recent.Len(), l.frequent.Len())
-		}
-	}
-}
-
-func Test2Q_Get_RecentToFrequent(t *testing.T) {
-	l, err := New2Q(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Touch all the entries, should be in t1
-	for i := 0; i < 128; i++ {
-		l.Add(i, i)
-	}
-	if n := l.recent.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Get should upgrade to t2
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("missing: %d", i)
-		}
-	}
-	if n := l.recent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Get be from t2
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("missing: %d", i)
-		}
-	}
-	if n := l.recent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func Test2Q_Add_RecentToFrequent(t *testing.T) {
-	l, err := New2Q(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Add initially to recent
-	l.Add(1, 1)
-	if n := l.recent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add should upgrade to frequent
-	l.Add(1, 1)
-	if n := l.recent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add should remain in frequent
-	l.Add(1, 1)
-	if n := l.recent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func Test2Q_Add_RecentEvict(t *testing.T) {
-	l, err := New2Q(4)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Add 1,2,3,4,5 -> Evict 1
-	l.Add(1, 1)
-	l.Add(2, 2)
-	l.Add(3, 3)
-	l.Add(4, 4)
-	l.Add(5, 5)
-	if n := l.recent.Len(); n != 4 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.recentEvict.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Pull in the recently evicted
-	l.Add(1, 1)
-	if n := l.recent.Len(); n != 3 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.recentEvict.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add 6, should cause another recent evict
-	l.Add(6, 6)
-	if n := l.recent.Len(); n != 3 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.recentEvict.Len(); n != 2 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func Test2Q(t *testing.T) {
-	l, err := New2Q(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		l.Remove(i)
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-// Test that Contains doesn't update recent-ness
-func Test2Q_Contains(t *testing.T) {
-	l, err := New2Q(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// Test that Peek doesn't update recent-ness
-func Test2Q_Peek(t *testing.T) {
-	l, err := New2Q(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

vendor/github.com/hashicorp/golang-lru/arc_test.go

@@ -1,377 +0,0 @@
-package lru
-
-import (
-	"math/rand"
-	"testing"
-	"time"
-)
-
-func init() {
-	rand.Seed(time.Now().Unix())
-}
-
-func BenchmarkARC_Rand(b *testing.B) {
-	l, err := NewARC(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		trace[i] = rand.Int63() % 32768
-	}
-
-	b.ResetTimer()
-
-	var hit, miss int
-	for i := 0; i < 2*b.N; i++ {
-		if i%2 == 0 {
-			l.Add(trace[i], trace[i])
-		} else {
-			_, ok := l.Get(trace[i])
-			if ok {
-				hit++
-			} else {
-				miss++
-			}
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func BenchmarkARC_Freq(b *testing.B) {
-	l, err := NewARC(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		if i%2 == 0 {
-			trace[i] = rand.Int63() % 16384
-		} else {
-			trace[i] = rand.Int63() % 32768
-		}
-	}
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		l.Add(trace[i], trace[i])
-	}
-	var hit, miss int
-	for i := 0; i < b.N; i++ {
-		_, ok := l.Get(trace[i])
-		if ok {
-			hit++
-		} else {
-			miss++
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func TestARC_RandomOps(t *testing.T) {
-	size := 128
-	l, err := NewARC(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	n := 200000
-	for i := 0; i < n; i++ {
-		key := rand.Int63() % 512
-		r := rand.Int63()
-		switch r % 3 {
-		case 0:
-			l.Add(key, key)
-		case 1:
-			l.Get(key)
-		case 2:
-			l.Remove(key)
-		}
-
-		if l.t1.Len()+l.t2.Len() > size {
-			t.Fatalf("bad: t1: %d t2: %d b1: %d b2: %d p: %d",
-				l.t1.Len(), l.t2.Len(), l.b1.Len(), l.b2.Len(), l.p)
-		}
-		if l.b1.Len()+l.b2.Len() > size {
-			t.Fatalf("bad: t1: %d t2: %d b1: %d b2: %d p: %d",
-				l.t1.Len(), l.t2.Len(), l.b1.Len(), l.b2.Len(), l.p)
-		}
-	}
-}
-
-func TestARC_Get_RecentToFrequent(t *testing.T) {
-	l, err := NewARC(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Touch all the entries, should be in t1
-	for i := 0; i < 128; i++ {
-		l.Add(i, i)
-	}
-	if n := l.t1.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Get should upgrade to t2
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("missing: %d", i)
-		}
-	}
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Get be from t2
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("missing: %d", i)
-		}
-	}
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func TestARC_Add_RecentToFrequent(t *testing.T) {
-	l, err := NewARC(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Add initially to t1
-	l.Add(1, 1)
-	if n := l.t1.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add should upgrade to t2
-	l.Add(1, 1)
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add should remain in t2
-	l.Add(1, 1)
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func TestARC_Adaptive(t *testing.T) {
-	l, err := NewARC(4)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Fill t1
-	for i := 0; i < 4; i++ {
-		l.Add(i, i)
-	}
-	if n := l.t1.Len(); n != 4 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Move to t2
-	l.Get(0)
-	l.Get(1)
-	if n := l.t2.Len(); n != 2 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Evict from t1
-	l.Add(4, 4)
-	if n := l.b1.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Current state
-	// t1 : (MRU) [4, 3] (LRU)
-	// t2 : (MRU) [1, 0] (LRU)
-	// b1 : (MRU) [2] (LRU)
-	// b2 : (MRU) [] (LRU)
-
-	// Add 2, should cause hit on b1
-	l.Add(2, 2)
-	if n := l.b1.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if l.p != 1 {
-		t.Fatalf("bad: %d", l.p)
-	}
-	if n := l.t2.Len(); n != 3 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Current state
-	// t1 : (MRU) [4] (LRU)
-	// t2 : (MRU) [2, 1, 0] (LRU)
-	// b1 : (MRU) [3] (LRU)
-	// b2 : (MRU) [] (LRU)
-
-	// Add 4, should migrate to t2
-	l.Add(4, 4)
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 4 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Current state
-	// t1 : (MRU) [] (LRU)
-	// t2 : (MRU) [4, 2, 1, 0] (LRU)
-	// b1 : (MRU) [3] (LRU)
-	// b2 : (MRU) [] (LRU)
-
-	// Add 4, should evict to b2
-	l.Add(5, 5)
-	if n := l.t1.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 3 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.b2.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Current state
-	// t1 : (MRU) [5] (LRU)
-	// t2 : (MRU) [4, 2, 1] (LRU)
-	// b1 : (MRU) [3] (LRU)
-	// b2 : (MRU) [0] (LRU)
-
-	// Add 0, should decrease p
-	l.Add(0, 0)
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 4 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.b1.Len(); n != 2 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.b2.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if l.p != 0 {
-		t.Fatalf("bad: %d", l.p)
-	}
-
-	// Current state
-	// t1 : (MRU) [] (LRU)
-	// t2 : (MRU) [0, 4, 2, 1] (LRU)
-	// b1 : (MRU) [5, 3] (LRU)
-	// b2 : (MRU) [0] (LRU)
-}
-
-func TestARC(t *testing.T) {
-	l, err := NewARC(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		l.Remove(i)
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-// Test that Contains doesn't update recent-ness
-func TestARC_Contains(t *testing.T) {
-	l, err := NewARC(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// Test that Peek doesn't update recent-ness
-func TestARC_Peek(t *testing.T) {
-	l, err := NewARC(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

vendor/github.com/hashicorp/golang-lru/lru_test.go

@@ -1,221 +0,0 @@
-package lru
-
-import (
-	"math/rand"
-	"testing"
-)
-
-func BenchmarkLRU_Rand(b *testing.B) {
-	l, err := New(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		trace[i] = rand.Int63() % 32768
-	}
-
-	b.ResetTimer()
-
-	var hit, miss int
-	for i := 0; i < 2*b.N; i++ {
-		if i%2 == 0 {
-			l.Add(trace[i], trace[i])
-		} else {
-			_, ok := l.Get(trace[i])
-			if ok {
-				hit++
-			} else {
-				miss++
-			}
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func BenchmarkLRU_Freq(b *testing.B) {
-	l, err := New(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		if i%2 == 0 {
-			trace[i] = rand.Int63() % 16384
-		} else {
-			trace[i] = rand.Int63() % 32768
-		}
-	}
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		l.Add(trace[i], trace[i])
-	}
-	var hit, miss int
-	for i := 0; i < b.N; i++ {
-		_, ok := l.Get(trace[i])
-		if ok {
-			hit++
-		} else {
-			miss++
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func TestLRU(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		if k != v {
-			t.Fatalf("Evict values not equal (%v!=%v)", k, v)
-		}
-		evictCounter++
-	}
-	l, err := NewWithEvict(128, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	if evictCounter != 128 {
-		t.Fatalf("bad evict count: %v", evictCounter)
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		l.Remove(i)
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Get(192) // expect 192 to be last key in l.Keys()
-
-	for i, k := range l.Keys() {
-		if (i < 63 && k != i+193) || (i == 63 && k != 192) {
-			t.Fatalf("out of order key: %v", k)
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-// test that Add returns true/false if an eviction occurred
-func TestLRUAdd(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		evictCounter++
-	}
-
-	l, err := NewWithEvict(1, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	if l.Add(1, 1) == true || evictCounter != 0 {
-		t.Errorf("should not have an eviction")
-	}
-	if l.Add(2, 2) == false || evictCounter != 1 {
-		t.Errorf("should have an eviction")
-	}
-}
-
-// test that Contains doesn't update recent-ness
-func TestLRUContains(t *testing.T) {
-	l, err := New(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// test that Contains doesn't update recent-ness
-func TestLRUContainsOrAdd(t *testing.T) {
-	l, err := New(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	contains, evict := l.ContainsOrAdd(1, 1)
-	if !contains {
-		t.Errorf("1 should be contained")
-	}
-	if evict {
-		t.Errorf("nothing should be evicted here")
-	}
-
-	l.Add(3, 3)
-	contains, evict = l.ContainsOrAdd(1, 1)
-	if contains {
-		t.Errorf("1 should not have been contained")
-	}
-	if !evict {
-		t.Errorf("an eviction should have occurred")
-	}
-	if !l.Contains(1) {
-		t.Errorf("now 1 should be contained")
-	}
-}
-
-// test that Peek doesn't update recent-ness
-func TestLRUPeek(t *testing.T) {
-	l, err := New(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

vendor/github.com/hashicorp/golang-lru/simplelru/lru_test.go

@@ -1,167 +0,0 @@
-package simplelru
-
-import "testing"
-
-func TestLRU(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		if k != v {
-			t.Fatalf("Evict values not equal (%v!=%v)", k, v)
-		}
-		evictCounter++
-	}
-	l, err := NewLRU(128, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	if evictCounter != 128 {
-		t.Fatalf("bad evict count: %v", evictCounter)
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		ok := l.Remove(i)
-		if !ok {
-			t.Fatalf("should be contained")
-		}
-		ok = l.Remove(i)
-		if ok {
-			t.Fatalf("should not be contained")
-		}
-		_, ok = l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Get(192) // expect 192 to be last key in l.Keys()
-
-	for i, k := range l.Keys() {
-		if (i < 63 && k != i+193) || (i == 63 && k != 192) {
-			t.Fatalf("out of order key: %v", k)
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-func TestLRU_GetOldest_RemoveOldest(t *testing.T) {
-	l, err := NewLRU(128, nil)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	k, _, ok := l.GetOldest()
-	if !ok {
-		t.Fatalf("missing")
-	}
-	if k.(int) != 128 {
-		t.Fatalf("bad: %v", k)
-	}
-
-	k, _, ok = l.RemoveOldest()
-	if !ok {
-		t.Fatalf("missing")
-	}
-	if k.(int) != 128 {
-		t.Fatalf("bad: %v", k)
-	}
-
-	k, _, ok = l.RemoveOldest()
-	if !ok {
-		t.Fatalf("missing")
-	}
-	if k.(int) != 129 {
-		t.Fatalf("bad: %v", k)
-	}
-}
-
-// Test that Add returns true/false if an eviction occurred
-func TestLRU_Add(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		evictCounter++
-	}
-
-	l, err := NewLRU(1, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	if l.Add(1, 1) == true || evictCounter != 0 {
-		t.Errorf("should not have an eviction")
-	}
-	if l.Add(2, 2) == false || evictCounter != 1 {
-		t.Errorf("should have an eviction")
-	}
-}
-
-// Test that Contains doesn't update recent-ness
-func TestLRU_Contains(t *testing.T) {
-	l, err := NewLRU(2, nil)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// Test that Peek doesn't update recent-ness
-func TestLRU_Peek(t *testing.T) {
-	l, err := NewLRU(2, nil)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

vendor/github.com/jedisct1/dlog/dlog_test.go

@@ -1,9 +0,0 @@
-package dlog
-
-func Example() {
-	Init("example", SeverityNotice, "")
-	// Call flag.Parse() around that time
-	Info("Application is starting")
-	Debugf("Counter value: %d", 0)
-	Fatal("Kaboom")
-}

vendor/github.com/jedisct1/xsecretbox/xsecretbox_test.go

@@ -1,26 +0,0 @@
-package xsecretbox
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestSecretbox(t *testing.T) {
-	key := [32]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
-	nonce := [24]byte{23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
-	src := []byte{42, 42, 42, 42, 42, 42, 42, 42, 42, 42}
-
-	dst := Seal(nil, nonce[:], src[:], key[:])
-	dec, err := Open(nil, nonce[:], dst[:], key[:])
-	if err != nil || !bytes.Equal(src, dec) {
-		t.Errorf("got %x instead of %x", dec, src)
-	}
-
-	dst[0]++
-	_, err = Open(nil, nonce[:], dst[:], key[:])
-	if err == nil {
-		t.Errorf("tag validation failed")
-	}
-
-	_, _ = SharedKey(key, key)
-}

vendor/github.com/k-sone/critbitgo/critbit_test.go

@@ -1,361 +0,0 @@
-package critbitgo_test
-
-import (
-	"bytes"
-	"math/rand"
-	"testing"
-
-	"github.com/k-sone/critbitgo"
-)
-
-func buildTrie(t *testing.T, keys []string) *critbitgo.Trie {
-	trie := critbitgo.NewTrie()
-	for _, key := range keys {
-		if !trie.Insert([]byte(key), key) {
-			t.Errorf("Insert() - failed insert \"%s\"\n%s", key, dumpTrie(trie))
-		}
-	}
-	return trie
-}
-
-func dumpTrie(trie *critbitgo.Trie) string {
-	buf := bytes.NewBufferString("")
-	trie.Dump(buf)
-	return buf.String()
-}
-
-func TestInsert(t *testing.T) {
-	// normal build
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	trie := buildTrie(t, keys)
-	dump := dumpTrie(trie)
-
-	// random build
-	random := rand.New(rand.NewSource(0))
-	for i := 0; i < 10; i++ {
-		// shuffle keys
-		lkeys := make([]string, len(keys))
-		for j, index := range random.Perm(len(keys)) {
-			lkeys[j] = keys[index]
-		}
-
-		ltrie := buildTrie(t, lkeys)
-		ldump := dumpTrie(ltrie)
-		if dump != ldump {
-			t.Errorf("Insert() - different tries\norigin:\n%s\nother:\n%s\n", dump, ldump)
-		}
-	}
-
-	// error check
-	if trie.Insert([]byte("a"), nil) {
-		t.Error("Insert() - check exists")
-	}
-	if !trie.Insert([]byte("c"), nil) {
-		t.Error("Insert() - check not exists")
-	}
-}
-
-func TestSet(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	trie := buildTrie(t, keys)
-
-	trie.Set([]byte("a"), 100)
-	v, _ := trie.Get([]byte("a"))
-	if n, ok := v.(int); !ok || n != 100 {
-		t.Errorf("Set() - failed replace - %v", v)
-	}
-}
-
-func TestContains(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	trie := buildTrie(t, keys)
-
-	for _, key := range keys {
-		if !trie.Contains([]byte(key)) {
-			t.Error("Contains() - not found - %s", key)
-		}
-	}
-
-	if trie.Contains([]byte("aaa")) {
-		t.Error("Contains() - phantom found")
-	}
-}
-
-func TestGet(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	trie := buildTrie(t, keys)
-
-	for _, key := range keys {
-		if value, ok := trie.Get([]byte(key)); value != key || !ok {
-			t.Error("Get() - not found - %s", key)
-		}
-	}
-
-	if value, ok := trie.Get([]byte("aaa")); value != nil || ok {
-		t.Error("Get() - phantom found")
-	}
-}
-
-func TestDelete(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	trie := buildTrie(t, keys)
-
-	for i, key := range keys {
-		if !trie.Contains([]byte(key)) {
-			t.Error("Delete() - not exists - %s", key)
-		}
-		if v, ok := trie.Delete([]byte(key)); !ok || v != key {
-			t.Error("Delete() - failed - %s", key)
-		}
-		if trie.Contains([]byte(key)) {
-			t.Error("Delete() - exists - %s", key)
-		}
-		if i != len(keys) {
-			for _, key2 := range keys[i+1:] {
-				if !trie.Contains([]byte(key2)) {
-					t.Errorf("Delete() - other not exists - %s", key2)
-				}
-			}
-		}
-	}
-}
-
-func TestSize(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	trie := buildTrie(t, keys)
-	klen := len(keys)
-	if s := trie.Size(); s != klen {
-		t.Errorf("Size() - expected [%s], actual [%s]", klen, s)
-	}
-
-	for i, key := range keys {
-		trie.Delete([]byte(key))
-		if s := trie.Size(); s != klen-(i+1) {
-			t.Errorf("Size() - expected [%s], actual [%s]", klen, s)
-		}
-	}
-}
-
-func TestAllprefixed(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab", "bc"}
-	trie := buildTrie(t, keys)
-
-	elems := make([]string, 0, len(keys))
-	handle := func(key []byte, value interface{}) bool {
-		if k := string(key); k == value {
-			elems = append(elems, k)
-		}
-		return true
-	}
-	if !trie.Allprefixed([]byte{}, handle) {
-		t.Error("Allprefixed() - invalid result")
-	}
-	if len(elems) != 10 {
-		t.Errorf("Allprefixed() - invalid elems length [%v]", elems)
-	}
-	for i, key := range []string{"", "a", "aa", "ab", "aba", "b", "ba", "bab", "bb", "bc"} {
-		if key != elems[i] {
-			t.Errorf("Allprefixed() - not found [%s]", key)
-		}
-	}
-
-	elems = make([]string, 0, len(keys))
-	if !trie.Allprefixed([]byte("a"), handle) {
-		t.Error("Allprefixed() - invalid result")
-	}
-	if len(elems) != 4 {
-		t.Errorf("Allprefixed() - invalid elems length [%v]", elems)
-	}
-	for i, key := range []string{"a", "aa", "ab", "aba"} {
-		if key != elems[i] {
-			t.Errorf("Allprefixed() - not found [%s]", key)
-		}
-	}
-
-	elems = make([]string, 0, len(keys))
-	if !trie.Allprefixed([]byte("bb"), handle) {
-		t.Error("Allprefixed() - invalid result")
-	}
-	if len(elems) != 1 {
-		t.Errorf("Allprefixed() - invalid elems length [%v]", elems)
-	}
-	for i, key := range []string{"bb"} {
-		if key != elems[i] {
-			t.Errorf("Allprefixed() - not found [%s]", key)
-		}
-	}
-
-	elems = make([]string, 0, len(keys))
-	handle = func(key []byte, value interface{}) bool {
-		if k := string(key); k == value {
-			elems = append(elems, k)
-		}
-		if string(key) == "aa" {
-			return false
-		}
-		return true
-	}
-	if trie.Allprefixed([]byte("a"), handle) {
-		t.Error("Allprefixed() - invalid result")
-	}
-	if len(elems) != 2 {
-		t.Errorf("Allprefixed() - invalid elems length [%v]", elems)
-	}
-	for i, key := range []string{"a", "aa"} {
-		if key != elems[i] {
-			t.Errorf("Allprefixed() - not found [%s]", key)
-		}
-	}
-}
-
-func TestLongestPrefix(t *testing.T) {
-	keys := []string{"a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	trie := buildTrie(t, keys)
-
-	expects := map[string]string{
-		"a":   "a",
-		"a^":  "a",
-		"aaa": "aa",
-		"abc": "ab",
-		"bac": "ba",
-		"bbb": "bb",
-		"bc":  "b",
-	}
-	for g, k := range expects {
-		if key, value, ok := trie.LongestPrefix([]byte(g)); !ok || string(key) != k || value != k {
-			t.Errorf("LongestPrefix() - invalid result - %s not %s", key, g)
-		}
-	}
-
-	if _, _, ok := trie.LongestPrefix([]byte{}); ok {
-		t.Error("LongestPrefix() - invalid result - not empty")
-	}
-	if _, _, ok := trie.LongestPrefix([]byte("^")); ok {
-		t.Error("LongestPrefix() - invalid result - not empty")
-	}
-	if _, _, ok := trie.LongestPrefix([]byte("c")); ok {
-		t.Error("LongestPrefix() - invalid result - not empty")
-	}
-}
-
-func TestWalk(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	trie := buildTrie(t, keys)
-
-	elems := make([]string, 0, len(keys))
-	handle := func(key []byte, value interface{}) bool {
-		if k := string(key); k == value {
-			elems = append(elems, k)
-		}
-		return true
-	}
-	if !trie.Walk([]byte{}, handle) {
-		t.Error("Walk() - invalid result")
-	}
-	if len(elems) != 9 {
-		t.Errorf("Walk() - invalid elems length [%v]", elems)
-	}
-	for i, key := range []string{"", "a", "aa", "ab", "aba", "b", "ba", "bab", "bb"} {
-		if key != elems[i] {
-			t.Errorf("Walk() - not found [%s]", key)
-		}
-	}
-
-	elems = make([]string, 0, len(keys))
-	if !trie.Walk([]byte("ab"), handle) {
-		t.Error("Walk() - invalid result")
-	}
-	if len(elems) != 6 {
-		t.Errorf("Walk() - invalid elems length [%v]", elems)
-	}
-	for i, key := range []string{"ab", "aba", "b", "ba", "bab", "bb"} {
-		if key != elems[i] {
-			t.Errorf("Walk() - not found [%s]", key)
-		}
-	}
-
-	elems = make([]string, 0, len(keys))
-	if !trie.Walk(nil, handle) {
-		t.Error("Walk() - invalid result")
-	}
-	if len(elems) != 9 {
-		t.Errorf("Walk() - invalid elems length [%v]", elems)
-	}
-	for i, key := range []string{"", "a", "aa", "ab", "aba", "b", "ba", "bab", "bb"} {
-		if key != elems[i] {
-			t.Errorf("Walk() - not found [%s]", key)
-		}
-	}
-
-	elems = make([]string, 0, len(keys))
-	handle = func(key []byte, value interface{}) bool {
-		if k := string(key); k == value {
-			elems = append(elems, k)
-		}
-		if string(key) == "aa" {
-			return false
-		}
-		return true
-	}
-	if trie.Walk([]byte("a"), handle) {
-		t.Error("Walk() - invalid result")
-	}
-	if len(elems) != 2 {
-		t.Errorf("Walk() - invalid elems length [%v]", elems)
-	}
-	for i, key := range []string{"a", "aa"} {
-		if key != elems[i] {
-			t.Errorf("Walk() - not found [%s]", key)
-		}
-	}
-
-	if trie.Walk([]byte("^"), handle) {
-		t.Error("Walk() - invalid result")
-	}
-	if trie.Walk([]byte("aaa"), handle) {
-		t.Error("Walk() - invalid result")
-	}
-	if trie.Walk([]byte("c"), handle) {
-		t.Error("Walk() - invalid result")
-	}
-}
-
-func TestKeyContainsZeroValue(t *testing.T) {
-	trie := critbitgo.NewTrie()
-	trie.Insert([]byte{1, 0, 1}, nil)
-	trie.Insert([]byte{1}, nil)
-	trie.Insert([]byte{0, 1, 1}, nil)
-	trie.Insert([]byte{}, nil)
-	trie.Insert([]byte{0, 0, 1}, nil)
-	trie.Insert([]byte{1, 1}, nil)
-	trie.Insert([]byte{1, 1, 1}, nil)
-	trie.Insert([]byte{0, 1}, nil)
-	trie.Insert([]byte{0, 1, 0}, nil)
-	trie.Insert([]byte{0, 0}, nil)
-	trie.Insert([]byte{0, 0, 0}, nil)
-	trie.Insert([]byte{0}, nil)
-
-	var index int
-	exp := [][]byte{
-		[]byte{},
-		[]byte{0},
-		[]byte{0, 0},
-		[]byte{0, 0, 0},
-		[]byte{0, 0, 1},
-		[]byte{0, 1},
-		[]byte{0, 1, 0},
-		[]byte{0, 1, 1},
-		[]byte{1},
-		[]byte{1, 0, 1},
-		[]byte{1, 1},
-		[]byte{1, 1, 1},
-	}
-	handle := func(key []byte, _ interface{}) bool {
-		if !bytes.Equal(exp[index], key) {
-			t.Errorf("Key Order - index=%d, expected [%x], actula [%x]", index, exp[index], key)
-		}
-		index += 1
-		return true
-	}
-	trie.Allprefixed([]byte(""), handle)
-}

vendor/github.com/k-sone/critbitgo/map_bench_test.go

@@ -1,119 +0,0 @@
-package critbitgo_test
-
-import (
-	"bytes"
-	"math/rand"
-	"sort"
-	"testing"
-)
-
-var keyCount int = 10000
-var keyLen int = 128
-
-var keys []string
-var alphabet string = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-var alphalen int = len(alphabet)
-
-func init() {
-	keys = make([]string, keyCount)
-	random := rand.New(rand.NewSource(0))
-	for i := 0; i < len(keys); i++ {
-		keys[i] = genRandomKey(random)
-	}
-}
-
-func genRandomKey(rand *rand.Rand) string {
-	buf := bytes.NewBufferString("")
-	for i := 0; i < keyLen; i++ {
-		buf.WriteByte(alphabet[rand.Intn(alphalen)])
-	}
-	return buf.String()
-}
-
-func buildMap(keys []string) map[string]string {
-	m := make(map[string]string)
-	for _, key := range keys {
-		m[key] = key
-	}
-	return m
-}
-
-func BenchmarkMapBuild(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		buildMap(keys)
-	}
-}
-
-func BenchmarkSortedMapBuild(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		buildSortedMap(keys)
-	}
-}
-
-func BenchmarkMapGet(b *testing.B) {
-	m := buildMap(keys)
-	random := rand.New(rand.NewSource(0))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		k := keys[random.Intn(keyCount)]
-		_ = m[k]
-	}
-}
-
-func BenchmarkSortedMapGet(b *testing.B) {
-	m := buildSortedMap(keys)
-	random := rand.New(rand.NewSource(0))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		k := keys[random.Intn(keyCount)]
-		_, _ = m.Get(k)
-	}
-}
-
-func BenchmarkMapDelete(b *testing.B) {
-	m := buildMap(keys)
-	random := rand.New(rand.NewSource(0))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		k := keys[random.Intn(keyCount)]
-		if _, ok := m[k]; ok {
-			delete(m, k)
-		}
-	}
-}
-
-func BenchmarkSortedMapDelete(b *testing.B) {
-	m := buildSortedMap(keys)
-	random := rand.New(rand.NewSource(0))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		k := keys[random.Intn(keyCount)]
-		m.Delete(k)
-	}
-}
-
-func BenchmarkMapKeys(b *testing.B) {
-	m := buildMap(keys)
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		list := make([]string, 0, len(m))
-		for _, k := range m {
-			list = append(list, k)
-		}
-		sort.Strings(list)
-	}
-}
-
-func BenchmarkSortedMapKeys(b *testing.B) {
-	m := buildSortedMap(keys)
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		m.Keys()
-	}
-}

vendor/github.com/k-sone/critbitgo/map_test.go

@@ -1,164 +0,0 @@
-package critbitgo_test
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/k-sone/critbitgo"
-)
-
-func buildSortedMap(keys []string) *critbitgo.SortedMap {
-	m := critbitgo.NewSortedMap()
-	for _, key := range keys {
-		m.Set(key, key)
-	}
-	return m
-}
-
-func TestSortedMapContains(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	m := buildSortedMap(keys)
-
-	for _, key := range keys {
-		if !m.Contains(key) {
-			t.Error("Contains() - not found - [%s]", key)
-		}
-	}
-
-	if m.Contains("aaa") {
-		t.Error("Contains() - phantom found")
-	}
-}
-
-func TestSortedMapGet(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	m := buildSortedMap(keys)
-
-	for _, key := range keys {
-		if value, ok := m.Get(key); !ok || value != key {
-			t.Error("Get() - not found - [%s]", key)
-		}
-	}
-
-	if value, ok := m.Get("aaa"); ok || value != nil {
-		t.Error("Get() - phantom found")
-	}
-}
-
-func TestSortedMapDelete(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	m := buildSortedMap(keys)
-
-	for i, key := range keys {
-		if !m.Contains(key) {
-			t.Error("Delete() - not exists - [%s]", key)
-		}
-		if value, ok := m.Delete(key); !ok || value != key {
-			t.Error("Delete() - failed - [%s]", key)
-		}
-		if m.Contains(key) {
-			t.Error("Delete() - exists - [%s]", key)
-		}
-		if value, ok := m.Delete(key); ok || value != nil {
-			t.Error("Delete() - phantom found - [%s]", key)
-		}
-		if i != len(keys) {
-			for _, key2 := range keys[i+1:] {
-				if !m.Contains(key2) {
-					t.Errorf("Delete() - other not exists - [%s](%s)", key2, key)
-				}
-			}
-		}
-	}
-}
-
-func TestSortedMapSize(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	m := buildSortedMap(keys)
-	klen := len(keys)
-	if s := m.Size(); s != klen {
-		t.Errorf("Size() - expected [%s], actual [%s]", klen, s)
-	}
-
-	for i, key := range keys {
-		m.Delete(key)
-		if s := m.Size(); s != klen-(i+1) {
-			t.Errorf("Size() - expected [%s], actual [%s]", klen, s)
-		}
-	}
-}
-
-func TestSortedMapKeys(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	m := buildSortedMap(keys)
-	skeys := m.Keys()
-	for _, key := range keys {
-		match := false
-		for _, skey := range skeys {
-			if key == skey {
-				match = true
-				break
-			}
-		}
-		if !match {
-			t.Errorf("Keys() - not found [%s]", key)
-		}
-	}
-}
-
-func TestSortedMapEach(t *testing.T) {
-	keys := []string{"", "a", "aa", "b", "bb", "ab", "ba", "aba", "bab"}
-	m := buildSortedMap(keys)
-
-	elems := make(map[string]interface{})
-	handle := func(key string, value interface{}) bool {
-		elems[key] = value
-		return true
-	}
-	if !m.Each("", handle) {
-		t.Error("Each() - invalid result")
-	}
-	for _, key := range keys {
-		if _, ok := elems[key]; !ok {
-			t.Errorf("Each() - not found [%s]", key)
-		} else if value, ok := elems[key].(string); !ok || value != key {
-			t.Errorf("Each() - invalid value [%s](%s)", value, key)
-		}
-	}
-
-	elems = make(map[string]interface{})
-	handle = func(key string, value interface{}) bool {
-		elems[key] = value
-		return true
-	}
-	if !m.Each("b", handle) {
-		t.Error("Each() - invalid result")
-	}
-	for _, key := range keys {
-		if strings.Index(key, "b") == 0 {
-			if _, ok := elems[key]; !ok {
-				t.Errorf("Each() - not found [%s]", key)
-			} else if value, ok := elems[key].(string); !ok || value != key {
-				t.Errorf("Each() - invalid value [%s](%s)", value, key)
-			}
-		} else {
-			if _, ok := elems[key]; ok {
-				t.Errorf("Each() - phantom found [%s]", key)
-			}
-		}
-	}
-
-	elems = make(map[string]interface{})
-	handle = func(key string, value interface{}) bool {
-		elems[key] = value
-		return true
-	}
-	if !m.Each("c", handle) {
-		t.Error("Each() - invalid result")
-	}
-	for _, key := range keys {
-		if _, ok := elems[key]; ok {
-			t.Errorf("Each() - phantom found [%s]", key)
-		}
-	}
-}

vendor/github.com/k-sone/critbitgo/net_bench_test.go

@@ -1,78 +0,0 @@
-package critbitgo_test
-
-import (
-	"math/rand"
-	"net"
-	"testing"
-
-	"github.com/k-sone/critbitgo"
-)
-
-var routeCount int = 10000
-var routes []string
-
-func init() {
-	routes = make([]string, routeCount)
-	random := rand.New(rand.NewSource(0))
-	for i := 0; i < len(routes); i++ {
-		routes[i] = genRoute(random)
-	}
-}
-
-func genRoute(rand *rand.Rand) string {
-	ip := rand.Int31()
-	mask := rand.Intn(33)
-	ipnet := &net.IPNet{
-		IP:   net.IP{byte(ip >> 24), byte(ip >> 16), byte(ip >> 8), byte(ip)},
-		Mask: net.CIDRMask(mask, 32),
-	}
-	return ipnet.String()
-}
-
-func buildNet(keys []string) *critbitgo.Net {
-	tree := critbitgo.NewNet()
-	for i := 0; i < len(keys); i++ {
-		tree.AddCIDR(keys[i], nil)
-	}
-	tree.AddCIDR("0.0.0.0/5", nil)
-	return tree
-}
-
-func BenchmarkNetBuild(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		buildNet(routes)
-	}
-}
-
-func BenchmarkNetGet(b *testing.B) {
-	n := buildNet(routes)
-	random := rand.New(rand.NewSource(0))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		k := routes[random.Intn(routeCount)]
-		n.GetCIDR(k)
-	}
-}
-
-func BenchmarkNetDelete(b *testing.B) {
-	n := buildNet(routes)
-	random := rand.New(rand.NewSource(0))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		k := routes[random.Intn(keyCount)]
-		n.DeleteCIDR(k)
-	}
-}
-
-func BenchmarkNetMatch(b *testing.B) {
-	n := buildNet(routes)
-	random := rand.New(rand.NewSource(0))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		s := genRoute(random)
-		n.MatchCIDR(s)
-	}
-}

vendor/github.com/k-sone/critbitgo/net_test.go

@@ -1,119 +0,0 @@
-package critbitgo_test
-
-import (
-	"net"
-	"testing"
-
-	"github.com/k-sone/critbitgo"
-)
-
-func TestNet(t *testing.T) {
-	trie := critbitgo.NewNet()
-	cidr := "192.168.1.0/24"
-	host := "192.168.1.1/32"
-	hostIP := net.IPv4(192, 168, 1, 1)
-
-	if _, _, err := trie.GetCIDR(""); err == nil {
-		t.Error("GetCIDR() - not error")
-	}
-	if v, ok, err := trie.GetCIDR(cidr); v != nil || ok || err != nil {
-		t.Errorf("GetCIDR() - phantom: %v, %v, %v", v, ok, err)
-	}
-	if _, _, err := trie.MatchCIDR(""); err == nil {
-		t.Error("MatchCIDR() - not error")
-	}
-	if r, v, err := trie.MatchCIDR(host); r != nil || v != nil || err != nil {
-		t.Errorf("MatchCIDR() - phantom: %v, %v, %v", r, v, err)
-	}
-	if _, _, err := trie.MatchIP(net.IP([]byte{})); err == nil {
-		t.Error("MatchIP() - not error")
-	}
-	if r, v, err := trie.MatchIP(hostIP); r != nil || v != nil || err != nil {
-		t.Errorf("MatchIP() - phantom: %v, %v, %v", r, v, err)
-	}
-	if _, err := trie.ContainedIP(net.IP([]byte{})); err == nil {
-		t.Error("ContainedIP() - not error")
-	}
-	if b, err := trie.ContainedIP(hostIP); b || err != nil {
-		t.Errorf("ContainedIP() - phantom: %v, %v", b, err)
-	}
-	if _, _, err := trie.DeleteCIDR(""); err == nil {
-		t.Error("DeleteCIDR() - not error")
-	}
-	if v, ok, err := trie.DeleteCIDR(cidr); v != nil || ok || err != nil {
-		t.Errorf("DeleteCIDR() - phantom: %v, %v, %v", v, ok, err)
-	}
-
-	if err := trie.AddCIDR(cidr, &cidr); err != nil {
-		t.Errorf("AddCIDR() - %s: error occurred %s", cidr, err)
-	}
-	if v, ok, err := trie.GetCIDR(cidr); v != &cidr || !ok || err != nil {
-		t.Errorf("GetCIDR() - failed: %v, %v, %v", v, ok, err)
-	}
-	if r, v, err := trie.MatchCIDR(host); r == nil || r.String() != cidr || v != &cidr || err != nil {
-		t.Errorf("MatchCIDR() - failed: %v, %v, %v", r, v, err)
-	}
-	if r, v, err := trie.MatchIP(hostIP); r == nil || r.String() != cidr || v != &cidr || err != nil {
-		t.Errorf("MatchIP() - failed: %v, %v, %v", r, v, err)
-	}
-	if b, err := trie.ContainedIP(hostIP); !b || err != nil {
-		t.Errorf("ContainedIP() - failed: %v, %v", b, err)
-	}
-	if v, ok, err := trie.DeleteCIDR(cidr); v != &cidr || !ok || err != nil {
-		t.Errorf("DeleteCIDR() - failed: %v, %v, %v", v, ok, err)
-	}
-}
-
-func checkMatch(t *testing.T, trie *critbitgo.Net, request, expect string) {
-	route, value, err := trie.MatchCIDR(request)
-	if err != nil {
-		t.Errorf("MatchCIDR() - %s: error occurred %s", request, err)
-	}
-	if cidr := route.String(); expect != cidr {
-		t.Errorf("MatchCIDR() - %s: expected [%s], actual [%s]", request, expect, cidr)
-	}
-	if value == nil {
-		t.Errorf("MatchCIDR() - %s: no value", request)
-	}
-}
-
-func TestNetMatch(t *testing.T) {
-	trie := critbitgo.NewNet()
-
-	cidrs := []string{
-		"0.0.0.0/4",
-		"192.168.0.0/16",
-		"192.168.1.0/24",
-		"192.168.1.0/28",
-		"192.168.1.0/32",
-		"192.168.1.1/32",
-		"192.168.1.2/32",
-		"192.168.1.32/27",
-		"192.168.1.32/30",
-		"192.168.2.1/32",
-		"192.168.2.2/32",
-	}
-
-	for _, cidr := range cidrs {
-		if err := trie.AddCIDR(cidr, &cidr); err != nil {
-			t.Errorf("AddCIDR() - %s: error occurred %s", cidr, err)
-		}
-	}
-
-	checkMatch(t, trie, "10.0.0.0/8", "0.0.0.0/4")
-	checkMatch(t, trie, "192.168.1.0/24", "192.168.1.0/24")
-	checkMatch(t, trie, "192.168.1.0/30", "192.168.1.0/28")
-	checkMatch(t, trie, "192.168.1.0/32", "192.168.1.0/32")
-	checkMatch(t, trie, "192.168.1.128/26", "192.168.1.0/24")
-	checkMatch(t, trie, "192.168.2.128/26", "192.168.0.0/16")
-	checkMatch(t, trie, "192.168.1.1/32", "192.168.1.1/32")
-	checkMatch(t, trie, "192.168.1.2/32", "192.168.1.2/32")
-	checkMatch(t, trie, "192.168.1.3/32", "192.168.1.0/28")
-	checkMatch(t, trie, "192.168.1.32/32", "192.168.1.32/30")
-	checkMatch(t, trie, "192.168.1.35/32", "192.168.1.32/30")
-	checkMatch(t, trie, "192.168.1.36/32", "192.168.1.32/27")
-	checkMatch(t, trie, "192.168.1.63/32", "192.168.1.32/27")
-	checkMatch(t, trie, "192.168.1.64/32", "192.168.1.0/24")
-	checkMatch(t, trie, "192.168.2.2/32", "192.168.2.2/32")
-	checkMatch(t, trie, "192.168.2.3/32", "192.168.0.0/16")
-}

vendor/github.com/kardianos/osext/osext_test.go

@@ -1,203 +0,0 @@
-// Copyright 2012 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 linux freebsd netbsd windows openbsd
-
-package osext
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-const (
-	executableEnvVar = "OSTEST_OUTPUT_EXECUTABLE"
-
-	executableEnvValueMatch  = "match"
-	executableEnvValueDelete = "delete"
-)
-
-func TestPrintExecutable(t *testing.T) {
-	ef, err := Executable()
-	if err != nil {
-		t.Fatalf("Executable failed: %v", err)
-	}
-	t.Log("Executable:", ef)
-}
-func TestPrintExecutableFolder(t *testing.T) {
-	ef, err := ExecutableFolder()
-	if err != nil {
-		t.Fatalf("ExecutableFolder failed: %v", err)
-	}
-	t.Log("Executable Folder:", ef)
-}
-func TestExecutableFolder(t *testing.T) {
-	ef, err := ExecutableFolder()
-	if err != nil {
-		t.Fatalf("ExecutableFolder failed: %v", err)
-	}
-	if ef[len(ef)-1] == filepath.Separator {
-		t.Fatal("ExecutableFolder ends with a trailing slash.")
-	}
-}
-func TestExecutableMatch(t *testing.T) {
-	ep, err := Executable()
-	if err != nil {
-		t.Fatalf("Executable failed: %v", err)
-	}
-
-	// fullpath to be of the form "dir/prog".
-	dir := filepath.Dir(filepath.Dir(ep))
-	fullpath, err := filepath.Rel(dir, ep)
-	if err != nil {
-		t.Fatalf("filepath.Rel: %v", err)
-	}
-	// Make child start with a relative program path.
-	// Alter argv[0] for child to verify getting real path without argv[0].
-	cmd := &exec.Cmd{
-		Dir:  dir,
-		Path: fullpath,
-		Env:  []string{fmt.Sprintf("%s=%s", executableEnvVar, executableEnvValueMatch)},
-	}
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("exec(self) failed: %v", err)
-	}
-	outs := string(out)
-	if !filepath.IsAbs(outs) {
-		t.Fatalf("Child returned %q, want an absolute path", out)
-	}
-	if !sameFile(outs, ep) {
-		t.Fatalf("Child returned %q, not the same file as %q", out, ep)
-	}
-}
-
-func TestExecutableDelete(t *testing.T) {
-	if runtime.GOOS != "linux" {
-		t.Skip()
-	}
-	fpath, err := Executable()
-	if err != nil {
-		t.Fatalf("Executable failed: %v", err)
-	}
-
-	r, w := io.Pipe()
-	stderrBuff := &bytes.Buffer{}
-	stdoutBuff := &bytes.Buffer{}
-	cmd := &exec.Cmd{
-		Path:   fpath,
-		Env:    []string{fmt.Sprintf("%s=%s", executableEnvVar, executableEnvValueDelete)},
-		Stdin:  r,
-		Stderr: stderrBuff,
-		Stdout: stdoutBuff,
-	}
-	err = cmd.Start()
-	if err != nil {
-		t.Fatalf("exec(self) start failed: %v", err)
-	}
-
-	tempPath := fpath + "_copy"
-	_ = os.Remove(tempPath)
-
-	err = copyFile(tempPath, fpath)
-	if err != nil {
-		t.Fatalf("copy file failed: %v", err)
-	}
-	err = os.Remove(fpath)
-	if err != nil {
-		t.Fatalf("remove running test file failed: %v", err)
-	}
-	err = os.Rename(tempPath, fpath)
-	if err != nil {
-		t.Fatalf("rename copy to previous name failed: %v", err)
-	}
-
-	w.Write([]byte{0})
-	w.Close()
-
-	err = cmd.Wait()
-	if err != nil {
-		t.Fatalf("exec wait failed: %v", err)
-	}
-
-	childPath := stderrBuff.String()
-	if !filepath.IsAbs(childPath) {
-		t.Fatalf("Child returned %q, want an absolute path", childPath)
-	}
-	if !sameFile(childPath, fpath) {
-		t.Fatalf("Child returned %q, not the same file as %q", childPath, fpath)
-	}
-}
-
-func sameFile(fn1, fn2 string) bool {
-	fi1, err := os.Stat(fn1)
-	if err != nil {
-		return false
-	}
-	fi2, err := os.Stat(fn2)
-	if err != nil {
-		return false
-	}
-	return os.SameFile(fi1, fi2)
-}
-func copyFile(dest, src string) error {
-	df, err := os.Create(dest)
-	if err != nil {
-		return err
-	}
-	defer df.Close()
-
-	sf, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer sf.Close()
-
-	_, err = io.Copy(df, sf)
-	return err
-}
-
-func TestMain(m *testing.M) {
-	env := os.Getenv(executableEnvVar)
-	switch env {
-	case "":
-		os.Exit(m.Run())
-	case executableEnvValueMatch:
-		// First chdir to another path.
-		dir := "/"
-		if runtime.GOOS == "windows" {
-			dir = filepath.VolumeName(".")
-		}
-		os.Chdir(dir)
-		if ep, err := Executable(); err != nil {
-			fmt.Fprint(os.Stderr, "ERROR: ", err)
-		} else {
-			fmt.Fprint(os.Stderr, ep)
-		}
-	case executableEnvValueDelete:
-		bb := make([]byte, 1)
-		var err error
-		n, err := os.Stdin.Read(bb)
-		if err != nil {
-			fmt.Fprint(os.Stderr, "ERROR: ", err)
-			os.Exit(2)
-		}
-		if n != 1 {
-			fmt.Fprint(os.Stderr, "ERROR: n != 1, n == ", n)
-			os.Exit(2)
-		}
-		if ep, err := Executable(); err != nil {
-			fmt.Fprint(os.Stderr, "ERROR: ", err)
-		} else {
-			fmt.Fprint(os.Stderr, ep)
-		}
-	}
-	os.Exit(0)
-}

vendor/github.com/kardianos/service/name_test.go

@@ -1,20 +0,0 @@
-// Copyright 2015 Daniel Theophanes.
-// Use of this source code is governed by a zlib-style
-// license that can be found in the LICENSE file.
-
-package service
-
-import (
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func TestPlatformName(t *testing.T) {
-	got := Platform()
-	t.Logf("Platform is %v", got)
-	wantPrefix := runtime.GOOS + "-"
-	if !strings.HasPrefix(got, wantPrefix) {
-		t.Errorf("Platform() want: /^%s.*$/, got: %s", wantPrefix, got)
-	}
-}

vendor/github.com/kardianos/service/service_nosu_test.go

@@ -1,13 +0,0 @@
-// Copyright 2016 Lawrence Woodman <lwoodman@vlifesystems.com>
-// Use of this source code is governed by a zlib-style
-// license that can be found in the LICENSE file.
-
-// +build !su
-
-package service_test
-
-import "testing"
-
-func TestInstallRunRestartStopRemove(t *testing.T) {
-	t.Skip("skipping test as not running as root/admin (Build tag: su)")
-}

vendor/github.com/kardianos/service/service_su_test.go

@@ -1,180 +0,0 @@
-// Copyright 2015 Daniel Theophanes.
-// Use of this source code is governed by a zlib-style
-// license that can be found in the LICENSE file.
-
-// This needs to be run as root/admin hence the reason there is a build tag
-// +build su
-
-package service_test
-
-import (
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"regexp"
-	"testing"
-	"time"
-
-	"github.com/kardianos/service"
-)
-
-const runAsServiceArg = "RunThisAsService"
-
-func TestMain(m *testing.M) {
-	reportDir := flag.String("su.reportDir", "", "")
-	runAsService := flag.Bool("su.runAsService", false, "")
-	flag.Parse()
-	if !*runAsService {
-		os.Exit(m.Run())
-	}
-	if len(*reportDir) == 0 {
-		log.Fatal("missing su.reportDir argument")
-	}
-	writeReport(*reportDir, "call")
-	runService()
-	writeReport(*reportDir, "finished")
-}
-
-func TestInstallRunRestartStopRemove(t *testing.T) {
-	p := &program{}
-	reportDir := mustTempDir(t)
-	defer os.RemoveAll(reportDir)
-
-	s := mustNewRunAsService(t, p, reportDir)
-	_ = s.Uninstall()
-
-	if err := s.Install(); err != nil {
-		t.Fatal("Install", err)
-	}
-	defer s.Uninstall()
-
-	if err := s.Start(); err != nil {
-		t.Fatal("Start", err)
-	}
-	defer s.Stop()
-	checkReport(t, reportDir, "Start()", 1, 0)
-
-	if err := s.Restart(); err != nil {
-		t.Fatal("restart", err)
-	}
-
-	checkReport(t, reportDir, "Restart()", 2, 1)
-	p.numStopped = 0
-	if err := s.Stop(); err != nil {
-		t.Fatal("stop", err)
-	}
-	checkReport(t, reportDir, "Stop()", 2, 2)
-
-	if err := s.Uninstall(); err != nil {
-		t.Fatal("uninstall", err)
-	}
-}
-
-func runService() {
-	p := &program{}
-	sc := &service.Config{
-		Name: "go_service_test",
-	}
-	s, err := service.New(p, sc)
-	if err != nil {
-		log.Fatal(err)
-	}
-	if err = s.Run(); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func mustTempDir(t *testing.T) string {
-	dir, err := ioutil.TempDir("", "servicetest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	return dir
-}
-
-func writeReport(reportDir string, action string) {
-	b := []byte("go_test_service_report")
-	timeStamp := time.Now().UnixNano()
-	err := ioutil.WriteFile(
-		filepath.Join(reportDir, fmt.Sprintf("%d-%s", timeStamp, action)),
-		b,
-		0644,
-	)
-	if err != nil {
-		log.Fatal(err)
-	}
-}
-
-var matchActionRegexp = regexp.MustCompile("^(\\d+-)([a-z]*)$")
-
-func getReport(
-	t *testing.T,
-	reportDir string,
-) (numCalls int, numFinished int) {
-	numCalls = 0
-	numFinished = 0
-	files, err := ioutil.ReadDir(reportDir)
-	if err != nil {
-		t.Fatalf("ReadDir(%s) err: %s", reportDir, err)
-	}
-
-	for _, file := range files {
-		if matchActionRegexp.MatchString(file.Name()) {
-			action := matchActionRegexp.ReplaceAllString(file.Name(), "$2")
-			switch action {
-			case "call":
-				numCalls++
-			case "finished":
-				numFinished++
-			default:
-				t.Fatalf("getReport() found report with incorrect action: %s", action)
-			}
-		}
-	}
-	return
-}
-
-func checkReport(
-	t *testing.T,
-	reportDir string,
-	msgPrefix string,
-	wantNumCalled int,
-	wantNumFinished int,
-) {
-	var numCalled int
-	var numFinished int
-	for i := 0; i < 25; i++ {
-		numCalled, numFinished = getReport(t, reportDir)
-		<-time.After(200 * time.Millisecond)
-		if numCalled == wantNumCalled && numFinished == wantNumFinished {
-			return
-		}
-	}
-	if numCalled != wantNumCalled {
-		t.Fatalf("%s - numCalled: %d, want %d",
-			msgPrefix, numCalled, wantNumCalled)
-	}
-	if numFinished != wantNumFinished {
-		t.Fatalf("%s - numFinished: %d, want %d",
-			msgPrefix, numFinished, wantNumFinished)
-	}
-}
-
-func mustNewRunAsService(
-	t *testing.T,
-	p *program,
-	reportDir string,
-) service.Service {
-	sc := &service.Config{
-		Name:      "go_service_test",
-		Arguments: []string{"-test.v=true", "-su.runAsService", "-su.reportDir", reportDir},
-	}
-	s, err := service.New(p, sc)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return s
-}

vendor/github.com/kardianos/service/service_test.go

@@ -1,57 +0,0 @@
-// Copyright 2015 Daniel Theophanes.
-// Use of this source code is governed by a zlib-style
-// license that can be found in the LICENSE file.
-
-package service_test
-
-import (
-	"testing"
-	"time"
-
-	"github.com/kardianos/service"
-)
-
-func TestRunInterrupt(t *testing.T) {
-	p := &program{}
-	sc := &service.Config{
-		Name: "go_service_test",
-	}
-	s, err := service.New(p, sc)
-	if err != nil {
-		t.Fatalf("New err: %s", err)
-	}
-
-	go func() {
-		<-time.After(1 * time.Second)
-		interruptProcess(t)
-	}()
-
-	go func() {
-		for i := 0; i < 25 && p.numStopped == 0; i++ {
-			<-time.After(200 * time.Millisecond)
-		}
-		if p.numStopped == 0 {
-			t.Fatal("Run() hasn't been stopped")
-		}
-	}()
-
-	if err = s.Run(); err != nil {
-		t.Fatalf("Run() err: %s", err)
-	}
-}
-
-type program struct {
-	numStopped int
-}
-
-func (p *program) Start(s service.Service) error {
-	go p.run()
-	return nil
-}
-func (p *program) run() {
-	// Do work here
-}
-func (p *program) Stop(s service.Service) error {
-	p.numStopped++
-	return nil
-}

vendor/github.com/kardianos/service/service_windows_test.go

@@ -1,14 +0,0 @@
-// Copyright 2015 Daniel Theophanes.
-// Use of this source code is governed by a zlib-style
-// license that can be found in the LICENSE file.
-
-package service
-
-import (
-	"testing"
-)
-
-func TestTimeout(t *testing.T) {
-	stopSpan := getStopTimeout()
-	t.Log("Max Stop Duration", stopSpan)
-}

vendor/github.com/kardianos/service/servicetest_unix_test.go

@@ -1,23 +0,0 @@
-// Copyright 2016 Lawrence Woodman <lwoodman@vlifesystems.com>
-// Use of this source code is governed by a zlib-style
-// license that can be found in the LICENSE file.
-
-// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
-
-package service_test
-
-import (
-	"os"
-	"testing"
-)
-
-func interruptProcess(t *testing.T) {
-	pid := os.Getpid()
-	p, err := os.FindProcess(pid)
-	if err != nil {
-		t.Fatalf("FindProcess: %s", err)
-	}
-	if err := p.Signal(os.Interrupt); err != nil {
-		t.Fatalf("Signal: %s", err)
-	}
-}

vendor/github.com/kardianos/service/servicetest_windows_test.go

@@ -1,30 +0,0 @@
-// Copyright 2016 Lawrence Woodman <lwoodman@vlifesystems.com>
-// Use of this source code is governed by a zlib-style
-// license that can be found in the LICENSE file.
-
-package service_test
-
-import (
-	"os"
-	"syscall"
-	"testing"
-)
-
-func interruptProcess(t *testing.T) {
-	dll, err := syscall.LoadDLL("kernel32.dll")
-	if err != nil {
-		t.Fatalf("LoadDLL(\"kernel32.dll\") err: %s", err)
-	}
-	p, err := dll.FindProc("GenerateConsoleCtrlEvent")
-	if err != nil {
-		t.Fatalf("FindProc(\"GenerateConsoleCtrlEvent\") err: %s", err)
-	}
-	// Send the CTRL_BREAK_EVENT to a console process group that shares
-	// the console associated with the calling process.
-	// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683155(v=vs.85).aspx
-	pid := os.Getpid()
-	r1, _, err := p.Call(syscall.CTRL_BREAK_EVENT, uintptr(pid))
-	if r1 == 0 {
-		t.Fatalf("Call(CTRL_BREAK_EVENT, %d) err: %s", pid, err)
-	}
-}

vendor/github.com/miekg/dns/client_test.go

@@ -1,612 +0,0 @@
-package dns
-
-import (
-	"context"
-	"crypto/tls"
-	"fmt"
-	"net"
-	"strconv"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-func TestDialUDP(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServer)
-	defer HandleRemove("miek.nl.")
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeSOA)
-
-	c := new(Client)
-	conn, err := c.Dial(addrstr)
-	if err != nil {
-		t.Fatalf("failed to dial: %v", err)
-	}
-	if conn == nil {
-		t.Fatalf("conn is nil")
-	}
-}
-
-func TestClientSync(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServer)
-	defer HandleRemove("miek.nl.")
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeSOA)
-
-	c := new(Client)
-	r, _, err := c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatalf("failed to exchange: %v", err)
-	}
-	if r == nil {
-		t.Fatal("response is nil")
-	}
-	if r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-	// And now with plain Exchange().
-	r, err = Exchange(m, addrstr)
-	if err != nil {
-		t.Errorf("failed to exchange: %v", err)
-	}
-	if r == nil || r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-}
-
-func TestClientLocalAddress(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServerEchoAddrPort)
-	defer HandleRemove("miek.nl.")
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeSOA)
-
-	c := new(Client)
-	laddr := net.UDPAddr{IP: net.ParseIP("0.0.0.0"), Port: 12345, Zone: ""}
-	c.Dialer = &net.Dialer{LocalAddr: &laddr}
-	r, _, err := c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatalf("failed to exchange: %v", err)
-	}
-	if r != nil && r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-	if len(r.Extra) != 1 {
-		t.Errorf("failed to get additional answers\n%v", r)
-	}
-	txt := r.Extra[0].(*TXT)
-	if txt == nil {
-		t.Errorf("invalid TXT response\n%v", txt)
-	}
-	if len(txt.Txt) != 1 || !strings.Contains(txt.Txt[0], ":12345") {
-		t.Errorf("invalid TXT response\n%v", txt.Txt)
-	}
-}
-
-func TestClientTLSSyncV4(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServer)
-	defer HandleRemove("miek.nl.")
-
-	cert, err := tls.X509KeyPair(CertPEMBlock, KeyPEMBlock)
-	if err != nil {
-		t.Fatalf("unable to build certificate: %v", err)
-	}
-
-	config := tls.Config{
-		Certificates: []tls.Certificate{cert},
-	}
-
-	s, addrstr, err := RunLocalTLSServer(":0", &config)
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeSOA)
-
-	c := new(Client)
-
-	// test tcp-tls
-	c.Net = "tcp-tls"
-	c.TLSConfig = &tls.Config{
-		InsecureSkipVerify: true,
-	}
-
-	r, _, err := c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatalf("failed to exchange: %v", err)
-	}
-	if r == nil {
-		t.Fatal("response is nil")
-	}
-	if r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-
-	// test tcp4-tls
-	c.Net = "tcp4-tls"
-	c.TLSConfig = &tls.Config{
-		InsecureSkipVerify: true,
-	}
-
-	r, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatalf("failed to exchange: %v", err)
-	}
-	if r == nil {
-		t.Fatal("response is nil")
-	}
-	if r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-}
-
-func TestClientSyncBadID(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServerBadID)
-	defer HandleRemove("miek.nl.")
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeSOA)
-
-	c := new(Client)
-	if _, _, err := c.Exchange(m, addrstr); err != ErrId {
-		t.Errorf("did not find a bad Id")
-	}
-	// And now with plain Exchange().
-	if _, err := Exchange(m, addrstr); err != ErrId {
-		t.Errorf("did not find a bad Id")
-	}
-}
-
-func TestClientEDNS0(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServer)
-	defer HandleRemove("miek.nl.")
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeDNSKEY)
-
-	m.SetEdns0(2048, true)
-
-	c := new(Client)
-	r, _, err := c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatalf("failed to exchange: %v", err)
-	}
-
-	if r != nil && r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get a valid answer\n%v", r)
-	}
-}
-
-// Validates the transmission and parsing of local EDNS0 options.
-func TestClientEDNS0Local(t *testing.T) {
-	optStr1 := "1979:0x0707"
-	optStr2 := strconv.Itoa(EDNS0LOCALSTART) + ":0x0601"
-
-	handler := func(w ResponseWriter, req *Msg) {
-		m := new(Msg)
-		m.SetReply(req)
-
-		m.Extra = make([]RR, 1, 2)
-		m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello local edns"}}
-
-		// If the local options are what we expect, then reflect them back.
-		ec1 := req.Extra[0].(*OPT).Option[0].(*EDNS0_LOCAL).String()
-		ec2 := req.Extra[0].(*OPT).Option[1].(*EDNS0_LOCAL).String()
-		if ec1 == optStr1 && ec2 == optStr2 {
-			m.Extra = append(m.Extra, req.Extra[0])
-		}
-
-		w.WriteMsg(m)
-	}
-
-	HandleFunc("miek.nl.", handler)
-	defer HandleRemove("miek.nl.")
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %s", err)
-	}
-	defer s.Shutdown()
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeTXT)
-
-	// Add two local edns options to the query.
-	ec1 := &EDNS0_LOCAL{Code: 1979, Data: []byte{7, 7}}
-	ec2 := &EDNS0_LOCAL{Code: EDNS0LOCALSTART, Data: []byte{6, 1}}
-	o := &OPT{Hdr: RR_Header{Name: ".", Rrtype: TypeOPT}, Option: []EDNS0{ec1, ec2}}
-	m.Extra = append(m.Extra, o)
-
-	c := new(Client)
-	r, _, err := c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatalf("failed to exchange: %s", err)
-	}
-
-	if r == nil {
-		t.Fatal("response is nil")
-	}
-	if r.Rcode != RcodeSuccess {
-		t.Fatal("failed to get a valid answer")
-	}
-
-	txt := r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello local edns" {
-		t.Error("Unexpected result for miek.nl", txt, "!= Hello local edns")
-	}
-
-	// Validate the local options in the reply.
-	got := r.Extra[1].(*OPT).Option[0].(*EDNS0_LOCAL).String()
-	if got != optStr1 {
-		t.Errorf("failed to get local edns0 answer; got %s, expected %s", got, optStr1)
-	}
-
-	got = r.Extra[1].(*OPT).Option[1].(*EDNS0_LOCAL).String()
-	if got != optStr2 {
-		t.Errorf("failed to get local edns0 answer; got %s, expected %s", got, optStr2)
-	}
-}
-
-func TestClientConn(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServer)
-	defer HandleRemove("miek.nl.")
-
-	// This uses TCP just to make it slightly different than TestClientSync
-	s, addrstr, err := RunLocalTCPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeSOA)
-
-	cn, err := Dial("tcp", addrstr)
-	if err != nil {
-		t.Errorf("failed to dial %s: %v", addrstr, err)
-	}
-
-	err = cn.WriteMsg(m)
-	if err != nil {
-		t.Errorf("failed to exchange: %v", err)
-	}
-	r, err := cn.ReadMsg()
-	if err != nil {
-		t.Errorf("failed to get a valid answer: %v", err)
-	}
-	if r == nil || r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-
-	err = cn.WriteMsg(m)
-	if err != nil {
-		t.Errorf("failed to exchange: %v", err)
-	}
-	h := new(Header)
-	buf, err := cn.ReadMsgHeader(h)
-	if buf == nil {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-	if err != nil {
-		t.Errorf("failed to get a valid answer: %v", err)
-	}
-	if int(h.Bits&0xF) != RcodeSuccess {
-		t.Errorf("failed to get an valid answer in ReadMsgHeader\n%v", r)
-	}
-	if h.Ancount != 0 || h.Qdcount != 1 || h.Nscount != 0 || h.Arcount != 1 {
-		t.Errorf("expected to have question and additional in response; got something else: %+v", h)
-	}
-	if err = r.Unpack(buf); err != nil {
-		t.Errorf("unable to unpack message fully: %v", err)
-	}
-}
-
-func TestTruncatedMsg(t *testing.T) {
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeSRV)
-	cnt := 10
-	for i := 0; i < cnt; i++ {
-		r := &SRV{
-			Hdr:    RR_Header{Name: m.Question[0].Name, Rrtype: TypeSRV, Class: ClassINET, Ttl: 0},
-			Port:   uint16(i + 8000),
-			Target: "target.miek.nl.",
-		}
-		m.Answer = append(m.Answer, r)
-
-		re := &A{
-			Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeA, Class: ClassINET, Ttl: 0},
-			A:   net.ParseIP(fmt.Sprintf("127.0.0.%d", i)).To4(),
-		}
-		m.Extra = append(m.Extra, re)
-	}
-	buf, err := m.Pack()
-	if err != nil {
-		t.Errorf("failed to pack: %v", err)
-	}
-
-	r := new(Msg)
-	if err = r.Unpack(buf); err != nil {
-		t.Errorf("unable to unpack message: %v", err)
-	}
-	if len(r.Answer) != cnt {
-		t.Errorf("answer count after regular unpack doesn't match: %d", len(r.Answer))
-	}
-	if len(r.Extra) != cnt {
-		t.Errorf("extra count after regular unpack doesn't match: %d", len(r.Extra))
-	}
-
-	m.Truncated = true
-	buf, err = m.Pack()
-	if err != nil {
-		t.Errorf("failed to pack truncated: %v", err)
-	}
-
-	r = new(Msg)
-	if err = r.Unpack(buf); err != nil && err != ErrTruncated {
-		t.Errorf("unable to unpack truncated message: %v", err)
-	}
-	if !r.Truncated {
-		t.Errorf("truncated message wasn't unpacked as truncated")
-	}
-	if len(r.Answer) != cnt {
-		t.Errorf("answer count after truncated unpack doesn't match: %d", len(r.Answer))
-	}
-	if len(r.Extra) != cnt {
-		t.Errorf("extra count after truncated unpack doesn't match: %d", len(r.Extra))
-	}
-
-	// Now we want to remove almost all of the extra records
-	// We're going to loop over the extra to get the count of the size of all
-	// of them
-	off := 0
-	buf1 := make([]byte, m.Len())
-	for i := 0; i < len(m.Extra); i++ {
-		off, err = PackRR(m.Extra[i], buf1, off, nil, m.Compress)
-		if err != nil {
-			t.Errorf("failed to pack extra: %v", err)
-		}
-	}
-
-	// Remove all of the extra bytes but 10 bytes from the end of buf
-	off -= 10
-	buf1 = buf[:len(buf)-off]
-
-	r = new(Msg)
-	if err = r.Unpack(buf1); err != nil && err != ErrTruncated {
-		t.Errorf("unable to unpack cutoff message: %v", err)
-	}
-	if !r.Truncated {
-		t.Error("truncated cutoff message wasn't unpacked as truncated")
-	}
-	if len(r.Answer) != cnt {
-		t.Errorf("answer count after cutoff unpack doesn't match: %d", len(r.Answer))
-	}
-	if len(r.Extra) != 0 {
-		t.Errorf("extra count after cutoff unpack is not zero: %d", len(r.Extra))
-	}
-
-	// Now we want to remove almost all of the answer records too
-	buf1 = make([]byte, m.Len())
-	as := 0
-	for i := 0; i < len(m.Extra); i++ {
-		off1 := off
-		off, err = PackRR(m.Extra[i], buf1, off, nil, m.Compress)
-		as = off - off1
-		if err != nil {
-			t.Errorf("failed to pack extra: %v", err)
-		}
-	}
-
-	// Keep exactly one answer left
-	// This should still cause Answer to be nil
-	off -= as
-	buf1 = buf[:len(buf)-off]
-
-	r = new(Msg)
-	if err = r.Unpack(buf1); err != nil && err != ErrTruncated {
-		t.Errorf("unable to unpack cutoff message: %v", err)
-	}
-	if !r.Truncated {
-		t.Error("truncated cutoff message wasn't unpacked as truncated")
-	}
-	if len(r.Answer) != 0 {
-		t.Errorf("answer count after second cutoff unpack is not zero: %d", len(r.Answer))
-	}
-
-	// Now leave only 1 byte of the question
-	// Since the header is always 12 bytes, we just need to keep 13
-	buf1 = buf[:13]
-
-	r = new(Msg)
-	err = r.Unpack(buf1)
-	if err == nil || err == ErrTruncated {
-		t.Errorf("error should not be ErrTruncated from question cutoff unpack: %v", err)
-	}
-
-	// Finally, if we only have the header, we don't return an error.
-	buf1 = buf[:12]
-
-	r = new(Msg)
-	if err = r.Unpack(buf1); err != nil {
-		t.Errorf("from header-only unpack should not return an error: %v", err)
-	}
-}
-
-func TestTimeout(t *testing.T) {
-	// Set up a dummy UDP server that won't respond
-	addr, err := net.ResolveUDPAddr("udp", ":0")
-	if err != nil {
-		t.Fatalf("unable to resolve local udp address: %v", err)
-	}
-	conn, err := net.ListenUDP("udp", addr)
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer conn.Close()
-	addrstr := conn.LocalAddr().String()
-
-	// Message to send
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeTXT)
-
-	// Use a channel + timeout to ensure we don't get stuck if the
-	// Client Timeout is not working properly
-	done := make(chan struct{}, 2)
-
-	timeout := time.Millisecond
-	allowable := timeout + (10 * time.Millisecond)
-	abortAfter := timeout + (100 * time.Millisecond)
-
-	start := time.Now()
-
-	go func() {
-		c := &Client{Timeout: timeout}
-		_, _, err := c.Exchange(m, addrstr)
-		if err == nil {
-			t.Error("no timeout using Client.Exchange")
-		}
-		done <- struct{}{}
-	}()
-
-	go func() {
-		ctx, cancel := context.WithTimeout(context.Background(), timeout)
-		defer cancel()
-		c := &Client{}
-		_, _, err := c.ExchangeContext(ctx, m, addrstr)
-		if err == nil {
-			t.Error("no timeout using Client.ExchangeContext")
-		}
-		done <- struct{}{}
-	}()
-
-	// Wait for both the Exchange and ExchangeContext tests to be done.
-	for i := 0; i < 2; i++ {
-		select {
-		case <-done:
-		case <-time.After(abortAfter):
-		}
-	}
-
-	length := time.Since(start)
-
-	if length > allowable {
-		t.Errorf("exchange took longer %v than specified Timeout %v", length, allowable)
-	}
-}
-
-// Check that responses from deduplicated requests aren't shared between callers
-func TestConcurrentExchanges(t *testing.T) {
-	cases := make([]*Msg, 2)
-	cases[0] = new(Msg)
-	cases[1] = new(Msg)
-	cases[1].Truncated = true
-	for _, m := range cases {
-		block := make(chan struct{})
-		waiting := make(chan struct{})
-
-		handler := func(w ResponseWriter, req *Msg) {
-			r := m.Copy()
-			r.SetReply(req)
-
-			waiting <- struct{}{}
-			<-block
-			w.WriteMsg(r)
-		}
-
-		HandleFunc("miek.nl.", handler)
-		defer HandleRemove("miek.nl.")
-
-		s, addrstr, err := RunLocalUDPServer(":0")
-		if err != nil {
-			t.Fatalf("unable to run test server: %s", err)
-		}
-		defer s.Shutdown()
-
-		m := new(Msg)
-		m.SetQuestion("miek.nl.", TypeSRV)
-		c := &Client{
-			SingleInflight: true,
-		}
-		r := make([]*Msg, 2)
-
-		var wg sync.WaitGroup
-		wg.Add(len(r))
-		for i := 0; i < len(r); i++ {
-			go func(i int) {
-				defer wg.Done()
-				r[i], _, _ = c.Exchange(m.Copy(), addrstr)
-				if r[i] == nil {
-					t.Errorf("response %d is nil", i)
-				}
-			}(i)
-		}
-		select {
-		case <-waiting:
-		case <-time.After(time.Second):
-			t.FailNow()
-		}
-		close(block)
-		wg.Wait()
-
-		if r[0] == r[1] {
-			t.Errorf("got same response, expected non-shared responses")
-		}
-	}
-}
-
-func TestDoHExchange(t *testing.T) {
-	const addrstr = "https://dns.cloudflare.com/dns-query"
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeSOA)
-
-	cl := &Client{Net: "https"}
-
-	r, _, err := cl.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatalf("failed to exchange: %v", err)
-	}
-
-	if r == nil || r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-
-	t.Log(r)
-
-	// TODO: proper tests for this
-}

vendor/github.com/miekg/dns/clientconfig_test.go

@@ -1,181 +0,0 @@
-package dns
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-const normal string = `
-# Comment
-domain somedomain.com
-nameserver 10.28.10.2
-nameserver 11.28.10.1
-`
-
-const missingNewline string = `
-domain somedomain.com
-nameserver 10.28.10.2
-nameserver 11.28.10.1` // <- NOTE: NO newline.
-
-func testConfig(t *testing.T, data string) {
-	cc, err := ClientConfigFromReader(strings.NewReader(data))
-	if err != nil {
-		t.Errorf("error parsing resolv.conf: %v", err)
-	}
-	if l := len(cc.Servers); l != 2 {
-		t.Errorf("incorrect number of nameservers detected: %d", l)
-	}
-	if l := len(cc.Search); l != 1 {
-		t.Errorf("domain directive not parsed correctly: %v", cc.Search)
-	} else {
-		if cc.Search[0] != "somedomain.com" {
-			t.Errorf("domain is unexpected: %v", cc.Search[0])
-		}
-	}
-}
-
-func TestNameserver(t *testing.T)          { testConfig(t, normal) }
-func TestMissingFinalNewLine(t *testing.T) { testConfig(t, missingNewline) }
-
-func TestNdots(t *testing.T) {
-	ndotsVariants := map[string]int{
-		"options ndots:0":  0,
-		"options ndots:1":  1,
-		"options ndots:15": 15,
-		"options ndots:16": 15,
-		"options ndots:-1": 0,
-		"":                 1,
-	}
-
-	for data := range ndotsVariants {
-		cc, err := ClientConfigFromReader(strings.NewReader(data))
-		if err != nil {
-			t.Errorf("error parsing resolv.conf: %v", err)
-		}
-		if cc.Ndots != ndotsVariants[data] {
-			t.Errorf("Ndots not properly parsed: (Expected: %d / Was: %d)", ndotsVariants[data], cc.Ndots)
-		}
-	}
-}
-
-func TestClientConfigFromReaderAttempts(t *testing.T) {
-	testCases := []struct {
-		data     string
-		expected int
-	}{
-		{data: "options attempts:0", expected: 1},
-		{data: "options attempts:1", expected: 1},
-		{data: "options attempts:15", expected: 15},
-		{data: "options attempts:16", expected: 16},
-		{data: "options attempts:-1", expected: 1},
-		{data: "options attempt:", expected: 2},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(strings.Replace(test.data, ":", " ", -1), func(t *testing.T) {
-			t.Parallel()
-
-			cc, err := ClientConfigFromReader(strings.NewReader(test.data))
-			if err != nil {
-				t.Errorf("error parsing resolv.conf: %v", err)
-			}
-			if cc.Attempts != test.expected {
-				t.Errorf("A attempts not properly parsed: (Expected: %d / Was: %d)", test.expected, cc.Attempts)
-			}
-		})
-	}
-}
-
-func TestReadFromFile(t *testing.T) {
-	tempDir, err := ioutil.TempDir("", "")
-	if err != nil {
-		t.Fatalf("tempDir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	path := filepath.Join(tempDir, "resolv.conf")
-	if err := ioutil.WriteFile(path, []byte(normal), 0644); err != nil {
-		t.Fatalf("writeFile: %v", err)
-	}
-	cc, err := ClientConfigFromFile(path)
-	if err != nil {
-		t.Errorf("error parsing resolv.conf: %v", err)
-	}
-	if l := len(cc.Servers); l != 2 {
-		t.Errorf("incorrect number of nameservers detected: %d", l)
-	}
-	if l := len(cc.Search); l != 1 {
-		t.Errorf("domain directive not parsed correctly: %v", cc.Search)
-	} else {
-		if cc.Search[0] != "somedomain.com" {
-			t.Errorf("domain is unexpected: %v", cc.Search[0])
-		}
-	}
-}
-
-func TestNameListNdots1(t *testing.T) {
-	cfg := ClientConfig{
-		Ndots: 1,
-	}
-	// fqdn should be only result returned
-	names := cfg.NameList("miek.nl.")
-	if len(names) != 1 {
-		t.Errorf("NameList returned != 1 names: %v", names)
-	} else if names[0] != "miek.nl." {
-		t.Errorf("NameList didn't return sent fqdn domain: %v", names[0])
-	}
-
-	cfg.Search = []string{
-		"test",
-	}
-	// Sent domain has NDots and search
-	names = cfg.NameList("miek.nl")
-	if len(names) != 2 {
-		t.Errorf("NameList returned != 2 names: %v", names)
-	} else if names[0] != "miek.nl." {
-		t.Errorf("NameList didn't return sent domain first: %v", names[0])
-	} else if names[1] != "miek.nl.test." {
-		t.Errorf("NameList didn't return search last: %v", names[1])
-	}
-}
-func TestNameListNdots2(t *testing.T) {
-	cfg := ClientConfig{
-		Ndots: 2,
-	}
-
-	// Sent domain has less than NDots and search
-	cfg.Search = []string{
-		"test",
-	}
-	names := cfg.NameList("miek.nl")
-
-	if len(names) != 2 {
-		t.Errorf("NameList returned != 2 names: %v", names)
-	} else if names[0] != "miek.nl.test." {
-		t.Errorf("NameList didn't return search first: %v", names[0])
-	} else if names[1] != "miek.nl." {
-		t.Errorf("NameList didn't return sent domain last: %v", names[1])
-	}
-}
-
-func TestNameListNdots0(t *testing.T) {
-	cfg := ClientConfig{
-		Ndots: 0,
-	}
-	cfg.Search = []string{
-		"test",
-	}
-	// Sent domain has less than NDots and search
-	names := cfg.NameList("miek")
-	if len(names) != 2 {
-		t.Errorf("NameList returned != 2 names: %v", names)
-	} else if names[0] != "miek." {
-		t.Errorf("NameList didn't return search first: %v", names[0])
-	} else if names[1] != "miek.test." {
-		t.Errorf("NameList didn't return sent domain last: %v", names[1])
-	}
-}

vendor/github.com/miekg/dns/dns_bench_test.go

@@ -1,230 +0,0 @@
-package dns
-
-import (
-	"net"
-	"testing"
-)
-
-func BenchmarkMsgLength(b *testing.B) {
-	b.StopTimer()
-	makeMsg := func(question string, ans, ns, e []RR) *Msg {
-		msg := new(Msg)
-		msg.SetQuestion(Fqdn(question), TypeANY)
-		msg.Answer = append(msg.Answer, ans...)
-		msg.Ns = append(msg.Ns, ns...)
-		msg.Extra = append(msg.Extra, e...)
-		msg.Compress = true
-		return msg
-	}
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	rrMx := testRR(name1 + " 3600 IN MX 10 " + name1)
-	msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		msg.Len()
-	}
-}
-
-func BenchmarkMsgLengthNoCompression(b *testing.B) {
-	b.StopTimer()
-	makeMsg := func(question string, ans, ns, e []RR) *Msg {
-		msg := new(Msg)
-		msg.SetQuestion(Fqdn(question), TypeANY)
-		msg.Answer = append(msg.Answer, ans...)
-		msg.Ns = append(msg.Ns, ns...)
-		msg.Extra = append(msg.Extra, e...)
-		return msg
-	}
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	rrMx := testRR(name1 + " 3600 IN MX 10 " + name1)
-	msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		msg.Len()
-	}
-}
-
-func BenchmarkMsgLengthPack(b *testing.B) {
-	makeMsg := func(question string, ans, ns, e []RR) *Msg {
-		msg := new(Msg)
-		msg.SetQuestion(Fqdn(question), TypeANY)
-		msg.Answer = append(msg.Answer, ans...)
-		msg.Ns = append(msg.Ns, ns...)
-		msg.Extra = append(msg.Extra, e...)
-		msg.Compress = true
-		return msg
-	}
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	rrMx := testRR(name1 + " 3600 IN MX 10 " + name1)
-	msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = msg.Pack()
-	}
-}
-
-func BenchmarkPackDomainName(b *testing.B) {
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	buf := make([]byte, len(name1)+1)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = PackDomainName(name1, buf, 0, nil, false)
-	}
-}
-
-func BenchmarkUnpackDomainName(b *testing.B) {
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	buf := make([]byte, len(name1)+1)
-	_, _ = PackDomainName(name1, buf, 0, nil, false)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _, _ = UnpackDomainName(buf, 0)
-	}
-}
-
-func BenchmarkUnpackDomainNameUnprintable(b *testing.B) {
-	name1 := "\x02\x02\x02\x025\x02\x02\x02\x02.12345678.123."
-	buf := make([]byte, len(name1)+1)
-	_, _ = PackDomainName(name1, buf, 0, nil, false)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _, _ = UnpackDomainName(buf, 0)
-	}
-}
-
-func BenchmarkCopy(b *testing.B) {
-	b.ReportAllocs()
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeA)
-	rr := testRR("miek.nl. 2311 IN A 127.0.0.1")
-	m.Answer = []RR{rr}
-	rr = testRR("miek.nl. 2311 IN NS 127.0.0.1")
-	m.Ns = []RR{rr}
-	rr = testRR("miek.nl. 2311 IN A 127.0.0.1")
-	m.Extra = []RR{rr}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		m.Copy()
-	}
-}
-
-func BenchmarkPackA(b *testing.B) {
-	a := &A{Hdr: RR_Header{Name: ".", Rrtype: TypeA, Class: ClassANY}, A: net.IPv4(127, 0, 0, 1)}
-
-	buf := make([]byte, a.len())
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = PackRR(a, buf, 0, nil, false)
-	}
-}
-
-func BenchmarkUnpackA(b *testing.B) {
-	a := &A{Hdr: RR_Header{Name: ".", Rrtype: TypeA, Class: ClassANY}, A: net.IPv4(127, 0, 0, 1)}
-
-	buf := make([]byte, a.len())
-	PackRR(a, buf, 0, nil, false)
-	a = nil
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _, _ = UnpackRR(buf, 0)
-	}
-}
-
-func BenchmarkPackMX(b *testing.B) {
-	m := &MX{Hdr: RR_Header{Name: ".", Rrtype: TypeA, Class: ClassANY}, Mx: "mx.miek.nl."}
-
-	buf := make([]byte, m.len())
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = PackRR(m, buf, 0, nil, false)
-	}
-}
-
-func BenchmarkUnpackMX(b *testing.B) {
-	m := &MX{Hdr: RR_Header{Name: ".", Rrtype: TypeA, Class: ClassANY}, Mx: "mx.miek.nl."}
-
-	buf := make([]byte, m.len())
-	PackRR(m, buf, 0, nil, false)
-	m = nil
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _, _ = UnpackRR(buf, 0)
-	}
-}
-
-func BenchmarkPackAAAAA(b *testing.B) {
-	aaaa := testRR(". IN A ::1")
-
-	buf := make([]byte, aaaa.len())
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = PackRR(aaaa, buf, 0, nil, false)
-	}
-}
-
-func BenchmarkUnpackAAAA(b *testing.B) {
-	aaaa := testRR(". IN A ::1")
-
-	buf := make([]byte, aaaa.len())
-	PackRR(aaaa, buf, 0, nil, false)
-	aaaa = nil
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _, _ = UnpackRR(buf, 0)
-	}
-}
-
-func BenchmarkPackMsg(b *testing.B) {
-	makeMsg := func(question string, ans, ns, e []RR) *Msg {
-		msg := new(Msg)
-		msg.SetQuestion(Fqdn(question), TypeANY)
-		msg.Answer = append(msg.Answer, ans...)
-		msg.Ns = append(msg.Ns, ns...)
-		msg.Extra = append(msg.Extra, e...)
-		msg.Compress = true
-		return msg
-	}
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	rrMx := testRR(name1 + " 3600 IN MX 10 " + name1)
-	msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
-	buf := make([]byte, 512)
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = msg.PackBuffer(buf)
-	}
-}
-
-func BenchmarkUnpackMsg(b *testing.B) {
-	makeMsg := func(question string, ans, ns, e []RR) *Msg {
-		msg := new(Msg)
-		msg.SetQuestion(Fqdn(question), TypeANY)
-		msg.Answer = append(msg.Answer, ans...)
-		msg.Ns = append(msg.Ns, ns...)
-		msg.Extra = append(msg.Extra, e...)
-		msg.Compress = true
-		return msg
-	}
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	rrMx := testRR(name1 + " 3600 IN MX 10 " + name1)
-	msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
-	msgBuf, _ := msg.Pack()
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = msg.Unpack(msgBuf)
-	}
-}
-
-func BenchmarkIdGeneration(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		_ = id()
-	}
-}

vendor/github.com/miekg/dns/dns_test.go

@@ -1,320 +0,0 @@
-package dns
-
-import (
-	"bytes"
-	"encoding/hex"
-	"net"
-	"testing"
-)
-
-func TestPackUnpack(t *testing.T) {
-	out := new(Msg)
-	out.Answer = make([]RR, 1)
-	key := new(DNSKEY)
-	key = &DNSKEY{Flags: 257, Protocol: 3, Algorithm: RSASHA1}
-	key.Hdr = RR_Header{Name: "miek.nl.", Rrtype: TypeDNSKEY, Class: ClassINET, Ttl: 3600}
-	key.PublicKey = "AwEAAaHIwpx3w4VHKi6i1LHnTaWeHCL154Jug0Rtc9ji5qwPXpBo6A5sRv7cSsPQKPIwxLpyCrbJ4mr2L0EPOdvP6z6YfljK2ZmTbogU9aSU2fiq/4wjxbdkLyoDVgtO+JsxNN4bjr4WcWhsmk1Hg93FV9ZpkWb0Tbad8DFqNDzr//kZ"
-
-	out.Answer[0] = key
-	msg, err := out.Pack()
-	if err != nil {
-		t.Error("failed to pack msg with DNSKEY")
-	}
-	in := new(Msg)
-	if in.Unpack(msg) != nil {
-		t.Error("failed to unpack msg with DNSKEY")
-	}
-
-	sig := new(RRSIG)
-	sig = &RRSIG{TypeCovered: TypeDNSKEY, Algorithm: RSASHA1, Labels: 2,
-		OrigTtl: 3600, Expiration: 4000, Inception: 4000, KeyTag: 34641, SignerName: "miek.nl.",
-		Signature: "AwEAAaHIwpx3w4VHKi6i1LHnTaWeHCL154Jug0Rtc9ji5qwPXpBo6A5sRv7cSsPQKPIwxLpyCrbJ4mr2L0EPOdvP6z6YfljK2ZmTbogU9aSU2fiq/4wjxbdkLyoDVgtO+JsxNN4bjr4WcWhsmk1Hg93FV9ZpkWb0Tbad8DFqNDzr//kZ"}
-	sig.Hdr = RR_Header{Name: "miek.nl.", Rrtype: TypeRRSIG, Class: ClassINET, Ttl: 3600}
-
-	out.Answer[0] = sig
-	msg, err = out.Pack()
-	if err != nil {
-		t.Error("failed to pack msg with RRSIG")
-	}
-
-	if in.Unpack(msg) != nil {
-		t.Error("failed to unpack msg with RRSIG")
-	}
-}
-
-func TestPackUnpack2(t *testing.T) {
-	m := new(Msg)
-	m.Extra = make([]RR, 1)
-	m.Answer = make([]RR, 1)
-	dom := "miek.nl."
-	rr := new(A)
-	rr.Hdr = RR_Header{Name: dom, Rrtype: TypeA, Class: ClassINET, Ttl: 0}
-	rr.A = net.IPv4(127, 0, 0, 1)
-
-	x := new(TXT)
-	x.Hdr = RR_Header{Name: dom, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}
-	x.Txt = []string{"heelalaollo"}
-
-	m.Extra[0] = x
-	m.Answer[0] = rr
-	_, err := m.Pack()
-	if err != nil {
-		t.Error("Packing failed: ", err)
-		return
-	}
-}
-
-func TestPackUnpack3(t *testing.T) {
-	m := new(Msg)
-	m.Extra = make([]RR, 2)
-	m.Answer = make([]RR, 1)
-	dom := "miek.nl."
-	rr := new(A)
-	rr.Hdr = RR_Header{Name: dom, Rrtype: TypeA, Class: ClassINET, Ttl: 0}
-	rr.A = net.IPv4(127, 0, 0, 1)
-
-	x1 := new(TXT)
-	x1.Hdr = RR_Header{Name: dom, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}
-	x1.Txt = []string{}
-
-	x2 := new(TXT)
-	x2.Hdr = RR_Header{Name: dom, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}
-	x2.Txt = []string{"heelalaollo"}
-
-	m.Extra[0] = x1
-	m.Extra[1] = x2
-	m.Answer[0] = rr
-	b, err := m.Pack()
-	if err != nil {
-		t.Error("packing failed: ", err)
-		return
-	}
-
-	var unpackMsg Msg
-	err = unpackMsg.Unpack(b)
-	if err != nil {
-		t.Error("unpacking failed")
-		return
-	}
-}
-
-func TestBailiwick(t *testing.T) {
-	yes := map[string]string{
-		"miek1.nl": "miek1.nl",
-		"miek.nl":  "ns.miek.nl",
-		".":        "miek.nl",
-	}
-	for parent, child := range yes {
-		if !IsSubDomain(parent, child) {
-			t.Errorf("%s should be child of %s", child, parent)
-			t.Errorf("comparelabels %d", CompareDomainName(parent, child))
-			t.Errorf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
-		}
-	}
-	no := map[string]string{
-		"www.miek.nl":  "ns.miek.nl",
-		"m\\.iek.nl":   "ns.miek.nl",
-		"w\\.iek.nl":   "w.iek.nl",
-		"p\\\\.iek.nl": "ns.p.iek.nl", // p\\.iek.nl , literal \ in domain name
-		"miek.nl":      ".",
-	}
-	for parent, child := range no {
-		if IsSubDomain(parent, child) {
-			t.Errorf("%s should not be child of %s", child, parent)
-			t.Errorf("comparelabels %d", CompareDomainName(parent, child))
-			t.Errorf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
-		}
-	}
-}
-
-func TestPackNAPTR(t *testing.T) {
-	for _, n := range []string{
-		`apple.com. IN NAPTR   100 50 "se" "SIP+D2U" "" _sip._udp.apple.com.`,
-		`apple.com. IN NAPTR   90 50 "se" "SIP+D2T" "" _sip._tcp.apple.com.`,
-		`apple.com. IN NAPTR   50 50 "se" "SIPS+D2T" "" _sips._tcp.apple.com.`,
-	} {
-		rr := testRR(n)
-		msg := make([]byte, rr.len())
-		if off, err := PackRR(rr, msg, 0, nil, false); err != nil {
-			t.Errorf("packing failed: %v", err)
-			t.Errorf("length %d, need more than %d", rr.len(), off)
-		}
-	}
-}
-
-func TestToRFC3597(t *testing.T) {
-	a := testRR("miek.nl. IN A 10.0.1.1")
-	x := new(RFC3597)
-	x.ToRFC3597(a)
-	if x.String() != `miek.nl.	3600	CLASS1	TYPE1	\# 4 0a000101` {
-		t.Errorf("string mismatch, got: %s", x)
-	}
-
-	b := testRR("miek.nl. IN MX 10 mx.miek.nl.")
-	x.ToRFC3597(b)
-	if x.String() != `miek.nl.	3600	CLASS1	TYPE15	\# 14 000a026d78046d69656b026e6c00` {
-		t.Errorf("string mismatch, got: %s", x)
-	}
-}
-
-func TestNoRdataPack(t *testing.T) {
-	data := make([]byte, 1024)
-	for typ, fn := range TypeToRR {
-		r := fn()
-		*r.Header() = RR_Header{Name: "miek.nl.", Rrtype: typ, Class: ClassINET, Ttl: 16}
-		_, err := PackRR(r, data, 0, nil, false)
-		if err != nil {
-			t.Errorf("failed to pack RR with zero rdata: %s: %v", TypeToString[typ], err)
-		}
-	}
-}
-
-func TestNoRdataUnpack(t *testing.T) {
-	data := make([]byte, 1024)
-	for typ, fn := range TypeToRR {
-		if typ == TypeSOA || typ == TypeTSIG || typ == TypeTKEY {
-			// SOA, TSIG will not be seen (like this) in dyn. updates?
-			// TKEY requires length fields to be present for the Key and OtherData fields
-			continue
-		}
-		r := fn()
-		*r.Header() = RR_Header{Name: "miek.nl.", Rrtype: typ, Class: ClassINET, Ttl: 16}
-		off, err := PackRR(r, data, 0, nil, false)
-		if err != nil {
-			// Should always works, TestNoDataPack should have caught this
-			t.Errorf("failed to pack RR: %v", err)
-			continue
-		}
-		if _, _, err := UnpackRR(data[:off], 0); err != nil {
-			t.Errorf("failed to unpack RR with zero rdata: %s: %v", TypeToString[typ], err)
-		}
-	}
-}
-
-func TestRdataOverflow(t *testing.T) {
-	rr := new(RFC3597)
-	rr.Hdr.Name = "."
-	rr.Hdr.Class = ClassINET
-	rr.Hdr.Rrtype = 65280
-	rr.Rdata = hex.EncodeToString(make([]byte, 0xFFFF))
-	buf := make([]byte, 0xFFFF*2)
-	if _, err := PackRR(rr, buf, 0, nil, false); err != nil {
-		t.Fatalf("maximum size rrdata pack failed: %v", err)
-	}
-	rr.Rdata += "00"
-	if _, err := PackRR(rr, buf, 0, nil, false); err != ErrRdata {
-		t.Fatalf("oversize rrdata pack didn't return ErrRdata - instead: %v", err)
-	}
-}
-
-func TestCopy(t *testing.T) {
-	rr := testRR("miek.nl. 2311 IN A 127.0.0.1") // Weird TTL to avoid catching TTL
-	rr1 := Copy(rr)
-	if rr.String() != rr1.String() {
-		t.Fatalf("Copy() failed %s != %s", rr.String(), rr1.String())
-	}
-}
-
-func TestMsgCopy(t *testing.T) {
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeA)
-	rr := testRR("miek.nl. 2311 IN A 127.0.0.1")
-	m.Answer = []RR{rr}
-	rr = testRR("miek.nl. 2311 IN NS 127.0.0.1")
-	m.Ns = []RR{rr}
-
-	m1 := m.Copy()
-	if m.String() != m1.String() {
-		t.Fatalf("Msg.Copy() failed %s != %s", m.String(), m1.String())
-	}
-
-	m1.Answer[0] = testRR("somethingelse.nl. 2311 IN A 127.0.0.1")
-	if m.String() == m1.String() {
-		t.Fatalf("Msg.Copy() failed; change to copy changed template %s", m.String())
-	}
-
-	rr = testRR("miek.nl. 2311 IN A 127.0.0.2")
-	m1.Answer = append(m1.Answer, rr)
-	if m1.Ns[0].String() == m1.Answer[1].String() {
-		t.Fatalf("Msg.Copy() failed; append changed underlying array %s", m1.Ns[0].String())
-	}
-}
-
-func TestMsgPackBuffer(t *testing.T) {
-	var testMessages = []string{
-		// news.ycombinator.com.in.escapemg.com.	IN	A, response
-		"586285830001000000010000046e6577730b79636f6d62696e61746f7203636f6d02696e086573636170656d6703636f6d0000010001c0210006000100000e10002c036e7332c02103646e730b67726f6f7665736861726bc02d77ed50e600002a3000000e1000093a8000000e10",
-
-		// news.ycombinator.com.in.escapemg.com.	IN	A, question
-		"586201000001000000000000046e6577730b79636f6d62696e61746f7203636f6d02696e086573636170656d6703636f6d0000010001",
-
-		"398781020001000000000000046e6577730b79636f6d62696e61746f7203636f6d0000010001",
-	}
-
-	for i, hexData := range testMessages {
-		// we won't fail the decoding of the hex
-		input, _ := hex.DecodeString(hexData)
-		m := new(Msg)
-		if err := m.Unpack(input); err != nil {
-			t.Errorf("packet %d failed to unpack", i)
-			continue
-		}
-	}
-}
-
-// Make sure we can decode a TKEY packet from the string, modify the RR, and then pack it again.
-func TestTKEY(t *testing.T) {
-	// An example TKEY RR captured.  There is no known accepted standard text format for a TKEY
-	// record so we do this from a hex string instead of from a text readable string.
-	tkeyStr := "0737362d6d732d370932322d3332633233332463303439663961662d633065612d313165372d363839362d6463333937396666656666640000f900ff0000000000d2086773732d747369670059fd01f359fe53730003000000b8a181b53081b2a0030a0100a10b06092a864882f712010202a2819d04819a60819706092a864886f71201020202006f8187308184a003020105a10302010fa2783076a003020112a26f046db29b1b1d2625da3b20b49dafef930dd1e9aad335e1c5f45dcd95e0005d67a1100f3e573d70506659dbed064553f1ab890f68f65ae10def0dad5b423b39f240ebe666f2886c5fe03819692d29182bbed87b83e1f9d16b7334ec16a3c4fc5ad4a990088e0be43f0c6957916f5fe60000"
-	tkeyBytes, err := hex.DecodeString(tkeyStr)
-	if err != nil {
-		t.Fatal("unable to decode TKEY string ", err)
-	}
-	// Decode the RR
-	rr, tkeyLen, unPackErr := UnpackRR(tkeyBytes, 0)
-	if unPackErr != nil {
-		t.Fatal("unable to decode TKEY RR", unPackErr)
-	}
-	// Make sure it's a TKEY record
-	if rr.Header().Rrtype != TypeTKEY {
-		t.Fatal("Unable to decode TKEY")
-	}
-	// Make sure we get back the same length
-	if rr.len() != len(tkeyBytes) {
-		t.Fatalf("Lengths don't match %d != %d", rr.len(), len(tkeyBytes))
-	}
-	// make space for it with some fudge room
-	msg := make([]byte, tkeyLen+1000)
-	offset, packErr := PackRR(rr, msg, 0, nil, false)
-	if packErr != nil {
-		t.Fatal("unable to pack TKEY RR", packErr)
-	}
-	if offset != len(tkeyBytes) {
-		t.Fatalf("mismatched TKEY RR size %d != %d", len(tkeyBytes), offset)
-	}
-	if bytes.Compare(tkeyBytes, msg[0:offset]) != 0 {
-		t.Fatal("mismatched TKEY data after rewriting bytes")
-	}
-	t.Logf("got TKEY of: " + rr.String())
-	// Now add some bytes to this and make sure we can encode OtherData properly
-	tkey := rr.(*TKEY)
-	tkey.OtherData = "abcd"
-	tkey.OtherLen = 2
-	offset, packErr = PackRR(tkey, msg, 0, nil, false)
-	if packErr != nil {
-		t.Fatal("unable to pack TKEY RR after modification", packErr)
-	}
-	if offset != (len(tkeyBytes) + 2) {
-		t.Fatalf("mismatched TKEY RR size %d != %d", offset, len(tkeyBytes)+2)
-	}
-	t.Logf("modified to TKEY of: " + rr.String())
-
-	// Make sure we can parse our string output
-	tkey.Hdr.Class = ClassINET // https://github.com/miekg/dns/issues/577
-	newRR, newError := NewRR(tkey.String())
-	if newError != nil {
-		t.Fatalf("unable to parse TKEY string: %s", newError)
-	}
-	t.Log("got reparsed TKEY of newRR: " + newRR.String())
-}

vendor/github.com/miekg/dns/dnssec_test.go

@@ -1,860 +0,0 @@
-package dns
-
-import (
-	"crypto"
-	"crypto/ecdsa"
-	"crypto/rsa"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-
-	"golang.org/x/crypto/ed25519"
-)
-
-func getKey() *DNSKEY {
-	key := new(DNSKEY)
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 14400
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = RSASHA256
-	key.PublicKey = "AwEAAcNEU67LJI5GEgF9QLNqLO1SMq1EdoQ6E9f85ha0k0ewQGCblyW2836GiVsm6k8Kr5ECIoMJ6fZWf3CQSQ9ycWfTyOHfmI3eQ/1Covhb2y4bAmL/07PhrL7ozWBW3wBfM335Ft9xjtXHPy7ztCbV9qZ4TVDTW/Iyg0PiwgoXVesz"
-	return key
-}
-
-func getSoa() *SOA {
-	soa := new(SOA)
-	soa.Hdr = RR_Header{"miek.nl.", TypeSOA, ClassINET, 14400, 0}
-	soa.Ns = "open.nlnetlabs.nl."
-	soa.Mbox = "miekg.atoom.net."
-	soa.Serial = 1293945905
-	soa.Refresh = 14400
-	soa.Retry = 3600
-	soa.Expire = 604800
-	soa.Minttl = 86400
-	return soa
-}
-
-func TestSecure(t *testing.T) {
-	soa := getSoa()
-
-	sig := new(RRSIG)
-	sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
-	sig.TypeCovered = TypeSOA
-	sig.Algorithm = RSASHA256
-	sig.Labels = 2
-	sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
-	sig.Inception = 1293942305  // date -u '+%s' -d"2011-01-02 04:25:05"
-	sig.OrigTtl = 14400
-	sig.KeyTag = 12051
-	sig.SignerName = "miek.nl."
-	sig.Signature = "oMCbslaAVIp/8kVtLSms3tDABpcPRUgHLrOR48OOplkYo+8TeEGWwkSwaz/MRo2fB4FxW0qj/hTlIjUGuACSd+b1wKdH5GvzRJc2pFmxtCbm55ygAh4EUL0F6U5cKtGJGSXxxg6UFCQ0doJCmiGFa78LolaUOXImJrk6AFrGa0M="
-
-	key := new(DNSKEY)
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 14400
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = RSASHA256
-	key.PublicKey = "AwEAAcNEU67LJI5GEgF9QLNqLO1SMq1EdoQ6E9f85ha0k0ewQGCblyW2836GiVsm6k8Kr5ECIoMJ6fZWf3CQSQ9ycWfTyOHfmI3eQ/1Covhb2y4bAmL/07PhrL7ozWBW3wBfM335Ft9xjtXHPy7ztCbV9qZ4TVDTW/Iyg0PiwgoXVesz"
-
-	// It should validate. Period is checked separately, so this will keep on working
-	if sig.Verify(key, []RR{soa}) != nil {
-		t.Error("failure to validate")
-	}
-}
-
-func TestSignature(t *testing.T) {
-	sig := new(RRSIG)
-	sig.Hdr.Name = "miek.nl."
-	sig.Hdr.Class = ClassINET
-	sig.Hdr.Ttl = 3600
-	sig.TypeCovered = TypeDNSKEY
-	sig.Algorithm = RSASHA1
-	sig.Labels = 2
-	sig.OrigTtl = 4000
-	sig.Expiration = 1000 //Thu Jan  1 02:06:40 CET 1970
-	sig.Inception = 800   //Thu Jan  1 01:13:20 CET 1970
-	sig.KeyTag = 34641
-	sig.SignerName = "miek.nl."
-	sig.Signature = "AwEAAaHIwpx3w4VHKi6i1LHnTaWeHCL154Jug0Rtc9ji5qwPXpBo6A5sRv7cSsPQKPIwxLpyCrbJ4mr2L0EPOdvP6z6YfljK2ZmTbogU9aSU2fiq/4wjxbdkLyoDVgtO+JsxNN4bjr4WcWhsmk1Hg93FV9ZpkWb0Tbad8DFqNDzr//kZ"
-
-	// Should not be valid
-	if sig.ValidityPeriod(time.Now()) {
-		t.Error("should not be valid")
-	}
-
-	sig.Inception = 315565800   //Tue Jan  1 10:10:00 CET 1980
-	sig.Expiration = 4102477800 //Fri Jan  1 10:10:00 CET 2100
-	if !sig.ValidityPeriod(time.Now()) {
-		t.Error("should be valid")
-	}
-}
-
-func TestSignVerify(t *testing.T) {
-	// The record we want to sign
-	soa := new(SOA)
-	soa.Hdr = RR_Header{"miek.nl.", TypeSOA, ClassINET, 14400, 0}
-	soa.Ns = "open.nlnetlabs.nl."
-	soa.Mbox = "miekg.atoom.net."
-	soa.Serial = 1293945905
-	soa.Refresh = 14400
-	soa.Retry = 3600
-	soa.Expire = 604800
-	soa.Minttl = 86400
-
-	soa1 := new(SOA)
-	soa1.Hdr = RR_Header{"*.miek.nl.", TypeSOA, ClassINET, 14400, 0}
-	soa1.Ns = "open.nlnetlabs.nl."
-	soa1.Mbox = "miekg.atoom.net."
-	soa1.Serial = 1293945905
-	soa1.Refresh = 14400
-	soa1.Retry = 3600
-	soa1.Expire = 604800
-	soa1.Minttl = 86400
-
-	srv := new(SRV)
-	srv.Hdr = RR_Header{"srv.miek.nl.", TypeSRV, ClassINET, 14400, 0}
-	srv.Port = 1000
-	srv.Weight = 800
-	srv.Target = "web1.miek.nl."
-
-	hinfo := &HINFO{
-		Hdr: RR_Header{
-			Name:   "miek.nl.",
-			Rrtype: TypeHINFO,
-			Class:  ClassINET,
-			Ttl:    3789,
-		},
-		Cpu: "X",
-		Os:  "Y",
-	}
-
-	// With this key
-	key := new(DNSKEY)
-	key.Hdr.Rrtype = TypeDNSKEY
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 14400
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = RSASHA256
-	privkey, _ := key.Generate(512)
-
-	// Fill in the values of the Sig, before signing
-	sig := new(RRSIG)
-	sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
-	sig.TypeCovered = soa.Hdr.Rrtype
-	sig.Labels = uint8(CountLabel(soa.Hdr.Name)) // works for all 3
-	sig.OrigTtl = soa.Hdr.Ttl
-	sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
-	sig.Inception = 1293942305  // date -u '+%s' -d"2011-01-02 04:25:05"
-	sig.KeyTag = key.KeyTag()   // Get the keyfrom the Key
-	sig.SignerName = key.Hdr.Name
-	sig.Algorithm = RSASHA256
-
-	for _, r := range []RR{soa, soa1, srv, hinfo} {
-		if err := sig.Sign(privkey.(*rsa.PrivateKey), []RR{r}); err != nil {
-			t.Error("failure to sign the record:", err)
-			continue
-		}
-		if err := sig.Verify(key, []RR{r}); err != nil {
-			t.Errorf("failure to validate: %s", r.Header().Name)
-			continue
-		}
-	}
-}
-
-func Test65534(t *testing.T) {
-	t6 := new(RFC3597)
-	t6.Hdr = RR_Header{"miek.nl.", 65534, ClassINET, 14400, 0}
-	t6.Rdata = "505D870001"
-	key := new(DNSKEY)
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Rrtype = TypeDNSKEY
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 14400
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = RSASHA256
-	privkey, _ := key.Generate(1024)
-
-	sig := new(RRSIG)
-	sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
-	sig.TypeCovered = t6.Hdr.Rrtype
-	sig.Labels = uint8(CountLabel(t6.Hdr.Name))
-	sig.OrigTtl = t6.Hdr.Ttl
-	sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
-	sig.Inception = 1293942305  // date -u '+%s' -d"2011-01-02 04:25:05"
-	sig.KeyTag = key.KeyTag()
-	sig.SignerName = key.Hdr.Name
-	sig.Algorithm = RSASHA256
-	if err := sig.Sign(privkey.(*rsa.PrivateKey), []RR{t6}); err != nil {
-		t.Error(err)
-		t.Error("failure to sign the TYPE65534 record")
-	}
-	if err := sig.Verify(key, []RR{t6}); err != nil {
-		t.Error(err)
-		t.Errorf("failure to validate %s", t6.Header().Name)
-	}
-}
-
-func TestDnskey(t *testing.T) {
-	pubkey, err := ReadRR(strings.NewReader(`
-miek.nl.	IN	DNSKEY	256 3 10 AwEAAZuMCu2FdugHkTrXYgl5qixvcDw1aDDlvL46/xJKbHBAHY16fNUb2b65cwko2Js/aJxUYJbZk5dwCDZxYfrfbZVtDPQuc3o8QaChVxC7/JYz2AHc9qHvqQ1j4VrH71RWINlQo6VYjzN/BGpMhOZoZOEwzp1HfsOE3lNYcoWU1smL ;{id = 5240 (zsk), size = 1024b}
-`), "Kmiek.nl.+010+05240.key")
-	if err != nil {
-		t.Fatal(err)
-	}
-	privStr := `Private-key-format: v1.3
-Algorithm: 10 (RSASHA512)
-Modulus: m4wK7YV26AeROtdiCXmqLG9wPDVoMOW8vjr/EkpscEAdjXp81RvZvrlzCSjYmz9onFRgltmTl3AINnFh+t9tlW0M9C5zejxBoKFXELv8ljPYAdz2oe+pDWPhWsfvVFYg2VCjpViPM38EakyE5mhk4TDOnUd+w4TeU1hyhZTWyYs=
-PublicExponent: AQAB
-PrivateExponent: UfCoIQ/Z38l8vB6SSqOI/feGjHEl/fxIPX4euKf0D/32k30fHbSaNFrFOuIFmWMB3LimWVEs6u3dpbB9CQeCVg7hwU5puG7OtuiZJgDAhNeOnxvo5btp4XzPZrJSxR4WNQnwIiYWbl0aFlL1VGgHC/3By89ENZyWaZcMLW4KGWE=
-Prime1: yxwC6ogAu8aVcDx2wg1V0b5M5P6jP8qkRFVMxWNTw60Vkn+ECvw6YAZZBHZPaMyRYZLzPgUlyYRd0cjupy4+fQ==
-Prime2: xA1bF8M0RTIQ6+A11AoVG6GIR/aPGg5sogRkIZ7ID/sF6g9HMVU/CM2TqVEBJLRPp73cv6ZeC3bcqOCqZhz+pw==
-Exponent1: xzkblyZ96bGYxTVZm2/vHMOXswod4KWIyMoOepK6B/ZPcZoIT6omLCgtypWtwHLfqyCz3MK51Nc0G2EGzg8rFQ==
-Exponent2: Pu5+mCEb7T5F+kFNZhQadHUklt0JUHbi3hsEvVoHpEGSw3BGDQrtIflDde0/rbWHgDPM4WQY+hscd8UuTXrvLw==
-Coefficient: UuRoNqe7YHnKmQzE6iDWKTMIWTuoqqrFAmXPmKQnC+Y+BQzOVEHUo9bXdDnoI9hzXP1gf8zENMYwYLeWpuYlFQ==
-`
-	privkey, err := pubkey.(*DNSKEY).ReadPrivateKey(strings.NewReader(privStr),
-		"Kmiek.nl.+010+05240.private")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if pubkey.(*DNSKEY).PublicKey != "AwEAAZuMCu2FdugHkTrXYgl5qixvcDw1aDDlvL46/xJKbHBAHY16fNUb2b65cwko2Js/aJxUYJbZk5dwCDZxYfrfbZVtDPQuc3o8QaChVxC7/JYz2AHc9qHvqQ1j4VrH71RWINlQo6VYjzN/BGpMhOZoZOEwzp1HfsOE3lNYcoWU1smL" {
-		t.Error("pubkey is not what we've read")
-	}
-	if pubkey.(*DNSKEY).PrivateKeyString(privkey) != privStr {
-		t.Error("privkey is not what we've read")
-		t.Errorf("%v", pubkey.(*DNSKEY).PrivateKeyString(privkey))
-	}
-}
-
-func TestTag(t *testing.T) {
-	key := new(DNSKEY)
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Rrtype = TypeDNSKEY
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 3600
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = RSASHA256
-	key.PublicKey = "AwEAAcNEU67LJI5GEgF9QLNqLO1SMq1EdoQ6E9f85ha0k0ewQGCblyW2836GiVsm6k8Kr5ECIoMJ6fZWf3CQSQ9ycWfTyOHfmI3eQ/1Covhb2y4bAmL/07PhrL7ozWBW3wBfM335Ft9xjtXHPy7ztCbV9qZ4TVDTW/Iyg0PiwgoXVesz"
-
-	tag := key.KeyTag()
-	if tag != 12051 {
-		t.Errorf("wrong key tag: %d for key %v", tag, key)
-	}
-}
-
-func TestKeyRSA(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping test in short mode.")
-	}
-	key := new(DNSKEY)
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Rrtype = TypeDNSKEY
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 3600
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = RSASHA256
-	priv, _ := key.Generate(2048)
-
-	soa := new(SOA)
-	soa.Hdr = RR_Header{"miek.nl.", TypeSOA, ClassINET, 14400, 0}
-	soa.Ns = "open.nlnetlabs.nl."
-	soa.Mbox = "miekg.atoom.net."
-	soa.Serial = 1293945905
-	soa.Refresh = 14400
-	soa.Retry = 3600
-	soa.Expire = 604800
-	soa.Minttl = 86400
-
-	sig := new(RRSIG)
-	sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
-	sig.TypeCovered = TypeSOA
-	sig.Algorithm = RSASHA256
-	sig.Labels = 2
-	sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
-	sig.Inception = 1293942305  // date -u '+%s' -d"2011-01-02 04:25:05"
-	sig.OrigTtl = soa.Hdr.Ttl
-	sig.KeyTag = key.KeyTag()
-	sig.SignerName = key.Hdr.Name
-
-	if err := sig.Sign(priv.(*rsa.PrivateKey), []RR{soa}); err != nil {
-		t.Error("failed to sign")
-		return
-	}
-	if err := sig.Verify(key, []RR{soa}); err != nil {
-		t.Error("failed to verify")
-	}
-}
-
-func TestKeyToDS(t *testing.T) {
-	key := new(DNSKEY)
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Rrtype = TypeDNSKEY
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 3600
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = RSASHA256
-	key.PublicKey = "AwEAAcNEU67LJI5GEgF9QLNqLO1SMq1EdoQ6E9f85ha0k0ewQGCblyW2836GiVsm6k8Kr5ECIoMJ6fZWf3CQSQ9ycWfTyOHfmI3eQ/1Covhb2y4bAmL/07PhrL7ozWBW3wBfM335Ft9xjtXHPy7ztCbV9qZ4TVDTW/Iyg0PiwgoXVesz"
-
-	ds := key.ToDS(SHA1)
-	if strings.ToUpper(ds.Digest) != "B5121BDB5B8D86D0CC5FFAFBAAABE26C3E20BAC1" {
-		t.Errorf("wrong DS digest for SHA1\n%v", ds)
-	}
-}
-
-func TestSignRSA(t *testing.T) {
-	pub := "miek.nl. IN DNSKEY 256 3 5 AwEAAb+8lGNCxJgLS8rYVer6EnHVuIkQDghdjdtewDzU3G5R7PbMbKVRvH2Ma7pQyYceoaqWZQirSj72euPWfPxQnMy9ucCylA+FuH9cSjIcPf4PqJfdupHk9X6EBYjxrCLY4p1/yBwgyBIRJtZtAqM3ceAH2WovEJD6rTtOuHo5AluJ"
-
-	priv := `Private-key-format: v1.3
-Algorithm: 5 (RSASHA1)
-Modulus: v7yUY0LEmAtLythV6voScdW4iRAOCF2N217APNTcblHs9sxspVG8fYxrulDJhx6hqpZlCKtKPvZ649Z8/FCczL25wLKUD4W4f1xKMhw9/g+ol926keT1foQFiPGsItjinX/IHCDIEhEm1m0Cozdx4AfZai8QkPqtO064ejkCW4k=
-PublicExponent: AQAB
-PrivateExponent: YPwEmwjk5HuiROKU4xzHQ6l1hG8Iiha4cKRG3P5W2b66/EN/GUh07ZSf0UiYB67o257jUDVEgwCuPJz776zfApcCB4oGV+YDyEu7Hp/rL8KcSN0la0k2r9scKwxTp4BTJT23zyBFXsV/1wRDK1A5NxsHPDMYi2SoK63Enm/1ptk=
-Prime1: /wjOG+fD0ybNoSRn7nQ79udGeR1b0YhUA5mNjDx/x2fxtIXzygYk0Rhx9QFfDy6LOBvz92gbNQlzCLz3DJt5hw==
-Prime2: wHZsJ8OGhkp5p3mrJFZXMDc2mbYusDVTA+t+iRPdS797Tj0pjvU2HN4vTnTj8KBQp6hmnY7dLp9Y1qserySGbw==
-Exponent1: N0A7FsSRIg+IAN8YPQqlawoTtG1t1OkJ+nWrurPootScApX6iMvn8fyvw3p2k51rv84efnzpWAYiC8SUaQDNxQ==
-Exponent2: SvuYRaGyvo0zemE3oS+WRm2scxR8eiA8WJGeOc+obwOKCcBgeZblXzfdHGcEC1KaOcetOwNW/vwMA46lpLzJNw==
-Coefficient: 8+7ZN/JgByqv0NfULiFKTjtyegUcijRuyij7yNxYbCBneDvZGxJwKNi4YYXWx743pcAj4Oi4Oh86gcmxLs+hGw==
-Created: 20110302104537
-Publish: 20110302104537
-Activate: 20110302104537`
-
-	xk := testRR(pub)
-	k := xk.(*DNSKEY)
-	p, err := k.NewPrivateKey(priv)
-	if err != nil {
-		t.Error(err)
-	}
-	switch priv := p.(type) {
-	case *rsa.PrivateKey:
-		if 65537 != priv.PublicKey.E {
-			t.Error("exponenent should be 65537")
-		}
-	default:
-		t.Errorf("we should have read an RSA key: %v", priv)
-	}
-	if k.KeyTag() != 37350 {
-		t.Errorf("keytag should be 37350, got %d %v", k.KeyTag(), k)
-	}
-
-	soa := new(SOA)
-	soa.Hdr = RR_Header{"miek.nl.", TypeSOA, ClassINET, 14400, 0}
-	soa.Ns = "open.nlnetlabs.nl."
-	soa.Mbox = "miekg.atoom.net."
-	soa.Serial = 1293945905
-	soa.Refresh = 14400
-	soa.Retry = 3600
-	soa.Expire = 604800
-	soa.Minttl = 86400
-
-	sig := new(RRSIG)
-	sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
-	sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
-	sig.Inception = 1293942305  // date -u '+%s' -d"2011-01-02 04:25:05"
-	sig.KeyTag = k.KeyTag()
-	sig.SignerName = k.Hdr.Name
-	sig.Algorithm = k.Algorithm
-
-	sig.Sign(p.(*rsa.PrivateKey), []RR{soa})
-	if sig.Signature != "D5zsobpQcmMmYsUMLxCVEtgAdCvTu8V/IEeP4EyLBjqPJmjt96bwM9kqihsccofA5LIJ7DN91qkCORjWSTwNhzCv7bMyr2o5vBZElrlpnRzlvsFIoAZCD9xg6ZY7ZyzUJmU6IcTwG4v3xEYajcpbJJiyaw/RqR90MuRdKPiBzSo=" {
-		t.Errorf("signature is not correct: %v", sig)
-	}
-}
-
-func TestSignVerifyECDSA(t *testing.T) {
-	pub := `example.net. 3600 IN DNSKEY 257 3 14 (
-	xKYaNhWdGOfJ+nPrL8/arkwf2EY3MDJ+SErKivBVSum1
-	w/egsXvSADtNJhyem5RCOpgQ6K8X1DRSEkrbYQ+OB+v8
-	/uX45NBwY8rp65F6Glur8I/mlVNgF6W/qTI37m40 )`
-	priv := `Private-key-format: v1.2
-Algorithm: 14 (ECDSAP384SHA384)
-PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
-
-	eckey := testRR(pub)
-	privkey, err := eckey.(*DNSKEY).NewPrivateKey(priv)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// TODO: Create separate test for this
-	ds := eckey.(*DNSKEY).ToDS(SHA384)
-	if ds.KeyTag != 10771 {
-		t.Fatal("wrong keytag on DS")
-	}
-	if ds.Digest != "72d7b62976ce06438e9c0bf319013cf801f09ecc84b8d7e9495f27e305c6a9b0563a9b5f4d288405c3008a946df983d6" {
-		t.Fatal("wrong DS Digest")
-	}
-	a := testRR("www.example.net. 3600 IN A 192.0.2.1")
-	sig := new(RRSIG)
-	sig.Hdr = RR_Header{"example.net.", TypeRRSIG, ClassINET, 14400, 0}
-	sig.Expiration, _ = StringToTime("20100909102025")
-	sig.Inception, _ = StringToTime("20100812102025")
-	sig.KeyTag = eckey.(*DNSKEY).KeyTag()
-	sig.SignerName = eckey.(*DNSKEY).Hdr.Name
-	sig.Algorithm = eckey.(*DNSKEY).Algorithm
-
-	if sig.Sign(privkey.(*ecdsa.PrivateKey), []RR{a}) != nil {
-		t.Fatal("failure to sign the record")
-	}
-
-	if err := sig.Verify(eckey.(*DNSKEY), []RR{a}); err != nil {
-		t.Fatalf("failure to validate:\n%s\n%s\n%s\n\n%s\n\n%v",
-			eckey.(*DNSKEY).String(),
-			a.String(),
-			sig.String(),
-			eckey.(*DNSKEY).PrivateKeyString(privkey),
-			err,
-		)
-	}
-}
-
-func TestSignVerifyECDSA2(t *testing.T) {
-	srv1 := testRR("srv.miek.nl. IN SRV 1000 800 0 web1.miek.nl.")
-	srv := srv1.(*SRV)
-
-	// With this key
-	key := new(DNSKEY)
-	key.Hdr.Rrtype = TypeDNSKEY
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 14400
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = ECDSAP256SHA256
-	privkey, err := key.Generate(256)
-	if err != nil {
-		t.Fatal("failure to generate key")
-	}
-
-	// Fill in the values of the Sig, before signing
-	sig := new(RRSIG)
-	sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
-	sig.TypeCovered = srv.Hdr.Rrtype
-	sig.Labels = uint8(CountLabel(srv.Hdr.Name)) // works for all 3
-	sig.OrigTtl = srv.Hdr.Ttl
-	sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
-	sig.Inception = 1293942305  // date -u '+%s' -d"2011-01-02 04:25:05"
-	sig.KeyTag = key.KeyTag()   // Get the keyfrom the Key
-	sig.SignerName = key.Hdr.Name
-	sig.Algorithm = ECDSAP256SHA256
-
-	if sig.Sign(privkey.(*ecdsa.PrivateKey), []RR{srv}) != nil {
-		t.Fatal("failure to sign the record")
-	}
-
-	err = sig.Verify(key, []RR{srv})
-	if err != nil {
-		t.Errorf("failure to validate:\n%s\n%s\n%s\n\n%s\n\n%v",
-			key.String(),
-			srv.String(),
-			sig.String(),
-			key.PrivateKeyString(privkey),
-			err,
-		)
-	}
-}
-
-func TestSignVerifyEd25519(t *testing.T) {
-	srv1, err := NewRR("srv.miek.nl. IN SRV 1000 800 0 web1.miek.nl.")
-	if err != nil {
-		t.Fatal(err)
-	}
-	srv := srv1.(*SRV)
-
-	// With this key
-	key := new(DNSKEY)
-	key.Hdr.Rrtype = TypeDNSKEY
-	key.Hdr.Name = "miek.nl."
-	key.Hdr.Class = ClassINET
-	key.Hdr.Ttl = 14400
-	key.Flags = 256
-	key.Protocol = 3
-	key.Algorithm = ED25519
-	privkey, err := key.Generate(256)
-	if err != nil {
-		t.Fatal("failure to generate key")
-	}
-
-	// Fill in the values of the Sig, before signing
-	sig := new(RRSIG)
-	sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
-	sig.TypeCovered = srv.Hdr.Rrtype
-	sig.Labels = uint8(CountLabel(srv.Hdr.Name)) // works for all 3
-	sig.OrigTtl = srv.Hdr.Ttl
-	sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
-	sig.Inception = 1293942305  // date -u '+%s' -d"2011-01-02 04:25:05"
-	sig.KeyTag = key.KeyTag()   // Get the keyfrom the Key
-	sig.SignerName = key.Hdr.Name
-	sig.Algorithm = ED25519
-
-	if sig.Sign(privkey.(ed25519.PrivateKey), []RR{srv}) != nil {
-		t.Fatal("failure to sign the record")
-	}
-
-	err = sig.Verify(key, []RR{srv})
-	if err != nil {
-		t.Logf("failure to validate:\n%s\n%s\n%s\n\n%s\n\n%v",
-			key.String(),
-			srv.String(),
-			sig.String(),
-			key.PrivateKeyString(privkey),
-			err,
-		)
-	}
-}
-
-// Here the test vectors from the relevant RFCs are checked.
-// rfc6605 6.1
-func TestRFC6605P256(t *testing.T) {
-	exDNSKEY := `example.net. 3600 IN DNSKEY 257 3 13 (
-                 GojIhhXUN/u4v54ZQqGSnyhWJwaubCvTmeexv7bR6edb
-                 krSqQpF64cYbcB7wNcP+e+MAnLr+Wi9xMWyQLc8NAA== )`
-	exPriv := `Private-key-format: v1.2
-Algorithm: 13 (ECDSAP256SHA256)
-PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=`
-	rrDNSKEY := testRR(exDNSKEY)
-	priv, err := rrDNSKEY.(*DNSKEY).NewPrivateKey(exPriv)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	exDS := `example.net. 3600 IN DS 55648 13 2 (
-             b4c8c1fe2e7477127b27115656ad6256f424625bf5c1
-             e2770ce6d6e37df61d17 )`
-	rrDS := testRR(exDS)
-	ourDS := rrDNSKEY.(*DNSKEY).ToDS(SHA256)
-	if !reflect.DeepEqual(ourDS, rrDS.(*DS)) {
-		t.Errorf("DS record differs:\n%v\n%v", ourDS, rrDS.(*DS))
-	}
-
-	exA := `www.example.net. 3600 IN A 192.0.2.1`
-	exRRSIG := `www.example.net. 3600 IN RRSIG A 13 3 3600 (
-                20100909100439 20100812100439 55648 example.net.
-                qx6wLYqmh+l9oCKTN6qIc+bw6ya+KJ8oMz0YP107epXA
-                yGmt+3SNruPFKG7tZoLBLlUzGGus7ZwmwWep666VCw== )`
-	rrA := testRR(exA)
-	rrRRSIG := testRR(exRRSIG)
-	if err := rrRRSIG.(*RRSIG).Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
-		t.Errorf("failure to validate the spec RRSIG: %v", err)
-	}
-
-	ourRRSIG := &RRSIG{
-		Hdr: RR_Header{
-			Ttl: rrA.Header().Ttl,
-		},
-		KeyTag:     rrDNSKEY.(*DNSKEY).KeyTag(),
-		SignerName: rrDNSKEY.(*DNSKEY).Hdr.Name,
-		Algorithm:  rrDNSKEY.(*DNSKEY).Algorithm,
-	}
-	ourRRSIG.Expiration, _ = StringToTime("20100909100439")
-	ourRRSIG.Inception, _ = StringToTime("20100812100439")
-	err = ourRRSIG.Sign(priv.(*ecdsa.PrivateKey), []RR{rrA})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err = ourRRSIG.Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
-		t.Errorf("failure to validate our RRSIG: %v", err)
-	}
-
-	// Signatures are randomized
-	rrRRSIG.(*RRSIG).Signature = ""
-	ourRRSIG.Signature = ""
-	if !reflect.DeepEqual(ourRRSIG, rrRRSIG.(*RRSIG)) {
-		t.Fatalf("RRSIG record differs:\n%v\n%v", ourRRSIG, rrRRSIG.(*RRSIG))
-	}
-}
-
-// rfc6605 6.2
-func TestRFC6605P384(t *testing.T) {
-	exDNSKEY := `example.net. 3600 IN DNSKEY 257 3 14 (
-                 xKYaNhWdGOfJ+nPrL8/arkwf2EY3MDJ+SErKivBVSum1
-                 w/egsXvSADtNJhyem5RCOpgQ6K8X1DRSEkrbYQ+OB+v8
-                 /uX45NBwY8rp65F6Glur8I/mlVNgF6W/qTI37m40 )`
-	exPriv := `Private-key-format: v1.2
-Algorithm: 14 (ECDSAP384SHA384)
-PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
-	rrDNSKEY := testRR(exDNSKEY)
-	priv, err := rrDNSKEY.(*DNSKEY).NewPrivateKey(exPriv)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	exDS := `example.net. 3600 IN DS 10771 14 4 (
-           72d7b62976ce06438e9c0bf319013cf801f09ecc84b8
-           d7e9495f27e305c6a9b0563a9b5f4d288405c3008a94
-           6df983d6 )`
-	rrDS := testRR(exDS)
-	ourDS := rrDNSKEY.(*DNSKEY).ToDS(SHA384)
-	if !reflect.DeepEqual(ourDS, rrDS.(*DS)) {
-		t.Fatalf("DS record differs:\n%v\n%v", ourDS, rrDS.(*DS))
-	}
-
-	exA := `www.example.net. 3600 IN A 192.0.2.1`
-	exRRSIG := `www.example.net. 3600 IN RRSIG A 14 3 3600 (
-           20100909102025 20100812102025 10771 example.net.
-           /L5hDKIvGDyI1fcARX3z65qrmPsVz73QD1Mr5CEqOiLP
-           95hxQouuroGCeZOvzFaxsT8Glr74hbavRKayJNuydCuz
-           WTSSPdz7wnqXL5bdcJzusdnI0RSMROxxwGipWcJm )`
-	rrA := testRR(exA)
-	rrRRSIG := testRR(exRRSIG)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err = rrRRSIG.(*RRSIG).Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
-		t.Errorf("failure to validate the spec RRSIG: %v", err)
-	}
-
-	ourRRSIG := &RRSIG{
-		Hdr: RR_Header{
-			Ttl: rrA.Header().Ttl,
-		},
-		KeyTag:     rrDNSKEY.(*DNSKEY).KeyTag(),
-		SignerName: rrDNSKEY.(*DNSKEY).Hdr.Name,
-		Algorithm:  rrDNSKEY.(*DNSKEY).Algorithm,
-	}
-	ourRRSIG.Expiration, _ = StringToTime("20100909102025")
-	ourRRSIG.Inception, _ = StringToTime("20100812102025")
-	err = ourRRSIG.Sign(priv.(*ecdsa.PrivateKey), []RR{rrA})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err = ourRRSIG.Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
-		t.Errorf("failure to validate our RRSIG: %v", err)
-	}
-
-	// Signatures are randomized
-	rrRRSIG.(*RRSIG).Signature = ""
-	ourRRSIG.Signature = ""
-	if !reflect.DeepEqual(ourRRSIG, rrRRSIG.(*RRSIG)) {
-		t.Fatalf("RRSIG record differs:\n%v\n%v", ourRRSIG, rrRRSIG.(*RRSIG))
-	}
-}
-
-// rfc8080 6.1
-func TestRFC8080Ed25519Example1(t *testing.T) {
-	exDNSKEY := `example.com. 3600 IN DNSKEY 257 3 15 (
-             l02Woi0iS8Aa25FQkUd9RMzZHJpBoRQwAQEX1SxZJA4= )`
-	exPriv := `Private-key-format: v1.2
-Algorithm: 15 (ED25519)
-PrivateKey: ODIyNjAzODQ2MjgwODAxMjI2NDUxOTAyMDQxNDIyNjI=`
-	rrDNSKEY, err := NewRR(exDNSKEY)
-	if err != nil {
-		t.Fatal(err)
-	}
-	priv, err := rrDNSKEY.(*DNSKEY).NewPrivateKey(exPriv)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	exDS := `example.com. 3600 IN DS 3613 15 2 (
-             3aa5ab37efce57f737fc1627013fee07bdf241bd10f3b1964ab55c78e79
-             a304b )`
-	rrDS, err := NewRR(exDS)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ourDS := rrDNSKEY.(*DNSKEY).ToDS(SHA256)
-	if !reflect.DeepEqual(ourDS, rrDS.(*DS)) {
-		t.Fatalf("DS record differs:\n%v\n%v", ourDS, rrDS.(*DS))
-	}
-
-	exMX := `example.com. 3600 IN MX 10 mail.example.com.`
-	exRRSIG := `example.com. 3600 IN RRSIG MX 15 2 3600 (
-             1440021600 1438207200 3613 example.com. (
-             oL9krJun7xfBOIWcGHi7mag5/hdZrKWw15jPGrHpjQeRAvTdszaPD+QLs3f
-             x8A4M3e23mRZ9VrbpMngwcrqNAg== ) )`
-	rrMX, err := NewRR(exMX)
-	if err != nil {
-		t.Fatal(err)
-	}
-	rrRRSIG, err := NewRR(exRRSIG)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err = rrRRSIG.(*RRSIG).Verify(rrDNSKEY.(*DNSKEY), []RR{rrMX}); err != nil {
-		t.Errorf("failure to validate the spec RRSIG: %v", err)
-	}
-
-	ourRRSIG := &RRSIG{
-		Hdr: RR_Header{
-			Ttl: rrMX.Header().Ttl,
-		},
-		KeyTag:     rrDNSKEY.(*DNSKEY).KeyTag(),
-		SignerName: rrDNSKEY.(*DNSKEY).Hdr.Name,
-		Algorithm:  rrDNSKEY.(*DNSKEY).Algorithm,
-	}
-	ourRRSIG.Expiration, _ = StringToTime("20150819220000")
-	ourRRSIG.Inception, _ = StringToTime("20150729220000")
-	err = ourRRSIG.Sign(priv.(ed25519.PrivateKey), []RR{rrMX})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err = ourRRSIG.Verify(rrDNSKEY.(*DNSKEY), []RR{rrMX}); err != nil {
-		t.Errorf("failure to validate our RRSIG: %v", err)
-	}
-
-	if !reflect.DeepEqual(ourRRSIG, rrRRSIG.(*RRSIG)) {
-		t.Fatalf("RRSIG record differs:\n%v\n%v", ourRRSIG, rrRRSIG.(*RRSIG))
-	}
-}
-
-// rfc8080 6.1
-func TestRFC8080Ed25519Example2(t *testing.T) {
-	exDNSKEY := `example.com. 3600 IN DNSKEY 257 3 15 (
-             zPnZ/QwEe7S8C5SPz2OfS5RR40ATk2/rYnE9xHIEijs= )`
-	exPriv := `Private-key-format: v1.2
-Algorithm: 15 (ED25519)
-PrivateKey: DSSF3o0s0f+ElWzj9E/Osxw8hLpk55chkmx0LYN5WiY=`
-	rrDNSKEY, err := NewRR(exDNSKEY)
-	if err != nil {
-		t.Fatal(err)
-	}
-	priv, err := rrDNSKEY.(*DNSKEY).NewPrivateKey(exPriv)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	exDS := `example.com. 3600 IN DS 35217 15 2 (
-             401781b934e392de492ec77ae2e15d70f6575a1c0bc59c5275c04ebe80c
-             6614c )`
-	rrDS, err := NewRR(exDS)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ourDS := rrDNSKEY.(*DNSKEY).ToDS(SHA256)
-	if !reflect.DeepEqual(ourDS, rrDS.(*DS)) {
-		t.Fatalf("DS record differs:\n%v\n%v", ourDS, rrDS.(*DS))
-	}
-
-	exMX := `example.com. 3600 IN MX 10 mail.example.com.`
-	exRRSIG := `example.com. 3600 IN RRSIG MX 15 2 3600 (
-             1440021600 1438207200 35217 example.com. (
-             zXQ0bkYgQTEFyfLyi9QoiY6D8ZdYo4wyUhVioYZXFdT410QPRITQSqJSnzQ
-             oSm5poJ7gD7AQR0O7KuI5k2pcBg== ) )`
-	rrMX, err := NewRR(exMX)
-	if err != nil {
-		t.Fatal(err)
-	}
-	rrRRSIG, err := NewRR(exRRSIG)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err = rrRRSIG.(*RRSIG).Verify(rrDNSKEY.(*DNSKEY), []RR{rrMX}); err != nil {
-		t.Errorf("failure to validate the spec RRSIG: %v", err)
-	}
-
-	ourRRSIG := &RRSIG{
-		Hdr: RR_Header{
-			Ttl: rrMX.Header().Ttl,
-		},
-		KeyTag:     rrDNSKEY.(*DNSKEY).KeyTag(),
-		SignerName: rrDNSKEY.(*DNSKEY).Hdr.Name,
-		Algorithm:  rrDNSKEY.(*DNSKEY).Algorithm,
-	}
-	ourRRSIG.Expiration, _ = StringToTime("20150819220000")
-	ourRRSIG.Inception, _ = StringToTime("20150729220000")
-	err = ourRRSIG.Sign(priv.(ed25519.PrivateKey), []RR{rrMX})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err = ourRRSIG.Verify(rrDNSKEY.(*DNSKEY), []RR{rrMX}); err != nil {
-		t.Errorf("failure to validate our RRSIG: %v", err)
-	}
-
-	if !reflect.DeepEqual(ourRRSIG, rrRRSIG.(*RRSIG)) {
-		t.Fatalf("RRSIG record differs:\n%v\n%v", ourRRSIG, rrRRSIG.(*RRSIG))
-	}
-}
-
-func TestInvalidRRSet(t *testing.T) {
-	goodRecords := make([]RR, 2)
-	goodRecords[0] = &TXT{Hdr: RR_Header{Name: "name.cloudflare.com.", Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
-	goodRecords[1] = &TXT{Hdr: RR_Header{Name: "name.cloudflare.com.", Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"_o/"}}
-
-	// Generate key
-	keyname := "cloudflare.com."
-	key := &DNSKEY{
-		Hdr:       RR_Header{Name: keyname, Rrtype: TypeDNSKEY, Class: ClassINET, Ttl: 0},
-		Algorithm: ECDSAP256SHA256,
-		Flags:     ZONE,
-		Protocol:  3,
-	}
-	privatekey, err := key.Generate(256)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
-
-	// Need to fill in: Inception, Expiration, KeyTag, SignerName and Algorithm
-	curTime := time.Now()
-	signature := &RRSIG{
-		Inception:  uint32(curTime.Unix()),
-		Expiration: uint32(curTime.Add(time.Hour).Unix()),
-		KeyTag:     key.KeyTag(),
-		SignerName: keyname,
-		Algorithm:  ECDSAP256SHA256,
-	}
-
-	// Inconsistent name between records
-	badRecords := make([]RR, 2)
-	badRecords[0] = &TXT{Hdr: RR_Header{Name: "name.cloudflare.com.", Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
-	badRecords[1] = &TXT{Hdr: RR_Header{Name: "nama.cloudflare.com.", Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"_o/"}}
-
-	if IsRRset(badRecords) {
-		t.Fatal("Record set with inconsistent names considered valid")
-	}
-
-	badRecords[0] = &TXT{Hdr: RR_Header{Name: "name.cloudflare.com.", Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
-	badRecords[1] = &A{Hdr: RR_Header{Name: "name.cloudflare.com.", Rrtype: TypeA, Class: ClassINET, Ttl: 0}}
-
-	if IsRRset(badRecords) {
-		t.Fatal("Record set with inconsistent record types considered valid")
-	}
-
-	badRecords[0] = &TXT{Hdr: RR_Header{Name: "name.cloudflare.com.", Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
-	badRecords[1] = &TXT{Hdr: RR_Header{Name: "name.cloudflare.com.", Rrtype: TypeTXT, Class: ClassCHAOS, Ttl: 0}, Txt: []string{"_o/"}}
-
-	if IsRRset(badRecords) {
-		t.Fatal("Record set with inconsistent record class considered valid")
-	}
-
-	// Sign the good record set and then make sure verification fails on the bad record set
-	if err := signature.Sign(privatekey.(crypto.Signer), goodRecords); err != nil {
-		t.Fatal("Signing good records failed")
-	}
-
-	if err := signature.Verify(key, badRecords); err != ErrRRset {
-		t.Fatal("Verification did not return ErrRRset with inconsistent records")
-	}
-}
-
-// Issue #688 - RSA exponent unpacked in reverse
-func TestRsaExponentUnpack(t *testing.T) {
-	zskRrDnskey, _ := NewRR("isc.org.                7200    IN      DNSKEY  256 3 5 AwEAAcdkaRUlsRD4gcF63PpPJJ1E6kOIb3yn/UHptVsPEQtEbgJ2y20O eix4unpwoQkz+bIAd2rrOU/95wgV530x0/qqKwBLWoGkxdcnNcvVT4hl 3SOTZy1VjwkAfyayHPU8VisXqJGbB3KWevBZlb6AtrXzFu8AHuBeeAAe /fOgreCh")
-	kskRrDnskey, _ := NewRR("isc.org.                7200    IN      DNSKEY  257 3 5 BEAAAAOhHQDBrhQbtphgq2wQUpEQ5t4DtUHxoMVFu2hWLDMvoOMRXjGr hhCeFvAZih7yJHf8ZGfW6hd38hXG/xylYCO6Krpbdojwx8YMXLA5/kA+ u50WIL8ZR1R6KTbsYVMf/Qx5RiNbPClw+vT+U8eXEJmO20jIS1ULgqy3 47cBB1zMnnz/4LJpA0da9CbKj3A254T515sNIMcwsB8/2+2E63/zZrQz Bkj0BrN/9Bexjpiks3jRhZatEsXn3dTy47R09Uix5WcJt+xzqZ7+ysyL KOOedS39Z7SDmsn2eA0FKtQpwA6LXeG2w+jxmw3oA8lVUgEf/rzeC/bB yBNsO70aEFTd")
-	kskRrRrsig, _ := NewRR("isc.org.                7200    IN      RRSIG   DNSKEY 5 2 7200 20180627230244 20180528230244 12892 isc.org. ebKBlhYi1hPGTdPg6zSwvprOIkoFMs+WIhMSjoYW6/K5CS9lDDFdK4cu TgXJRT3etrltTuJiFe2HRpp+7t5cKLy+CeJZVzqrCz200MoHiFuLI9yI DJQGaS5YYCiFbw5+jUGU6aUhZ7Y5/YufeqATkRZzdrKwgK+zri8LPw9T WLoVJPAOW7GR0dgxl9WKmO7Fzi9P8BZR3NuwLV7329X94j+4zyswaw7q e5vif0ybzFveODLsEi/E0a2rTXc4QzzyM0fSVxRkVQyQ7ifIPP4ohnnT d5qpPUbE8xxBzTdWR/TaKADC5aCFkppG9lVAq5CPfClii2949X5RYzy1 rxhuSA==")
-	zskRrRrsig, _ := NewRR("isc.org.                7200    IN      RRSIG   DNSKEY 5 2 7200 20180627230244 20180528230244 19923 isc.org. RgCfzUeq4RJPGoe9RRB6cWf6d/Du+tHK5SxI5QL1waA3O5qVtQKFkY1C dq/yyVjwzfjD9F62TObujOaktv8X80ZMcNPmgHbvK1xOqelMBWv5hxj3 xRe+QQObLZ5NPfHFsphQKXvwgO5Sjk8py2B2iCr3BHCZ8S38oIfuSrQx sn8=")
-
-	zsk, ksk := zskRrDnskey.(*DNSKEY), kskRrDnskey.(*DNSKEY)
-	zskSig, kskSig := zskRrRrsig.(*RRSIG), kskRrRrsig.(*RRSIG)
-
-	if e := zskSig.Verify(zsk, []RR{zsk, ksk}); e != nil {
-		t.Fatalf("cannot verify RRSIG with keytag [%d]. Cause [%s]", zsk.KeyTag(), e.Error())
-	}
-
-	if e := kskSig.Verify(ksk, []RR{zsk, ksk}); e != nil {
-		t.Fatalf("cannot verify RRSIG with keytag [%d]. Cause [%s]", ksk.KeyTag(), e.Error())
-	}
-}

vendor/github.com/miekg/dns/dyn_test.go

@@ -1,3 +0,0 @@
-package dns
-
-// Find better solution

vendor/github.com/miekg/dns/edns_test.go

@@ -1,68 +0,0 @@
-package dns
-
-import "testing"
-
-func TestOPTTtl(t *testing.T) {
-	e := &OPT{}
-	e.Hdr.Name = "."
-	e.Hdr.Rrtype = TypeOPT
-
-	// verify the default setting of DO=0
-	if e.Do() {
-		t.Errorf("DO bit should be zero")
-	}
-
-	// There are 6 possible invocations of SetDo():
-	//
-	// 1. Starting with DO=0, using SetDo()
-	// 2. Starting with DO=0, using SetDo(true)
-	// 3. Starting with DO=0, using SetDo(false)
-	// 4. Starting with DO=1, using SetDo()
-	// 5. Starting with DO=1, using SetDo(true)
-	// 6. Starting with DO=1, using SetDo(false)
-
-	// verify that invoking SetDo() sets DO=1 (TEST #1)
-	e.SetDo()
-	if !e.Do() {
-		t.Errorf("DO bit should be non-zero")
-	}
-	// verify that using SetDo(true) works when DO=1 (TEST #5)
-	e.SetDo(true)
-	if !e.Do() {
-		t.Errorf("DO bit should still be non-zero")
-	}
-	// verify that we can use SetDo(false) to set DO=0 (TEST #6)
-	e.SetDo(false)
-	if e.Do() {
-		t.Errorf("DO bit should be zero")
-	}
-	// verify that if we call SetDo(false) when DO=0 that it is unchanged (TEST #3)
-	e.SetDo(false)
-	if e.Do() {
-		t.Errorf("DO bit should still be zero")
-	}
-	// verify that using SetDo(true) works for DO=0 (TEST #2)
-	e.SetDo(true)
-	if !e.Do() {
-		t.Errorf("DO bit should be non-zero")
-	}
-	// verify that using SetDo() works for DO=1 (TEST #4)
-	e.SetDo()
-	if !e.Do() {
-		t.Errorf("DO bit should be non-zero")
-	}
-
-	if e.Version() != 0 {
-		t.Errorf("version should be non-zero")
-	}
-
-	e.SetVersion(42)
-	if e.Version() != 42 {
-		t.Errorf("set 42, expected %d, got %d", 42, e.Version())
-	}
-
-	e.SetExtendedRcode(42)
-	if e.ExtendedRcode() != 42 {
-		t.Errorf("set 42, expected %d, got %d", 42, e.ExtendedRcode())
-	}
-}

vendor/github.com/miekg/dns/example_test.go

@@ -1,146 +0,0 @@
-package dns_test
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"net"
-
-	"github.com/miekg/dns"
-)
-
-// Retrieve the MX records for miek.nl.
-func ExampleMX() {
-	config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
-	c := new(dns.Client)
-	m := new(dns.Msg)
-	m.SetQuestion("miek.nl.", dns.TypeMX)
-	m.RecursionDesired = true
-	r, _, err := c.Exchange(m, config.Servers[0]+":"+config.Port)
-	if err != nil {
-		return
-	}
-	if r.Rcode != dns.RcodeSuccess {
-		return
-	}
-	for _, a := range r.Answer {
-		if mx, ok := a.(*dns.MX); ok {
-			fmt.Printf("%s\n", mx.String())
-		}
-	}
-}
-
-// Retrieve the DNSKEY records of a zone and convert them
-// to DS records for SHA1, SHA256 and SHA384.
-func ExampleDS() {
-	config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
-	c := new(dns.Client)
-	m := new(dns.Msg)
-	zone := "miek.nl"
-	m.SetQuestion(dns.Fqdn(zone), dns.TypeDNSKEY)
-	m.SetEdns0(4096, true)
-	r, _, err := c.Exchange(m, config.Servers[0]+":"+config.Port)
-	if err != nil {
-		return
-	}
-	if r.Rcode != dns.RcodeSuccess {
-		return
-	}
-	for _, k := range r.Answer {
-		if key, ok := k.(*dns.DNSKEY); ok {
-			for _, alg := range []uint8{dns.SHA1, dns.SHA256, dns.SHA384} {
-				fmt.Printf("%s; %d\n", key.ToDS(alg).String(), key.Flags)
-			}
-		}
-	}
-}
-
-const TypeAPAIR = 0x0F99
-
-type APAIR struct {
-	addr [2]net.IP
-}
-
-func NewAPAIR() dns.PrivateRdata { return new(APAIR) }
-
-func (rd *APAIR) String() string { return rd.addr[0].String() + " " + rd.addr[1].String() }
-func (rd *APAIR) Parse(txt []string) error {
-	if len(txt) != 2 {
-		return errors.New("two addresses required for APAIR")
-	}
-	for i, s := range txt {
-		ip := net.ParseIP(s)
-		if ip == nil {
-			return errors.New("invalid IP in APAIR text representation")
-		}
-		rd.addr[i] = ip
-	}
-	return nil
-}
-
-func (rd *APAIR) Pack(buf []byte) (int, error) {
-	b := append([]byte(rd.addr[0]), []byte(rd.addr[1])...)
-	n := copy(buf, b)
-	if n != len(b) {
-		return n, dns.ErrBuf
-	}
-	return n, nil
-}
-
-func (rd *APAIR) Unpack(buf []byte) (int, error) {
-	ln := net.IPv4len * 2
-	if len(buf) != ln {
-		return 0, errors.New("invalid length of APAIR rdata")
-	}
-	cp := make([]byte, ln)
-	copy(cp, buf) // clone bytes to use them in IPs
-
-	rd.addr[0] = net.IP(cp[:3])
-	rd.addr[1] = net.IP(cp[4:])
-
-	return len(buf), nil
-}
-
-func (rd *APAIR) Copy(dest dns.PrivateRdata) error {
-	cp := make([]byte, rd.Len())
-	_, err := rd.Pack(cp)
-	if err != nil {
-		return err
-	}
-
-	d := dest.(*APAIR)
-	d.addr[0] = net.IP(cp[:3])
-	d.addr[1] = net.IP(cp[4:])
-	return nil
-}
-
-func (rd *APAIR) Len() int {
-	return net.IPv4len * 2
-}
-
-func ExamplePrivateHandle() {
-	dns.PrivateHandle("APAIR", TypeAPAIR, NewAPAIR)
-	defer dns.PrivateHandleRemove(TypeAPAIR)
-
-	rr, err := dns.NewRR("miek.nl. APAIR (1.2.3.4    1.2.3.5)")
-	if err != nil {
-		log.Fatal("could not parse APAIR record: ", err)
-	}
-	fmt.Println(rr)
-	// Output: miek.nl.	3600	IN	APAIR	1.2.3.4 1.2.3.5
-
-	m := new(dns.Msg)
-	m.Id = 12345
-	m.SetQuestion("miek.nl.", TypeAPAIR)
-	m.Answer = append(m.Answer, rr)
-
-	fmt.Println(m)
-	// ;; opcode: QUERY, status: NOERROR, id: 12345
-	// ;; flags: rd; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0
-	//
-	// ;; QUESTION SECTION:
-	// ;miek.nl.	IN	 APAIR
-	//
-	// ;; ANSWER SECTION:
-	// miek.nl.	3600	IN	APAIR	1.2.3.4 1.2.3.5
-}

vendor/github.com/miekg/dns/issue_test.go

@@ -1,62 +0,0 @@
-package dns
-
-// Tests that solve that an specific issue.
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestTCPRtt(t *testing.T) {
-	m := new(Msg)
-	m.RecursionDesired = true
-	m.SetQuestion("example.org.", TypeA)
-
-	c := &Client{}
-	for _, proto := range []string{"udp", "tcp"} {
-		c.Net = proto
-		_, rtt, err := c.Exchange(m, "8.8.4.4:53")
-		if err != nil {
-			t.Fatal(err)
-		}
-		if rtt == 0 {
-			t.Fatalf("expecting non zero rtt %s, got zero", c.Net)
-		}
-	}
-}
-
-func TestNSEC3MissingSalt(t *testing.T) {
-	rr := testRR("ji6neoaepv8b5o6k4ev33abha8ht9fgc.example. NSEC3 1 1 12 aabbccdd K8UDEMVP1J2F7EG6JEBPS17VP3N8I58H")
-	m := new(Msg)
-	m.Answer = []RR{rr}
-	mb, err := m.Pack()
-	if err != nil {
-		t.Fatalf("expected to pack message. err: %s", err)
-	}
-	if err := m.Unpack(mb); err != nil {
-		t.Fatalf("expected to unpack message. missing salt? err: %s", err)
-	}
-	in := rr.(*NSEC3).Salt
-	out := m.Answer[0].(*NSEC3).Salt
-	if in != out {
-		t.Fatalf("expected salts to match. packed: `%s`. returned: `%s`", in, out)
-	}
-}
-
-func TestNSEC3MixedNextDomain(t *testing.T) {
-	rr := testRR("ji6neoaepv8b5o6k4ev33abha8ht9fgc.example. NSEC3 1 1 12 - k8udemvp1j2f7eg6jebps17vp3n8i58h")
-	m := new(Msg)
-	m.Answer = []RR{rr}
-	mb, err := m.Pack()
-	if err != nil {
-		t.Fatalf("expected to pack message. err: %s", err)
-	}
-	if err := m.Unpack(mb); err != nil {
-		t.Fatalf("expected to unpack message. err: %s", err)
-	}
-	in := strings.ToUpper(rr.(*NSEC3).NextDomain)
-	out := m.Answer[0].(*NSEC3).NextDomain
-	if in != out {
-		t.Fatalf("expected round trip to produce NextDomain `%s`, instead `%s`", in, out)
-	}
-}

vendor/github.com/miekg/dns/labels_test.go

@@ -1,201 +0,0 @@
-package dns
-
-import "testing"
-
-func TestCompareDomainName(t *testing.T) {
-	s1 := "www.miek.nl."
-	s2 := "miek.nl."
-	s3 := "www.bla.nl."
-	s4 := "nl.www.bla."
-	s5 := "nl."
-	s6 := "miek.nl."
-
-	if CompareDomainName(s1, s2) != 2 {
-		t.Errorf("%s with %s should be %d", s1, s2, 2)
-	}
-	if CompareDomainName(s1, s3) != 1 {
-		t.Errorf("%s with %s should be %d", s1, s3, 1)
-	}
-	if CompareDomainName(s3, s4) != 0 {
-		t.Errorf("%s with %s should be %d", s3, s4, 0)
-	}
-	// Non qualified tests
-	if CompareDomainName(s1, s5) != 1 {
-		t.Errorf("%s with %s should be %d", s1, s5, 1)
-	}
-	if CompareDomainName(s1, s6) != 2 {
-		t.Errorf("%s with %s should be %d", s1, s5, 2)
-	}
-
-	if CompareDomainName(s1, ".") != 0 {
-		t.Errorf("%s with %s should be %d", s1, s5, 0)
-	}
-	if CompareDomainName(".", ".") != 0 {
-		t.Errorf("%s with %s should be %d", ".", ".", 0)
-	}
-	if CompareDomainName("test.com.", "TEST.COM.") != 2 {
-		t.Errorf("test.com. and TEST.COM. should be an exact match")
-	}
-}
-
-func TestSplit(t *testing.T) {
-	splitter := map[string]int{
-		"www.miek.nl.":   3,
-		"www.miek.nl":    3,
-		"www..miek.nl":   4,
-		`www\.miek.nl.`:  2,
-		`www\\.miek.nl.`: 3,
-		".":              0,
-		"nl.":            1,
-		"nl":             1,
-		"com.":           1,
-		".com.":          2,
-	}
-	for s, i := range splitter {
-		if x := len(Split(s)); x != i {
-			t.Errorf("labels should be %d, got %d: %s %v", i, x, s, Split(s))
-		}
-	}
-}
-
-func TestSplit2(t *testing.T) {
-	splitter := map[string][]int{
-		"www.miek.nl.": {0, 4, 9},
-		"www.miek.nl":  {0, 4, 9},
-		"nl":           {0},
-	}
-	for s, i := range splitter {
-		x := Split(s)
-		switch len(i) {
-		case 1:
-			if x[0] != i[0] {
-				t.Errorf("labels should be %v, got %v: %s", i, x, s)
-			}
-		default:
-			if x[0] != i[0] || x[1] != i[1] || x[2] != i[2] {
-				t.Errorf("labels should be %v, got %v: %s", i, x, s)
-			}
-		}
-	}
-}
-
-func TestPrevLabel(t *testing.T) {
-	type prev struct {
-		string
-		int
-	}
-	prever := map[prev]int{
-		{"www.miek.nl.", 0}: 12,
-		{"www.miek.nl.", 1}: 9,
-		{"www.miek.nl.", 2}: 4,
-
-		{"www.miek.nl", 0}: 11,
-		{"www.miek.nl", 1}: 9,
-		{"www.miek.nl", 2}: 4,
-
-		{"www.miek.nl.", 5}: 0,
-		{"www.miek.nl", 5}:  0,
-
-		{"www.miek.nl.", 3}: 0,
-		{"www.miek.nl", 3}:  0,
-	}
-	for s, i := range prever {
-		x, ok := PrevLabel(s.string, s.int)
-		if i != x {
-			t.Errorf("label should be %d, got %d, %t: preving %d, %s", i, x, ok, s.int, s.string)
-		}
-	}
-}
-
-func TestCountLabel(t *testing.T) {
-	splitter := map[string]int{
-		"www.miek.nl.": 3,
-		"www.miek.nl":  3,
-		"nl":           1,
-		".":            0,
-	}
-	for s, i := range splitter {
-		x := CountLabel(s)
-		if x != i {
-			t.Errorf("CountLabel should have %d, got %d", i, x)
-		}
-	}
-}
-
-func TestSplitDomainName(t *testing.T) {
-	labels := map[string][]string{
-		"miek.nl":       {"miek", "nl"},
-		".":             nil,
-		"www.miek.nl.":  {"www", "miek", "nl"},
-		"www.miek.nl":   {"www", "miek", "nl"},
-		"www..miek.nl":  {"www", "", "miek", "nl"},
-		`www\.miek.nl`:  {`www\.miek`, "nl"},
-		`www\\.miek.nl`: {`www\\`, "miek", "nl"},
-		".www.miek.nl.": {"", "www", "miek", "nl"},
-	}
-domainLoop:
-	for domain, splits := range labels {
-		parts := SplitDomainName(domain)
-		if len(parts) != len(splits) {
-			t.Errorf("SplitDomainName returned %v for %s, expected %v", parts, domain, splits)
-			continue domainLoop
-		}
-		for i := range parts {
-			if parts[i] != splits[i] {
-				t.Errorf("SplitDomainName returned %v for %s, expected %v", parts, domain, splits)
-				continue domainLoop
-			}
-		}
-	}
-}
-
-func TestIsDomainName(t *testing.T) {
-	type ret struct {
-		ok  bool
-		lab int
-	}
-	names := map[string]*ret{
-		"..":               {false, 1},
-		"@.":               {true, 1},
-		"www.example.com":  {true, 3},
-		"www.e%ample.com":  {true, 3},
-		"www.example.com.": {true, 3},
-		"mi\\k.nl.":        {true, 2},
-		"mi\\k.nl":         {true, 2},
-	}
-	for d, ok := range names {
-		l, k := IsDomainName(d)
-		if ok.ok != k || ok.lab != l {
-			t.Errorf(" got %v %d for %s ", k, l, d)
-			t.Errorf("have %v %d for %s ", ok.ok, ok.lab, d)
-		}
-	}
-}
-
-func BenchmarkSplitLabels(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		Split("www.example.com.")
-	}
-}
-
-func BenchmarkLenLabels(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		CountLabel("www.example.com.")
-	}
-}
-
-func BenchmarkCompareDomainName(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		CompareDomainName("www.example.com.", "aa.example.com.")
-	}
-}
-
-func BenchmarkIsSubDomain(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		IsSubDomain("www.example.com.", "aa.example.com.")
-		IsSubDomain("example.com.", "aa.example.com.")
-		IsSubDomain("miek.nl.", "aa.example.com.")
-	}
-}

vendor/github.com/miekg/dns/leak_test.go

@@ -1,72 +0,0 @@
-package dns
-
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"sort"
-	"strings"
-	"testing"
-	"time"
-)
-
-// copied from net/http/main_test.go
-
-func interestingGoroutines() (gs []string) {
-	buf := make([]byte, 2<<20)
-	buf = buf[:runtime.Stack(buf, true)]
-	for _, g := range strings.Split(string(buf), "\n\n") {
-		sl := strings.SplitN(g, "\n", 2)
-		if len(sl) != 2 {
-			continue
-		}
-		stack := strings.TrimSpace(sl[1])
-		if stack == "" ||
-			strings.Contains(stack, "testing.(*M).before.func1") ||
-			strings.Contains(stack, "os/signal.signal_recv") ||
-			strings.Contains(stack, "created by net.startServer") ||
-			strings.Contains(stack, "created by testing.RunTests") ||
-			strings.Contains(stack, "closeWriteAndWait") ||
-			strings.Contains(stack, "testing.Main(") ||
-			strings.Contains(stack, "testing.(*T).Run(") ||
-			strings.Contains(stack, "created by net/http.(*http2Transport).newClientConn") ||
-			// These only show up with GOTRACEBACK=2; Issue 5005 (comment 28)
-			strings.Contains(stack, "runtime.goexit") ||
-			strings.Contains(stack, "created by runtime.gc") ||
-			strings.Contains(stack, "dns.interestingGoroutines") ||
-			strings.Contains(stack, "runtime.MHeap_Scavenger") {
-			continue
-		}
-		gs = append(gs, stack)
-	}
-	sort.Strings(gs)
-	return
-}
-
-func goroutineLeaked() error {
-	if testing.Short() {
-		// Don't worry about goroutine leaks in -short mode or in
-		// benchmark mode. Too distracting when there are false positives.
-		return nil
-	}
-
-	var stackCount map[string]int
-	for i := 0; i < 5; i++ {
-		n := 0
-		stackCount = make(map[string]int)
-		gs := interestingGoroutines()
-		for _, g := range gs {
-			stackCount[g]++
-			n++
-		}
-		if n == 0 {
-			return nil
-		}
-		// Wait for goroutines to schedule and die off:
-		time.Sleep(100 * time.Millisecond)
-	}
-	for stack, count := range stackCount {
-		fmt.Fprintf(os.Stderr, "%d instances of:\n%s\n", count, stack)
-	}
-	return fmt.Errorf("too many goroutines running after dns test(s)")
-}

vendor/github.com/miekg/dns/length_test.go

@@ -1,371 +0,0 @@
-package dns
-
-import (
-	"encoding/hex"
-	"fmt"
-	"net"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func TestCompressLength(t *testing.T) {
-	m := new(Msg)
-	m.SetQuestion("miek.nl", TypeMX)
-	ul := m.Len()
-	m.Compress = true
-	if ul != m.Len() {
-		t.Fatalf("should be equal")
-	}
-}
-
-// Does the predicted length match final packed length?
-func TestMsgCompressLength(t *testing.T) {
-	makeMsg := func(question string, ans, ns, e []RR) *Msg {
-		msg := new(Msg)
-		msg.SetQuestion(Fqdn(question), TypeANY)
-		msg.Answer = append(msg.Answer, ans...)
-		msg.Ns = append(msg.Ns, ns...)
-		msg.Extra = append(msg.Extra, e...)
-		msg.Compress = true
-		return msg
-	}
-
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	rrA := testRR(name1 + " 3600 IN A 192.0.2.1")
-	rrMx := testRR(name1 + " 3600 IN MX 10 " + name1)
-	tests := []*Msg{
-		makeMsg(name1, []RR{rrA}, nil, nil),
-		makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)}
-
-	for _, msg := range tests {
-		predicted := msg.Len()
-		buf, err := msg.Pack()
-		if err != nil {
-			t.Error(err)
-		}
-		if predicted < len(buf) {
-			t.Errorf("predicted compressed length is wrong: predicted %s (len=%d) %d, actual %d",
-				msg.Question[0].Name, len(msg.Answer), predicted, len(buf))
-		}
-	}
-}
-
-func TestMsgLength(t *testing.T) {
-	makeMsg := func(question string, ans, ns, e []RR) *Msg {
-		msg := new(Msg)
-		msg.Compress = true
-		msg.SetQuestion(Fqdn(question), TypeANY)
-		msg.Answer = append(msg.Answer, ans...)
-		msg.Ns = append(msg.Ns, ns...)
-		msg.Extra = append(msg.Extra, e...)
-		return msg
-	}
-
-	name1 := "12345678901234567890123456789012345.12345678.123."
-	rrA := testRR(name1 + " 3600 IN A 192.0.2.1")
-	rrMx := testRR(name1 + " 3600 IN MX 10 " + name1)
-	tests := []*Msg{
-		makeMsg(name1, []RR{rrA}, nil, nil),
-		makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)}
-
-	for _, msg := range tests {
-		predicted := msg.Len()
-		buf, err := msg.Pack()
-		if err != nil {
-			t.Error(err)
-		}
-		if predicted < len(buf) {
-			t.Errorf("predicted length is wrong: predicted %s (len=%d), actual %d",
-				msg.Question[0].Name, predicted, len(buf))
-		}
-	}
-}
-
-func TestCompressionLenHelper(t *testing.T) {
-	c := make(map[string]int)
-	compressionLenHelper(c, "example.com", 12)
-	if c["example.com"] != 12 {
-		t.Errorf("bad %d", c["example.com"])
-	}
-	if c["com"] != 20 {
-		t.Errorf("bad %d", c["com"])
-	}
-
-	// Test boundaries
-	c = make(map[string]int)
-	// foo label starts at 16379
-	// com label starts at 16384
-	compressionLenHelper(c, "foo.com", 16379)
-	if c["foo.com"] != 16379 {
-		t.Errorf("bad %d", c["foo.com"])
-	}
-	// com label is accessible
-	if c["com"] != 16383 {
-		t.Errorf("bad %d", c["com"])
-	}
-
-	c = make(map[string]int)
-	// foo label starts at 16379
-	// com label starts at 16385 => outside range
-	compressionLenHelper(c, "foo.com", 16380)
-	if c["foo.com"] != 16380 {
-		t.Errorf("bad %d", c["foo.com"])
-	}
-	// com label is NOT accessible
-	if c["com"] != 0 {
-		t.Errorf("bad %d", c["com"])
-	}
-
-	c = make(map[string]int)
-	compressionLenHelper(c, "example.com", 16375)
-	if c["example.com"] != 16375 {
-		t.Errorf("bad %d", c["example.com"])
-	}
-	// com starts AFTER 16384
-	if c["com"] != 16383 {
-		t.Errorf("bad %d", c["com"])
-	}
-
-	c = make(map[string]int)
-	compressionLenHelper(c, "example.com", 16376)
-	if c["example.com"] != 16376 {
-		t.Errorf("bad %d", c["example.com"])
-	}
-	// com starts AFTER 16384
-	if c["com"] != 0 {
-		t.Errorf("bad %d", c["com"])
-	}
-}
-
-func TestCompressionLenSearch(t *testing.T) {
-	c := make(map[string]int)
-	compressed, ok, fullSize := compressionLenSearch(c, "a.b.org.")
-	if compressed != 0 || ok || fullSize != 14 {
-		panic(fmt.Errorf("Failed: compressed:=%d, ok:=%v, fullSize:=%d", compressed, ok, fullSize))
-	}
-	c["org."] = 3
-	compressed, ok, fullSize = compressionLenSearch(c, "a.b.org.")
-	if compressed != 4 || !ok || fullSize != 8 {
-		panic(fmt.Errorf("Failed: compressed:=%d, ok:=%v, fullSize:=%d", compressed, ok, fullSize))
-	}
-	c["b.org."] = 5
-	compressed, ok, fullSize = compressionLenSearch(c, "a.b.org.")
-	if compressed != 6 || !ok || fullSize != 4 {
-		panic(fmt.Errorf("Failed: compressed:=%d, ok:=%v, fullSize:=%d", compressed, ok, fullSize))
-	}
-	// Not found long compression
-	c["x.b.org."] = 5
-	compressed, ok, fullSize = compressionLenSearch(c, "a.b.org.")
-	if compressed != 6 || !ok || fullSize != 4 {
-		panic(fmt.Errorf("Failed: compressed:=%d, ok:=%v, fullSize:=%d", compressed, ok, fullSize))
-	}
-	// Found long compression
-	c["a.b.org."] = 5
-	compressed, ok, fullSize = compressionLenSearch(c, "a.b.org.")
-	if compressed != 8 || !ok || fullSize != 0 {
-		panic(fmt.Errorf("Failed: compressed:=%d, ok:=%v, fullSize:=%d", compressed, ok, fullSize))
-	}
-}
-
-func TestMsgLength2(t *testing.T) {
-	// Serialized replies
-	var testMessages = []string{
-		// google.com. IN A?
-		"064e81800001000b0004000506676f6f676c6503636f6d0000010001c00c00010001000000050004adc22986c00c00010001000000050004adc22987c00c00010001000000050004adc22988c00c00010001000000050004adc22989c00c00010001000000050004adc2298ec00c00010001000000050004adc22980c00c00010001000000050004adc22981c00c00010001000000050004adc22982c00c00010001000000050004adc22983c00c00010001000000050004adc22984c00c00010001000000050004adc22985c00c00020001000000050006036e7331c00cc00c00020001000000050006036e7332c00cc00c00020001000000050006036e7333c00cc00c00020001000000050006036e7334c00cc0d800010001000000050004d8ef200ac0ea00010001000000050004d8ef220ac0fc00010001000000050004d8ef240ac10e00010001000000050004d8ef260a0000290500000000050000",
-		// amazon.com. IN A? (reply has no EDNS0 record)
-		// TODO(miek): this one is off-by-one, need to find out why
-		//"6de1818000010004000a000806616d617a6f6e03636f6d0000010001c00c000100010000000500044815c2d4c00c000100010000000500044815d7e8c00c00010001000000050004b02062a6c00c00010001000000050004cdfbf236c00c000200010000000500140570646e733408756c747261646e73036f726700c00c000200010000000500150570646e733508756c747261646e7304696e666f00c00c000200010000000500160570646e733608756c747261646e7302636f02756b00c00c00020001000000050014036e7331037033310664796e656374036e657400c00c00020001000000050006036e7332c0cfc00c00020001000000050006036e7333c0cfc00c00020001000000050006036e7334c0cfc00c000200010000000500110570646e733108756c747261646e73c0dac00c000200010000000500080570646e7332c127c00c000200010000000500080570646e7333c06ec0cb00010001000000050004d04e461fc0eb00010001000000050004cc0dfa1fc0fd00010001000000050004d04e471fc10f00010001000000050004cc0dfb1fc12100010001000000050004cc4a6c01c121001c000100000005001020010502f3ff00000000000000000001c13e00010001000000050004cc4a6d01c13e001c0001000000050010261000a1101400000000000000000001",
-		// yahoo.com. IN A?
-		"fc2d81800001000300070008057961686f6f03636f6d0000010001c00c00010001000000050004628afd6dc00c00010001000000050004628bb718c00c00010001000000050004cebe242dc00c00020001000000050006036e7336c00cc00c00020001000000050006036e7338c00cc00c00020001000000050006036e7331c00cc00c00020001000000050006036e7332c00cc00c00020001000000050006036e7333c00cc00c00020001000000050006036e7334c00cc00c00020001000000050006036e7335c00cc07b0001000100000005000444b48310c08d00010001000000050004448eff10c09f00010001000000050004cb54dd35c0b100010001000000050004628a0b9dc0c30001000100000005000477a0f77cc05700010001000000050004ca2bdfaac06900010001000000050004caa568160000290500000000050000",
-		// microsoft.com. IN A?
-		"f4368180000100020005000b096d6963726f736f667403636f6d0000010001c00c0001000100000005000440040b25c00c0001000100000005000441373ac9c00c0002000100000005000e036e7331046d736674036e657400c00c00020001000000050006036e7332c04fc00c00020001000000050006036e7333c04fc00c00020001000000050006036e7334c04fc00c00020001000000050006036e7335c04fc04b000100010000000500044137253ec04b001c00010000000500102a010111200500000000000000010001c0650001000100000005000440043badc065001c00010000000500102a010111200600060000000000010001c07700010001000000050004d5c7b435c077001c00010000000500102a010111202000000000000000010001c08900010001000000050004cf2e4bfec089001c00010000000500102404f800200300000000000000010001c09b000100010000000500044137e28cc09b001c00010000000500102a010111200f000100000000000100010000290500000000050000",
-		// google.com. IN MX?
-		"724b8180000100050004000b06676f6f676c6503636f6d00000f0001c00c000f000100000005000c000a056173706d78016cc00cc00c000f0001000000050009001404616c7431c02ac00c000f0001000000050009001e04616c7432c02ac00c000f0001000000050009002804616c7433c02ac00c000f0001000000050009003204616c7434c02ac00c00020001000000050006036e7332c00cc00c00020001000000050006036e7333c00cc00c00020001000000050006036e7334c00cc00c00020001000000050006036e7331c00cc02a00010001000000050004adc2421bc02a001c00010000000500102a00145040080c01000000000000001bc04200010001000000050004adc2461bc05700010001000000050004adc2451bc06c000100010000000500044a7d8f1bc081000100010000000500044a7d191bc0ca00010001000000050004d8ef200ac09400010001000000050004d8ef220ac0a600010001000000050004d8ef240ac0b800010001000000050004d8ef260a0000290500000000050000",
-		// reddit.com. IN A?
-		"12b98180000100080000000c0672656464697403636f6d0000020001c00c0002000100000005000f046175733204616b616d036e657400c00c000200010000000500070475736534c02dc00c000200010000000500070475737733c02dc00c000200010000000500070475737735c02dc00c00020001000000050008056173696131c02dc00c00020001000000050008056173696139c02dc00c00020001000000050008056e73312d31c02dc00c0002000100000005000a076e73312d313935c02dc02800010001000000050004c30a242ec04300010001000000050004451f1d39c05600010001000000050004451f3bc7c0690001000100000005000460073240c07c000100010000000500046007fb81c090000100010000000500047c283484c090001c00010000000500102a0226f0006700000000000000000064c0a400010001000000050004c16c5b01c0a4001c000100000005001026001401000200000000000000000001c0b800010001000000050004c16c5bc3c0b8001c0001000000050010260014010002000000000000000000c30000290500000000050000",
-	}
-
-	for i, hexData := range testMessages {
-		// we won't fail the decoding of the hex
-		input, _ := hex.DecodeString(hexData)
-
-		m := new(Msg)
-		m.Unpack(input)
-		m.Compress = true
-		lenComp := m.Len()
-		b, _ := m.Pack()
-		pacComp := len(b)
-		m.Compress = false
-		lenUnComp := m.Len()
-		b, _ = m.Pack()
-		pacUnComp := len(b)
-		if pacComp+1 != lenComp {
-			t.Errorf("msg.Len(compressed)=%d actual=%d for test %d", lenComp, pacComp, i)
-		}
-		if pacUnComp+1 != lenUnComp {
-			t.Errorf("msg.Len(uncompressed)=%d actual=%d for test %d", lenUnComp, pacUnComp, i)
-		}
-	}
-}
-
-func TestMsgLengthCompressionMalformed(t *testing.T) {
-	// SOA with empty hostmaster, which is illegal
-	soa := &SOA{Hdr: RR_Header{Name: ".", Rrtype: TypeSOA, Class: ClassINET, Ttl: 12345},
-		Ns:      ".",
-		Mbox:    "",
-		Serial:  0,
-		Refresh: 28800,
-		Retry:   7200,
-		Expire:  604800,
-		Minttl:  60}
-	m := new(Msg)
-	m.Compress = true
-	m.Ns = []RR{soa}
-	m.Len() // Should not crash.
-}
-
-func TestMsgCompressLength2(t *testing.T) {
-	msg := new(Msg)
-	msg.Compress = true
-	msg.SetQuestion(Fqdn("bliep."), TypeANY)
-	msg.Answer = append(msg.Answer, &SRV{Hdr: RR_Header{Name: "blaat.", Rrtype: 0x21, Class: 0x1, Ttl: 0x3c}, Port: 0x4c57, Target: "foo.bar."})
-	msg.Extra = append(msg.Extra, &A{Hdr: RR_Header{Name: "foo.bar.", Rrtype: 0x1, Class: 0x1, Ttl: 0x3c}, A: net.IP{0xac, 0x11, 0x0, 0x3}})
-	predicted := msg.Len()
-	buf, err := msg.Pack()
-	if err != nil {
-		t.Error(err)
-	}
-	if predicted != len(buf) {
-		t.Errorf("predicted compressed length is wrong: predicted %s (len=%d) %d, actual %d",
-			msg.Question[0].Name, len(msg.Answer), predicted, len(buf))
-	}
-}
-
-func TestMsgCompressLengthLargeRecords(t *testing.T) {
-	msg := new(Msg)
-	msg.Compress = true
-	msg.SetQuestion("my.service.acme.", TypeSRV)
-	j := 1
-	for i := 0; i < 250; i++ {
-		target := fmt.Sprintf("host-redis-1-%d.test.acme.com.node.dc1.consul.", i)
-		msg.Answer = append(msg.Answer, &SRV{Hdr: RR_Header{Name: "redis.service.consul.", Class: 1, Rrtype: TypeSRV, Ttl: 0x3c}, Port: 0x4c57, Target: target})
-		msg.Extra = append(msg.Extra, &CNAME{Hdr: RR_Header{Name: target, Class: 1, Rrtype: TypeCNAME, Ttl: 0x3c}, Target: fmt.Sprintf("fx.168.%d.%d.", j, i)})
-	}
-	predicted := msg.Len()
-	buf, err := msg.Pack()
-	if err != nil {
-		t.Error(err)
-	}
-	if predicted != len(buf) {
-		t.Fatalf("predicted compressed length is wrong: predicted %s (len=%d) %d, actual %d", msg.Question[0].Name, len(msg.Answer), predicted, len(buf))
-	}
-}
-
-func TestCompareCompressionMapsForANY(t *testing.T) {
-	msg := new(Msg)
-	msg.Compress = true
-	msg.SetQuestion("a.service.acme.", TypeANY)
-	// Be sure to have more than 14bits
-	for i := 0; i < 2000; i++ {
-		target := fmt.Sprintf("host.app-%d.x%d.test.acme.", i%250, i)
-		msg.Answer = append(msg.Answer, &AAAA{Hdr: RR_Header{Name: target, Rrtype: TypeAAAA, Class: ClassINET, Ttl: 0x3c}, AAAA: net.IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, byte(i / 255), byte(i % 255)}})
-		msg.Answer = append(msg.Answer, &A{Hdr: RR_Header{Name: target, Rrtype: TypeA, Class: ClassINET, Ttl: 0x3c}, A: net.IP{127, 0, byte(i / 255), byte(i % 255)}})
-		if msg.Len() > 16384 {
-			break
-		}
-	}
-	for labelSize := 0; labelSize < 63; labelSize++ {
-		msg.SetQuestion(fmt.Sprintf("a%s.service.acme.", strings.Repeat("x", labelSize)), TypeANY)
-
-		compressionFake := make(map[string]int)
-		lenFake := compressedLenWithCompressionMap(msg, compressionFake)
-
-		compressionReal := make(map[string]int)
-		buf, err := msg.packBufferWithCompressionMap(nil, compressionReal)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if lenFake != len(buf) {
-			t.Fatalf("padding= %d ; Predicted len := %d != real:= %d", labelSize, lenFake, len(buf))
-		}
-		if !reflect.DeepEqual(compressionFake, compressionReal) {
-			t.Fatalf("padding= %d ; Fake Compression Map != Real Compression Map\n*** Real:= %v\n\n***Fake:= %v", labelSize, compressionReal, compressionFake)
-		}
-	}
-}
-
-func TestCompareCompressionMapsForSRV(t *testing.T) {
-	msg := new(Msg)
-	msg.Compress = true
-	msg.SetQuestion("a.service.acme.", TypeSRV)
-	// Be sure to have more than 14bits
-	for i := 0; i < 2000; i++ {
-		target := fmt.Sprintf("host.app-%d.x%d.test.acme.", i%250, i)
-		msg.Answer = append(msg.Answer, &SRV{Hdr: RR_Header{Name: "redis.service.consul.", Class: ClassINET, Rrtype: TypeSRV, Ttl: 0x3c}, Port: 0x4c57, Target: target})
-		msg.Extra = append(msg.Extra, &A{Hdr: RR_Header{Name: target, Rrtype: TypeA, Class: ClassINET, Ttl: 0x3c}, A: net.IP{127, 0, byte(i / 255), byte(i % 255)}})
-		if msg.Len() > 16384 {
-			break
-		}
-	}
-	for labelSize := 0; labelSize < 63; labelSize++ {
-		msg.SetQuestion(fmt.Sprintf("a%s.service.acme.", strings.Repeat("x", labelSize)), TypeAAAA)
-
-		compressionFake := make(map[string]int)
-		lenFake := compressedLenWithCompressionMap(msg, compressionFake)
-
-		compressionReal := make(map[string]int)
-		buf, err := msg.packBufferWithCompressionMap(nil, compressionReal)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if lenFake != len(buf) {
-			t.Fatalf("padding= %d ; Predicted len := %d != real:= %d", labelSize, lenFake, len(buf))
-		}
-		if !reflect.DeepEqual(compressionFake, compressionReal) {
-			t.Fatalf("padding= %d ; Fake Compression Map != Real Compression Map\n*** Real:= %v\n\n***Fake:= %v", labelSize, compressionReal, compressionFake)
-		}
-	}
-}
-
-func TestMsgCompressLengthLargeRecordsWithPaddingPermutation(t *testing.T) {
-	msg := new(Msg)
-	msg.Compress = true
-	msg.SetQuestion("my.service.acme.", TypeSRV)
-
-	for i := 0; i < 250; i++ {
-		target := fmt.Sprintf("host-redis-x-%d.test.acme.com.node.dc1.consul.", i)
-		msg.Answer = append(msg.Answer, &SRV{Hdr: RR_Header{Name: "redis.service.consul.", Class: 1, Rrtype: TypeSRV, Ttl: 0x3c}, Port: 0x4c57, Target: target})
-		msg.Extra = append(msg.Extra, &CNAME{Hdr: RR_Header{Name: target, Class: ClassINET, Rrtype: TypeCNAME, Ttl: 0x3c}, Target: fmt.Sprintf("fx.168.x.%d.", i)})
-	}
-	for labelSize := 1; labelSize < 63; labelSize++ {
-		msg.SetQuestion(fmt.Sprintf("my.%s.service.acme.", strings.Repeat("x", labelSize)), TypeSRV)
-		predicted := msg.Len()
-		buf, err := msg.Pack()
-		if err != nil {
-			t.Error(err)
-		}
-		if predicted != len(buf) {
-			t.Fatalf("padding= %d ; predicted compressed length is wrong: predicted %s (len=%d) %d, actual %d", labelSize, msg.Question[0].Name, len(msg.Answer), predicted, len(buf))
-		}
-	}
-}
-
-func TestMsgCompressLengthLargeRecordsAllValues(t *testing.T) {
-	msg := new(Msg)
-	msg.Compress = true
-	msg.SetQuestion("redis.service.consul.", TypeSRV)
-	for i := 0; i < 900; i++ {
-		target := fmt.Sprintf("host-redis-%d-%d.test.acme.com.node.dc1.consul.", i/256, i%256)
-		msg.Answer = append(msg.Answer, &SRV{Hdr: RR_Header{Name: "redis.service.consul.", Class: 1, Rrtype: TypeSRV, Ttl: 0x3c}, Port: 0x4c57, Target: target})
-		msg.Extra = append(msg.Extra, &CNAME{Hdr: RR_Header{Name: target, Class: ClassINET, Rrtype: TypeCNAME, Ttl: 0x3c}, Target: fmt.Sprintf("fx.168.%d.%d.", i/256, i%256)})
-		predicted := msg.Len()
-		buf, err := msg.Pack()
-		if err != nil {
-			t.Error(err)
-		}
-		if predicted != len(buf) {
-			t.Fatalf("predicted compressed length is wrong for %d records: predicted %s (len=%d) %d, actual %d", i, msg.Question[0].Name, len(msg.Answer), predicted, len(buf))
-		}
-	}
-}

vendor/github.com/miekg/dns/msg_test.go

@@ -1,146 +0,0 @@
-package dns
-
-import (
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-const (
-	maxPrintableLabel = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789x"
-	tooLongLabel      = maxPrintableLabel + "x"
-)
-
-var (
-	longDomain = maxPrintableLabel[:53] + strings.TrimSuffix(
-		strings.Join([]string{".", ".", ".", ".", "."}, maxPrintableLabel[:49]), ".")
-	reChar              = regexp.MustCompile(`.`)
-	i                   = -1
-	maxUnprintableLabel = reChar.ReplaceAllStringFunc(maxPrintableLabel, func(ch string) string {
-		if i++; i >= 32 {
-			i = 0
-		}
-		return fmt.Sprintf("\\%03d", i)
-	})
-)
-
-func TestPackNoSideEffect(t *testing.T) {
-	m := new(Msg)
-	m.SetQuestion(Fqdn("example.com."), TypeNS)
-
-	a := new(Msg)
-	o := &OPT{
-		Hdr: RR_Header{
-			Name:   ".",
-			Rrtype: TypeOPT,
-		},
-	}
-	o.SetUDPSize(DefaultMsgSize)
-
-	a.Extra = append(a.Extra, o)
-	a.SetRcode(m, RcodeBadVers)
-
-	a.Pack()
-	if a.Rcode != RcodeBadVers {
-		t.Errorf("after pack: Rcode is expected to be BADVERS")
-	}
-}
-
-func TestUnpackDomainName(t *testing.T) {
-	var cases = []struct {
-		label          string
-		input          string
-		expectedOutput string
-		expectedError  string
-	}{
-		{"empty domain",
-			"\x00",
-			".",
-			""},
-		{"long label",
-			string(63) + maxPrintableLabel + "\x00",
-			maxPrintableLabel + ".",
-			""},
-		{"unprintable label",
-			string(63) + regexp.MustCompile(`\\[0-9]+`).ReplaceAllStringFunc(maxUnprintableLabel,
-				func(escape string) string {
-					n, _ := strconv.ParseInt(escape[1:], 10, 8)
-					return string(n)
-				}) + "\x00",
-			maxUnprintableLabel + ".",
-			""},
-		{"long domain",
-			string(53) + strings.Replace(longDomain, ".", string(49), -1) + "\x00",
-			longDomain + ".",
-			""},
-		{"compression pointer",
-			// an unrealistic but functional test referencing an offset _inside_ a label
-			"\x03foo" + "\x05\x03com\x00" + "\x07example" + "\xC0\x05",
-			"foo.\\003com\\000.example.com.",
-			""},
-
-		{"too long domain",
-			string(54) + "x" + strings.Replace(longDomain, ".", string(49), -1) + "\x00",
-			"x" + longDomain + ".",
-			ErrLongDomain.Error()},
-		{"too long by pointer",
-			// a matryoshka doll name to get over 255 octets after expansion via internal pointers
-			string([]byte{
-				// 11 length values, first to last
-				40, 37, 34, 31, 28, 25, 22, 19, 16, 13, 0,
-				// 12 filler values
-				120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
-				// 10 pointers, last to first
-				192, 10, 192, 9, 192, 8, 192, 7, 192, 6, 192, 5, 192, 4, 192, 3, 192, 2, 192, 1,
-			}),
-			"",
-			ErrLongDomain.Error()},
-		{"long by pointer",
-			// a matryoshka doll name _not_ exceeding 255 octets after expansion
-			string([]byte{
-				// 11 length values, first to last
-				37, 34, 31, 28, 25, 22, 19, 16, 13, 10, 0,
-				// 9 filler values
-				120, 120, 120, 120, 120, 120, 120, 120, 120,
-				// 10 pointers, last to first
-				192, 10, 192, 9, 192, 8, 192, 7, 192, 6, 192, 5, 192, 4, 192, 3, 192, 2, 192, 1,
-			}),
-			"" +
-				(`\"\031\028\025\022\019\016\013\010\000xxxxxxxxx` +
-					`\192\010\192\009\192\008\192\007\192\006\192\005\192\004\192\003\192\002.`) +
-				(`\031\028\025\022\019\016\013\010\000xxxxxxxxx` +
-					`\192\010\192\009\192\008\192\007\192\006\192\005\192\004\192\003.`) +
-				(`\028\025\022\019\016\013\010\000xxxxxxxxx` +
-					`\192\010\192\009\192\008\192\007\192\006\192\005\192\004.`) +
-				(`\025\022\019\016\013\010\000xxxxxxxxx` +
-					`\192\010\192\009\192\008\192\007\192\006\192\005.`) +
-				`\022\019\016\013\010\000xxxxxxxxx\192\010\192\009\192\008\192\007\192\006.` +
-				`\019\016\013\010\000xxxxxxxxx\192\010\192\009\192\008\192\007.` +
-				`\016\013\010\000xxxxxxxxx\192\010\192\009\192\008.` +
-				`\013\010\000xxxxxxxxx\192\010\192\009.` +
-				`\010\000xxxxxxxxx\192\010.` +
-				`\000xxxxxxxxx.`,
-			""},
-		{"truncated name", "\x07example\x03", "", "dns: buffer size too small"},
-		{"non-absolute name", "\x07example\x03com", "", "dns: buffer size too small"},
-		{"compression pointer cycle",
-			"\x03foo" + "\x03bar" + "\x07example" + "\xC0\x04",
-			"",
-			"dns: too many compression pointers"},
-		{"reserved compression pointer 0b10", "\x07example\x80", "", "dns: bad rdata"},
-		{"reserved compression pointer 0b01", "\x07example\x40", "", "dns: bad rdata"},
-	}
-	for _, test := range cases {
-		output, idx, err := UnpackDomainName([]byte(test.input), 0)
-		if test.expectedOutput != "" && output != test.expectedOutput {
-			t.Errorf("%s: expected %s, got %s", test.label, test.expectedOutput, output)
-		}
-		if test.expectedError == "" && err != nil {
-			t.Errorf("%s: expected no error, got %d %v", test.label, idx, err)
-		} else if test.expectedError != "" && (err == nil || err.Error() != test.expectedError) {
-			t.Errorf("%s: expected error %s, got %d %v", test.label, test.expectedError, idx, err)
-		}
-	}
-}

vendor/github.com/miekg/dns/nsecx_test.go

@@ -1,141 +0,0 @@
-package dns
-
-import "testing"
-
-func TestPackNsec3(t *testing.T) {
-	nsec3 := HashName("dnsex.nl.", SHA1, 0, "DEAD")
-	if nsec3 != "ROCCJAE8BJJU7HN6T7NG3TNM8ACRS87J" {
-		t.Error(nsec3)
-	}
-
-	nsec3 = HashName("a.b.c.example.org.", SHA1, 2, "DEAD")
-	if nsec3 != "6LQ07OAHBTOOEU2R9ANI2AT70K5O0RCG" {
-		t.Error(nsec3)
-	}
-}
-
-func TestNsec3(t *testing.T) {
-	nsec3 := testRR("sk4e8fj94u78smusb40o1n0oltbblu2r.nl. IN NSEC3 1 1 5 F10E9F7EA83FC8F3 SK4F38CQ0ATIEI8MH3RGD0P5I4II6QAN NS SOA TXT RRSIG DNSKEY NSEC3PARAM")
-	if !nsec3.(*NSEC3).Match("nl.") { // name hash = sk4e8fj94u78smusb40o1n0oltbblu2r
-		t.Fatal("sk4e8fj94u78smusb40o1n0oltbblu2r.nl. should match sk4e8fj94u78smusb40o1n0oltbblu2r.nl.")
-	}
-	if !nsec3.(*NSEC3).Match("NL.") { // name hash = sk4e8fj94u78smusb40o1n0oltbblu2r
-		t.Fatal("sk4e8fj94u78smusb40o1n0oltbblu2r.NL. should match sk4e8fj94u78smusb40o1n0oltbblu2r.nl.")
-	}
-	if nsec3.(*NSEC3).Match("com.") { //
-		t.Fatal("com. is not in the zone nl.")
-	}
-	if nsec3.(*NSEC3).Match("test.nl.") { // name hash = gd0ptr5bnfpimpu2d3v6gd4n0bai7s0q
-		t.Fatal("gd0ptr5bnfpimpu2d3v6gd4n0bai7s0q.nl. should not match sk4e8fj94u78smusb40o1n0oltbblu2r.nl.")
-	}
-	nsec3 = testRR("nl. IN NSEC3 1 1 5 F10E9F7EA83FC8F3 SK4F38CQ0ATIEI8MH3RGD0P5I4II6QAN NS SOA TXT RRSIG DNSKEY NSEC3PARAM")
-	if nsec3.(*NSEC3).Match("nl.") {
-		t.Fatal("sk4e8fj94u78smusb40o1n0oltbblu2r.nl. should not match a record without a owner hash")
-	}
-
-	for _, tc := range []struct {
-		rr     *NSEC3
-		name   string
-		covers bool
-	}{
-		// positive tests
-		{ // name hash between owner hash and next hash
-			rr: &NSEC3{
-				Hdr:        RR_Header{Name: "2N1TB3VAIRUOBL6RKDVII42N9TFMIALP.com."},
-				Hash:       1,
-				Flags:      1,
-				Iterations: 5,
-				Salt:       "F10E9F7EA83FC8F3",
-				NextDomain: "PT3RON8N7PM3A0OE989IB84OOSADP7O8",
-			},
-			name:   "bsd.com.",
-			covers: true,
-		},
-		{ // end of zone, name hash is after owner hash
-			rr: &NSEC3{
-				Hdr:        RR_Header{Name: "3v62ulr0nre83v0rja2vjgtlif9v6rab.com."},
-				Hash:       1,
-				Flags:      1,
-				Iterations: 5,
-				Salt:       "F10E9F7EA83FC8F3",
-				NextDomain: "2N1TB3VAIRUOBL6RKDVII42N9TFMIALP",
-			},
-			name:   "csd.com.",
-			covers: true,
-		},
-		{ // end of zone, name hash is before beginning of zone
-			rr: &NSEC3{
-				Hdr:        RR_Header{Name: "PT3RON8N7PM3A0OE989IB84OOSADP7O8.com."},
-				Hash:       1,
-				Flags:      1,
-				Iterations: 5,
-				Salt:       "F10E9F7EA83FC8F3",
-				NextDomain: "3V62ULR0NRE83V0RJA2VJGTLIF9V6RAB",
-			},
-			name:   "asd.com.",
-			covers: true,
-		},
-		// negative tests
-		{ // too short owner name
-			rr: &NSEC3{
-				Hdr:        RR_Header{Name: "nl."},
-				Hash:       1,
-				Flags:      1,
-				Iterations: 5,
-				Salt:       "F10E9F7EA83FC8F3",
-				NextDomain: "39P99DCGG0MDLARTCRMCF6OFLLUL7PR6",
-			},
-			name:   "asd.com.",
-			covers: false,
-		},
-		{ // outside of zone
-			rr: &NSEC3{
-				Hdr:        RR_Header{Name: "39p91242oslggest5e6a7cci4iaeqvnk.nl."},
-				Hash:       1,
-				Flags:      1,
-				Iterations: 5,
-				Salt:       "F10E9F7EA83FC8F3",
-				NextDomain: "39P99DCGG0MDLARTCRMCF6OFLLUL7PR6",
-			},
-			name:   "asd.com.",
-			covers: false,
-		},
-		{ // empty interval
-			rr: &NSEC3{
-				Hdr:        RR_Header{Name: "2n1tb3vairuobl6rkdvii42n9tfmialp.com."},
-				Hash:       1,
-				Flags:      1,
-				Iterations: 5,
-				Salt:       "F10E9F7EA83FC8F3",
-				NextDomain: "2N1TB3VAIRUOBL6RKDVII42N9TFMIALP",
-			},
-			name:   "asd.com.",
-			covers: false,
-		},
-		{ // name hash is before owner hash, not covered
-			rr: &NSEC3{
-				Hdr:        RR_Header{Name: "3V62ULR0NRE83V0RJA2VJGTLIF9V6RAB.com."},
-				Hash:       1,
-				Flags:      1,
-				Iterations: 5,
-				Salt:       "F10E9F7EA83FC8F3",
-				NextDomain: "PT3RON8N7PM3A0OE989IB84OOSADP7O8",
-			},
-			name:   "asd.com.",
-			covers: false,
-		},
-	} {
-		covers := tc.rr.Cover(tc.name)
-		if tc.covers != covers {
-			t.Fatalf("cover failed for %s: expected %t, got %t [record: %s]", tc.name, tc.covers, covers, tc.rr)
-		}
-	}
-}
-
-func TestNsec3EmptySalt(t *testing.T) {
-	rr, _ := NewRR("CK0POJMG874LJREF7EFN8430QVIT8BSM.com. 86400 IN NSEC3 1 1 0 - CK0Q1GIN43N1ARRC9OSM6QPQR81H5M9A  NS SOA RRSIG DNSKEY NSEC3PARAM")
-
-	if !rr.(*NSEC3).Match("com.") {
-		t.Fatalf("expected record to match com. label")
-	}
-}

vendor/github.com/miekg/dns/privaterr_test.go

@@ -1,166 +0,0 @@
-package dns_test
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/miekg/dns"
-)
-
-const TypeISBN uint16 = 0xFF00
-
-// A crazy new RR type :)
-type ISBN struct {
-	x string // rdata with 10 or 13 numbers, dashes or spaces allowed
-}
-
-func NewISBN() dns.PrivateRdata { return &ISBN{""} }
-
-func (rd *ISBN) Len() int       { return len([]byte(rd.x)) }
-func (rd *ISBN) String() string { return rd.x }
-
-func (rd *ISBN) Parse(txt []string) error {
-	rd.x = strings.TrimSpace(strings.Join(txt, " "))
-	return nil
-}
-
-func (rd *ISBN) Pack(buf []byte) (int, error) {
-	b := []byte(rd.x)
-	n := copy(buf, b)
-	if n != len(b) {
-		return n, dns.ErrBuf
-	}
-	return n, nil
-}
-
-func (rd *ISBN) Unpack(buf []byte) (int, error) {
-	rd.x = string(buf)
-	return len(buf), nil
-}
-
-func (rd *ISBN) Copy(dest dns.PrivateRdata) error {
-	isbn, ok := dest.(*ISBN)
-	if !ok {
-		return dns.ErrRdata
-	}
-	isbn.x = rd.x
-	return nil
-}
-
-var testrecord = strings.Join([]string{"example.org.", "3600", "IN", "ISBN", "12-3 456789-0-123"}, "\t")
-
-func TestPrivateText(t *testing.T) {
-	dns.PrivateHandle("ISBN", TypeISBN, NewISBN)
-	defer dns.PrivateHandleRemove(TypeISBN)
-
-	rr, err := dns.NewRR(testrecord)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rr.String() != testrecord {
-		t.Errorf("record string representation did not match original %#v != %#v", rr.String(), testrecord)
-	}
-}
-
-func TestPrivateByteSlice(t *testing.T) {
-	dns.PrivateHandle("ISBN", TypeISBN, NewISBN)
-	defer dns.PrivateHandleRemove(TypeISBN)
-
-	rr, err := dns.NewRR(testrecord)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	buf := make([]byte, 100)
-	off, err := dns.PackRR(rr, buf, 0, nil, false)
-	if err != nil {
-		t.Errorf("got error packing ISBN: %v", err)
-	}
-
-	custrr := rr.(*dns.PrivateRR)
-	if ln := custrr.Data.Len() + len(custrr.Header().Name) + 11; ln != off {
-		t.Errorf("offset is not matching to length of Private RR: %d!=%d", off, ln)
-	}
-
-	rr1, off1, err := dns.UnpackRR(buf[:off], 0)
-	if err != nil {
-		t.Errorf("got error unpacking ISBN: %v", err)
-		return
-	}
-
-	if off1 != off {
-		t.Errorf("offset after unpacking differs: %d != %d", off1, off)
-	}
-
-	if rr1.String() != testrecord {
-		t.Errorf("record string representation did not match original %#v != %#v", rr1.String(), testrecord)
-	}
-}
-
-const TypeVERSION uint16 = 0xFF01
-
-type VERSION struct {
-	x string
-}
-
-func NewVersion() dns.PrivateRdata { return &VERSION{""} }
-
-func (rd *VERSION) String() string { return rd.x }
-func (rd *VERSION) Parse(txt []string) error {
-	rd.x = strings.TrimSpace(strings.Join(txt, " "))
-	return nil
-}
-
-func (rd *VERSION) Pack(buf []byte) (int, error) {
-	b := []byte(rd.x)
-	n := copy(buf, b)
-	if n != len(b) {
-		return n, dns.ErrBuf
-	}
-	return n, nil
-}
-
-func (rd *VERSION) Unpack(buf []byte) (int, error) {
-	rd.x = string(buf)
-	return len(buf), nil
-}
-
-func (rd *VERSION) Copy(dest dns.PrivateRdata) error {
-	isbn, ok := dest.(*VERSION)
-	if !ok {
-		return dns.ErrRdata
-	}
-	isbn.x = rd.x
-	return nil
-}
-
-func (rd *VERSION) Len() int {
-	return len([]byte(rd.x))
-}
-
-var smallzone = `$ORIGIN example.org.
-@ 3600 IN SOA	sns.dns.icann.org. noc.dns.icann.org. (
-		2014091518 7200 3600 1209600 3600
-)
-    A   1.2.3.4
-ok ISBN 1231-92110-12
-go VERSION (
-	1.3.1 ; comment
-)
-www ISBN 1231-92110-16
-*  CNAME @
-`
-
-func TestPrivateZoneParser(t *testing.T) {
-	dns.PrivateHandle("ISBN", TypeISBN, NewISBN)
-	dns.PrivateHandle("VERSION", TypeVERSION, NewVersion)
-	defer dns.PrivateHandleRemove(TypeISBN)
-	defer dns.PrivateHandleRemove(TypeVERSION)
-
-	r := strings.NewReader(smallzone)
-	for x := range dns.ParseZone(r, ".", "") {
-		if err := x.Error; err != nil {
-			t.Fatal(err)
-		}
-	}
-}

vendor/github.com/miekg/dns/remote_test.go

@@ -1,19 +0,0 @@
-package dns
-
-import "testing"
-
-const LinodeAddr = "176.58.119.54:53"
-
-func TestClientRemote(t *testing.T) {
-	m := new(Msg)
-	m.SetQuestion("go.dns.miek.nl.", TypeTXT)
-
-	c := new(Client)
-	r, _, err := c.Exchange(m, LinodeAddr)
-	if err != nil {
-		t.Errorf("failed to exchange: %v", err)
-	}
-	if r != nil && r.Rcode != RcodeSuccess {
-		t.Errorf("failed to get an valid answer\n%v", r)
-	}
-}

vendor/github.com/miekg/dns/rr_test.go

@@ -1,7 +0,0 @@
-package dns
-
-// testRR returns the RR from string s. The error is thrown away.
-func testRR(s string) RR {
-	r, _ := NewRR(s)
-	return r
-}

vendor/github.com/miekg/dns/sanitize_test.go

@@ -1,75 +0,0 @@
-package dns
-
-import "testing"
-
-func TestDedup(t *testing.T) {
-	testcases := map[[3]RR][]string{
-		[...]RR{
-			testRR("mIek.nl. IN A 127.0.0.1"),
-			testRR("mieK.nl. IN A 127.0.0.1"),
-			testRR("miek.Nl. IN A 127.0.0.1"),
-		}: {"mIek.nl.\t3600\tIN\tA\t127.0.0.1"},
-		[...]RR{
-			testRR("miEk.nl. 2000 IN A 127.0.0.1"),
-			testRR("mieK.Nl. 1000 IN A 127.0.0.1"),
-			testRR("Miek.nL. 500 IN A 127.0.0.1"),
-		}: {"miEk.nl.\t500\tIN\tA\t127.0.0.1"},
-		[...]RR{
-			testRR("miek.nl. IN A 127.0.0.1"),
-			testRR("miek.nl. CH A 127.0.0.1"),
-			testRR("miek.nl. IN A 127.0.0.1"),
-		}: {"miek.nl.\t3600\tIN\tA\t127.0.0.1",
-			"miek.nl.\t3600\tCH\tA\t127.0.0.1",
-		},
-		[...]RR{
-			testRR("miek.nl. CH A 127.0.0.1"),
-			testRR("miek.nl. IN A 127.0.0.1"),
-			testRR("miek.de. IN A 127.0.0.1"),
-		}: {"miek.nl.\t3600\tCH\tA\t127.0.0.1",
-			"miek.nl.\t3600\tIN\tA\t127.0.0.1",
-			"miek.de.\t3600\tIN\tA\t127.0.0.1",
-		},
-		[...]RR{
-			testRR("miek.de. IN A 127.0.0.1"),
-			testRR("miek.nl. 200 IN A 127.0.0.1"),
-			testRR("miek.nl. 300 IN A 127.0.0.1"),
-		}: {"miek.de.\t3600\tIN\tA\t127.0.0.1",
-			"miek.nl.\t200\tIN\tA\t127.0.0.1",
-		},
-	}
-
-	for rr, expected := range testcases {
-		out := Dedup([]RR{rr[0], rr[1], rr[2]}, nil)
-		for i, o := range out {
-			if o.String() != expected[i] {
-				t.Fatalf("expected %v, got %v", expected[i], o.String())
-			}
-		}
-	}
-}
-
-func BenchmarkDedup(b *testing.B) {
-	rrs := []RR{
-		testRR("miEk.nl. 2000 IN A 127.0.0.1"),
-		testRR("mieK.Nl. 1000 IN A 127.0.0.1"),
-		testRR("Miek.nL. 500 IN A 127.0.0.1"),
-	}
-	m := make(map[string]RR)
-	for i := 0; i < b.N; i++ {
-		Dedup(rrs, m)
-	}
-}
-
-func TestNormalizedString(t *testing.T) {
-	tests := map[RR]string{
-		testRR("mIEk.Nl. 3600 IN A 127.0.0.1"):     "miek.nl.\tIN\tA\t127.0.0.1",
-		testRR("m\\ iek.nL. 3600 IN A 127.0.0.1"):  "m\\ iek.nl.\tIN\tA\t127.0.0.1",
-		testRR("m\\\tIeK.nl. 3600 in A 127.0.0.1"): "m\\009iek.nl.\tIN\tA\t127.0.0.1",
-	}
-	for tc, expected := range tests {
-		n := normalizedString(tc)
-		if n != expected {
-			t.Errorf("expected %s, got %s", expected, n)
-		}
-	}
-}

vendor/github.com/miekg/dns/scan_test.go

@@ -1,48 +0,0 @@
-package dns
-
-import (
-	"io/ioutil"
-	"os"
-	"strings"
-	"testing"
-)
-
-func TestParseZoneInclude(t *testing.T) {
-
-	tmpfile, err := ioutil.TempFile("", "dns")
-	if err != nil {
-		t.Fatalf("could not create tmpfile for test: %s", err)
-	}
-
-	if _, err := tmpfile.WriteString("foo\tIN\tA\t127.0.0.1"); err != nil {
-		t.Fatalf("unable to write content to tmpfile %q: %s", tmpfile.Name(), err)
-	}
-	if err := tmpfile.Close(); err != nil {
-		t.Fatalf("could not close tmpfile %q: %s", tmpfile.Name(), err)
-	}
-
-	zone := "$ORIGIN example.org.\n$INCLUDE " + tmpfile.Name()
-
-	tok := ParseZone(strings.NewReader(zone), "", "")
-	for x := range tok {
-		if x.Error != nil {
-			t.Fatalf("expected no error, but got %s", x.Error)
-		}
-		if x.RR.Header().Name != "foo.example.org." {
-			t.Fatalf("expected %s, but got %s", "foo.example.org.", x.RR.Header().Name)
-		}
-	}
-
-	os.Remove(tmpfile.Name())
-
-	tok = ParseZone(strings.NewReader(zone), "", "")
-	for x := range tok {
-		if x.Error == nil {
-			t.Fatalf("expected first token to contain an error but it didn't")
-		}
-		if !strings.Contains(x.Error.Error(), "failed to open") ||
-			!strings.Contains(x.Error.Error(), tmpfile.Name()) {
-			t.Fatalf(`expected error to contain: "failed to open" and %q but got: %s`, tmpfile.Name(), x.Error)
-		}
-	}
-}

vendor/github.com/miekg/dns/server_test.go

@@ -1,792 +0,0 @@
-package dns
-
-import (
-	"crypto/tls"
-	"fmt"
-	"io"
-	"net"
-	"runtime"
-	"sync"
-	"testing"
-	"time"
-)
-
-func HelloServer(w ResponseWriter, req *Msg) {
-	m := new(Msg)
-	m.SetReply(req)
-
-	m.Extra = make([]RR, 1)
-	m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
-	w.WriteMsg(m)
-}
-
-func HelloServerBadID(w ResponseWriter, req *Msg) {
-	m := new(Msg)
-	m.SetReply(req)
-	m.Id++
-
-	m.Extra = make([]RR, 1)
-	m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
-	w.WriteMsg(m)
-}
-
-func HelloServerEchoAddrPort(w ResponseWriter, req *Msg) {
-	m := new(Msg)
-	m.SetReply(req)
-
-	remoteAddr := w.RemoteAddr().String()
-	m.Extra = make([]RR, 1)
-	m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{remoteAddr}}
-	w.WriteMsg(m)
-}
-
-func AnotherHelloServer(w ResponseWriter, req *Msg) {
-	m := new(Msg)
-	m.SetReply(req)
-
-	m.Extra = make([]RR, 1)
-	m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello example"}}
-	w.WriteMsg(m)
-}
-
-func RunLocalUDPServer(laddr string) (*Server, string, error) {
-	server, l, _, err := RunLocalUDPServerWithFinChan(laddr)
-
-	return server, l, err
-}
-
-func RunLocalUDPServerWithFinChan(laddr string) (*Server, string, chan error, error) {
-	pc, err := net.ListenPacket("udp", laddr)
-	if err != nil {
-		return nil, "", nil, err
-	}
-	server := &Server{PacketConn: pc, ReadTimeout: time.Hour, WriteTimeout: time.Hour}
-
-	waitLock := sync.Mutex{}
-	waitLock.Lock()
-	server.NotifyStartedFunc = waitLock.Unlock
-
-	// fin must be buffered so the goroutine below won't block
-	// forever if fin is never read from. This always happens
-	// in RunLocalUDPServer and can happen in TestShutdownUDP.
-	fin := make(chan error, 1)
-
-	go func() {
-		fin <- server.ActivateAndServe()
-		pc.Close()
-	}()
-
-	waitLock.Lock()
-	return server, pc.LocalAddr().String(), fin, nil
-}
-
-func RunLocalUDPServerUnsafe(laddr string) (*Server, string, error) {
-	pc, err := net.ListenPacket("udp", laddr)
-	if err != nil {
-		return nil, "", err
-	}
-	server := &Server{PacketConn: pc, Unsafe: true,
-		ReadTimeout: time.Hour, WriteTimeout: time.Hour}
-
-	waitLock := sync.Mutex{}
-	waitLock.Lock()
-	server.NotifyStartedFunc = waitLock.Unlock
-
-	go func() {
-		server.ActivateAndServe()
-		pc.Close()
-	}()
-
-	waitLock.Lock()
-	return server, pc.LocalAddr().String(), nil
-}
-
-func RunLocalTCPServer(laddr string) (*Server, string, error) {
-	server, l, _, err := RunLocalTCPServerWithFinChan(laddr)
-
-	return server, l, err
-}
-
-func RunLocalTCPServerWithFinChan(laddr string) (*Server, string, chan error, error) {
-	l, err := net.Listen("tcp", laddr)
-	if err != nil {
-		return nil, "", nil, err
-	}
-
-	server := &Server{Listener: l, ReadTimeout: time.Hour, WriteTimeout: time.Hour}
-
-	waitLock := sync.Mutex{}
-	waitLock.Lock()
-	server.NotifyStartedFunc = waitLock.Unlock
-
-	// See the comment in RunLocalUDPServerWithFinChan as to
-	// why fin must be buffered.
-	fin := make(chan error, 1)
-
-	go func() {
-		fin <- server.ActivateAndServe()
-		l.Close()
-	}()
-
-	waitLock.Lock()
-	return server, l.Addr().String(), fin, nil
-}
-
-func RunLocalTLSServer(laddr string, config *tls.Config) (*Server, string, error) {
-	l, err := tls.Listen("tcp", laddr, config)
-	if err != nil {
-		return nil, "", err
-	}
-
-	server := &Server{Listener: l, ReadTimeout: time.Hour, WriteTimeout: time.Hour}
-
-	waitLock := sync.Mutex{}
-	waitLock.Lock()
-	server.NotifyStartedFunc = waitLock.Unlock
-
-	go func() {
-		server.ActivateAndServe()
-		l.Close()
-	}()
-
-	waitLock.Lock()
-	return server, l.Addr().String(), nil
-}
-
-func TestServing(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServer)
-	HandleFunc("example.com.", AnotherHelloServer)
-	defer HandleRemove("miek.nl.")
-	defer HandleRemove("example.com.")
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	c := new(Client)
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeTXT)
-	r, _, err := c.Exchange(m, addrstr)
-	if err != nil || len(r.Extra) == 0 {
-		t.Fatal("failed to exchange miek.nl", err)
-	}
-	txt := r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello world" {
-		t.Error("unexpected result for miek.nl", txt, "!= Hello world")
-	}
-
-	m.SetQuestion("example.com.", TypeTXT)
-	r, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatal("failed to exchange example.com", err)
-	}
-	txt = r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello example" {
-		t.Error("unexpected result for example.com", txt, "!= Hello example")
-	}
-
-	// Test Mixes cased as noticed by Ask.
-	m.SetQuestion("eXaMplE.cOm.", TypeTXT)
-	r, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Error("failed to exchange eXaMplE.cOm", err)
-	}
-	txt = r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello example" {
-		t.Error("unexpected result for example.com", txt, "!= Hello example")
-	}
-}
-
-func TestServingTLS(t *testing.T) {
-	HandleFunc("miek.nl.", HelloServer)
-	HandleFunc("example.com.", AnotherHelloServer)
-	defer HandleRemove("miek.nl.")
-	defer HandleRemove("example.com.")
-
-	cert, err := tls.X509KeyPair(CertPEMBlock, KeyPEMBlock)
-	if err != nil {
-		t.Fatalf("unable to build certificate: %v", err)
-	}
-
-	config := tls.Config{
-		Certificates: []tls.Certificate{cert},
-	}
-
-	s, addrstr, err := RunLocalTLSServer(":0", &config)
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	c := new(Client)
-	c.Net = "tcp-tls"
-	c.TLSConfig = &tls.Config{
-		InsecureSkipVerify: true,
-	}
-
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeTXT)
-	r, _, err := c.Exchange(m, addrstr)
-	if err != nil || len(r.Extra) == 0 {
-		t.Fatal("failed to exchange miek.nl", err)
-	}
-	txt := r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello world" {
-		t.Error("unexpected result for miek.nl", txt, "!= Hello world")
-	}
-
-	m.SetQuestion("example.com.", TypeTXT)
-	r, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatal("failed to exchange example.com", err)
-	}
-	txt = r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello example" {
-		t.Error("unexpected result for example.com", txt, "!= Hello example")
-	}
-
-	// Test Mixes cased as noticed by Ask.
-	m.SetQuestion("eXaMplE.cOm.", TypeTXT)
-	r, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Error("failed to exchange eXaMplE.cOm", err)
-	}
-	txt = r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello example" {
-		t.Error("unexpected result for example.com", txt, "!= Hello example")
-	}
-}
-
-func TestServingListenAndServe(t *testing.T) {
-	HandleFunc("example.com.", AnotherHelloServer)
-	defer HandleRemove("example.com.")
-
-	waitLock := sync.Mutex{}
-	server := &Server{Addr: ":0", Net: "udp", ReadTimeout: time.Hour, WriteTimeout: time.Hour, NotifyStartedFunc: waitLock.Unlock}
-	waitLock.Lock()
-
-	go func() {
-		server.ListenAndServe()
-	}()
-	waitLock.Lock()
-
-	c, m := new(Client), new(Msg)
-	m.SetQuestion("example.com.", TypeTXT)
-	addr := server.PacketConn.LocalAddr().String() // Get address via the PacketConn that gets set.
-	r, _, err := c.Exchange(m, addr)
-	if err != nil {
-		t.Fatal("failed to exchange example.com", err)
-	}
-	txt := r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello example" {
-		t.Error("unexpected result for example.com", txt, "!= Hello example")
-	}
-	server.Shutdown()
-}
-
-func TestServingListenAndServeTLS(t *testing.T) {
-	HandleFunc("example.com.", AnotherHelloServer)
-	defer HandleRemove("example.com.")
-
-	cert, err := tls.X509KeyPair(CertPEMBlock, KeyPEMBlock)
-	if err != nil {
-		t.Fatalf("unable to build certificate: %v", err)
-	}
-
-	config := &tls.Config{
-		Certificates: []tls.Certificate{cert},
-	}
-
-	waitLock := sync.Mutex{}
-	server := &Server{Addr: ":0", Net: "tcp", TLSConfig: config, ReadTimeout: time.Hour, WriteTimeout: time.Hour, NotifyStartedFunc: waitLock.Unlock}
-	waitLock.Lock()
-
-	go func() {
-		server.ListenAndServe()
-	}()
-	waitLock.Lock()
-
-	c, m := new(Client), new(Msg)
-	c.Net = "tcp"
-	m.SetQuestion("example.com.", TypeTXT)
-	addr := server.Listener.Addr().String() // Get address via the Listener that gets set.
-	r, _, err := c.Exchange(m, addr)
-	if err != nil {
-		t.Fatal(err)
-	}
-	txt := r.Extra[0].(*TXT).Txt[0]
-	if txt != "Hello example" {
-		t.Error("unexpected result for example.com", txt, "!= Hello example")
-	}
-	server.Shutdown()
-}
-
-func BenchmarkServe(b *testing.B) {
-	b.StopTimer()
-	HandleFunc("miek.nl.", HelloServer)
-	defer HandleRemove("miek.nl.")
-	a := runtime.GOMAXPROCS(4)
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		b.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	c := new(Client)
-	m := new(Msg)
-	m.SetQuestion("miek.nl", TypeSOA)
-
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		c.Exchange(m, addrstr)
-	}
-	runtime.GOMAXPROCS(a)
-}
-
-func benchmarkServe6(b *testing.B) {
-	b.StopTimer()
-	HandleFunc("miek.nl.", HelloServer)
-	defer HandleRemove("miek.nl.")
-	a := runtime.GOMAXPROCS(4)
-	s, addrstr, err := RunLocalUDPServer("[::1]:0")
-	if err != nil {
-		b.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	c := new(Client)
-	m := new(Msg)
-	m.SetQuestion("miek.nl", TypeSOA)
-
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		c.Exchange(m, addrstr)
-	}
-	runtime.GOMAXPROCS(a)
-}
-
-func HelloServerCompress(w ResponseWriter, req *Msg) {
-	m := new(Msg)
-	m.SetReply(req)
-	m.Extra = make([]RR, 1)
-	m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
-	m.Compress = true
-	w.WriteMsg(m)
-}
-
-func BenchmarkServeCompress(b *testing.B) {
-	b.StopTimer()
-	HandleFunc("miek.nl.", HelloServerCompress)
-	defer HandleRemove("miek.nl.")
-	a := runtime.GOMAXPROCS(4)
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		b.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	c := new(Client)
-	m := new(Msg)
-	m.SetQuestion("miek.nl", TypeSOA)
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		c.Exchange(m, addrstr)
-	}
-	runtime.GOMAXPROCS(a)
-}
-
-func TestDotAsCatchAllWildcard(t *testing.T) {
-	mux := NewServeMux()
-	mux.Handle(".", HandlerFunc(HelloServer))
-	mux.Handle("example.com.", HandlerFunc(AnotherHelloServer))
-
-	handler := mux.match("www.miek.nl.", TypeTXT)
-	if handler == nil {
-		t.Error("wildcard match failed")
-	}
-
-	handler = mux.match("www.example.com.", TypeTXT)
-	if handler == nil {
-		t.Error("example.com match failed")
-	}
-
-	handler = mux.match("a.www.example.com.", TypeTXT)
-	if handler == nil {
-		t.Error("a.www.example.com match failed")
-	}
-
-	handler = mux.match("boe.", TypeTXT)
-	if handler == nil {
-		t.Error("boe. match failed")
-	}
-}
-
-func TestCaseFolding(t *testing.T) {
-	mux := NewServeMux()
-	mux.Handle("_udp.example.com.", HandlerFunc(HelloServer))
-
-	handler := mux.match("_dns._udp.example.com.", TypeSRV)
-	if handler == nil {
-		t.Error("case sensitive characters folded")
-	}
-
-	handler = mux.match("_DNS._UDP.EXAMPLE.COM.", TypeSRV)
-	if handler == nil {
-		t.Error("case insensitive characters not folded")
-	}
-}
-
-func TestRootServer(t *testing.T) {
-	mux := NewServeMux()
-	mux.Handle(".", HandlerFunc(HelloServer))
-
-	handler := mux.match(".", TypeNS)
-	if handler == nil {
-		t.Error("root match failed")
-	}
-}
-
-type maxRec struct {
-	max int
-	sync.RWMutex
-}
-
-var M = new(maxRec)
-
-func HelloServerLargeResponse(resp ResponseWriter, req *Msg) {
-	m := new(Msg)
-	m.SetReply(req)
-	m.Authoritative = true
-	m1 := 0
-	M.RLock()
-	m1 = M.max
-	M.RUnlock()
-	for i := 0; i < m1; i++ {
-		aRec := &A{
-			Hdr: RR_Header{
-				Name:   req.Question[0].Name,
-				Rrtype: TypeA,
-				Class:  ClassINET,
-				Ttl:    0,
-			},
-			A: net.ParseIP(fmt.Sprintf("127.0.0.%d", i+1)).To4(),
-		}
-		m.Answer = append(m.Answer, aRec)
-	}
-	resp.WriteMsg(m)
-}
-
-func TestServingLargeResponses(t *testing.T) {
-	HandleFunc("example.", HelloServerLargeResponse)
-	defer HandleRemove("example.")
-
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	// Create request
-	m := new(Msg)
-	m.SetQuestion("web.service.example.", TypeANY)
-
-	c := new(Client)
-	c.Net = "udp"
-	M.Lock()
-	M.max = 2
-	M.Unlock()
-	_, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Errorf("failed to exchange: %v", err)
-	}
-	// This must fail
-	M.Lock()
-	M.max = 20
-	M.Unlock()
-	_, _, err = c.Exchange(m, addrstr)
-	if err == nil {
-		t.Error("failed to fail exchange, this should generate packet error")
-	}
-	// But this must work again
-	c.UDPSize = 7000
-	_, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Errorf("failed to exchange: %v", err)
-	}
-}
-
-func TestServingResponse(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping test in short mode.")
-	}
-	HandleFunc("miek.nl.", HelloServer)
-	s, addrstr, err := RunLocalUDPServer(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-
-	c := new(Client)
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeTXT)
-	m.Response = false
-	_, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatal("failed to exchange", err)
-	}
-	m.Response = true
-	_, _, err = c.Exchange(m, addrstr)
-	if err == nil {
-		t.Fatal("exchanged response message")
-	}
-
-	s.Shutdown()
-	s, addrstr, err = RunLocalUDPServerUnsafe(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	defer s.Shutdown()
-
-	m.Response = true
-	_, _, err = c.Exchange(m, addrstr)
-	if err != nil {
-		t.Fatal("could exchanged response message in Unsafe mode")
-	}
-}
-
-func TestShutdownTCP(t *testing.T) {
-	s, _, fin, err := RunLocalTCPServerWithFinChan(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	err = s.Shutdown()
-	if err != nil {
-		t.Fatalf("could not shutdown test TCP server, %v", err)
-	}
-	select {
-	case err := <-fin:
-		if err != nil {
-			t.Errorf("error returned from ActivateAndServe, %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Error("could not shutdown test TCP server. Gave up waiting")
-	}
-}
-
-func TestShutdownTLS(t *testing.T) {
-	cert, err := tls.X509KeyPair(CertPEMBlock, KeyPEMBlock)
-	if err != nil {
-		t.Fatalf("unable to build certificate: %v", err)
-	}
-
-	config := tls.Config{
-		Certificates: []tls.Certificate{cert},
-	}
-
-	s, _, err := RunLocalTLSServer(":0", &config)
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	err = s.Shutdown()
-	if err != nil {
-		t.Errorf("could not shutdown test TLS server, %v", err)
-	}
-}
-
-type trigger struct {
-	done bool
-	sync.RWMutex
-}
-
-func (t *trigger) Set() {
-	t.Lock()
-	defer t.Unlock()
-	t.done = true
-}
-func (t *trigger) Get() bool {
-	t.RLock()
-	defer t.RUnlock()
-	return t.done
-}
-
-func TestHandlerCloseTCP(t *testing.T) {
-
-	ln, err := net.Listen("tcp", ":0")
-	if err != nil {
-		panic(err)
-	}
-	addr := ln.Addr().String()
-
-	server := &Server{Addr: addr, Net: "tcp", Listener: ln}
-
-	hname := "testhandlerclosetcp."
-	triggered := &trigger{}
-	HandleFunc(hname, func(w ResponseWriter, r *Msg) {
-		triggered.Set()
-		w.Close()
-	})
-	defer HandleRemove(hname)
-
-	go func() {
-		defer server.Shutdown()
-		c := &Client{Net: "tcp"}
-		m := new(Msg).SetQuestion(hname, 1)
-		tries := 0
-	exchange:
-		_, _, err := c.Exchange(m, addr)
-		if err != nil && err != io.EOF {
-			t.Errorf("exchange failed: %s\n", err)
-			if tries == 3 {
-				return
-			}
-			time.Sleep(time.Second / 10)
-			tries++
-			goto exchange
-		}
-	}()
-	server.ActivateAndServe()
-	if !triggered.Get() {
-		t.Fatalf("handler never called")
-	}
-}
-
-func TestShutdownUDP(t *testing.T) {
-	s, _, fin, err := RunLocalUDPServerWithFinChan(":0")
-	if err != nil {
-		t.Fatalf("unable to run test server: %v", err)
-	}
-	err = s.Shutdown()
-	if err != nil {
-		t.Errorf("could not shutdown test UDP server, %v", err)
-	}
-	select {
-	case err := <-fin:
-		if err != nil {
-			t.Errorf("error returned from ActivateAndServe, %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Error("could not shutdown test UDP server. Gave up waiting")
-	}
-}
-
-func TestServerStartStopRace(t *testing.T) {
-	for i := 0; i < 10; i++ {
-		var err error
-		s := &Server{}
-		s, _, _, err = RunLocalUDPServerWithFinChan(":0")
-		if err != nil {
-			t.Fatalf("could not start server: %s", err)
-		}
-		go func() {
-			if err := s.Shutdown(); err != nil {
-				t.Fatalf("could not stop server: %s", err)
-			}
-		}()
-	}
-}
-
-type ExampleFrameLengthWriter struct {
-	Writer
-}
-
-func (e *ExampleFrameLengthWriter) Write(m []byte) (int, error) {
-	fmt.Println("writing raw DNS message of length", len(m))
-	return e.Writer.Write(m)
-}
-
-func ExampleDecorateWriter() {
-	// instrument raw DNS message writing
-	wf := DecorateWriter(func(w Writer) Writer {
-		return &ExampleFrameLengthWriter{w}
-	})
-
-	// simple UDP server
-	pc, err := net.ListenPacket("udp", ":0")
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	server := &Server{
-		PacketConn:     pc,
-		DecorateWriter: wf,
-		ReadTimeout:    time.Hour, WriteTimeout: time.Hour,
-	}
-
-	waitLock := sync.Mutex{}
-	waitLock.Lock()
-	server.NotifyStartedFunc = waitLock.Unlock
-	defer server.Shutdown()
-
-	go func() {
-		server.ActivateAndServe()
-		pc.Close()
-	}()
-
-	waitLock.Lock()
-
-	HandleFunc("miek.nl.", HelloServer)
-
-	c := new(Client)
-	m := new(Msg)
-	m.SetQuestion("miek.nl.", TypeTXT)
-	_, _, err = c.Exchange(m, pc.LocalAddr().String())
-	if err != nil {
-		fmt.Println("failed to exchange", err.Error())
-		return
-	}
-	// Output: writing raw DNS message of length 56
-}
-
-var (
-	// CertPEMBlock is a X509 data used to test TLS servers (used with tls.X509KeyPair)
-	CertPEMBlock = []byte(`-----BEGIN CERTIFICATE-----
-MIIDAzCCAeugAwIBAgIRAJFYMkcn+b8dpU15wjf++GgwDQYJKoZIhvcNAQELBQAw
-EjEQMA4GA1UEChMHQWNtZSBDbzAeFw0xNjAxMDgxMjAzNTNaFw0xNzAxMDcxMjAz
-NTNaMBIxEDAOBgNVBAoTB0FjbWUgQ28wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
-ggEKAoIBAQDXjqO6skvP03k58CNjQggd9G/mt+Wa+xRU+WXiKCCHttawM8x+slq5
-yfsHCwxlwsGn79HmJqecNqgHb2GWBXAvVVokFDTcC1hUP4+gp2gu9Ny27UHTjlLm
-O0l/xZ5MN8tfKyYlFw18tXu3fkaPyHj8v/D1RDkuo4ARdFvGSe8TqisbhLk2+9ow
-xfIGbEM9Fdiw8qByC2+d+FfvzIKz3GfQVwn0VoRom8L6NBIANq1IGrB5JefZB6nv
-DnfuxkBmY7F1513HKuEJ8KsLWWZWV9OPU4j4I4Rt+WJNlKjbD2srHxyrS2RDsr91
-8nCkNoWVNO3sZq0XkWKecdc921vL4ginAgMBAAGjVDBSMA4GA1UdDwEB/wQEAwIC
-pDATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MBoGA1UdEQQT
-MBGCCWxvY2FsaG9zdIcEfwAAATANBgkqhkiG9w0BAQsFAAOCAQEAGcU3iyLBIVZj
-aDzSvEDHUd1bnLBl1C58Xu/CyKlPqVU7mLfK0JcgEaYQTSX6fCJVNLbbCrcGLsPJ
-fbjlBbyeLjTV413fxPVuona62pBFjqdtbli2Qe8FRH2KBdm41JUJGdo+SdsFu7nc
-BFOcubdw6LLIXvsTvwndKcHWx1rMX709QU1Vn1GAIsbJV/DWI231Jyyb+lxAUx/C
-8vce5uVxiKcGS+g6OjsN3D3TtiEQGSXLh013W6Wsih8td8yMCMZ3w8LQ38br1GUe
-ahLIgUJ9l6HDguM17R7kGqxNvbElsMUHfTtXXP7UDQUiYXDakg8xDP6n9DCDhJ8Y
-bSt7OLB7NQ==
------END CERTIFICATE-----`)
-
-	// KeyPEMBlock is a X509 data used to test TLS servers (used with tls.X509KeyPair)
-	KeyPEMBlock = []byte(`-----BEGIN RSA PRIVATE KEY-----
-MIIEpQIBAAKCAQEA146jurJLz9N5OfAjY0IIHfRv5rflmvsUVPll4iggh7bWsDPM
-frJaucn7BwsMZcLBp+/R5iannDaoB29hlgVwL1VaJBQ03AtYVD+PoKdoLvTctu1B
-045S5jtJf8WeTDfLXysmJRcNfLV7t35Gj8h4/L/w9UQ5LqOAEXRbxknvE6orG4S5
-NvvaMMXyBmxDPRXYsPKgcgtvnfhX78yCs9xn0FcJ9FaEaJvC+jQSADatSBqweSXn
-2Qep7w537sZAZmOxdeddxyrhCfCrC1lmVlfTj1OI+COEbfliTZSo2w9rKx8cq0tk
-Q7K/dfJwpDaFlTTt7GatF5FinnHXPdtby+IIpwIDAQABAoIBAAJK4RDmPooqTJrC
-JA41MJLo+5uvjwCT9QZmVKAQHzByUFw1YNJkITTiognUI0CdzqNzmH7jIFs39ZeG
-proKusO2G6xQjrNcZ4cV2fgyb5g4QHStl0qhs94A+WojduiGm2IaumAgm6Mc5wDv
-ld6HmknN3Mku/ZCyanVFEIjOVn2WB7ZQLTBs6ZYaebTJG2Xv6p9t2YJW7pPQ9Xce
-s9ohAWohyM4X/OvfnfnLtQp2YLw/BxwehBsCR5SXM3ibTKpFNtxJC8hIfTuWtxZu
-2ywrmXShYBRB1WgtZt5k04bY/HFncvvcHK3YfI1+w4URKtwdaQgPUQRbVwDwuyBn
-flfkCJECgYEA/eWt01iEyE/lXkGn6V9lCocUU7lCU6yk5UT8VXVUc5If4KZKPfCk
-p4zJDOqwn2eM673aWz/mG9mtvAvmnugaGjcaVCyXOp/D/GDmKSoYcvW5B/yjfkLy
-dK6Yaa5LDRVYlYgyzcdCT5/9Qc626NzFwKCZNI4ncIU8g7ViATRxWJ8CgYEA2Ver
-vZ0M606sfgC0H3NtwNBxmuJ+lIF5LNp/wDi07lDfxRR1rnZMX5dnxjcpDr/zvm8J
-WtJJX3xMgqjtHuWKL3yKKony9J5ZPjichSbSbhrzfovgYIRZLxLLDy4MP9L3+CX/
-yBXnqMWuSnFX+M5fVGxdDWiYF3V+wmeOv9JvavkCgYEAiXAPDFzaY+R78O3xiu7M
-r0o3wqqCMPE/wav6O/hrYrQy9VSO08C0IM6g9pEEUwWmzuXSkZqhYWoQFb8Lc/GI
-T7CMXAxXQLDDUpbRgG79FR3Wr3AewHZU8LyiXHKwxcBMV4WGmsXGK3wbh8fyU1NO
-6NsGk+BvkQVOoK1LBAPzZ1kCgYEAsBSmD8U33T9s4dxiEYTrqyV0lH3g/SFz8ZHH
-pAyNEPI2iC1ONhyjPWKlcWHpAokiyOqeUpVBWnmSZtzC1qAydsxYB6ShT+sl9BHb
-RMix/QAauzBJhQhUVJ3OIys0Q1UBDmqCsjCE8SfOT4NKOUnA093C+YT+iyrmmktZ
-zDCJkckCgYEAndqM5KXGk5xYo+MAA1paZcbTUXwaWwjLU+XSRSSoyBEi5xMtfvUb
-7+a1OMhLwWbuz+pl64wFKrbSUyimMOYQpjVE/1vk/kb99pxbgol27hdKyTH1d+ov
-kFsxKCqxAnBVGEWAvVZAiiTOxleQFjz5RnL0BQp9Lg2cQe+dvuUmIAA=
------END RSA PRIVATE KEY-----`)
-)

vendor/github.com/miekg/dns/sig0_test.go

@@ -1,89 +0,0 @@
-package dns
-
-import (
-	"crypto"
-	"testing"
-	"time"
-)
-
-func TestSIG0(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping test in short mode.")
-	}
-	m := new(Msg)
-	m.SetQuestion("example.org.", TypeSOA)
-	for _, alg := range []uint8{ECDSAP256SHA256, ECDSAP384SHA384, RSASHA1, RSASHA256, RSASHA512} {
-		algstr := AlgorithmToString[alg]
-		keyrr := new(KEY)
-		keyrr.Hdr.Name = algstr + "."
-		keyrr.Hdr.Rrtype = TypeKEY
-		keyrr.Hdr.Class = ClassINET
-		keyrr.Algorithm = alg
-		keysize := 1024
-		switch alg {
-		case ECDSAP256SHA256:
-			keysize = 256
-		case ECDSAP384SHA384:
-			keysize = 384
-		}
-		pk, err := keyrr.Generate(keysize)
-		if err != nil {
-			t.Errorf("failed to generate key for “%s”: %v", algstr, err)
-			continue
-		}
-		now := uint32(time.Now().Unix())
-		sigrr := new(SIG)
-		sigrr.Hdr.Name = "."
-		sigrr.Hdr.Rrtype = TypeSIG
-		sigrr.Hdr.Class = ClassANY
-		sigrr.Algorithm = alg
-		sigrr.Expiration = now + 300
-		sigrr.Inception = now - 300
-		sigrr.KeyTag = keyrr.KeyTag()
-		sigrr.SignerName = keyrr.Hdr.Name
-		mb, err := sigrr.Sign(pk.(crypto.Signer), m)
-		if err != nil {
-			t.Errorf("failed to sign message using “%s”: %v", algstr, err)
-			continue
-		}
-		m := new(Msg)
-		if err := m.Unpack(mb); err != nil {
-			t.Errorf("failed to unpack message signed using “%s”: %v", algstr, err)
-			continue
-		}
-		if len(m.Extra) != 1 {
-			t.Errorf("missing SIG for message signed using “%s”", algstr)
-			continue
-		}
-		var sigrrwire *SIG
-		switch rr := m.Extra[0].(type) {
-		case *SIG:
-			sigrrwire = rr
-		default:
-			t.Errorf("expected SIG RR, instead: %v", rr)
-			continue
-		}
-		for _, rr := range []*SIG{sigrr, sigrrwire} {
-			id := "sigrr"
-			if rr == sigrrwire {
-				id = "sigrrwire"
-			}
-			if err := rr.Verify(keyrr, mb); err != nil {
-				t.Errorf("failed to verify “%s” signed SIG(%s): %v", algstr, id, err)
-				continue
-			}
-		}
-		mb[13]++
-		if err := sigrr.Verify(keyrr, mb); err == nil {
-			t.Errorf("verify succeeded on an altered message using “%s”", algstr)
-			continue
-		}
-		sigrr.Expiration = 2
-		sigrr.Inception = 1
-		mb, _ = sigrr.Sign(pk.(crypto.Signer), m)
-		if err := sigrr.Verify(keyrr, mb); err == nil {
-			t.Errorf("verify succeeded on an expired message using “%s”", algstr)
-			continue
-		}
-	}
-}

vendor/github.com/miekg/dns/tsig_test.go

@@ -1,52 +0,0 @@
-package dns
-
-import (
-	"encoding/binary"
-	"testing"
-	"time"
-)
-
-func newTsig(algo string) *Msg {
-	m := new(Msg)
-	m.SetQuestion("example.org.", TypeA)
-	m.SetTsig("example.", algo, 300, time.Now().Unix())
-	return m
-}
-
-func TestTsig(t *testing.T) {
-	m := newTsig(HmacMD5)
-	buf, _, err := TsigGenerate(m, "pRZgBrBvI4NAHZYhxmhs/Q==", "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = TsigVerify(buf, "pRZgBrBvI4NAHZYhxmhs/Q==", "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// TSIG accounts for ID substitution. This means if the message ID is
-	// changed by a forwarder, we should still be able to verify the TSIG.
-	m = newTsig(HmacMD5)
-	buf, _, err = TsigGenerate(m, "pRZgBrBvI4NAHZYhxmhs/Q==", "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	binary.BigEndian.PutUint16(buf[0:2], uint16(42))
-	err = TsigVerify(buf, "pRZgBrBvI4NAHZYhxmhs/Q==", "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestTsigCase(t *testing.T) {
-	m := newTsig("HmAc-mD5.sig-ALg.rEg.int.") // HmacMD5
-	buf, _, err := TsigGenerate(m, "pRZgBrBvI4NAHZYhxmhs/Q==", "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = TsigVerify(buf, "pRZgBrBvI4NAHZYhxmhs/Q==", "", false)
-	if err != nil {
-		t.Fatal(err)
-	}
-}

vendor/github.com/miekg/dns/types_test.go

@@ -1,74 +0,0 @@
-package dns
-
-import (
-	"testing"
-)
-
-func TestCmToM(t *testing.T) {
-	s := cmToM(0, 0)
-	if s != "0.00" {
-		t.Error("0, 0")
-	}
-
-	s = cmToM(1, 0)
-	if s != "0.01" {
-		t.Error("1, 0")
-	}
-
-	s = cmToM(3, 1)
-	if s != "0.30" {
-		t.Error("3, 1")
-	}
-
-	s = cmToM(4, 2)
-	if s != "4" {
-		t.Error("4, 2")
-	}
-
-	s = cmToM(5, 3)
-	if s != "50" {
-		t.Error("5, 3")
-	}
-
-	s = cmToM(7, 5)
-	if s != "7000" {
-		t.Error("7, 5")
-	}
-
-	s = cmToM(9, 9)
-	if s != "90000000" {
-		t.Error("9, 9")
-	}
-}
-
-func TestSplitN(t *testing.T) {
-	xs := splitN("abc", 5)
-	if len(xs) != 1 && xs[0] != "abc" {
-		t.Errorf("failure to split abc")
-	}
-
-	s := ""
-	for i := 0; i < 255; i++ {
-		s += "a"
-	}
-
-	xs = splitN(s, 255)
-	if len(xs) != 1 && xs[0] != s {
-		t.Errorf("failure to split 255 char long string")
-	}
-
-	s += "b"
-	xs = splitN(s, 255)
-	if len(xs) != 2 || xs[1] != "b" {
-		t.Errorf("failure to split 256 char long string: %d", len(xs))
-	}
-
-	// Make s longer
-	for i := 0; i < 255; i++ {
-		s += "a"
-	}
-	xs = splitN(s, 255)
-	if len(xs) != 3 || xs[2] != "a" {
-		t.Errorf("failure to split 510 char long string: %d", len(xs))
-	}
-}

vendor/github.com/miekg/dns/udp_test.go

@@ -1,140 +0,0 @@
-// +build linux,!appengine
-
-package dns
-
-import (
-	"bytes"
-	"net"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"golang.org/x/net/ipv4"
-	"golang.org/x/net/ipv6"
-)
-
-func TestSetUDPSocketOptions(t *testing.T) {
-	// returns an error if we cannot resolve that address
-	testFamily := func(n, addr string) error {
-		a, err := net.ResolveUDPAddr(n, addr)
-		if err != nil {
-			return err
-		}
-		c, err := net.ListenUDP(n, a)
-		if err != nil {
-			return err
-		}
-		if err := setUDPSocketOptions(c); err != nil {
-			t.Fatalf("failed to set socket options: %v", err)
-		}
-		ch := make(chan *SessionUDP)
-		go func() {
-			// Set some deadline so this goroutine doesn't hang forever
-			c.SetReadDeadline(time.Now().Add(time.Minute))
-			b := make([]byte, 1)
-			_, sess, err := ReadFromSessionUDP(c, b)
-			if err != nil {
-				t.Fatalf("failed to read from conn: %v", err)
-			}
-			ch <- sess
-		}()
-
-		c2, err := net.Dial("udp", c.LocalAddr().String())
-		if err != nil {
-			t.Fatalf("failed to dial udp: %v", err)
-		}
-		if _, err := c2.Write([]byte{1}); err != nil {
-			t.Fatalf("failed to write to conn: %v", err)
-		}
-		sess := <-ch
-		if len(sess.context) == 0 {
-			t.Fatalf("empty session context: %v", sess)
-		}
-		ip := parseDstFromOOB(sess.context)
-		if ip == nil {
-			t.Fatalf("failed to parse dst: %v", sess)
-		}
-		if !strings.Contains(c.LocalAddr().String(), ip.String()) {
-			t.Fatalf("dst was different than listen addr: %v != %v", ip.String(), c.LocalAddr().String())
-		}
-		return nil
-	}
-
-	// we require that ipv4 be supported
-	if err := testFamily("udp4", "127.0.0.1:0"); err != nil {
-		t.Fatalf("failed to test socket options on IPv4: %v", err)
-	}
-	// IPv6 might not be supported so these will just log
-	if err := testFamily("udp6", "[::1]:0"); err != nil {
-		t.Logf("failed to test socket options on IPv6-only: %v", err)
-	}
-	if err := testFamily("udp", "[::1]:0"); err != nil {
-		t.Logf("failed to test socket options on IPv6/IPv4: %v", err)
-	}
-}
-
-func TestParseDstFromOOB(t *testing.T) {
-	if runtime.GOARCH != "amd64" {
-		// The cmsghdr struct differs in the width (32/64-bit) of
-		// lengths and the struct padding between architectures.
-		// The data below was only written with amd64 in mind, and
-		// thus the test must be skipped on other architectures.
-		t.Skip("skipping test on unsupported architecture")
-	}
-
-	// dst is :ffff:100.100.100.100
-	oob := []byte{36, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 100, 100, 100, 100, 2, 0, 0, 0}
-	dst := parseDstFromOOB(oob)
-	dst4 := dst.To4()
-	if dst4 == nil {
-		t.Errorf("failed to parse IPv4 in IPv6: %v", dst)
-	} else if dst4.String() != "100.100.100.100" {
-		t.Errorf("unexpected IPv4: %v", dst4)
-	}
-
-	// dst is 2001:db8::1
-	oob = []byte{36, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 50, 0, 0, 0, 32, 1, 13, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0}
-	dst = parseDstFromOOB(oob)
-	dst6 := dst.To16()
-	if dst6 == nil {
-		t.Errorf("failed to parse IPv6: %v", dst)
-	} else if dst6.String() != "2001:db8::1" {
-		t.Errorf("unexpected IPv6: %v", dst4)
-	}
-
-	// dst is 100.100.100.100 but was received on 10.10.10.10
-	oob = []byte{28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 10, 10, 10, 10, 100, 100, 100, 100, 0, 0, 0, 0}
-	dst = parseDstFromOOB(oob)
-	dst4 = dst.To4()
-	if dst4 == nil {
-		t.Errorf("failed to parse IPv4: %v", dst)
-	} else if dst4.String() != "100.100.100.100" {
-		t.Errorf("unexpected IPv4: %v", dst4)
-	}
-}
-
-func TestCorrectSource(t *testing.T) {
-	if runtime.GOARCH != "amd64" {
-		// See comment above in TestParseDstFromOOB.
-		t.Skip("skipping test on unsupported architecture")
-	}
-
-	// dst is :ffff:100.100.100.100 which should be counted as IPv4
-	oob := []byte{36, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 100, 100, 100, 100, 2, 0, 0, 0}
-	soob := correctSource(oob)
-	cm4 := new(ipv4.ControlMessage)
-	cm4.Src = net.ParseIP("100.100.100.100")
-	if !bytes.Equal(soob, cm4.Marshal()) {
-		t.Errorf("unexpected oob for ipv4 address: %v", soob)
-	}
-
-	// dst is 2001:db8::1
-	oob = []byte{36, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 50, 0, 0, 0, 32, 1, 13, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0}
-	soob = correctSource(oob)
-	cm6 := new(ipv6.ControlMessage)
-	cm6.Src = net.ParseIP("2001:db8::1")
-	if !bytes.Equal(soob, cm6.Marshal()) {
-		t.Errorf("unexpected oob for IPv6 address: %v", soob)
-	}
-}

vendor/github.com/miekg/dns/update_test.go

@@ -1,139 +0,0 @@
-package dns
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestDynamicUpdateParsing(t *testing.T) {
-	prefix := "example.com. IN "
-	for _, typ := range TypeToString {
-		if typ == "OPT" || typ == "AXFR" || typ == "IXFR" || typ == "ANY" || typ == "TKEY" ||
-			typ == "TSIG" || typ == "ISDN" || typ == "UNSPEC" || typ == "NULL" || typ == "ATMA" ||
-			typ == "Reserved" || typ == "None" || typ == "NXT" || typ == "MAILB" || typ == "MAILA" {
-			continue
-		}
-		if _, err := NewRR(prefix + typ); err != nil {
-			t.Errorf("failure to parse: %s %s: %v", prefix, typ, err)
-		}
-	}
-}
-
-func TestDynamicUpdateUnpack(t *testing.T) {
-	// From https://github.com/miekg/dns/issues/150#issuecomment-62296803
-	// It should be an update message for the zone "example.",
-	// deleting the A RRset "example." and then adding an A record at "example.".
-	// class ANY, TYPE A
-	buf := []byte{171, 68, 40, 0, 0, 1, 0, 0, 0, 2, 0, 0, 7, 101, 120, 97, 109, 112, 108, 101, 0, 0, 6, 0, 1, 192, 12, 0, 1, 0, 255, 0, 0, 0, 0, 0, 0, 192, 12, 0, 1, 0, 1, 0, 0, 0, 0, 0, 4, 127, 0, 0, 1}
-	msg := new(Msg)
-	err := msg.Unpack(buf)
-	if err != nil {
-		t.Errorf("failed to unpack: %v\n%s", err, msg.String())
-	}
-}
-
-func TestDynamicUpdateZeroRdataUnpack(t *testing.T) {
-	m := new(Msg)
-	rr := &RR_Header{Name: ".", Rrtype: 0, Class: 1, Ttl: ^uint32(0), Rdlength: 0}
-	m.Answer = []RR{rr, rr, rr, rr, rr}
-	m.Ns = m.Answer
-	for n, s := range TypeToString {
-		rr.Rrtype = n
-		bytes, err := m.Pack()
-		if err != nil {
-			t.Errorf("failed to pack %s: %v", s, err)
-			continue
-		}
-		if err := new(Msg).Unpack(bytes); err != nil {
-			t.Errorf("failed to unpack %s: %v", s, err)
-		}
-	}
-}
-
-func TestRemoveRRset(t *testing.T) {
-	// Should add a zero data RR in Class ANY with a TTL of 0
-	// for each set mentioned in the RRs provided to it.
-	rr := testRR(". 100 IN A 127.0.0.1")
-	m := new(Msg)
-	m.Ns = []RR{&RR_Header{Name: ".", Rrtype: TypeA, Class: ClassANY, Ttl: 0, Rdlength: 0}}
-	expectstr := m.String()
-	expect, err := m.Pack()
-	if err != nil {
-		t.Fatalf("error packing expected msg: %v", err)
-	}
-
-	m.Ns = nil
-	m.RemoveRRset([]RR{rr})
-	actual, err := m.Pack()
-	if err != nil {
-		t.Fatalf("error packing actual msg: %v", err)
-	}
-	if !bytes.Equal(actual, expect) {
-		tmp := new(Msg)
-		if err := tmp.Unpack(actual); err != nil {
-			t.Fatalf("error unpacking actual msg: %v\nexpected: %v\ngot: %v\n", err, expect, actual)
-		}
-		t.Errorf("expected msg:\n%s", expectstr)
-		t.Errorf("actual msg:\n%v", tmp)
-	}
-}
-
-func TestPreReqAndRemovals(t *testing.T) {
-	// Build a list of multiple prereqs and then somes removes followed by an insert.
-	// We should be able to add multiple prereqs and updates.
-	m := new(Msg)
-	m.SetUpdate("example.org.")
-	m.Id = 1234
-
-	// Use a full set of RRs each time, so we are sure the rdata is stripped.
-	rrName1 := testRR("name_used. 3600 IN A 127.0.0.1")
-	rrName2 := testRR("name_not_used. 3600 IN A 127.0.0.1")
-	rrRemove1 := testRR("remove1. 3600 IN A 127.0.0.1")
-	rrRemove2 := testRR("remove2. 3600 IN A 127.0.0.1")
-	rrRemove3 := testRR("remove3. 3600 IN A 127.0.0.1")
-	rrInsert := testRR("insert. 3600 IN A 127.0.0.1")
-	rrRrset1 := testRR("rrset_used1. 3600 IN A 127.0.0.1")
-	rrRrset2 := testRR("rrset_used2. 3600 IN A 127.0.0.1")
-	rrRrset3 := testRR("rrset_not_used. 3600 IN A 127.0.0.1")
-
-	// Handle the prereqs.
-	m.NameUsed([]RR{rrName1})
-	m.NameNotUsed([]RR{rrName2})
-	m.RRsetUsed([]RR{rrRrset1})
-	m.Used([]RR{rrRrset2})
-	m.RRsetNotUsed([]RR{rrRrset3})
-
-	// and now the updates.
-	m.RemoveName([]RR{rrRemove1})
-	m.RemoveRRset([]RR{rrRemove2})
-	m.Remove([]RR{rrRemove3})
-	m.Insert([]RR{rrInsert})
-
-	// This test function isn't a Example function because we print these RR with tabs at the
-	// end and the Example function trim these, thus they never match.
-	// TODO(miek): don't print these tabs and make this into an Example function.
-	expect := `;; opcode: UPDATE, status: NOERROR, id: 1234
-;; flags:; QUERY: 1, ANSWER: 5, AUTHORITY: 4, ADDITIONAL: 0
-
-;; QUESTION SECTION:
-;example.org.	IN	 SOA
-
-;; ANSWER SECTION:
-name_used.	0	CLASS255	ANY	
-name_not_used.	0	NONE	ANY	
-rrset_used1.	0	CLASS255	A	
-rrset_used2.	3600	IN	A	127.0.0.1
-rrset_not_used.	0	NONE	A	
-
-;; AUTHORITY SECTION:
-remove1.	0	CLASS255	ANY	
-remove2.	0	CLASS255	A	
-remove3.	0	NONE	A	127.0.0.1
-insert.	3600	IN	A	127.0.0.1
-`
-
-	if m.String() != expect {
-		t.Errorf("expected msg:\n%s", expect)
-		t.Errorf("actual msg:\n%v", m.String())
-	}
-}

vendor/github.com/miekg/dns/version_test.go

@@ -1,10 +0,0 @@
-package dns
-
-import "testing"
-
-func TestVersion(t *testing.T) {
-	v := V{1, 0, 0}
-	if x := v.String(); x != "1.0.0" {
-		t.Fatalf("Failed to convert version %v, got: %s", v, x)
-	}
-}

vendor/golang.org/x/crypto/.gitattributes

@@ -1,10 +0,0 @@
-# Treat all files in this repo as binary, with no git magic updating
-# line endings. Windows users contributing to Go will need to use a
-# modern version of git and editors capable of LF line endings.
-#
-# We'll prevent accidental CRLF line endings from entering the repo
-# via the git-review gofmt checks.
-#
-# See golang.org/issue/9281
-
-* -text

vendor/golang.org/x/crypto/.gitignore

@@ -1,2 +0,0 @@
-# Add no patterns to .hgignore except for files generated by the build.
-last-change

vendor/golang.org/x/crypto/CONTRIBUTING.md

@@ -1,26 +0,0 @@
-# Contributing to Go
-
-Go is an open source project.
-
-It is the work of hundreds of contributors. We appreciate your help!
-
-## Filing issues
-
-When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions:
-
-1.  What version of Go are you using (`go version`)?
-2.  What operating system and processor architecture are you using?
-3.  What did you do?
-4.  What did you expect to see?
-5.  What did you see instead?
-
-General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
-The gophers there will answer or ask you to file an issue if you've tripped over a bug.
-
-## Contributing code
-
-Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
-before sending patches.
-
-Unless otherwise noted, the Go source files are distributed under
-the BSD-style license found in the LICENSE file.

vendor/golang.org/x/crypto/README.md

@@ -1,21 +0,0 @@
-# Go Cryptography
-
-This repository holds supplementary Go cryptography libraries.
-
-## Download/Install
-
-The easiest way to install is to run `go get -u golang.org/x/crypto/...`. You
-can also manually git clone the repository to `$GOPATH/src/golang.org/x/crypto`.
-
-## Report Issues / Send Patches
-
-This repository uses Gerrit for code changes. To learn how to submit changes to
-this repository, see https://golang.org/doc/contribute.html.
-
-The main issue tracker for the crypto repository is located at
-https://github.com/golang/go/issues. Prefix your issue with "x/crypto:" in the
-subject line, so it is easy to find.
-
-Note that contributions to the cryptography package receive additional scrutiny
-due to their sensitive nature. Patches may take longer than normal to receive
-feedback.

vendor/golang.org/x/crypto/codereview.cfg

@@ -1 +0,0 @@
-issuerepo: golang/go

vendor/golang.org/x/crypto/curve25519/curve25519_test.go

@@ -1,39 +0,0 @@
-// Copyright 2012 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 curve25519
-
-import (
-	"fmt"
-	"testing"
-)
-
-const expectedHex = "89161fde887b2b53de549af483940106ecc114d6982daa98256de23bdf77661a"
-
-func TestBaseScalarMult(t *testing.T) {
-	var a, b [32]byte
-	in := &a
-	out := &b
-	a[0] = 1
-
-	for i := 0; i < 200; i++ {
-		ScalarBaseMult(out, in)
-		in, out = out, in
-	}
-
-	result := fmt.Sprintf("%x", in[:])
-	if result != expectedHex {
-		t.Errorf("incorrect result: got %s, want %s", result, expectedHex)
-	}
-}
-
-func BenchmarkScalarBaseMult(b *testing.B) {
-	var in, out [32]byte
-	in[0] = 1
-
-	b.SetBytes(32)
-	for i := 0; i < b.N; i++ {
-		ScalarBaseMult(&out, &in)
-	}
-}

vendor/golang.org/x/crypto/ed25519/ed25519_test.go

@@ -1,220 +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 ed25519
-
-import (
-	"bufio"
-	"bytes"
-	"compress/gzip"
-	"crypto"
-	"crypto/rand"
-	"encoding/hex"
-	"os"
-	"strings"
-	"testing"
-
-	"golang.org/x/crypto/ed25519/internal/edwards25519"
-)
-
-type zeroReader struct{}
-
-func (zeroReader) Read(buf []byte) (int, error) {
-	for i := range buf {
-		buf[i] = 0
-	}
-	return len(buf), nil
-}
-
-func TestUnmarshalMarshal(t *testing.T) {
-	pub, _, _ := GenerateKey(rand.Reader)
-
-	var A edwards25519.ExtendedGroupElement
-	var pubBytes [32]byte
-	copy(pubBytes[:], pub)
-	if !A.FromBytes(&pubBytes) {
-		t.Fatalf("ExtendedGroupElement.FromBytes failed")
-	}
-
-	var pub2 [32]byte
-	A.ToBytes(&pub2)
-
-	if pubBytes != pub2 {
-		t.Errorf("FromBytes(%v)->ToBytes does not round-trip, got %x\n", pubBytes, pub2)
-	}
-}
-
-func TestSignVerify(t *testing.T) {
-	var zero zeroReader
-	public, private, _ := GenerateKey(zero)
-
-	message := []byte("test message")
-	sig := Sign(private, message)
-	if !Verify(public, message, sig) {
-		t.Errorf("valid signature rejected")
-	}
-
-	wrongMessage := []byte("wrong message")
-	if Verify(public, wrongMessage, sig) {
-		t.Errorf("signature of different message accepted")
-	}
-}
-
-func TestCryptoSigner(t *testing.T) {
-	var zero zeroReader
-	public, private, _ := GenerateKey(zero)
-
-	signer := crypto.Signer(private)
-
-	publicInterface := signer.Public()
-	public2, ok := publicInterface.(PublicKey)
-	if !ok {
-		t.Fatalf("expected PublicKey from Public() but got %T", publicInterface)
-	}
-
-	if !bytes.Equal(public, public2) {
-		t.Errorf("public keys do not match: original:%x vs Public():%x", public, public2)
-	}
-
-	message := []byte("message")
-	var noHash crypto.Hash
-	signature, err := signer.Sign(zero, message, noHash)
-	if err != nil {
-		t.Fatalf("error from Sign(): %s", err)
-	}
-
-	if !Verify(public, message, signature) {
-		t.Errorf("Verify failed on signature from Sign()")
-	}
-}
-
-func TestGolden(t *testing.T) {
-	// sign.input.gz is a selection of test cases from
-	// https://ed25519.cr.yp.to/python/sign.input
-	testDataZ, err := os.Open("testdata/sign.input.gz")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer testDataZ.Close()
-	testData, err := gzip.NewReader(testDataZ)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer testData.Close()
-
-	scanner := bufio.NewScanner(testData)
-	lineNo := 0
-
-	for scanner.Scan() {
-		lineNo++
-
-		line := scanner.Text()
-		parts := strings.Split(line, ":")
-		if len(parts) != 5 {
-			t.Fatalf("bad number of parts on line %d", lineNo)
-		}
-
-		privBytes, _ := hex.DecodeString(parts[0])
-		pubKey, _ := hex.DecodeString(parts[1])
-		msg, _ := hex.DecodeString(parts[2])
-		sig, _ := hex.DecodeString(parts[3])
-		// The signatures in the test vectors also include the message
-		// at the end, but we just want R and S.
-		sig = sig[:SignatureSize]
-
-		if l := len(pubKey); l != PublicKeySize {
-			t.Fatalf("bad public key length on line %d: got %d bytes", lineNo, l)
-		}
-
-		var priv [PrivateKeySize]byte
-		copy(priv[:], privBytes)
-		copy(priv[32:], pubKey)
-
-		sig2 := Sign(priv[:], msg)
-		if !bytes.Equal(sig, sig2[:]) {
-			t.Errorf("different signature result on line %d: %x vs %x", lineNo, sig, sig2)
-		}
-
-		if !Verify(pubKey, msg, sig2) {
-			t.Errorf("signature failed to verify on line %d", lineNo)
-		}
-
-		priv2 := NewKeyFromSeed(priv[:32])
-		if !bytes.Equal(priv[:], priv2) {
-			t.Errorf("recreating key pair gave different private key on line %d: %x vs %x", lineNo, priv[:], priv2)
-		}
-
-		if pubKey2 := priv2.Public().(PublicKey); !bytes.Equal(pubKey, pubKey2) {
-			t.Errorf("recreating key pair gave different public key on line %d: %x vs %x", lineNo, pubKey, pubKey2)
-		}
-
-		if seed := priv2.Seed(); !bytes.Equal(priv[:32], seed) {
-			t.Errorf("recreating key pair gave different seed on line %d: %x vs %x", lineNo, priv[:32], seed)
-		}
-	}
-
-	if err := scanner.Err(); err != nil {
-		t.Fatalf("error reading test data: %s", err)
-	}
-}
-
-func TestMalleability(t *testing.T) {
-	// https://tools.ietf.org/html/rfc8032#section-5.1.7 adds an additional test
-	// that s be in [0, order). This prevents someone from adding a multiple of
-	// order to s and obtaining a second valid signature for the same message.
-	msg := []byte{0x54, 0x65, 0x73, 0x74}
-	sig := []byte{
-		0x7c, 0x38, 0xe0, 0x26, 0xf2, 0x9e, 0x14, 0xaa, 0xbd, 0x05, 0x9a,
-		0x0f, 0x2d, 0xb8, 0xb0, 0xcd, 0x78, 0x30, 0x40, 0x60, 0x9a, 0x8b,
-		0xe6, 0x84, 0xdb, 0x12, 0xf8, 0x2a, 0x27, 0x77, 0x4a, 0xb0, 0x67,
-		0x65, 0x4b, 0xce, 0x38, 0x32, 0xc2, 0xd7, 0x6f, 0x8f, 0x6f, 0x5d,
-		0xaf, 0xc0, 0x8d, 0x93, 0x39, 0xd4, 0xee, 0xf6, 0x76, 0x57, 0x33,
-		0x36, 0xa5, 0xc5, 0x1e, 0xb6, 0xf9, 0x46, 0xb3, 0x1d,
-	}
-	publicKey := []byte{
-		0x7d, 0x4d, 0x0e, 0x7f, 0x61, 0x53, 0xa6, 0x9b, 0x62, 0x42, 0xb5,
-		0x22, 0xab, 0xbe, 0xe6, 0x85, 0xfd, 0xa4, 0x42, 0x0f, 0x88, 0x34,
-		0xb1, 0x08, 0xc3, 0xbd, 0xae, 0x36, 0x9e, 0xf5, 0x49, 0xfa,
-	}
-
-	if Verify(publicKey, msg, sig) {
-		t.Fatal("non-canonical signature accepted")
-	}
-}
-
-func BenchmarkKeyGeneration(b *testing.B) {
-	var zero zeroReader
-	for i := 0; i < b.N; i++ {
-		if _, _, err := GenerateKey(zero); err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkSigning(b *testing.B) {
-	var zero zeroReader
-	_, priv, err := GenerateKey(zero)
-	if err != nil {
-		b.Fatal(err)
-	}
-	message := []byte("Hello, world!")
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Sign(priv, message)
-	}
-}
-
-func BenchmarkVerification(b *testing.B) {
-	var zero zeroReader
-	pub, priv, err := GenerateKey(zero)
-	if err != nil {
-		b.Fatal(err)
-	}
-	message := []byte("Hello, world!")
-	signature := Sign(priv, message)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Verify(pub, message, signature)
-	}
-}

vendor/golang.org/x/crypto/internal/subtle/aliasing_test.go

@@ -1,50 +0,0 @@
-// Copyright 2018 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 subtle_test
-
-import (
-	"testing"
-
-	"golang.org/x/crypto/internal/subtle"
-)
-
-var a, b [100]byte
-
-var aliasingTests = []struct {
-	x, y                       []byte
-	anyOverlap, inexactOverlap bool
-}{
-	{a[:], b[:], false, false},
-	{a[:], b[:0], false, false},
-	{a[:], b[:50], false, false},
-	{a[40:50], a[50:60], false, false},
-	{a[40:50], a[60:70], false, false},
-	{a[:51], a[50:], true, true},
-	{a[:], a[:], true, false},
-	{a[:50], a[:60], true, false},
-	{a[:], nil, false, false},
-	{nil, nil, false, false},
-	{a[:], a[:0], false, false},
-	{a[:10], a[:10:20], true, false},
-	{a[:10], a[5:10:20], true, true},
-}
-
-func testAliasing(t *testing.T, i int, x, y []byte, anyOverlap, inexactOverlap bool) {
-	any := subtle.AnyOverlap(x, y)
-	if any != anyOverlap {
-		t.Errorf("%d: wrong AnyOverlap result, expected %v, got %v", i, anyOverlap, any)
-	}
-	inexact := subtle.InexactOverlap(x, y)
-	if inexact != inexactOverlap {
-		t.Errorf("%d: wrong InexactOverlap result, expected %v, got %v", i, inexactOverlap, any)
-	}
-}
-
-func TestAliasing(t *testing.T) {
-	for i, tt := range aliasingTests {
-		testAliasing(t, i, tt.x, tt.y, tt.anyOverlap, tt.inexactOverlap)
-		testAliasing(t, i, tt.y, tt.x, tt.anyOverlap, tt.inexactOverlap)
-	}
-}

vendor/golang.org/x/crypto/nacl/box/box_test.go

@@ -1,78 +0,0 @@
-// Copyright 2012 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 box
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/hex"
-	"testing"
-
-	"golang.org/x/crypto/curve25519"
-)
-
-func TestSealOpen(t *testing.T) {
-	publicKey1, privateKey1, _ := GenerateKey(rand.Reader)
-	publicKey2, privateKey2, _ := GenerateKey(rand.Reader)
-
-	if *privateKey1 == *privateKey2 {
-		t.Fatalf("private keys are equal!")
-	}
-	if *publicKey1 == *publicKey2 {
-		t.Fatalf("public keys are equal!")
-	}
-	message := []byte("test message")
-	var nonce [24]byte
-
-	box := Seal(nil, message, &nonce, publicKey1, privateKey2)
-	opened, ok := Open(nil, box, &nonce, publicKey2, privateKey1)
-	if !ok {
-		t.Fatalf("failed to open box")
-	}
-
-	if !bytes.Equal(opened, message) {
-		t.Fatalf("got %x, want %x", opened, message)
-	}
-
-	for i := range box {
-		box[i] ^= 0x40
-		_, ok := Open(nil, box, &nonce, publicKey2, privateKey1)
-		if ok {
-			t.Fatalf("opened box with byte %d corrupted", i)
-		}
-		box[i] ^= 0x40
-	}
-}
-
-func TestBox(t *testing.T) {
-	var privateKey1, privateKey2 [32]byte
-	for i := range privateKey1[:] {
-		privateKey1[i] = 1
-	}
-	for i := range privateKey2[:] {
-		privateKey2[i] = 2
-	}
-
-	var publicKey1 [32]byte
-	curve25519.ScalarBaseMult(&publicKey1, &privateKey1)
-	var message [64]byte
-	for i := range message[:] {
-		message[i] = 3
-	}
-
-	var nonce [24]byte
-	for i := range nonce[:] {
-		nonce[i] = 4
-	}
-
-	box := Seal(nil, message[:], &nonce, &publicKey1, &privateKey2)
-
-	// expected was generated using the C implementation of NaCl.
-	expected, _ := hex.DecodeString("78ea30b19d2341ebbdba54180f821eec265cf86312549bea8a37652a8bb94f07b78a73ed1708085e6ddd0e943bbdeb8755079a37eb31d86163ce241164a47629c0539f330b4914cd135b3855bc2a2dfc")
-
-	if !bytes.Equal(box, expected) {
-		t.Fatalf("box didn't match, got\n%x\n, expected\n%x", box, expected)
-	}
-}

vendor/golang.org/x/crypto/nacl/box/example_test.go

@@ -1,95 +0,0 @@
-package box_test
-
-import (
-	crypto_rand "crypto/rand" // Custom so it's clear which rand we're using.
-	"fmt"
-	"io"
-
-	"golang.org/x/crypto/nacl/box"
-)
-
-func Example() {
-	senderPublicKey, senderPrivateKey, err := box.GenerateKey(crypto_rand.Reader)
-	if err != nil {
-		panic(err)
-	}
-
-	recipientPublicKey, recipientPrivateKey, err := box.GenerateKey(crypto_rand.Reader)
-	if err != nil {
-		panic(err)
-	}
-
-	// You must use a different nonce for each message you encrypt with the
-	// same key. Since the nonce here is 192 bits long, a random value
-	// provides a sufficiently small probability of repeats.
-	var nonce [24]byte
-	if _, err := io.ReadFull(crypto_rand.Reader, nonce[:]); err != nil {
-		panic(err)
-	}
-
-	msg := []byte("Alas, poor Yorick! I knew him, Horatio")
-	// This encrypts msg and appends the result to the nonce.
-	encrypted := box.Seal(nonce[:], msg, &nonce, recipientPublicKey, senderPrivateKey)
-
-	// The recipient can decrypt the message using their private key and the
-	// sender's public key. When you decrypt, you must use the same nonce you
-	// used to encrypt the message. One way to achieve this is to store the
-	// nonce alongside the encrypted message. Above, we stored the nonce in the
-	// first 24 bytes of the encrypted text.
-	var decryptNonce [24]byte
-	copy(decryptNonce[:], encrypted[:24])
-	decrypted, ok := box.Open(nil, encrypted[24:], &decryptNonce, senderPublicKey, recipientPrivateKey)
-	if !ok {
-		panic("decryption error")
-	}
-	fmt.Println(string(decrypted))
-	// Output: Alas, poor Yorick! I knew him, Horatio
-}
-
-func Example_precompute() {
-	senderPublicKey, senderPrivateKey, err := box.GenerateKey(crypto_rand.Reader)
-	if err != nil {
-		panic(err)
-	}
-
-	recipientPublicKey, recipientPrivateKey, err := box.GenerateKey(crypto_rand.Reader)
-	if err != nil {
-		panic(err)
-	}
-
-	// The shared key can be used to speed up processing when using the same
-	// pair of keys repeatedly.
-	sharedEncryptKey := new([32]byte)
-	box.Precompute(sharedEncryptKey, recipientPublicKey, senderPrivateKey)
-
-	// You must use a different nonce for each message you encrypt with the
-	// same key. Since the nonce here is 192 bits long, a random value
-	// provides a sufficiently small probability of repeats.
-	var nonce [24]byte
-	if _, err := io.ReadFull(crypto_rand.Reader, nonce[:]); err != nil {
-		panic(err)
-	}
-
-	msg := []byte("A fellow of infinite jest, of most excellent fancy")
-	// This encrypts msg and appends the result to the nonce.
-	encrypted := box.SealAfterPrecomputation(nonce[:], msg, &nonce, sharedEncryptKey)
-
-	// The shared key can be used to speed up processing when using the same
-	// pair of keys repeatedly.
-	var sharedDecryptKey [32]byte
-	box.Precompute(&sharedDecryptKey, senderPublicKey, recipientPrivateKey)
-
-	// The recipient can decrypt the message using the shared key. When you
-	// decrypt, you must use the same nonce you used to encrypt the message.
-	// One way to achieve this is to store the nonce alongside the encrypted
-	// message. Above, we stored the nonce in the first 24 bytes of the
-	// encrypted text.
-	var decryptNonce [24]byte
-	copy(decryptNonce[:], encrypted[:24])
-	decrypted, ok := box.OpenAfterPrecomputation(nil, encrypted[24:], &decryptNonce, &sharedDecryptKey)
-	if !ok {
-		panic("decryption error")
-	}
-	fmt.Println(string(decrypted))
-	// Output: A fellow of infinite jest, of most excellent fancy
-}

vendor/golang.org/x/crypto/nacl/secretbox/example_test.go

@@ -1,53 +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 secretbox_test
-
-import (
-	"crypto/rand"
-	"encoding/hex"
-	"fmt"
-	"io"
-
-	"golang.org/x/crypto/nacl/secretbox"
-)
-
-func Example() {
-	// Load your secret key from a safe place and reuse it across multiple
-	// Seal calls. (Obviously don't use this example key for anything
-	// real.) If you want to convert a passphrase to a key, use a suitable
-	// package like bcrypt or scrypt.
-	secretKeyBytes, err := hex.DecodeString("6368616e676520746869732070617373776f726420746f206120736563726574")
-	if err != nil {
-		panic(err)
-	}
-
-	var secretKey [32]byte
-	copy(secretKey[:], secretKeyBytes)
-
-	// You must use a different nonce for each message you encrypt with the
-	// same key. Since the nonce here is 192 bits long, a random value
-	// provides a sufficiently small probability of repeats.
-	var nonce [24]byte
-	if _, err := io.ReadFull(rand.Reader, nonce[:]); err != nil {
-		panic(err)
-	}
-
-	// This encrypts "hello world" and appends the result to the nonce.
-	encrypted := secretbox.Seal(nonce[:], []byte("hello world"), &nonce, &secretKey)
-
-	// When you decrypt, you must use the same nonce and key you used to
-	// encrypt the message. One way to achieve this is to store the nonce
-	// alongside the encrypted message. Above, we stored the nonce in the first
-	// 24 bytes of the encrypted text.
-	var decryptNonce [24]byte
-	copy(decryptNonce[:], encrypted[:24])
-	decrypted, ok := secretbox.Open(nil, encrypted[24:], &decryptNonce, &secretKey)
-	if !ok {
-		panic("decryption error")
-	}
-
-	fmt.Println(string(decrypted))
-	// Output: hello world
-}

vendor/golang.org/x/crypto/nacl/secretbox/secretbox_test.go

@@ -1,154 +0,0 @@
-// Copyright 2012 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 secretbox
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/hex"
-	"testing"
-)
-
-func TestSealOpen(t *testing.T) {
-	var key [32]byte
-	var nonce [24]byte
-
-	rand.Reader.Read(key[:])
-	rand.Reader.Read(nonce[:])
-
-	var box, opened []byte
-
-	for msgLen := 0; msgLen < 128; msgLen += 17 {
-		message := make([]byte, msgLen)
-		rand.Reader.Read(message)
-
-		box = Seal(box[:0], message, &nonce, &key)
-		var ok bool
-		opened, ok = Open(opened[:0], box, &nonce, &key)
-		if !ok {
-			t.Errorf("%d: failed to open box", msgLen)
-			continue
-		}
-
-		if !bytes.Equal(opened, message) {
-			t.Errorf("%d: got %x, expected %x", msgLen, opened, message)
-			continue
-		}
-	}
-
-	for i := range box {
-		box[i] ^= 0x20
-		_, ok := Open(opened[:0], box, &nonce, &key)
-		if ok {
-			t.Errorf("box was opened after corrupting byte %d", i)
-		}
-		box[i] ^= 0x20
-	}
-}
-
-func TestSecretBox(t *testing.T) {
-	var key [32]byte
-	var nonce [24]byte
-	var message [64]byte
-
-	for i := range key[:] {
-		key[i] = 1
-	}
-	for i := range nonce[:] {
-		nonce[i] = 2
-	}
-	for i := range message[:] {
-		message[i] = 3
-	}
-
-	box := Seal(nil, message[:], &nonce, &key)
-	// expected was generated using the C implementation of NaCl.
-	expected, _ := hex.DecodeString("8442bc313f4626f1359e3b50122b6ce6fe66ddfe7d39d14e637eb4fd5b45beadab55198df6ab5368439792a23c87db70acb6156dc5ef957ac04f6276cf6093b84be77ff0849cc33e34b7254d5a8f65ad")
-
-	if !bytes.Equal(box, expected) {
-		t.Fatalf("box didn't match, got\n%x\n, expected\n%x", box, expected)
-	}
-}
-
-func TestAppend(t *testing.T) {
-	var key [32]byte
-	var nonce [24]byte
-	var message [8]byte
-
-	out := make([]byte, 4)
-	box := Seal(out, message[:], &nonce, &key)
-	if !bytes.Equal(box[:4], out[:4]) {
-		t.Fatalf("Seal didn't correctly append")
-	}
-
-	out = make([]byte, 4, 100)
-	box = Seal(out, message[:], &nonce, &key)
-	if !bytes.Equal(box[:4], out[:4]) {
-		t.Fatalf("Seal didn't correctly append with sufficient capacity.")
-	}
-}
-
-func benchmarkSealSize(b *testing.B, size int) {
-	message := make([]byte, size)
-	out := make([]byte, size+Overhead)
-	var nonce [24]byte
-	var key [32]byte
-
-	b.SetBytes(int64(size))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		out = Seal(out[:0], message, &nonce, &key)
-	}
-}
-
-func BenchmarkSeal8Bytes(b *testing.B) {
-	benchmarkSealSize(b, 8)
-}
-
-func BenchmarkSeal100Bytes(b *testing.B) {
-	benchmarkSealSize(b, 100)
-}
-
-func BenchmarkSeal1K(b *testing.B) {
-	benchmarkSealSize(b, 1024)
-}
-
-func BenchmarkSeal8K(b *testing.B) {
-	benchmarkSealSize(b, 8192)
-}
-
-func benchmarkOpenSize(b *testing.B, size int) {
-	msg := make([]byte, size)
-	result := make([]byte, size)
-	var nonce [24]byte
-	var key [32]byte
-	box := Seal(nil, msg, &nonce, &key)
-
-	b.SetBytes(int64(size))
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		if _, ok := Open(result[:0], box, &nonce, &key); !ok {
-			panic("Open failed")
-		}
-	}
-}
-
-func BenchmarkOpen8Bytes(b *testing.B) {
-	benchmarkOpenSize(b, 8)
-}
-
-func BenchmarkOpen100Bytes(b *testing.B) {
-	benchmarkOpenSize(b, 100)
-}
-
-func BenchmarkOpen1K(b *testing.B) {
-	benchmarkOpenSize(b, 1024)
-}
-
-func BenchmarkOpen8K(b *testing.B) {
-	benchmarkOpenSize(b, 8192)
-}

vendor/golang.org/x/crypto/poly1305/poly1305_test.go

@@ -1,132 +0,0 @@
-// Copyright 2012 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 poly1305
-
-import (
-	"encoding/hex"
-	"flag"
-	"testing"
-	"unsafe"
-)
-
-var stressFlag = flag.Bool("stress", false, "run slow stress tests")
-
-type test struct {
-	in  string
-	key string
-	tag string
-}
-
-func (t *test) Input() []byte {
-	in, err := hex.DecodeString(t.in)
-	if err != nil {
-		panic(err)
-	}
-	return in
-}
-
-func (t *test) Key() [32]byte {
-	buf, err := hex.DecodeString(t.key)
-	if err != nil {
-		panic(err)
-	}
-	var key [32]byte
-	copy(key[:], buf[:32])
-	return key
-}
-
-func (t *test) Tag() [16]byte {
-	buf, err := hex.DecodeString(t.tag)
-	if err != nil {
-		panic(err)
-	}
-	var tag [16]byte
-	copy(tag[:], buf[:16])
-	return tag
-}
-
-func testSum(t *testing.T, unaligned bool, sumImpl func(tag *[TagSize]byte, msg []byte, key *[32]byte)) {
-	var tag [16]byte
-	for i, v := range testData {
-		in := v.Input()
-		if unaligned {
-			in = unalignBytes(in)
-		}
-		key := v.Key()
-		sumImpl(&tag, in, &key)
-		if tag != v.Tag() {
-			t.Errorf("%d: expected %x, got %x", i, v.Tag(), tag[:])
-		}
-	}
-}
-
-func TestBurnin(t *testing.T) {
-	// This test can be used to sanity-check significant changes. It can
-	// take about many minutes to run, even on fast machines. It's disabled
-	// by default.
-	if !*stressFlag {
-		t.Skip("skipping without -stress")
-	}
-
-	var key [32]byte
-	var input [25]byte
-	var output [16]byte
-
-	for i := range key {
-		key[i] = 1
-	}
-	for i := range input {
-		input[i] = 2
-	}
-
-	for i := uint64(0); i < 1e10; i++ {
-		Sum(&output, input[:], &key)
-		copy(key[0:], output[:])
-		copy(key[16:], output[:])
-		copy(input[:], output[:])
-		copy(input[16:], output[:])
-	}
-
-	const expected = "5e3b866aea0b636d240c83c428f84bfa"
-	if got := hex.EncodeToString(output[:]); got != expected {
-		t.Errorf("expected %s, got %s", expected, got)
-	}
-}
-
-func TestSum(t *testing.T)                 { testSum(t, false, Sum) }
-func TestSumUnaligned(t *testing.T)        { testSum(t, true, Sum) }
-func TestSumGeneric(t *testing.T)          { testSum(t, false, sumGeneric) }
-func TestSumGenericUnaligned(t *testing.T) { testSum(t, true, sumGeneric) }
-
-func benchmark(b *testing.B, size int, unaligned bool) {
-	var out [16]byte
-	var key [32]byte
-	in := make([]byte, size)
-	if unaligned {
-		in = unalignBytes(in)
-	}
-	b.SetBytes(int64(len(in)))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Sum(&out, in, &key)
-	}
-}
-
-func Benchmark64(b *testing.B)          { benchmark(b, 64, false) }
-func Benchmark1K(b *testing.B)          { benchmark(b, 1024, false) }
-func Benchmark64Unaligned(b *testing.B) { benchmark(b, 64, true) }
-func Benchmark1KUnaligned(b *testing.B) { benchmark(b, 1024, true) }
-func Benchmark2M(b *testing.B)          { benchmark(b, 2097152, true) }
-
-func unalignBytes(in []byte) []byte {
-	out := make([]byte, len(in)+1)
-	if uintptr(unsafe.Pointer(&out[0]))&(unsafe.Alignof(uint32(0))-1) == 0 {
-		out = out[1:]
-	} else {
-		out = out[:len(in)]
-	}
-	copy(out, in)
-	return out
-}

vendor/golang.org/x/crypto/salsa20/salsa/salsa_test.go

@@ -1,54 +0,0 @@
-// Copyright 2012 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 salsa
-
-import "testing"
-
-func TestCore208(t *testing.T) {
-	in := [64]byte{
-		0x7e, 0x87, 0x9a, 0x21, 0x4f, 0x3e, 0xc9, 0x86,
-		0x7c, 0xa9, 0x40, 0xe6, 0x41, 0x71, 0x8f, 0x26,
-		0xba, 0xee, 0x55, 0x5b, 0x8c, 0x61, 0xc1, 0xb5,
-		0x0d, 0xf8, 0x46, 0x11, 0x6d, 0xcd, 0x3b, 0x1d,
-		0xee, 0x24, 0xf3, 0x19, 0xdf, 0x9b, 0x3d, 0x85,
-		0x14, 0x12, 0x1e, 0x4b, 0x5a, 0xc5, 0xaa, 0x32,
-		0x76, 0x02, 0x1d, 0x29, 0x09, 0xc7, 0x48, 0x29,
-		0xed, 0xeb, 0xc6, 0x8d, 0xb8, 0xb8, 0xc2, 0x5e}
-
-	out := [64]byte{
-		0xa4, 0x1f, 0x85, 0x9c, 0x66, 0x08, 0xcc, 0x99,
-		0x3b, 0x81, 0xca, 0xcb, 0x02, 0x0c, 0xef, 0x05,
-		0x04, 0x4b, 0x21, 0x81, 0xa2, 0xfd, 0x33, 0x7d,
-		0xfd, 0x7b, 0x1c, 0x63, 0x96, 0x68, 0x2f, 0x29,
-		0xb4, 0x39, 0x31, 0x68, 0xe3, 0xc9, 0xe6, 0xbc,
-		0xfe, 0x6b, 0xc5, 0xb7, 0xa0, 0x6d, 0x96, 0xba,
-		0xe4, 0x24, 0xcc, 0x10, 0x2c, 0x91, 0x74, 0x5c,
-		0x24, 0xad, 0x67, 0x3d, 0xc7, 0x61, 0x8f, 0x81,
-	}
-
-	Core208(&in, &in)
-	if in != out {
-		t.Errorf("expected %x, got %x", out, in)
-	}
-}
-
-func TestOutOfBoundsWrite(t *testing.T) {
-	// encrypted "0123456789"
-	cipherText := []byte{170, 166, 196, 104, 175, 121, 68, 44, 174, 51}
-	var counter [16]byte
-	var key [32]byte
-	want := "abcdefghij"
-	plainText := []byte(want)
-	defer func() {
-		err := recover()
-		if err == nil {
-			t.Error("XORKeyStream expected to panic on len(dst) < len(src), but didn't")
-		}
-		if plainText[3] == '3' {
-			t.Errorf("XORKeyStream did out of bounds write, want %v, got %v", want, string(plainText))
-		}
-	}()
-	XORKeyStream(plainText[:3], cipherText, &counter, &key)
-}

vendor/golang.org/x/crypto/salsa20/salsa20.go

@@ -1,58 +0,0 @@
-// Copyright 2012 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 salsa20 implements the Salsa20 stream cipher as specified in https://cr.yp.to/snuffle/spec.pdf.
-
-Salsa20 differs from many other stream ciphers in that it is message orientated
-rather than byte orientated. Keystream blocks are not preserved between calls,
-therefore each side must encrypt/decrypt data with the same segmentation.
-
-Another aspect of this difference is that part of the counter is exposed as
-a nonce in each call. Encrypting two different messages with the same (key,
-nonce) pair leads to trivial plaintext recovery. This is analogous to
-encrypting two different messages with the same key with a traditional stream
-cipher.
-
-This package also implements XSalsa20: a version of Salsa20 with a 24-byte
-nonce as specified in https://cr.yp.to/snuffle/xsalsa-20081128.pdf. Simply
-passing a 24-byte slice as the nonce triggers XSalsa20.
-*/
-package salsa20 // import "golang.org/x/crypto/salsa20"
-
-// TODO(agl): implement XORKeyStream12 and XORKeyStream8 - the reduced round variants of Salsa20.
-
-import (
-	"golang.org/x/crypto/internal/subtle"
-	"golang.org/x/crypto/salsa20/salsa"
-)
-
-// XORKeyStream crypts bytes from in to out using the given key and nonce.
-// In and out must overlap entirely or not at all. Nonce must
-// be either 8 or 24 bytes long.
-func XORKeyStream(out, in []byte, nonce []byte, key *[32]byte) {
-	if len(out) < len(in) {
-		panic("salsa20: output smaller than input")
-	}
-	if subtle.InexactOverlap(out[:len(in)], in) {
-		panic("salsa20: invalid buffer overlap")
-	}
-
-	var subNonce [16]byte
-
-	if len(nonce) == 24 {
-		var subKey [32]byte
-		var hNonce [16]byte
-		copy(hNonce[:], nonce[:16])
-		salsa.HSalsa20(&subKey, &hNonce, key, &salsa.Sigma)
-		copy(subNonce[:], nonce[16:])
-		key = &subKey
-	} else if len(nonce) == 8 {
-		copy(subNonce[:], nonce[:])
-	} else {
-		panic("salsa20: nonce must be 8 or 24 bytes")
-	}
-
-	salsa.XORKeyStream(out, in, &subNonce, key)
-}

vendor/golang.org/x/crypto/salsa20/salsa20_test.go

@@ -1,139 +0,0 @@
-// Copyright 2012 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 salsa20
-
-import (
-	"bytes"
-	"encoding/hex"
-	"testing"
-)
-
-func fromHex(s string) []byte {
-	ret, err := hex.DecodeString(s)
-	if err != nil {
-		panic(err)
-	}
-	return ret
-}
-
-// testVectors was taken from set 6 of the ECRYPT test vectors:
-// http://www.ecrypt.eu.org/stream/svn/viewcvs.cgi/ecrypt/trunk/submissions/salsa20/full/verified.test-vectors?logsort=rev&rev=210&view=markup
-var testVectors = []struct {
-	key      []byte
-	iv       []byte
-	numBytes int
-	xor      []byte
-}{
-	{
-		fromHex("0053A6F94C9FF24598EB3E91E4378ADD3083D6297CCF2275C81B6EC11467BA0D"),
-		fromHex("0D74DB42A91077DE"),
-		131072,
-		fromHex("C349B6A51A3EC9B712EAED3F90D8BCEE69B7628645F251A996F55260C62EF31FD6C6B0AEA94E136C9D984AD2DF3578F78E457527B03A0450580DD874F63B1AB9"),
-	},
-	{
-		fromHex("0558ABFE51A4F74A9DF04396E93C8FE23588DB2E81D4277ACD2073C6196CBF12"),
-		fromHex("167DE44BB21980E7"),
-		131072,
-		fromHex("C3EAAF32836BACE32D04E1124231EF47E101367D6305413A0EEB07C60698A2876E4D031870A739D6FFDDD208597AFF0A47AC17EDB0167DD67EBA84F1883D4DFD"),
-	},
-	{
-		fromHex("0A5DB00356A9FC4FA2F5489BEE4194E73A8DE03386D92C7FD22578CB1E71C417"),
-		fromHex("1F86ED54BB2289F0"),
-		131072,
-		fromHex("3CD23C3DC90201ACC0CF49B440B6C417F0DC8D8410A716D5314C059E14B1A8D9A9FB8EA3D9C8DAE12B21402F674AA95C67B1FC514E994C9D3F3A6E41DFF5BBA6"),
-	},
-	{
-		fromHex("0F62B5085BAE0154A7FA4DA0F34699EC3F92E5388BDE3184D72A7DD02376C91C"),
-		fromHex("288FF65DC42B92F9"),
-		131072,
-		fromHex("E00EBCCD70D69152725F9987982178A2E2E139C7BCBE04CA8A0E99E318D9AB76F988C8549F75ADD790BA4F81C176DA653C1A043F11A958E169B6D2319F4EEC1A"),
-	},
-}
-
-func TestSalsa20(t *testing.T) {
-	var inBuf, outBuf []byte
-	var key [32]byte
-
-	for i, test := range testVectors {
-		if test.numBytes%64 != 0 {
-			t.Errorf("#%d: numBytes is not a multiple of 64", i)
-			continue
-		}
-
-		if test.numBytes > len(inBuf) {
-			inBuf = make([]byte, test.numBytes)
-			outBuf = make([]byte, test.numBytes)
-		}
-		in := inBuf[:test.numBytes]
-		out := outBuf[:test.numBytes]
-		copy(key[:], test.key)
-		XORKeyStream(out, in, test.iv, &key)
-
-		var xor [64]byte
-		for len(out) > 0 {
-			for i := 0; i < 64; i++ {
-				xor[i] ^= out[i]
-			}
-			out = out[64:]
-		}
-
-		if !bytes.Equal(xor[:], test.xor) {
-			t.Errorf("#%d: bad result", i)
-		}
-	}
-}
-
-var xSalsa20TestData = []struct {
-	in, nonce, key, out []byte
-}{
-	{
-		[]byte("Hello world!"),
-		[]byte("24-byte nonce for xsalsa"),
-		[]byte("this is 32-byte key for xsalsa20"),
-		[]byte{0x00, 0x2d, 0x45, 0x13, 0x84, 0x3f, 0xc2, 0x40, 0xc4, 0x01, 0xe5, 0x41},
-	},
-	{
-		make([]byte, 64),
-		[]byte("24-byte nonce for xsalsa"),
-		[]byte("this is 32-byte key for xsalsa20"),
-		[]byte{0x48, 0x48, 0x29, 0x7f, 0xeb, 0x1f, 0xb5, 0x2f, 0xb6,
-			0x6d, 0x81, 0x60, 0x9b, 0xd5, 0x47, 0xfa, 0xbc, 0xbe, 0x70,
-			0x26, 0xed, 0xc8, 0xb5, 0xe5, 0xe4, 0x49, 0xd0, 0x88, 0xbf,
-			0xa6, 0x9c, 0x08, 0x8f, 0x5d, 0x8d, 0xa1, 0xd7, 0x91, 0x26,
-			0x7c, 0x2c, 0x19, 0x5a, 0x7f, 0x8c, 0xae, 0x9c, 0x4b, 0x40,
-			0x50, 0xd0, 0x8c, 0xe6, 0xd3, 0xa1, 0x51, 0xec, 0x26, 0x5f,
-			0x3a, 0x58, 0xe4, 0x76, 0x48},
-	},
-}
-
-func TestXSalsa20(t *testing.T) {
-	var key [32]byte
-
-	for i, test := range xSalsa20TestData {
-		out := make([]byte, len(test.in))
-		copy(key[:], test.key)
-		XORKeyStream(out, test.in, test.nonce, &key)
-		if !bytes.Equal(out, test.out) {
-			t.Errorf("%d: expected %x, got %x", i, test.out, out)
-		}
-	}
-}
-
-var (
-	keyArray [32]byte
-	key      = &keyArray
-	nonce    [8]byte
-	msg      = make([]byte, 1<<10)
-)
-
-func BenchmarkXOR1K(b *testing.B) {
-	b.StopTimer()
-	out := make([]byte, 1024)
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		XORKeyStream(out, msg[:1024], nonce[:], key)
-	}
-	b.SetBytes(1024)
-}

vendor/golang.org/x/net/.gitattributes

@@ -1,10 +0,0 @@
-# Treat all files in this repo as binary, with no git magic updating
-# line endings. Windows users contributing to Go will need to use a
-# modern version of git and editors capable of LF line endings.
-#
-# We'll prevent accidental CRLF line endings from entering the repo
-# via the git-review gofmt checks.
-#
-# See golang.org/issue/9281
-
-* -text

vendor/golang.org/x/net/.gitignore

@@ -1,2 +0,0 @@
-# Add no patterns to .hgignore except for files generated by the build.
-last-change