[kubernetes/f21] Bump to upstream 52e165a4fd720d1703ebc31bd6660e01334227b8
Eric Paris
eparis at fedoraproject.org
Wed Dec 17 19:12:13 UTC 2014
commit 7dd4da31a356ce06534a18d2127c7d3b60eb304e
Author: Eric Paris <eparis at redhat.com>
Date: Wed Dec 17 14:11:24 2014 -0500
Bump to upstream 52e165a4fd720d1703ebc31bd6660e01334227b8
.gitignore | 2 +
0001-remove-all-third-party-software.patch | 8817 +++++++++++++++++++++++++---
getsource.sh | 29 +-
kubernetes.spec | 30 +-
sources | 2 +-
5 files changed, 8172 insertions(+), 708 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index cf31e03..def3adf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,3 +27,5 @@
/kubernetes-ff1e9f4.tar.gz
/kubernetes-6aabd98.tar.gz
/kubernetes-993ef88.tar.gz
+/kubernetes-5ef34bf.tar.gz
+/kubernetes-52e165a.tar.gz
diff --git a/0001-remove-all-third-party-software.patch b/0001-remove-all-third-party-software.patch
index 7660ddf..afb02ab 100644
--- a/0001-remove-all-third-party-software.patch
+++ b/0001-remove-all-third-party-software.patch
@@ -1,10 +1,10 @@
-From 7f8761307ff8962ac1e7f548485ff748f8a3e9a1 Mon Sep 17 00:00:00 2001
+From 4b46f840338013715d09dec378bcd2fbd62fa87d Mon Sep 17 00:00:00 2001
From: Eric Paris <eparis at redhat.com>
Date: Thu, 21 Aug 2014 13:55:27 -0400
-Subject: [PATCH 1/2] remove all third party software
+Subject: [PATCH] remove all third party software
---
- Godeps/Godeps.json | 158 -
+ Godeps/Godeps.json | 166 -
Godeps/Readme | 5 -
Godeps/_workspace/.gitignore | 2 -
.../_workspace/src/code.google.com/p/gcfg/LICENSE | 57 -
@@ -100,12 +100,27 @@ Subject: [PATCH 1/2] remove all third party software
.../src/github.com/coreos/go-etcd/etcd/version.go | 3 -
.../src/github.com/coreos/go-etcd/etcd/watch.go | 103 -
.../github.com/coreos/go-etcd/etcd/watch_test.go | 119 -
+ .../src/github.com/davecgh/go-spew/spew/common.go | 371 -
+ .../github.com/davecgh/go-spew/spew/common_test.go | 192 -
+ .../src/github.com/davecgh/go-spew/spew/config.go | 288 -
+ .../src/github.com/davecgh/go-spew/spew/doc.go | 196 -
+ .../src/github.com/davecgh/go-spew/spew/dump.go | 500 -
+ .../github.com/davecgh/go-spew/spew/dump_test.go | 978 --
+ .../davecgh/go-spew/spew/dumpcgo_test.go | 97 -
+ .../davecgh/go-spew/spew/dumpnocgo_test.go | 26 -
+ .../davecgh/go-spew/spew/example_test.go | 230 -
+ .../src/github.com/davecgh/go-spew/spew/format.go | 413 -
+ .../github.com/davecgh/go-spew/spew/format_test.go | 1483 --
+ .../davecgh/go-spew/spew/internal_test.go | 156 -
+ .../src/github.com/davecgh/go-spew/spew/spew.go | 148 -
+ .../github.com/davecgh/go-spew/spew/spew_test.go | 308 -
+ .../davecgh/go-spew/spew/testdata/dumpcgo.go | 82 -
.../github.com/elazarl/go-bindata-assetfs/LICENSE | 23 -
.../elazarl/go-bindata-assetfs/README.md | 18 -
.../elazarl/go-bindata-assetfs/assetfs.go | 141 -
.../github.com/elazarl/go-bindata-assetfs/doc.go | 13 -
.../src/github.com/emicklei/go-restful/.gitignore | 70 -
- .../src/github.com/emicklei/go-restful/CHANGES.md | 127 -
+ .../src/github.com/emicklei/go-restful/CHANGES.md | 130 -
.../src/github.com/emicklei/go-restful/LICENSE | 22 -
.../src/github.com/emicklei/go-restful/README.md | 70 -
.../src/github.com/emicklei/go-restful/Srcfile | 1 -
@@ -115,13 +130,13 @@ Subject: [PATCH 1/2] remove all third party software
.../src/github.com/emicklei/go-restful/compress.go | 89 -
.../emicklei/go-restful/compress_test.go | 53 -
.../github.com/emicklei/go-restful/constants.go | 29 -
- .../github.com/emicklei/go-restful/container.go | 257 -
+ .../github.com/emicklei/go-restful/container.go | 261 -
.../github.com/emicklei/go-restful/cors_filter.go | 170 -
.../emicklei/go-restful/cors_filter_test.go | 125 -
.../src/github.com/emicklei/go-restful/coverage.sh | 2 -
.../src/github.com/emicklei/go-restful/curly.go | 162 -
.../github.com/emicklei/go-restful/curly_route.go | 54 -
- .../github.com/emicklei/go-restful/curly_test.go | 228 -
+ .../github.com/emicklei/go-restful/curly_test.go | 231 -
.../src/github.com/emicklei/go-restful/doc.go | 184 -
.../emicklei/go-restful/doc_examples_test.go | 35 -
.../emicklei/go-restful/examples/.goconvey | 1 -
@@ -156,8 +171,8 @@ Subject: [PATCH 1/2] remove all third party software
.../src/github.com/emicklei/go-restful/filter.go | 26 -
.../github.com/emicklei/go-restful/filter_test.go | 141 -
.../src/github.com/emicklei/go-restful/install.sh | 9 -
- .../src/github.com/emicklei/go-restful/jsr311.go | 248 -
- .../github.com/emicklei/go-restful/jsr311_test.go | 231 -
+ .../src/github.com/emicklei/go-restful/jsr311.go | 247 -
+ .../github.com/emicklei/go-restful/jsr311_test.go | 236 -
.../src/github.com/emicklei/go-restful/logger.go | 16 -
.../emicklei/go-restful/options_filter.go | 24 -
.../emicklei/go-restful/options_filter_test.go | 34 -
@@ -165,8 +180,8 @@ Subject: [PATCH 1/2] remove all third party software
.../emicklei/go-restful/path_expression.go | 56 -
.../src/github.com/emicklei/go-restful/request.go | 135 -
.../github.com/emicklei/go-restful/request_test.go | 204 -
- .../src/github.com/emicklei/go-restful/response.go | 233 -
- .../emicklei/go-restful/response_test.go | 137 -
+ .../src/github.com/emicklei/go-restful/response.go | 241 -
+ .../emicklei/go-restful/response_test.go | 157 -
.../src/github.com/emicklei/go-restful/route.go | 166 -
.../emicklei/go-restful/route_builder.go | 208 -
.../emicklei/go-restful/route_builder_test.go | 55 -
@@ -184,7 +199,7 @@ Subject: [PATCH 1/2] remove all third party software
.../emicklei/go-restful/swagger/swagger_test.go | 116 -
.../go-restful/swagger/swagger_webservice.go | 353 -
.../emicklei/go-restful/swagger/utils_test.go | 70 -
- .../github.com/emicklei/go-restful/web_service.go | 194 -
+ .../github.com/emicklei/go-restful/web_service.go | 190 -
.../emicklei/go-restful/web_service_container.go | 39 -
.../emicklei/go-restful/web_service_test.go | 115 -
.../github.com/fsouza/go-dockerclient/.travis.yml | 13 -
@@ -218,19 +233,24 @@ Subject: [PATCH 1/2] remove all third party software
.../fsouza/go-dockerclient/testing/server.go | 692 -
.../fsouza/go-dockerclient/testing/server_test.go | 1017 --
.../fsouza/go-dockerclient/testing/writer.go | 43 -
+ .../src/github.com/ghodss/yaml/.gitignore | 20 -
+ .../_workspace/src/github.com/ghodss/yaml/LICENSE | 50 -
+ .../src/github.com/ghodss/yaml/README.md | 114 -
+ .../src/github.com/ghodss/yaml/fields.go | 497 -
+ .../_workspace/src/github.com/ghodss/yaml/yaml.go | 250 -
+ .../src/github.com/ghodss/yaml/yaml_test.go | 243 -
.../_workspace/src/github.com/golang/glog/LICENSE | 191 -
.../_workspace/src/github.com/golang/glog/README | 44 -
.../_workspace/src/github.com/golang/glog/glog.go | 1177 --
.../src/github.com/golang/glog/glog_file.go | 124 -
.../src/github.com/golang/glog/glog_test.go | 415 -
.../github.com/google/cadvisor/client/README.md | 54 -
- .../github.com/google/cadvisor/client/client.go | 123 -
+ .../github.com/google/cadvisor/client/client.go | 161 -
.../google/cadvisor/client/client_test.go | 154 -
- .../src/github.com/google/cadvisor/info/advice.go | 34 -
- .../github.com/google/cadvisor/info/container.go | 346 -
- .../google/cadvisor/info/container_test.go | 101 -
+ .../github.com/google/cadvisor/info/container.go | 379 -
+ .../google/cadvisor/info/container_test.go | 79 -
.../src/github.com/google/cadvisor/info/machine.go | 53 -
- .../google/cadvisor/info/test/datagen.go | 78 -
+ .../google/cadvisor/info/test/datagen.go | 76 -
.../src/github.com/google/cadvisor/info/version.go | 18 -
.../src/github.com/google/gofuzz/.travis.yml | 12 -
.../src/github.com/google/gofuzz/CONTRIBUTING.md | 67 -
@@ -523,26 +543,26 @@ Subject: [PATCH 1/2] remove all third party software
.../src/golang.org/x/net/websocket/server.go | 114 -
.../src/golang.org/x/net/websocket/websocket.go | 411 -
.../golang.org/x/net/websocket/websocket_test.go | 341 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE | 185 -
- .../src/gopkg.in/v1/yaml/LICENSE.libyaml | 31 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/README.md | 128 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/apic.go | 742 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/decode.go | 538 -
- .../_workspace/src/gopkg.in/v1/yaml/decode_test.go | 648 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/emitterc.go | 1682 --
- Godeps/_workspace/src/gopkg.in/v1/yaml/encode.go | 226 -
- .../_workspace/src/gopkg.in/v1/yaml/encode_test.go | 386 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/parserc.go | 1096 --
- Godeps/_workspace/src/gopkg.in/v1/yaml/readerc.go | 391 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/resolve.go | 148 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/scannerc.go | 2710 ---
- Godeps/_workspace/src/gopkg.in/v1/yaml/sorter.go | 104 -
- .../_workspace/src/gopkg.in/v1/yaml/suite_test.go | 12 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/writerc.go | 89 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/yaml.go | 306 -
- Godeps/_workspace/src/gopkg.in/v1/yaml/yamlh.go | 712 -
- .../src/gopkg.in/v1/yaml/yamlprivateh.go | 173 -
- 538 files changed, 134578 deletions(-)
+ Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE | 188 -
+ .../src/gopkg.in/v2/yaml/LICENSE.libyaml | 31 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/README.md | 128 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/apic.go | 742 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/decode.go | 665 -
+ .../_workspace/src/gopkg.in/v2/yaml/decode_test.go | 902 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/emitterc.go | 1685 --
+ Godeps/_workspace/src/gopkg.in/v2/yaml/encode.go | 290 -
+ .../_workspace/src/gopkg.in/v2/yaml/encode_test.go | 434 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/parserc.go | 1096 --
+ Godeps/_workspace/src/gopkg.in/v2/yaml/readerc.go | 391 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/resolve.go | 203 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/scannerc.go | 2710 ---
+ Godeps/_workspace/src/gopkg.in/v2/yaml/sorter.go | 104 -
+ .../_workspace/src/gopkg.in/v2/yaml/suite_test.go | 12 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/writerc.go | 89 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/yaml.go | 334 -
+ Godeps/_workspace/src/gopkg.in/v2/yaml/yamlh.go | 716 -
+ .../src/gopkg.in/v2/yaml/yamlprivateh.go | 173 -
+ 558 files changed, 141865 deletions(-)
delete mode 100644 Godeps/Godeps.json
delete mode 100644 Godeps/Readme
delete mode 100644 Godeps/_workspace/.gitignore
@@ -639,6 +659,21 @@ Subject: [PATCH 1/2] remove all third party software
delete mode 100644 Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/version.go
delete mode 100644 Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/watch.go
delete mode 100644 Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/watch_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/config.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/doc.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpcgo_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpnocgo_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/example_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/internal_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew_test.go
+ delete mode 100644 Godeps/_workspace/src/github.com/davecgh/go-spew/spew/testdata/dumpcgo.go
delete mode 100644 Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs/LICENSE
delete mode 100644 Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs/README.md
delete mode 100644 Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs/assetfs.go
@@ -757,6 +792,12 @@ Subject: [PATCH 1/2] remove all third party software
delete mode 100644 Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/server.go
delete mode 100644 Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/server_test.go
delete mode 100644 Godeps/_workspace/src/github.com/fsouza/go-dockerclient/testing/writer.go
+ delete mode 100644 Godeps/_workspace/src/github.com/ghodss/yaml/.gitignore
+ delete mode 100644 Godeps/_workspace/src/github.com/ghodss/yaml/LICENSE
+ delete mode 100644 Godeps/_workspace/src/github.com/ghodss/yaml/README.md
+ delete mode 100644 Godeps/_workspace/src/github.com/ghodss/yaml/fields.go
+ delete mode 100644 Godeps/_workspace/src/github.com/ghodss/yaml/yaml.go
+ delete mode 100644 Godeps/_workspace/src/github.com/ghodss/yaml/yaml_test.go
delete mode 100644 Godeps/_workspace/src/github.com/golang/glog/LICENSE
delete mode 100644 Godeps/_workspace/src/github.com/golang/glog/README
delete mode 100644 Godeps/_workspace/src/github.com/golang/glog/glog.go
@@ -765,7 +806,6 @@ Subject: [PATCH 1/2] remove all third party software
delete mode 100644 Godeps/_workspace/src/github.com/google/cadvisor/client/README.md
delete mode 100644 Godeps/_workspace/src/github.com/google/cadvisor/client/client.go
delete mode 100644 Godeps/_workspace/src/github.com/google/cadvisor/client/client_test.go
- delete mode 100644 Godeps/_workspace/src/github.com/google/cadvisor/info/advice.go
delete mode 100644 Godeps/_workspace/src/github.com/google/cadvisor/info/container.go
delete mode 100644 Godeps/_workspace/src/github.com/google/cadvisor/info/container_test.go
delete mode 100644 Godeps/_workspace/src/github.com/google/cadvisor/info/machine.go
@@ -1062,32 +1102,32 @@ Subject: [PATCH 1/2] remove all third party software
delete mode 100644 Godeps/_workspace/src/golang.org/x/net/websocket/server.go
delete mode 100644 Godeps/_workspace/src/golang.org/x/net/websocket/websocket.go
delete mode 100644 Godeps/_workspace/src/golang.org/x/net/websocket/websocket_test.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE.libyaml
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/README.md
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/apic.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/decode.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/decode_test.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/emitterc.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/encode.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/encode_test.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/parserc.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/readerc.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/resolve.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/scannerc.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/sorter.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/suite_test.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/writerc.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/yaml.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/yamlh.go
- delete mode 100644 Godeps/_workspace/src/gopkg.in/v1/yaml/yamlprivateh.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE.libyaml
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/README.md
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/apic.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/decode.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/decode_test.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/emitterc.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/encode.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/encode_test.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/parserc.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/readerc.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/resolve.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/scannerc.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/sorter.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/suite_test.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/writerc.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/yaml.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/yamlh.go
+ delete mode 100644 Godeps/_workspace/src/gopkg.in/v2/yaml/yamlprivateh.go
diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
deleted file mode 100644
-index 09dd3c8..0000000
+index 06bc6a2..0000000
--- a/Godeps/Godeps.json
+++ /dev/null
-@@ -1,158 +0,0 @@
+@@ -1,166 +0,0 @@
-{
- "ImportPath": "github.com/GoogleCloudPlatform/kubernetes",
- "GoVersion": "go1.3",
@@ -1135,13 +1175,17 @@ index 09dd3c8..0000000
- "Rev": "23142f6773a676cc2cae8dd0cb90b2ea761c853f"
- },
- {
+- "ImportPath": "github.com/davecgh/go-spew/spew",
+- "Rev": "83f84dc933714d51504ceed59f43ead21d096fe7"
+- },
+- {
- "ImportPath": "github.com/elazarl/go-bindata-assetfs",
- "Rev": "ae4665cf2d188c65764c73fe4af5378acc549510"
- },
- {
- "ImportPath": "github.com/emicklei/go-restful",
-- "Comment": "v1.1.2-38-gab99062",
-- "Rev": "ab990627e3546d3c6c8ab45c4d887a3d66b1b6ab"
+- "Comment": "v1.1.2-50-g692a500",
+- "Rev": "692a50017a7049b26cf7ea4ccfc0d8c77369a793"
- },
- {
- "ImportPath": "github.com/fsouza/go-dockerclient",
@@ -1149,18 +1193,22 @@ index 09dd3c8..0000000
- "Rev": "15d2c6e3eb670c545d0af0604d7f9aff3871af04"
- },
- {
+- "ImportPath": "github.com/ghodss/yaml",
+- "Rev": "4fb5c728a37b361a1e971a3bb3d785fcc96b6ef5"
+- },
+- {
- "ImportPath": "github.com/golang/glog",
- "Rev": "44145f04b68cf362d9c4df2182967c2275eaefed"
- },
- {
- "ImportPath": "github.com/google/cadvisor/client",
-- "Comment": "0.5.0",
-- "Rev": "8c4f650e62f096710da794e536de86e34447fca9"
+- "Comment": "0.6.2",
+- "Rev": "89088df70eca64cf9d6b9a23a3d2bc21a30916d6"
- },
- {
- "ImportPath": "github.com/google/cadvisor/info",
-- "Comment": "0.5.0",
-- "Rev": "8c4f650e62f096710da794e536de86e34447fca9"
+- "Comment": "0.6.2",
+- "Rev": "89088df70eca64cf9d6b9a23a3d2bc21a30916d6"
- },
- {
- "ImportPath": "github.com/google/gofuzz",
@@ -1241,8 +1289,8 @@ index 09dd3c8..0000000
- "Rev": "c043f0dc72e4cdd23ae039470ea9d63e6680a1b2"
- },
- {
-- "ImportPath": "gopkg.in/v1/yaml",
-- "Rev": "1b9791953ba4027efaeb728c7355e542a203be5e"
+- "ImportPath": "gopkg.in/v2/yaml",
+- "Rev": "d466437aa4adc35830964cffc5b5f262c63ddcb4"
- }
- ]
-}
@@ -40220,6 +40268,5564 @@ index 43e1dfe..0000000
- }
- stop <- true
-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common.go
+deleted file mode 100644
+index 0ce0df1..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common.go
++++ /dev/null
+@@ -1,371 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-package spew
+-
+-import (
+- "fmt"
+- "io"
+- "reflect"
+- "sort"
+- "strconv"
+- "unsafe"
+-)
+-
+-const (
+- // ptrSize is the size of a pointer on the current arch.
+- ptrSize = unsafe.Sizeof((*byte)(nil))
+-)
+-
+-var (
+- // offsetPtr, offsetScalar, and offsetFlag are the offsets for the
+- // internal reflect.Value fields. These values are valid before golang
+- // commit ecccf07e7f9d which changed the format. The are also valid
+- // after commit 82f48826c6c7 which changed the format again to mirror
+- // the original format. Code in the init function updates these offsets
+- // as necessary.
+- offsetPtr = uintptr(ptrSize)
+- offsetScalar = uintptr(0)
+- offsetFlag = uintptr(ptrSize * 2)
+-
+- // flagKindWidth and flagKindShift indicate various bits that the
+- // reflect package uses internally to track kind information.
+- //
+- // flagRO indicates whether or not the value field of a reflect.Value is
+- // read-only.
+- //
+- // flagIndir indicates whether the value field of a reflect.Value is
+- // the actual data or a pointer to the data.
+- //
+- // These values are valid before golang commit 90a7c3c86944 which
+- // changed their positions. Code in the init function updates these
+- // flags as necessary.
+- flagKindWidth = uintptr(5)
+- flagKindShift = uintptr(flagKindWidth - 1)
+- flagRO = uintptr(1 << 0)
+- flagIndir = uintptr(1 << 1)
+-)
+-
+-func init() {
+- // Older versions of reflect.Value stored small integers directly in the
+- // ptr field (which is named val in the older versions). Versions
+- // between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
+- // scalar for this purpose which unfortunately came before the flag
+- // field, so the offset of the flag field is different for those
+- // versions.
+- //
+- // This code constructs a new reflect.Value from a known small integer
+- // and checks if the size of the reflect.Value struct indicates it has
+- // the scalar field. When it does, the offsets are updated accordingly.
+- vv := reflect.ValueOf(0xf00)
+- if unsafe.Sizeof(vv) == (ptrSize * 4) {
+- offsetScalar = ptrSize * 2
+- offsetFlag = ptrSize * 3
+- }
+-
+- // Commit 90a7c3c86944 changed the flag positions such that the low
+- // order bits are the kind. This code extracts the kind from the flags
+- // field and ensures it's the correct type. When it's not, the flag
+- // order has been changed to the newer format, so the flags are updated
+- // accordingly.
+- upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
+- upfv := *(*uintptr)(upf)
+- flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
+- if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
+- flagKindShift = 0
+- flagRO = 1 << 5
+- flagIndir = 1 << 6
+- }
+-}
+-
+-// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
+-// the typical safety restrictions preventing access to unaddressable and
+-// unexported data. It works by digging the raw pointer to the underlying
+-// value out of the protected value and generating a new unprotected (unsafe)
+-// reflect.Value to it.
+-//
+-// This allows us to check for implementations of the Stringer and error
+-// interfaces to be used for pretty printing ordinarily unaddressable and
+-// inaccessible values such as unexported struct fields.
+-func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
+- indirects := 1
+- vt := v.Type()
+- upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
+- rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
+- if rvf&flagIndir != 0 {
+- vt = reflect.PtrTo(v.Type())
+- indirects++
+- } else if offsetScalar != 0 {
+- // The value is in the scalar field when it's not one of the
+- // reference types.
+- switch vt.Kind() {
+- case reflect.Uintptr:
+- case reflect.Chan:
+- case reflect.Func:
+- case reflect.Map:
+- case reflect.Ptr:
+- case reflect.UnsafePointer:
+- default:
+- upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
+- offsetScalar)
+- }
+- }
+-
+- pv := reflect.NewAt(vt, upv)
+- rv = pv
+- for i := 0; i < indirects; i++ {
+- rv = rv.Elem()
+- }
+- return rv
+-}
+-
+-// Some constants in the form of bytes to avoid string overhead. This mirrors
+-// the technique used in the fmt package.
+-var (
+- panicBytes = []byte("(PANIC=")
+- plusBytes = []byte("+")
+- iBytes = []byte("i")
+- trueBytes = []byte("true")
+- falseBytes = []byte("false")
+- interfaceBytes = []byte("(interface {})")
+- commaNewlineBytes = []byte(",\n")
+- newlineBytes = []byte("\n")
+- openBraceBytes = []byte("{")
+- openBraceNewlineBytes = []byte("{\n")
+- closeBraceBytes = []byte("}")
+- asteriskBytes = []byte("*")
+- colonBytes = []byte(":")
+- colonSpaceBytes = []byte(": ")
+- openParenBytes = []byte("(")
+- closeParenBytes = []byte(")")
+- spaceBytes = []byte(" ")
+- pointerChainBytes = []byte("->")
+- nilAngleBytes = []byte("<nil>")
+- maxNewlineBytes = []byte("<max depth reached>\n")
+- maxShortBytes = []byte("<max>")
+- circularBytes = []byte("<already shown>")
+- circularShortBytes = []byte("<shown>")
+- invalidAngleBytes = []byte("<invalid>")
+- openBracketBytes = []byte("[")
+- closeBracketBytes = []byte("]")
+- percentBytes = []byte("%")
+- precisionBytes = []byte(".")
+- openAngleBytes = []byte("<")
+- closeAngleBytes = []byte(">")
+- openMapBytes = []byte("map[")
+- closeMapBytes = []byte("]")
+- lenEqualsBytes = []byte("len=")
+- capEqualsBytes = []byte("cap=")
+-)
+-
+-// hexDigits is used to map a decimal value to a hex digit.
+-var hexDigits = "0123456789abcdef"
+-
+-// catchPanic handles any panics that might occur during the handleMethods
+-// calls.
+-func catchPanic(w io.Writer, v reflect.Value) {
+- if err := recover(); err != nil {
+- w.Write(panicBytes)
+- fmt.Fprintf(w, "%v", err)
+- w.Write(closeParenBytes)
+- }
+-}
+-
+-// handleMethods attempts to call the Error and String methods on the underlying
+-// type the passed reflect.Value represents and outputes the result to Writer w.
+-//
+-// It handles panics in any called methods by catching and displaying the error
+-// as the formatted value.
+-func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
+- // We need an interface to check if the type implements the error or
+- // Stringer interface. However, the reflect package won't give us an
+- // interface on certain things like unexported struct fields in order
+- // to enforce visibility rules. We use unsafe to bypass these restrictions
+- // since this package does not mutate the values.
+- if !v.CanInterface() {
+- v = unsafeReflectValue(v)
+- }
+-
+- // Choose whether or not to do error and Stringer interface lookups against
+- // the base type or a pointer to the base type depending on settings.
+- // Technically calling one of these methods with a pointer receiver can
+- // mutate the value, however, types which choose to satisify an error or
+- // Stringer interface with a pointer receiver should not be mutating their
+- // state inside these interface methods.
+- var viface interface{}
+- if !cs.DisablePointerMethods {
+- if !v.CanAddr() {
+- v = unsafeReflectValue(v)
+- }
+- viface = v.Addr().Interface()
+- } else {
+- if v.CanAddr() {
+- v = v.Addr()
+- }
+- viface = v.Interface()
+- }
+-
+- // Is it an error or Stringer?
+- switch iface := viface.(type) {
+- case error:
+- defer catchPanic(w, v)
+- if cs.ContinueOnMethod {
+- w.Write(openParenBytes)
+- w.Write([]byte(iface.Error()))
+- w.Write(closeParenBytes)
+- w.Write(spaceBytes)
+- return false
+- }
+-
+- w.Write([]byte(iface.Error()))
+- return true
+-
+- case fmt.Stringer:
+- defer catchPanic(w, v)
+- if cs.ContinueOnMethod {
+- w.Write(openParenBytes)
+- w.Write([]byte(iface.String()))
+- w.Write(closeParenBytes)
+- w.Write(spaceBytes)
+- return false
+- }
+- w.Write([]byte(iface.String()))
+- return true
+- }
+- return false
+-}
+-
+-// printBool outputs a boolean value as true or false to Writer w.
+-func printBool(w io.Writer, val bool) {
+- if val {
+- w.Write(trueBytes)
+- } else {
+- w.Write(falseBytes)
+- }
+-}
+-
+-// printInt outputs a signed integer value to Writer w.
+-func printInt(w io.Writer, val int64, base int) {
+- w.Write([]byte(strconv.FormatInt(val, base)))
+-}
+-
+-// printUint outputs an unsigned integer value to Writer w.
+-func printUint(w io.Writer, val uint64, base int) {
+- w.Write([]byte(strconv.FormatUint(val, base)))
+-}
+-
+-// printFloat outputs a floating point value using the specified precision,
+-// which is expected to be 32 or 64bit, to Writer w.
+-func printFloat(w io.Writer, val float64, precision int) {
+- w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
+-}
+-
+-// printComplex outputs a complex value using the specified float precision
+-// for the real and imaginary parts to Writer w.
+-func printComplex(w io.Writer, c complex128, floatPrecision int) {
+- r := real(c)
+- w.Write(openParenBytes)
+- w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
+- i := imag(c)
+- if i >= 0 {
+- w.Write(plusBytes)
+- }
+- w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
+- w.Write(iBytes)
+- w.Write(closeParenBytes)
+-}
+-
+-// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
+-// prefix to Writer w.
+-func printHexPtr(w io.Writer, p uintptr) {
+- // Null pointer.
+- num := uint64(p)
+- if num == 0 {
+- w.Write(nilAngleBytes)
+- return
+- }
+-
+- // Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
+- buf := make([]byte, 18)
+-
+- // It's simpler to construct the hex string right to left.
+- base := uint64(16)
+- i := len(buf) - 1
+- for num >= base {
+- buf[i] = hexDigits[num%base]
+- num /= base
+- i--
+- }
+- buf[i] = hexDigits[num]
+-
+- // Add '0x' prefix.
+- i--
+- buf[i] = 'x'
+- i--
+- buf[i] = '0'
+-
+- // Strip unused leading bytes.
+- buf = buf[i:]
+- w.Write(buf)
+-}
+-
+-// valuesSorter implements sort.Interface to allow a slice of reflect.Value
+-// elements to be sorted.
+-type valuesSorter struct {
+- values []reflect.Value
+-}
+-
+-// Len returns the number of values in the slice. It is part of the
+-// sort.Interface implementation.
+-func (s *valuesSorter) Len() int {
+- return len(s.values)
+-}
+-
+-// Swap swaps the values at the passed indices. It is part of the
+-// sort.Interface implementation.
+-func (s *valuesSorter) Swap(i, j int) {
+- s.values[i], s.values[j] = s.values[j], s.values[i]
+-}
+-
+-// Less returns whether the value at index i should sort before the
+-// value at index j. It is part of the sort.Interface implementation.
+-func (s *valuesSorter) Less(i, j int) bool {
+- switch s.values[i].Kind() {
+- case reflect.Bool:
+- return !s.values[i].Bool() && s.values[j].Bool()
+- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+- return s.values[i].Int() < s.values[j].Int()
+- case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+- return s.values[i].Uint() < s.values[j].Uint()
+- case reflect.Float32, reflect.Float64:
+- return s.values[i].Float() < s.values[j].Float()
+- case reflect.String:
+- return s.values[i].String() < s.values[j].String()
+- case reflect.Uintptr:
+- return s.values[i].Uint() < s.values[j].Uint()
+- }
+- return s.values[i].String() < s.values[j].String()
+-}
+-
+-// sortValues is a generic sort function for native types: int, uint, bool,
+-// string and uintptr. Other inputs are sorted according to their
+-// Value.String() value to ensure display stability.
+-func sortValues(values []reflect.Value) {
+- if len(values) == 0 {
+- return
+- }
+- sort.Sort(&valuesSorter{values})
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common_test.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common_test.go
+deleted file mode 100644
+index 3bea81f..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/common_test.go
++++ /dev/null
+@@ -1,192 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-package spew_test
+-
+-import (
+- "fmt"
+- "github.com/davecgh/go-spew/spew"
+- "reflect"
+- "testing"
+-)
+-
+-// custom type to test Stinger interface on non-pointer receiver.
+-type stringer string
+-
+-// String implements the Stringer interface for testing invocation of custom
+-// stringers on types with non-pointer receivers.
+-func (s stringer) String() string {
+- return "stringer " + string(s)
+-}
+-
+-// custom type to test Stinger interface on pointer receiver.
+-type pstringer string
+-
+-// String implements the Stringer interface for testing invocation of custom
+-// stringers on types with only pointer receivers.
+-func (s *pstringer) String() string {
+- return "stringer " + string(*s)
+-}
+-
+-// xref1 and xref2 are cross referencing structs for testing circular reference
+-// detection.
+-type xref1 struct {
+- ps2 *xref2
+-}
+-type xref2 struct {
+- ps1 *xref1
+-}
+-
+-// indirCir1, indirCir2, and indirCir3 are used to generate an indirect circular
+-// reference for testing detection.
+-type indirCir1 struct {
+- ps2 *indirCir2
+-}
+-type indirCir2 struct {
+- ps3 *indirCir3
+-}
+-type indirCir3 struct {
+- ps1 *indirCir1
+-}
+-
+-// embed is used to test embedded structures.
+-type embed struct {
+- a string
+-}
+-
+-// embedwrap is used to test embedded structures.
+-type embedwrap struct {
+- *embed
+- e *embed
+-}
+-
+-// panicer is used to intentionally cause a panic for testing spew properly
+-// handles them
+-type panicer int
+-
+-func (p panicer) String() string {
+- panic("test panic")
+-}
+-
+-// customError is used to test custom error interface invocation.
+-type customError int
+-
+-func (e customError) Error() string {
+- return fmt.Sprintf("error: %d", int(e))
+-}
+-
+-// stringizeWants converts a slice of wanted test output into a format suitable
+-// for a test error message.
+-func stringizeWants(wants []string) string {
+- s := ""
+- for i, want := range wants {
+- if i > 0 {
+- s += fmt.Sprintf("want%d: %s", i+1, want)
+- } else {
+- s += "want: " + want
+- }
+- }
+- return s
+-}
+-
+-// testFailed returns whether or not a test failed by checking if the result
+-// of the test is in the slice of wanted strings.
+-func testFailed(result string, wants []string) bool {
+- for _, want := range wants {
+- if result == want {
+- return false
+- }
+- }
+- return true
+-}
+-
+-// TestSortValues ensures the sort functionality for relect.Value based sorting
+-// works as intended.
+-func TestSortValues(t *testing.T) {
+- getInterfaces := func(values []reflect.Value) []interface{} {
+- interfaces := []interface{}{}
+- for _, v := range values {
+- interfaces = append(interfaces, v.Interface())
+- }
+- return interfaces
+- }
+-
+- v := reflect.ValueOf
+-
+- a := v("a")
+- b := v("b")
+- c := v("c")
+- embedA := v(embed{"a"})
+- embedB := v(embed{"b"})
+- embedC := v(embed{"c"})
+- tests := []struct {
+- input []reflect.Value
+- expected []reflect.Value
+- }{
+- // No values.
+- {
+- []reflect.Value{},
+- []reflect.Value{},
+- },
+- // Bools.
+- {
+- []reflect.Value{v(false), v(true), v(false)},
+- []reflect.Value{v(false), v(false), v(true)},
+- },
+- // Ints.
+- {
+- []reflect.Value{v(2), v(1), v(3)},
+- []reflect.Value{v(1), v(2), v(3)},
+- },
+- // Uints.
+- {
+- []reflect.Value{v(uint8(2)), v(uint8(1)), v(uint8(3))},
+- []reflect.Value{v(uint8(1)), v(uint8(2)), v(uint8(3))},
+- },
+- // Floats.
+- {
+- []reflect.Value{v(2.0), v(1.0), v(3.0)},
+- []reflect.Value{v(1.0), v(2.0), v(3.0)},
+- },
+- // Strings.
+- {
+- []reflect.Value{b, a, c},
+- []reflect.Value{a, b, c},
+- },
+- // Uintptrs.
+- {
+- []reflect.Value{v(uintptr(2)), v(uintptr(1)), v(uintptr(3))},
+- []reflect.Value{v(uintptr(1)), v(uintptr(2)), v(uintptr(3))},
+- },
+- // Invalid.
+- {
+- []reflect.Value{embedB, embedA, embedC},
+- []reflect.Value{embedB, embedA, embedC},
+- },
+- }
+- for _, test := range tests {
+- spew.SortValues(test.input)
+- // reflect.DeepEqual cannot really make sense of reflect.Value,
+- // probably because of all the pointer tricks. For instance,
+- // v(2.0) != v(2.0) on a 32-bits system. Turn them into interface{}
+- // instead.
+- input := getInterfaces(test.input)
+- expected := getInterfaces(test.expected)
+- if !reflect.DeepEqual(input, expected) {
+- t.Errorf("Sort mismatch:\n %v != %v", input, expected)
+- }
+- }
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/config.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/config.go
+deleted file mode 100644
+index e516675..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/config.go
++++ /dev/null
+@@ -1,288 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-package spew
+-
+-import (
+- "bytes"
+- "fmt"
+- "io"
+- "os"
+-)
+-
+-// ConfigState houses the configuration options used by spew to format and
+-// display values. There is a global instance, Config, that is used to control
+-// all top-level Formatter and Dump functionality. Each ConfigState instance
+-// provides methods equivalent to the top-level functions.
+-//
+-// The zero value for ConfigState provides no indentation. You would typically
+-// want to set it to a space or a tab.
+-//
+-// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
+-// with default settings. See the documentation of NewDefaultConfig for default
+-// values.
+-type ConfigState struct {
+- // Indent specifies the string to use for each indentation level. The
+- // global config instance that all top-level functions use set this to a
+- // single space by default. If you would like more indentation, you might
+- // set this to a tab with "\t" or perhaps two spaces with " ".
+- Indent string
+-
+- // MaxDepth controls the maximum number of levels to descend into nested
+- // data structures. The default, 0, means there is no limit.
+- //
+- // NOTE: Circular data structures are properly detected, so it is not
+- // necessary to set this value unless you specifically want to limit deeply
+- // nested data structures.
+- MaxDepth int
+-
+- // DisableMethods specifies whether or not error and Stringer interfaces are
+- // invoked for types that implement them.
+- DisableMethods bool
+-
+- // DisablePointerMethods specifies whether or not to check for and invoke
+- // error and Stringer interfaces on types which only accept a pointer
+- // receiver when the current type is not a pointer.
+- //
+- // NOTE: This might be an unsafe action since calling one of these methods
+- // with a pointer receiver could technically mutate the value, however,
+- // in practice, types which choose to satisify an error or Stringer
+- // interface with a pointer receiver should not be mutating their state
+- // inside these interface methods.
+- DisablePointerMethods bool
+-
+- // ContinueOnMethod specifies whether or not recursion should continue once
+- // a custom error or Stringer interface is invoked. The default, false,
+- // means it will print the results of invoking the custom error or Stringer
+- // interface and return immediately instead of continuing to recurse into
+- // the internals of the data type.
+- //
+- // NOTE: This flag does not have any effect if method invocation is disabled
+- // via the DisableMethods or DisablePointerMethods options.
+- ContinueOnMethod bool
+-
+- // SortKeys specifies map keys should be sorted before being printed. Use
+- // this to have a more deterministic, diffable output. Note that only
+- // native types (bool, int, uint, floats, uintptr and string) are supported
+- // with other types sorted according to the reflect.Value.String() output
+- // which guarantees display stability.
+- SortKeys bool
+-}
+-
+-// Config is the active configuration of the top-level functions.
+-// The configuration can be changed by modifying the contents of spew.Config.
+-var Config = ConfigState{Indent: " "}
+-
+-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+-// passed with a Formatter interface returned by c.NewFormatter. It returns
+-// the formatted string as a value that satisfies error. See NewFormatter
+-// for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
+- return fmt.Errorf(format, c.convertArgs(a)...)
+-}
+-
+-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+-// passed with a Formatter interface returned by c.NewFormatter. It returns
+-// the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+- return fmt.Fprint(w, c.convertArgs(a)...)
+-}
+-
+-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+-// passed with a Formatter interface returned by c.NewFormatter. It returns
+-// the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+- return fmt.Fprintf(w, format, c.convertArgs(a)...)
+-}
+-
+-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+-// passed with a Formatter interface returned by c.NewFormatter. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+- return fmt.Fprintln(w, c.convertArgs(a)...)
+-}
+-
+-// Print is a wrapper for fmt.Print that treats each argument as if it were
+-// passed with a Formatter interface returned by c.NewFormatter. It returns
+-// the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
+- return fmt.Print(c.convertArgs(a)...)
+-}
+-
+-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+-// passed with a Formatter interface returned by c.NewFormatter. It returns
+-// the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
+- return fmt.Printf(format, c.convertArgs(a)...)
+-}
+-
+-// Println is a wrapper for fmt.Println that treats each argument as if it were
+-// passed with a Formatter interface returned by c.NewFormatter. It returns
+-// the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
+- return fmt.Println(c.convertArgs(a)...)
+-}
+-
+-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+-// passed with a Formatter interface returned by c.NewFormatter. It returns
+-// the resulting string. See NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Sprint(a ...interface{}) string {
+- return fmt.Sprint(c.convertArgs(a)...)
+-}
+-
+-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+-// passed with a Formatter interface returned by c.NewFormatter. It returns
+-// the resulting string. See NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
+- return fmt.Sprintf(format, c.convertArgs(a)...)
+-}
+-
+-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+-// were passed with a Formatter interface returned by c.NewFormatter. It
+-// returns the resulting string. See NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
+-func (c *ConfigState) Sprintln(a ...interface{}) string {
+- return fmt.Sprintln(c.convertArgs(a)...)
+-}
+-
+-/*
+-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+-interface. As a result, it integrates cleanly with standard fmt package
+-printing functions. The formatter is useful for inline printing of smaller data
+-types similar to the standard %v format specifier.
+-
+-The custom formatter only responds to the %v (most compact), %+v (adds pointer
+-addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
+-combinations. Any other verbs such as %x and %q will be sent to the the
+-standard fmt package for formatting. In addition, the custom formatter ignores
+-the width and precision arguments (however they will still work on the format
+-specifiers not handled by the custom formatter).
+-
+-Typically this function shouldn't be called directly. It is much easier to make
+-use of the custom formatter by calling one of the convenience functions such as
+-c.Printf, c.Println, or c.Printf.
+-*/
+-func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
+- return newFormatter(c, v)
+-}
+-
+-// Fdump formats and displays the passed arguments to io.Writer w. It formats
+-// exactly the same as Dump.
+-func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
+- fdump(c, w, a...)
+-}
+-
+-/*
+-Dump displays the passed parameters to standard out with newlines, customizable
+-indentation, and additional debug information such as complete types and all
+-pointer addresses used to indirect to the final value. It provides the
+-following features over the built-in printing facilities provided by the fmt
+-package:
+-
+- * Pointers are dereferenced and followed
+- * Circular data structures are detected and handled properly
+- * Custom Stringer/error interfaces are optionally invoked, including
+- on unexported types
+- * Custom types which only implement the Stringer/error interfaces via
+- a pointer receiver are optionally invoked when passing non-pointer
+- variables
+- * Byte arrays and slices are dumped like the hexdump -C command which
+- includes offsets, byte values in hex, and ASCII output
+-
+-The configuration options are controlled by modifying the public members
+-of c. See ConfigState for options documentation.
+-
+-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+-get the formatted result as a string.
+-*/
+-func (c *ConfigState) Dump(a ...interface{}) {
+- fdump(c, os.Stdout, a...)
+-}
+-
+-// Sdump returns a string with the passed arguments formatted exactly the same
+-// as Dump.
+-func (c *ConfigState) Sdump(a ...interface{}) string {
+- var buf bytes.Buffer
+- fdump(c, &buf, a...)
+- return buf.String()
+-}
+-
+-// convertArgs accepts a slice of arguments and returns a slice of the same
+-// length with each argument converted to a spew Formatter interface using
+-// the ConfigState associated with s.
+-func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
+- formatters = make([]interface{}, len(args))
+- for index, arg := range args {
+- formatters[index] = newFormatter(c, arg)
+- }
+- return formatters
+-}
+-
+-// NewDefaultConfig returns a ConfigState with the following default settings.
+-//
+-// Indent: " "
+-// MaxDepth: 0
+-// DisableMethods: false
+-// DisablePointerMethods: false
+-// ContinueOnMethod: false
+-// SortKeys: false
+-func NewDefaultConfig() *ConfigState {
+- return &ConfigState{Indent: " "}
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/doc.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/doc.go
+deleted file mode 100644
+index a0d73ac..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/doc.go
++++ /dev/null
+@@ -1,196 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-/*
+-Package spew implements a deep pretty printer for Go data structures to aid in
+-debugging.
+-
+-A quick overview of the additional features spew provides over the built-in
+-printing facilities for Go data types are as follows:
+-
+- * Pointers are dereferenced and followed
+- * Circular data structures are detected and handled properly
+- * Custom Stringer/error interfaces are optionally invoked, including
+- on unexported types
+- * Custom types which only implement the Stringer/error interfaces via
+- a pointer receiver are optionally invoked when passing non-pointer
+- variables
+- * Byte arrays and slices are dumped like the hexdump -C command which
+- includes offsets, byte values in hex, and ASCII output (only when using
+- Dump style)
+-
+-There are two different approaches spew allows for dumping Go data structures:
+-
+- * Dump style which prints with newlines, customizable indentation,
+- and additional debug information such as types and all pointer addresses
+- used to indirect to the final value
+- * A custom Formatter interface that integrates cleanly with the standard fmt
+- package and replaces %v, %+v, %#v, and %#+v to provide inline printing
+- similar to the default %v while providing the additional functionality
+- outlined above and passing unsupported format verbs such as %x and %q
+- along to fmt
+-
+-Quick Start
+-
+-This section demonstrates how to quickly get started with spew. See the
+-sections below for further details on formatting and configuration options.
+-
+-To dump a variable with full newlines, indentation, type, and pointer
+-information use Dump, Fdump, or Sdump:
+- spew.Dump(myVar1, myVar2, ...)
+- spew.Fdump(someWriter, myVar1, myVar2, ...)
+- str := spew.Sdump(myVar1, myVar2, ...)
+-
+-Alternatively, if you would prefer to use format strings with a compacted inline
+-printing style, use the convenience wrappers Printf, Fprintf, etc with
+-%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
+-%#+v (adds types and pointer addresses):
+- spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+- spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+- spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+- spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+-
+-Configuration Options
+-
+-Configuration of spew is handled by fields in the ConfigState type. For
+-convenience, all of the top-level functions use a global state available
+-via the spew.Config global.
+-
+-It is also possible to create a ConfigState instance that provides methods
+-equivalent to the top-level functions. This allows concurrent configuration
+-options. See the ConfigState documentation for more details.
+-
+-The following configuration options are available:
+- * Indent
+- String to use for each indentation level for Dump functions.
+- It is a single space by default. A popular alternative is "\t".
+-
+- * MaxDepth
+- Maximum number of levels to descend into nested data structures.
+- There is no limit by default.
+-
+- * DisableMethods
+- Disables invocation of error and Stringer interface methods.
+- Method invocation is enabled by default.
+-
+- * DisablePointerMethods
+- Disables invocation of error and Stringer interface methods on types
+- which only accept pointer receivers from non-pointer variables.
+- Pointer method invocation is enabled by default.
+-
+- * ContinueOnMethod
+- Enables recursion into types after invoking error and Stringer interface
+- methods. Recursion after method invocation is disabled by default.
+-
+- * SortKeys
+- Specifies map keys should be sorted before being printed. Use
+- this to have a more deterministic, diffable output. Note that
+- only native types (bool, int, uint, floats, uintptr and string)
+- are supported with other types sorted according to the
+- reflect.Value.String() output which guarantees display stability.
+- Natural map order is used by default.
+-
+-Dump Usage
+-
+-Simply call spew.Dump with a list of variables you want to dump:
+-
+- spew.Dump(myVar1, myVar2, ...)
+-
+-You may also call spew.Fdump if you would prefer to output to an arbitrary
+-io.Writer. For example, to dump to standard error:
+-
+- spew.Fdump(os.Stderr, myVar1, myVar2, ...)
+-
+-A third option is to call spew.Sdump to get the formatted output as a string:
+-
+- str := spew.Sdump(myVar1, myVar2, ...)
+-
+-Sample Dump Output
+-
+-See the Dump example for details on the setup of the types and variables being
+-shown here.
+-
+- (main.Foo) {
+- unexportedField: (*main.Bar)(0xf84002e210)({
+- flag: (main.Flag) flagTwo,
+- data: (uintptr) <nil>
+- }),
+- ExportedField: (map[interface {}]interface {}) (len=1) {
+- (string) (len=3) "one": (bool) true
+- }
+- }
+-
+-Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
+-command as shown.
+- ([]uint8) (len=32 cap=32) {
+- 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
+- 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
+- 00000020 31 32 |12|
+- }
+-
+-Custom Formatter
+-
+-Spew provides a custom formatter that implements the fmt.Formatter interface
+-so that it integrates cleanly with standard fmt package printing functions. The
+-formatter is useful for inline printing of smaller data types similar to the
+-standard %v format specifier.
+-
+-The custom formatter only responds to the %v (most compact), %+v (adds pointer
+-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+-combinations. Any other verbs such as %x and %q will be sent to the the
+-standard fmt package for formatting. In addition, the custom formatter ignores
+-the width and precision arguments (however they will still work on the format
+-specifiers not handled by the custom formatter).
+-
+-Custom Formatter Usage
+-
+-The simplest way to make use of the spew custom formatter is to call one of the
+-convenience functions such as spew.Printf, spew.Println, or spew.Printf. The
+-functions have syntax you are most likely already familiar with:
+-
+- spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+- spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+- spew.Println(myVar, myVar2)
+- spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+- spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+-
+-See the Index for the full list convenience functions.
+-
+-Sample Formatter Output
+-
+-Double pointer to a uint8:
+- %v: <**>5
+- %+v: <**>(0xf8400420d0->0xf8400420c8)5
+- %#v: (**uint8)5
+- %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
+-
+-Pointer to circular struct with a uint8 field and a pointer to itself:
+- %v: <*>{1 <*><shown>}
+- %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
+- %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
+- %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
+-
+-See the Printf example for details on the setup of variables being shown
+-here.
+-
+-Errors
+-
+-Since it is possible for custom Stringer/error interfaces to panic, spew
+-detects them and handles them internally by printing the panic information
+-inline with the output. Since spew is intended to provide deep pretty printing
+-capabilities on structures, it intentionally does not return any errors.
+-*/
+-package spew
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump.go
+deleted file mode 100644
+index 02d4c9d..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump.go
++++ /dev/null
+@@ -1,500 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-package spew
+-
+-import (
+- "bytes"
+- "encoding/hex"
+- "fmt"
+- "io"
+- "os"
+- "reflect"
+- "regexp"
+- "strconv"
+- "strings"
+-)
+-
+-var (
+- // uint8Type is a reflect.Type representing a uint8. It is used to
+- // convert cgo types to uint8 slices for hexdumping.
+- uint8Type = reflect.TypeOf(uint8(0))
+-
+- // cCharRE is a regular expression that matches a cgo char.
+- // It is used to detect character arrays to hexdump them.
+- cCharRE = regexp.MustCompile("^.*\\._Ctype_char$")
+-
+- // cUnsignedCharRE is a regular expression that matches a cgo unsigned
+- // char. It is used to detect unsigned character arrays to hexdump
+- // them.
+- cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$")
+-
+- // cUint8tCharRE is a regular expression that matches a cgo uint8_t.
+- // It is used to detect uint8_t arrays to hexdump them.
+- cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$")
+-)
+-
+-// dumpState contains information about the state of a dump operation.
+-type dumpState struct {
+- w io.Writer
+- depth int
+- pointers map[uintptr]int
+- ignoreNextType bool
+- ignoreNextIndent bool
+- cs *ConfigState
+-}
+-
+-// indent performs indentation according to the depth level and cs.Indent
+-// option.
+-func (d *dumpState) indent() {
+- if d.ignoreNextIndent {
+- d.ignoreNextIndent = false
+- return
+- }
+- d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
+-}
+-
+-// unpackValue returns values inside of non-nil interfaces when possible.
+-// This is useful for data types like structs, arrays, slices, and maps which
+-// can contain varying types packed inside an interface.
+-func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
+- if v.Kind() == reflect.Interface && !v.IsNil() {
+- v = v.Elem()
+- }
+- return v
+-}
+-
+-// dumpPtr handles formatting of pointers by indirecting them as necessary.
+-func (d *dumpState) dumpPtr(v reflect.Value) {
+- // Remove pointers at or below the current depth from map used to detect
+- // circular refs.
+- for k, depth := range d.pointers {
+- if depth >= d.depth {
+- delete(d.pointers, k)
+- }
+- }
+-
+- // Keep list of all dereferenced pointers to show later.
+- pointerChain := make([]uintptr, 0)
+-
+- // Figure out how many levels of indirection there are by dereferencing
+- // pointers and unpacking interfaces down the chain while detecting circular
+- // references.
+- nilFound := false
+- cycleFound := false
+- indirects := 0
+- ve := v
+- for ve.Kind() == reflect.Ptr {
+- if ve.IsNil() {
+- nilFound = true
+- break
+- }
+- indirects++
+- addr := ve.Pointer()
+- pointerChain = append(pointerChain, addr)
+- if pd, ok := d.pointers[addr]; ok && pd < d.depth {
+- cycleFound = true
+- indirects--
+- break
+- }
+- d.pointers[addr] = d.depth
+-
+- ve = ve.Elem()
+- if ve.Kind() == reflect.Interface {
+- if ve.IsNil() {
+- nilFound = true
+- break
+- }
+- ve = ve.Elem()
+- }
+- }
+-
+- // Display type information.
+- d.w.Write(openParenBytes)
+- d.w.Write(bytes.Repeat(asteriskBytes, indirects))
+- d.w.Write([]byte(ve.Type().String()))
+- d.w.Write(closeParenBytes)
+-
+- // Display pointer information.
+- if len(pointerChain) > 0 {
+- d.w.Write(openParenBytes)
+- for i, addr := range pointerChain {
+- if i > 0 {
+- d.w.Write(pointerChainBytes)
+- }
+- printHexPtr(d.w, addr)
+- }
+- d.w.Write(closeParenBytes)
+- }
+-
+- // Display dereferenced value.
+- d.w.Write(openParenBytes)
+- switch {
+- case nilFound == true:
+- d.w.Write(nilAngleBytes)
+-
+- case cycleFound == true:
+- d.w.Write(circularBytes)
+-
+- default:
+- d.ignoreNextType = true
+- d.dump(ve)
+- }
+- d.w.Write(closeParenBytes)
+-}
+-
+-// dumpSlice handles formatting of arrays and slices. Byte (uint8 under
+-// reflection) arrays and slices are dumped in hexdump -C fashion.
+-func (d *dumpState) dumpSlice(v reflect.Value) {
+- // Determine whether this type should be hex dumped or not. Also,
+- // for types which should be hexdumped, try to use the underlying data
+- // first, then fall back to trying to convert them to a uint8 slice.
+- var buf []uint8
+- doConvert := false
+- doHexDump := false
+- numEntries := v.Len()
+- if numEntries > 0 {
+- vt := v.Index(0).Type()
+- vts := vt.String()
+- switch {
+- // C types that need to be converted.
+- case cCharRE.MatchString(vts):
+- fallthrough
+- case cUnsignedCharRE.MatchString(vts):
+- fallthrough
+- case cUint8tCharRE.MatchString(vts):
+- doConvert = true
+-
+- // Try to use existing uint8 slices and fall back to converting
+- // and copying if that fails.
+- case vt.Kind() == reflect.Uint8:
+- // We need an addressable interface to convert the type back
+- // into a byte slice. However, the reflect package won't give
+- // us an interface on certain things like unexported struct
+- // fields in order to enforce visibility rules. We use unsafe
+- // to bypass these restrictions since this package does not
+- // mutate the values.
+- vs := v
+- if !vs.CanInterface() || !vs.CanAddr() {
+- vs = unsafeReflectValue(vs)
+- }
+- vs = vs.Slice(0, numEntries)
+-
+- // Use the existing uint8 slice if it can be type
+- // asserted.
+- iface := vs.Interface()
+- if slice, ok := iface.([]uint8); ok {
+- buf = slice
+- doHexDump = true
+- break
+- }
+-
+- // The underlying data needs to be converted if it can't
+- // be type asserted to a uint8 slice.
+- doConvert = true
+- }
+-
+- // Copy and convert the underlying type if needed.
+- if doConvert && vt.ConvertibleTo(uint8Type) {
+- // Convert and copy each element into a uint8 byte
+- // slice.
+- buf = make([]uint8, numEntries)
+- for i := 0; i < numEntries; i++ {
+- vv := v.Index(i)
+- buf[i] = uint8(vv.Convert(uint8Type).Uint())
+- }
+- doHexDump = true
+- }
+- }
+-
+- // Hexdump the entire slice as needed.
+- if doHexDump {
+- indent := strings.Repeat(d.cs.Indent, d.depth)
+- str := indent + hex.Dump(buf)
+- str = strings.Replace(str, "\n", "\n"+indent, -1)
+- str = strings.TrimRight(str, d.cs.Indent)
+- d.w.Write([]byte(str))
+- return
+- }
+-
+- // Recursively call dump for each item.
+- for i := 0; i < numEntries; i++ {
+- d.dump(d.unpackValue(v.Index(i)))
+- if i < (numEntries - 1) {
+- d.w.Write(commaNewlineBytes)
+- } else {
+- d.w.Write(newlineBytes)
+- }
+- }
+-}
+-
+-// dump is the main workhorse for dumping a value. It uses the passed reflect
+-// value to figure out what kind of object we are dealing with and formats it
+-// appropriately. It is a recursive function, however circular data structures
+-// are detected and handled properly.
+-func (d *dumpState) dump(v reflect.Value) {
+- // Handle invalid reflect values immediately.
+- kind := v.Kind()
+- if kind == reflect.Invalid {
+- d.w.Write(invalidAngleBytes)
+- return
+- }
+-
+- // Handle pointers specially.
+- if kind == reflect.Ptr {
+- d.indent()
+- d.dumpPtr(v)
+- return
+- }
+-
+- // Print type information unless already handled elsewhere.
+- if !d.ignoreNextType {
+- d.indent()
+- d.w.Write(openParenBytes)
+- d.w.Write([]byte(v.Type().String()))
+- d.w.Write(closeParenBytes)
+- d.w.Write(spaceBytes)
+- }
+- d.ignoreNextType = false
+-
+- // Display length and capacity if the built-in len and cap functions
+- // work with the value's kind and the len/cap itself is non-zero.
+- valueLen, valueCap := 0, 0
+- switch v.Kind() {
+- case reflect.Array, reflect.Slice, reflect.Chan:
+- valueLen, valueCap = v.Len(), v.Cap()
+- case reflect.Map, reflect.String:
+- valueLen = v.Len()
+- }
+- if valueLen != 0 || valueCap != 0 {
+- d.w.Write(openParenBytes)
+- if valueLen != 0 {
+- d.w.Write(lenEqualsBytes)
+- printInt(d.w, int64(valueLen), 10)
+- }
+- if valueCap != 0 {
+- if valueLen != 0 {
+- d.w.Write(spaceBytes)
+- }
+- d.w.Write(capEqualsBytes)
+- printInt(d.w, int64(valueCap), 10)
+- }
+- d.w.Write(closeParenBytes)
+- d.w.Write(spaceBytes)
+- }
+-
+- // Call Stringer/error interfaces if they exist and the handle methods flag
+- // is enabled
+- if !d.cs.DisableMethods {
+- if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+- if handled := handleMethods(d.cs, d.w, v); handled {
+- return
+- }
+- }
+- }
+-
+- switch kind {
+- case reflect.Invalid:
+- // Do nothing. We should never get here since invalid has already
+- // been handled above.
+-
+- case reflect.Bool:
+- printBool(d.w, v.Bool())
+-
+- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+- printInt(d.w, v.Int(), 10)
+-
+- case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+- printUint(d.w, v.Uint(), 10)
+-
+- case reflect.Float32:
+- printFloat(d.w, v.Float(), 32)
+-
+- case reflect.Float64:
+- printFloat(d.w, v.Float(), 64)
+-
+- case reflect.Complex64:
+- printComplex(d.w, v.Complex(), 32)
+-
+- case reflect.Complex128:
+- printComplex(d.w, v.Complex(), 64)
+-
+- case reflect.Slice:
+- if v.IsNil() {
+- d.w.Write(nilAngleBytes)
+- break
+- }
+- fallthrough
+-
+- case reflect.Array:
+- d.w.Write(openBraceNewlineBytes)
+- d.depth++
+- if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+- d.indent()
+- d.w.Write(maxNewlineBytes)
+- } else {
+- d.dumpSlice(v)
+- }
+- d.depth--
+- d.indent()
+- d.w.Write(closeBraceBytes)
+-
+- case reflect.String:
+- d.w.Write([]byte(strconv.Quote(v.String())))
+-
+- case reflect.Interface:
+- // The only time we should get here is for nil interfaces due to
+- // unpackValue calls.
+- if v.IsNil() {
+- d.w.Write(nilAngleBytes)
+- }
+-
+- case reflect.Ptr:
+- // Do nothing. We should never get here since pointers have already
+- // been handled above.
+-
+- case reflect.Map:
+- d.w.Write(openBraceNewlineBytes)
+- d.depth++
+- if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+- d.indent()
+- d.w.Write(maxNewlineBytes)
+- } else {
+- numEntries := v.Len()
+- keys := v.MapKeys()
+- if d.cs.SortKeys {
+- sortValues(keys)
+- }
+- for i, key := range keys {
+- d.dump(d.unpackValue(key))
+- d.w.Write(colonSpaceBytes)
+- d.ignoreNextIndent = true
+- d.dump(d.unpackValue(v.MapIndex(key)))
+- if i < (numEntries - 1) {
+- d.w.Write(commaNewlineBytes)
+- } else {
+- d.w.Write(newlineBytes)
+- }
+- }
+- }
+- d.depth--
+- d.indent()
+- d.w.Write(closeBraceBytes)
+-
+- case reflect.Struct:
+- d.w.Write(openBraceNewlineBytes)
+- d.depth++
+- if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+- d.indent()
+- d.w.Write(maxNewlineBytes)
+- } else {
+- vt := v.Type()
+- numFields := v.NumField()
+- for i := 0; i < numFields; i++ {
+- d.indent()
+- vtf := vt.Field(i)
+- d.w.Write([]byte(vtf.Name))
+- d.w.Write(colonSpaceBytes)
+- d.ignoreNextIndent = true
+- d.dump(d.unpackValue(v.Field(i)))
+- if i < (numFields - 1) {
+- d.w.Write(commaNewlineBytes)
+- } else {
+- d.w.Write(newlineBytes)
+- }
+- }
+- }
+- d.depth--
+- d.indent()
+- d.w.Write(closeBraceBytes)
+-
+- case reflect.Uintptr:
+- printHexPtr(d.w, uintptr(v.Uint()))
+-
+- case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+- printHexPtr(d.w, v.Pointer())
+-
+- // There were not any other types at the time this code was written, but
+- // fall back to letting the default fmt package handle it in case any new
+- // types are added.
+- default:
+- if v.CanInterface() {
+- fmt.Fprintf(d.w, "%v", v.Interface())
+- } else {
+- fmt.Fprintf(d.w, "%v", v.String())
+- }
+- }
+-}
+-
+-// fdump is a helper function to consolidate the logic from the various public
+-// methods which take varying writers and config states.
+-func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
+- for _, arg := range a {
+- if arg == nil {
+- w.Write(interfaceBytes)
+- w.Write(spaceBytes)
+- w.Write(nilAngleBytes)
+- w.Write(newlineBytes)
+- continue
+- }
+-
+- d := dumpState{w: w, cs: cs}
+- d.pointers = make(map[uintptr]int)
+- d.dump(reflect.ValueOf(arg))
+- d.w.Write(newlineBytes)
+- }
+-}
+-
+-// Fdump formats and displays the passed arguments to io.Writer w. It formats
+-// exactly the same as Dump.
+-func Fdump(w io.Writer, a ...interface{}) {
+- fdump(&Config, w, a...)
+-}
+-
+-// Sdump returns a string with the passed arguments formatted exactly the same
+-// as Dump.
+-func Sdump(a ...interface{}) string {
+- var buf bytes.Buffer
+- fdump(&Config, &buf, a...)
+- return buf.String()
+-}
+-
+-/*
+-Dump displays the passed parameters to standard out with newlines, customizable
+-indentation, and additional debug information such as complete types and all
+-pointer addresses used to indirect to the final value. It provides the
+-following features over the built-in printing facilities provided by the fmt
+-package:
+-
+- * Pointers are dereferenced and followed
+- * Circular data structures are detected and handled properly
+- * Custom Stringer/error interfaces are optionally invoked, including
+- on unexported types
+- * Custom types which only implement the Stringer/error interfaces via
+- a pointer receiver are optionally invoked when passing non-pointer
+- variables
+- * Byte arrays and slices are dumped like the hexdump -C command which
+- includes offsets, byte values in hex, and ASCII output
+-
+-The configuration options are controlled by an exported package global,
+-spew.Config. See ConfigState for options documentation.
+-
+-See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+-get the formatted result as a string.
+-*/
+-func Dump(a ...interface{}) {
+- fdump(&Config, os.Stdout, a...)
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump_test.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump_test.go
+deleted file mode 100644
+index f1a5644..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dump_test.go
++++ /dev/null
+@@ -1,978 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-/*
+-Test Summary:
+-NOTE: For each test, a nil pointer, a single pointer and double pointer to the
+-base test element are also tested to ensure proper indirection across all types.
+-
+-- Max int8, int16, int32, int64, int
+-- Max uint8, uint16, uint32, uint64, uint
+-- Boolean true and false
+-- Standard complex64 and complex128
+-- Array containing standard ints
+-- Array containing type with custom formatter on pointer receiver only
+-- Array containing interfaces
+-- Array containing bytes
+-- Slice containing standard float32 values
+-- Slice containing type with custom formatter on pointer receiver only
+-- Slice containing interfaces
+-- Slice containing bytes
+-- Nil slice
+-- Standard string
+-- Nil interface
+-- Sub-interface
+-- Map with string keys and int vals
+-- Map with custom formatter type on pointer receiver only keys and vals
+-- Map with interface keys and values
+-- Map with nil interface value
+-- Struct with primitives
+-- Struct that contains another struct
+-- Struct that contains custom type with Stringer pointer interface via both
+- exported and unexported fields
+-- Struct that contains embedded struct and field to same struct
+-- Uintptr to 0 (null pointer)
+-- Uintptr address of real variable
+-- Unsafe.Pointer to 0 (null pointer)
+-- Unsafe.Pointer to address of real variable
+-- Nil channel
+-- Standard int channel
+-- Function with no params and no returns
+-- Function with param and no returns
+-- Function with multiple params and multiple returns
+-- Struct that is circular through self referencing
+-- Structs that are circular through cross referencing
+-- Structs that are indirectly circular
+-- Type that panics in its Stringer interface
+-*/
+-
+-package spew_test
+-
+-import (
+- "bytes"
+- "fmt"
+- "github.com/davecgh/go-spew/spew"
+- "testing"
+- "unsafe"
+-)
+-
+-// dumpTest is used to describe a test to be perfomed against the Dump method.
+-type dumpTest struct {
+- in interface{}
+- wants []string
+-}
+-
+-// dumpTests houses all of the tests to be performed against the Dump method.
+-var dumpTests = make([]dumpTest, 0)
+-
+-// addDumpTest is a helper method to append the passed input and desired result
+-// to dumpTests
+-func addDumpTest(in interface{}, wants ...string) {
+- test := dumpTest{in, wants}
+- dumpTests = append(dumpTests, test)
+-}
+-
+-func addIntDumpTests() {
+- // Max int8.
+- v := int8(127)
+- nv := (*int8)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "int8"
+- vs := "127"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Max int16.
+- v2 := int16(32767)
+- nv2 := (*int16)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "int16"
+- v2s := "32767"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+-
+- // Max int32.
+- v3 := int32(2147483647)
+- nv3 := (*int32)(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "int32"
+- v3s := "2147483647"
+- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+-
+- // Max int64.
+- v4 := int64(9223372036854775807)
+- nv4 := (*int64)(nil)
+- pv4 := &v4
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "int64"
+- v4s := "9223372036854775807"
+- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+-
+- // Max int.
+- v5 := int(2147483647)
+- nv5 := (*int)(nil)
+- pv5 := &v5
+- v5Addr := fmt.Sprintf("%p", pv5)
+- pv5Addr := fmt.Sprintf("%p", &pv5)
+- v5t := "int"
+- v5s := "2147483647"
+- addDumpTest(v5, "("+v5t+") "+v5s+"\n")
+- addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
+- addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
+- addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
+-}
+-
+-func addUintDumpTests() {
+- // Max uint8.
+- v := uint8(255)
+- nv := (*uint8)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "uint8"
+- vs := "255"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Max uint16.
+- v2 := uint16(65535)
+- nv2 := (*uint16)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "uint16"
+- v2s := "65535"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+-
+- // Max uint32.
+- v3 := uint32(4294967295)
+- nv3 := (*uint32)(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "uint32"
+- v3s := "4294967295"
+- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+-
+- // Max uint64.
+- v4 := uint64(18446744073709551615)
+- nv4 := (*uint64)(nil)
+- pv4 := &v4
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "uint64"
+- v4s := "18446744073709551615"
+- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+-
+- // Max uint.
+- v5 := uint(4294967295)
+- nv5 := (*uint)(nil)
+- pv5 := &v5
+- v5Addr := fmt.Sprintf("%p", pv5)
+- pv5Addr := fmt.Sprintf("%p", &pv5)
+- v5t := "uint"
+- v5s := "4294967295"
+- addDumpTest(v5, "("+v5t+") "+v5s+"\n")
+- addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
+- addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
+- addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
+-}
+-
+-func addBoolDumpTests() {
+- // Boolean true.
+- v := bool(true)
+- nv := (*bool)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "bool"
+- vs := "true"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Boolean false.
+- v2 := bool(false)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "bool"
+- v2s := "false"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+-}
+-
+-func addFloatDumpTests() {
+- // Standard float32.
+- v := float32(3.1415)
+- nv := (*float32)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "float32"
+- vs := "3.1415"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Standard float64.
+- v2 := float64(3.1415926)
+- nv2 := (*float64)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "float64"
+- v2s := "3.1415926"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+-}
+-
+-func addComplexDumpTests() {
+- // Standard complex64.
+- v := complex(float32(6), -2)
+- nv := (*complex64)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "complex64"
+- vs := "(6-2i)"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Standard complex128.
+- v2 := complex(float64(-6), 2)
+- nv2 := (*complex128)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "complex128"
+- v2s := "(-6+2i)"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+-}
+-
+-func addArrayDumpTests() {
+- // Array containing standard ints.
+- v := [3]int{1, 2, 3}
+- vLen := fmt.Sprintf("%d", len(v))
+- vCap := fmt.Sprintf("%d", cap(v))
+- nv := (*[3]int)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "int"
+- vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 1,\n (" +
+- vt + ") 2,\n (" + vt + ") 3\n}"
+- addDumpTest(v, "([3]"+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*[3]"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**[3]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*[3]"+vt+")(<nil>)\n")
+-
+- // Array containing type with custom formatter on pointer receiver only.
+- v2i0 := pstringer("1")
+- v2i1 := pstringer("2")
+- v2i2 := pstringer("3")
+- v2 := [3]pstringer{v2i0, v2i1, v2i2}
+- v2i0Len := fmt.Sprintf("%d", len(v2i0))
+- v2i1Len := fmt.Sprintf("%d", len(v2i1))
+- v2i2Len := fmt.Sprintf("%d", len(v2i2))
+- v2Len := fmt.Sprintf("%d", len(v2))
+- v2Cap := fmt.Sprintf("%d", cap(v2))
+- nv2 := (*[3]pstringer)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "spew_test.pstringer"
+- v2s := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t + ") (len=" +
+- v2i0Len + ") stringer 1,\n (" + v2t + ") (len=" + v2i1Len +
+- ") stringer 2,\n (" + v2t + ") (len=" + v2i2Len + ") " +
+- "stringer 3\n}"
+- addDumpTest(v2, "([3]"+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*[3]"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**[3]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*[3]"+v2t+")(<nil>)\n")
+-
+- // Array containing interfaces.
+- v3i0 := "one"
+- v3 := [3]interface{}{v3i0, int(2), uint(3)}
+- v3i0Len := fmt.Sprintf("%d", len(v3i0))
+- v3Len := fmt.Sprintf("%d", len(v3))
+- v3Cap := fmt.Sprintf("%d", cap(v3))
+- nv3 := (*[3]interface{})(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "[3]interface {}"
+- v3t2 := "string"
+- v3t3 := "int"
+- v3t4 := "uint"
+- v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
+- "(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
+- v3t4 + ") 3\n}"
+- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+-
+- // Array containing bytes.
+- v4 := [34]byte{
+- 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+- 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+- 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+- 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
+- 0x31, 0x32,
+- }
+- v4Len := fmt.Sprintf("%d", len(v4))
+- v4Cap := fmt.Sprintf("%d", cap(v4))
+- nv4 := (*[34]byte)(nil)
+- pv4 := &v4
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "[34]uint8"
+- v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
+- "{\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20" +
+- " |............... |\n" +
+- " 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30" +
+- " |!\"#$%&'()*+,-./0|\n" +
+- " 00000020 31 32 " +
+- " |12|\n}"
+- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+-}
+-
+-func addSliceDumpTests() {
+- // Slice containing standard float32 values.
+- v := []float32{3.14, 6.28, 12.56}
+- vLen := fmt.Sprintf("%d", len(v))
+- vCap := fmt.Sprintf("%d", cap(v))
+- nv := (*[]float32)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "float32"
+- vs := "(len=" + vLen + " cap=" + vCap + ") {\n (" + vt + ") 3.14,\n (" +
+- vt + ") 6.28,\n (" + vt + ") 12.56\n}"
+- addDumpTest(v, "([]"+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*[]"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**[]"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*[]"+vt+")(<nil>)\n")
+-
+- // Slice containing type with custom formatter on pointer receiver only.
+- v2i0 := pstringer("1")
+- v2i1 := pstringer("2")
+- v2i2 := pstringer("3")
+- v2 := []pstringer{v2i0, v2i1, v2i2}
+- v2i0Len := fmt.Sprintf("%d", len(v2i0))
+- v2i1Len := fmt.Sprintf("%d", len(v2i1))
+- v2i2Len := fmt.Sprintf("%d", len(v2i2))
+- v2Len := fmt.Sprintf("%d", len(v2))
+- v2Cap := fmt.Sprintf("%d", cap(v2))
+- nv2 := (*[]pstringer)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "spew_test.pstringer"
+- v2s := "(len=" + v2Len + " cap=" + v2Cap + ") {\n (" + v2t + ") (len=" +
+- v2i0Len + ") stringer 1,\n (" + v2t + ") (len=" + v2i1Len +
+- ") stringer 2,\n (" + v2t + ") (len=" + v2i2Len + ") " +
+- "stringer 3\n}"
+- addDumpTest(v2, "([]"+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*[]"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**[]"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*[]"+v2t+")(<nil>)\n")
+-
+- // Slice containing interfaces.
+- v3i0 := "one"
+- v3 := []interface{}{v3i0, int(2), uint(3), nil}
+- v3i0Len := fmt.Sprintf("%d", len(v3i0))
+- v3Len := fmt.Sprintf("%d", len(v3))
+- v3Cap := fmt.Sprintf("%d", cap(v3))
+- nv3 := (*[]interface{})(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "[]interface {}"
+- v3t2 := "string"
+- v3t3 := "int"
+- v3t4 := "uint"
+- v3t5 := "interface {}"
+- v3s := "(len=" + v3Len + " cap=" + v3Cap + ") {\n (" + v3t2 + ") " +
+- "(len=" + v3i0Len + ") \"one\",\n (" + v3t3 + ") 2,\n (" +
+- v3t4 + ") 3,\n (" + v3t5 + ") <nil>\n}"
+- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+-
+- // Slice containing bytes.
+- v4 := []byte{
+- 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+- 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+- 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+- 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
+- 0x31, 0x32,
+- }
+- v4Len := fmt.Sprintf("%d", len(v4))
+- v4Cap := fmt.Sprintf("%d", cap(v4))
+- nv4 := (*[]byte)(nil)
+- pv4 := &v4
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "[]uint8"
+- v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
+- "{\n 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20" +
+- " |............... |\n" +
+- " 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30" +
+- " |!\"#$%&'()*+,-./0|\n" +
+- " 00000020 31 32 " +
+- " |12|\n}"
+- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+-
+- // Nil slice.
+- v5 := []int(nil)
+- nv5 := (*[]int)(nil)
+- pv5 := &v5
+- v5Addr := fmt.Sprintf("%p", pv5)
+- pv5Addr := fmt.Sprintf("%p", &pv5)
+- v5t := "[]int"
+- v5s := "<nil>"
+- addDumpTest(v5, "("+v5t+") "+v5s+"\n")
+- addDumpTest(pv5, "(*"+v5t+")("+v5Addr+")("+v5s+")\n")
+- addDumpTest(&pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")("+v5s+")\n")
+- addDumpTest(nv5, "(*"+v5t+")(<nil>)\n")
+-}
+-
+-func addStringDumpTests() {
+- // Standard string.
+- v := "test"
+- vLen := fmt.Sprintf("%d", len(v))
+- nv := (*string)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "string"
+- vs := "(len=" + vLen + ") \"test\""
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-}
+-
+-func addInterfaceDumpTests() {
+- // Nil interface.
+- var v interface{}
+- nv := (*interface{})(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "interface {}"
+- vs := "<nil>"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Sub-interface.
+- v2 := interface{}(uint16(65535))
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "uint16"
+- v2s := "65535"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+-}
+-
+-func addMapDumpTests() {
+- // Map with string keys and int vals.
+- k := "one"
+- kk := "two"
+- m := map[string]int{k: 1, kk: 2}
+- klen := fmt.Sprintf("%d", len(k)) // not kLen to shut golint up
+- kkLen := fmt.Sprintf("%d", len(kk))
+- mLen := fmt.Sprintf("%d", len(m))
+- nm := (*map[string]int)(nil)
+- pm := &m
+- mAddr := fmt.Sprintf("%p", pm)
+- pmAddr := fmt.Sprintf("%p", &pm)
+- mt := "map[string]int"
+- mt1 := "string"
+- mt2 := "int"
+- ms := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + klen + ") " +
+- "\"one\": (" + mt2 + ") 1,\n (" + mt1 + ") (len=" + kkLen +
+- ") \"two\": (" + mt2 + ") 2\n}"
+- ms2 := "(len=" + mLen + ") {\n (" + mt1 + ") (len=" + kkLen + ") " +
+- "\"two\": (" + mt2 + ") 2,\n (" + mt1 + ") (len=" + klen +
+- ") \"one\": (" + mt2 + ") 1\n}"
+- addDumpTest(m, "("+mt+") "+ms+"\n", "("+mt+") "+ms2+"\n")
+- addDumpTest(pm, "(*"+mt+")("+mAddr+")("+ms+")\n",
+- "(*"+mt+")("+mAddr+")("+ms2+")\n")
+- addDumpTest(&pm, "(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms+")\n",
+- "(**"+mt+")("+pmAddr+"->"+mAddr+")("+ms2+")\n")
+- addDumpTest(nm, "(*"+mt+")(<nil>)\n")
+-
+- // Map with custom formatter type on pointer receiver only keys and vals.
+- k2 := pstringer("one")
+- v2 := pstringer("1")
+- m2 := map[pstringer]pstringer{k2: v2}
+- k2Len := fmt.Sprintf("%d", len(k2))
+- v2Len := fmt.Sprintf("%d", len(v2))
+- m2Len := fmt.Sprintf("%d", len(m2))
+- nm2 := (*map[pstringer]pstringer)(nil)
+- pm2 := &m2
+- m2Addr := fmt.Sprintf("%p", pm2)
+- pm2Addr := fmt.Sprintf("%p", &pm2)
+- m2t := "map[spew_test.pstringer]spew_test.pstringer"
+- m2t1 := "spew_test.pstringer"
+- m2t2 := "spew_test.pstringer"
+- m2s := "(len=" + m2Len + ") {\n (" + m2t1 + ") (len=" + k2Len + ") " +
+- "stringer one: (" + m2t2 + ") (len=" + v2Len + ") stringer 1\n}"
+- addDumpTest(m2, "("+m2t+") "+m2s+"\n")
+- addDumpTest(pm2, "(*"+m2t+")("+m2Addr+")("+m2s+")\n")
+- addDumpTest(&pm2, "(**"+m2t+")("+pm2Addr+"->"+m2Addr+")("+m2s+")\n")
+- addDumpTest(nm2, "(*"+m2t+")(<nil>)\n")
+-
+- // Map with interface keys and values.
+- k3 := "one"
+- k3Len := fmt.Sprintf("%d", len(k3))
+- m3 := map[interface{}]interface{}{k3: 1}
+- m3Len := fmt.Sprintf("%d", len(m3))
+- nm3 := (*map[interface{}]interface{})(nil)
+- pm3 := &m3
+- m3Addr := fmt.Sprintf("%p", pm3)
+- pm3Addr := fmt.Sprintf("%p", &pm3)
+- m3t := "map[interface {}]interface {}"
+- m3t1 := "string"
+- m3t2 := "int"
+- m3s := "(len=" + m3Len + ") {\n (" + m3t1 + ") (len=" + k3Len + ") " +
+- "\"one\": (" + m3t2 + ") 1\n}"
+- addDumpTest(m3, "("+m3t+") "+m3s+"\n")
+- addDumpTest(pm3, "(*"+m3t+")("+m3Addr+")("+m3s+")\n")
+- addDumpTest(&pm3, "(**"+m3t+")("+pm3Addr+"->"+m3Addr+")("+m3s+")\n")
+- addDumpTest(nm3, "(*"+m3t+")(<nil>)\n")
+-
+- // Map with nil interface value.
+- k4 := "nil"
+- k4Len := fmt.Sprintf("%d", len(k4))
+- m4 := map[string]interface{}{k4: nil}
+- m4Len := fmt.Sprintf("%d", len(m4))
+- nm4 := (*map[string]interface{})(nil)
+- pm4 := &m4
+- m4Addr := fmt.Sprintf("%p", pm4)
+- pm4Addr := fmt.Sprintf("%p", &pm4)
+- m4t := "map[string]interface {}"
+- m4t1 := "string"
+- m4t2 := "interface {}"
+- m4s := "(len=" + m4Len + ") {\n (" + m4t1 + ") (len=" + k4Len + ")" +
+- " \"nil\": (" + m4t2 + ") <nil>\n}"
+- addDumpTest(m4, "("+m4t+") "+m4s+"\n")
+- addDumpTest(pm4, "(*"+m4t+")("+m4Addr+")("+m4s+")\n")
+- addDumpTest(&pm4, "(**"+m4t+")("+pm4Addr+"->"+m4Addr+")("+m4s+")\n")
+- addDumpTest(nm4, "(*"+m4t+")(<nil>)\n")
+-}
+-
+-func addStructDumpTests() {
+- // Struct with primitives.
+- type s1 struct {
+- a int8
+- b uint8
+- }
+- v := s1{127, 255}
+- nv := (*s1)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "spew_test.s1"
+- vt2 := "int8"
+- vt3 := "uint8"
+- vs := "{\n a: (" + vt2 + ") 127,\n b: (" + vt3 + ") 255\n}"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Struct that contains another struct.
+- type s2 struct {
+- s1 s1
+- b bool
+- }
+- v2 := s2{s1{127, 255}, true}
+- nv2 := (*s2)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "spew_test.s2"
+- v2t2 := "spew_test.s1"
+- v2t3 := "int8"
+- v2t4 := "uint8"
+- v2t5 := "bool"
+- v2s := "{\n s1: (" + v2t2 + ") {\n a: (" + v2t3 + ") 127,\n b: (" +
+- v2t4 + ") 255\n },\n b: (" + v2t5 + ") true\n}"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+-
+- // Struct that contains custom type with Stringer pointer interface via both
+- // exported and unexported fields.
+- type s3 struct {
+- s pstringer
+- S pstringer
+- }
+- v3 := s3{"test", "test2"}
+- nv3 := (*s3)(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "spew_test.s3"
+- v3t2 := "spew_test.pstringer"
+- v3s := "{\n s: (" + v3t2 + ") (len=4) stringer test,\n S: (" + v3t2 +
+- ") (len=5) stringer test2\n}"
+- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+-
+- // Struct that contains embedded struct and field to same struct.
+- e := embed{"embedstr"}
+- eLen := fmt.Sprintf("%d", len("embedstr"))
+- v4 := embedwrap{embed: &e, e: &e}
+- nv4 := (*embedwrap)(nil)
+- pv4 := &v4
+- eAddr := fmt.Sprintf("%p", &e)
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "spew_test.embedwrap"
+- v4t2 := "spew_test.embed"
+- v4t3 := "string"
+- v4s := "{\n embed: (*" + v4t2 + ")(" + eAddr + ")({\n a: (" + v4t3 +
+- ") (len=" + eLen + ") \"embedstr\"\n }),\n e: (*" + v4t2 +
+- ")(" + eAddr + ")({\n a: (" + v4t3 + ") (len=" + eLen + ")" +
+- " \"embedstr\"\n })\n}"
+- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+- addDumpTest(pv4, "(*"+v4t+")("+v4Addr+")("+v4s+")\n")
+- addDumpTest(&pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")("+v4s+")\n")
+- addDumpTest(nv4, "(*"+v4t+")(<nil>)\n")
+-}
+-
+-func addUintptrDumpTests() {
+- // Null pointer.
+- v := uintptr(0)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "uintptr"
+- vs := "<nil>"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+-
+- // Address of real variable.
+- i := 1
+- v2 := uintptr(unsafe.Pointer(&i))
+- nv2 := (*uintptr)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "uintptr"
+- v2s := fmt.Sprintf("%p", &i)
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+-}
+-
+-func addUnsafePointerDumpTests() {
+- // Null pointer.
+- v := unsafe.Pointer(uintptr(0))
+- nv := (*unsafe.Pointer)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "unsafe.Pointer"
+- vs := "<nil>"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Address of real variable.
+- i := 1
+- v2 := unsafe.Pointer(&i)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "unsafe.Pointer"
+- v2s := fmt.Sprintf("%p", &i)
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-}
+-
+-func addChanDumpTests() {
+- // Nil channel.
+- var v chan int
+- pv := &v
+- nv := (*chan int)(nil)
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "chan int"
+- vs := "<nil>"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Real channel.
+- v2 := make(chan int)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "chan int"
+- v2s := fmt.Sprintf("%p", v2)
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+-}
+-
+-func addFuncDumpTests() {
+- // Function with no params and no returns.
+- v := addIntDumpTests
+- nv := (*func())(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "func()"
+- vs := fmt.Sprintf("%p", v)
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-
+- // Function with param and no returns.
+- v2 := TestDump
+- nv2 := (*func(*testing.T))(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "func(*testing.T)"
+- v2s := fmt.Sprintf("%p", v2)
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s+")\n")
+- addDumpTest(nv2, "(*"+v2t+")(<nil>)\n")
+-
+- // Function with multiple params and multiple returns.
+- var v3 = func(i int, s string) (b bool, err error) {
+- return true, nil
+- }
+- nv3 := (*func(int, string) (bool, error))(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "func(int, string) (bool, error)"
+- v3s := fmt.Sprintf("%p", v3)
+- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s+")\n")
+- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s+")\n")
+- addDumpTest(nv3, "(*"+v3t+")(<nil>)\n")
+-}
+-
+-func addCircularDumpTests() {
+- // Struct that is circular through self referencing.
+- type circular struct {
+- c *circular
+- }
+- v := circular{nil}
+- v.c = &v
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "spew_test.circular"
+- vs := "{\n c: (*" + vt + ")(" + vAddr + ")({\n c: (*" + vt + ")(" +
+- vAddr + ")(<already shown>)\n })\n}"
+- vs2 := "{\n c: (*" + vt + ")(" + vAddr + ")(<already shown>)\n}"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs2+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs2+")\n")
+-
+- // Structs that are circular through cross referencing.
+- v2 := xref1{nil}
+- ts2 := xref2{&v2}
+- v2.ps2 = &ts2
+- pv2 := &v2
+- ts2Addr := fmt.Sprintf("%p", &ts2)
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "spew_test.xref1"
+- v2t2 := "spew_test.xref2"
+- v2s := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n ps1: (*" + v2t +
+- ")(" + v2Addr + ")({\n ps2: (*" + v2t2 + ")(" + ts2Addr +
+- ")(<already shown>)\n })\n })\n}"
+- v2s2 := "{\n ps2: (*" + v2t2 + ")(" + ts2Addr + ")({\n ps1: (*" + v2t +
+- ")(" + v2Addr + ")(<already shown>)\n })\n}"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+- addDumpTest(pv2, "(*"+v2t+")("+v2Addr+")("+v2s2+")\n")
+- addDumpTest(&pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")("+v2s2+")\n")
+-
+- // Structs that are indirectly circular.
+- v3 := indirCir1{nil}
+- tic2 := indirCir2{nil}
+- tic3 := indirCir3{&v3}
+- tic2.ps3 = &tic3
+- v3.ps2 = &tic2
+- pv3 := &v3
+- tic2Addr := fmt.Sprintf("%p", &tic2)
+- tic3Addr := fmt.Sprintf("%p", &tic3)
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "spew_test.indirCir1"
+- v3t2 := "spew_test.indirCir2"
+- v3t3 := "spew_test.indirCir3"
+- v3s := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n ps3: (*" + v3t3 +
+- ")(" + tic3Addr + ")({\n ps1: (*" + v3t + ")(" + v3Addr +
+- ")({\n ps2: (*" + v3t2 + ")(" + tic2Addr +
+- ")(<already shown>)\n })\n })\n })\n}"
+- v3s2 := "{\n ps2: (*" + v3t2 + ")(" + tic2Addr + ")({\n ps3: (*" + v3t3 +
+- ")(" + tic3Addr + ")({\n ps1: (*" + v3t + ")(" + v3Addr +
+- ")(<already shown>)\n })\n })\n}"
+- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+- addDumpTest(pv3, "(*"+v3t+")("+v3Addr+")("+v3s2+")\n")
+- addDumpTest(&pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")("+v3s2+")\n")
+-}
+-
+-func addPanicDumpTests() {
+- // Type that panics in its Stringer interface.
+- v := panicer(127)
+- nv := (*panicer)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "spew_test.panicer"
+- vs := "(PANIC=test panic)127"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-}
+-
+-func addErrorDumpTests() {
+- // Type that has a custom Error interface.
+- v := customError(127)
+- nv := (*customError)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "spew_test.customError"
+- vs := "error: 127"
+- addDumpTest(v, "("+vt+") "+vs+"\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")("+vs+")\n")
+- addDumpTest(nv, "(*"+vt+")(<nil>)\n")
+-}
+-
+-// TestDump executes all of the tests described by dumpTests.
+-func TestDump(t *testing.T) {
+- // Setup tests.
+- addIntDumpTests()
+- addUintDumpTests()
+- addBoolDumpTests()
+- addFloatDumpTests()
+- addComplexDumpTests()
+- addArrayDumpTests()
+- addSliceDumpTests()
+- addStringDumpTests()
+- addInterfaceDumpTests()
+- addMapDumpTests()
+- addStructDumpTests()
+- addUintptrDumpTests()
+- addUnsafePointerDumpTests()
+- addChanDumpTests()
+- addFuncDumpTests()
+- addCircularDumpTests()
+- addPanicDumpTests()
+- addErrorDumpTests()
+- addCgoDumpTests()
+-
+- t.Logf("Running %d tests", len(dumpTests))
+- for i, test := range dumpTests {
+- buf := new(bytes.Buffer)
+- spew.Fdump(buf, test.in)
+- s := buf.String()
+- if testFailed(s, test.wants) {
+- t.Errorf("Dump #%d\n got: %s %s", i, s, stringizeWants(test.wants))
+- continue
+- }
+- }
+-}
+-
+-func TestDumpSortedKeys(t *testing.T) {
+- cfg := spew.ConfigState{SortKeys: true}
+- s := cfg.Sdump(map[int]string{1: "1", 3: "3", 2: "2"})
+- expected := `(map[int]string) (len=3) {
+-(int) 1: (string) (len=1) "1",
+-(int) 2: (string) (len=1) "2",
+-(int) 3: (string) (len=1) "3"
+-}
+-`
+- if s != expected {
+- t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
+- }
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpcgo_test.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpcgo_test.go
+deleted file mode 100644
+index 9b8a358..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpcgo_test.go
++++ /dev/null
+@@ -1,97 +0,0 @@
+-// Copyright (c) 2013 Dave Collins <dave at davec.name>
+-//
+-// Permission to use, copy, modify, and distribute this software for any
+-// purpose with or without fee is hereby granted, provided that the above
+-// copyright notice and this permission notice appear in all copies.
+-//
+-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+-
+-// NOTE: Due to the following build constraints, this file will only be compiled
+-// when both cgo is supported and "-tags testcgo" is added to the go test
+-// command line. This means the cgo tests are only added (and hence run) when
+-// specifially requested. This configuration is used because spew itself
+-// does not require cgo to run even though it does handle certain cgo types
+-// specially. Rather than forcing all clients to require cgo and an external
+-// C compiler just to run the tests, this scheme makes them optional.
+-// +build cgo,testcgo
+-
+-package spew_test
+-
+-import (
+- "fmt"
+- "github.com/davecgh/go-spew/spew/testdata"
+-)
+-
+-func addCgoDumpTests() {
+- // C char pointer.
+- v := testdata.GetCgoCharPointer()
+- nv := testdata.GetCgoNullCharPointer()
+- pv := &v
+- vcAddr := fmt.Sprintf("%p", v)
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "*testdata._Ctype_char"
+- vs := "116"
+- addDumpTest(v, "("+vt+")("+vcAddr+")("+vs+")\n")
+- addDumpTest(pv, "(*"+vt+")("+vAddr+"->"+vcAddr+")("+vs+")\n")
+- addDumpTest(&pv, "(**"+vt+")("+pvAddr+"->"+vAddr+"->"+vcAddr+")("+vs+")\n")
+- addDumpTest(nv, "("+vt+")(<nil>)\n")
+-
+- // C char array.
+- v2, v2l, v2c := testdata.GetCgoCharArray()
+- v2Len := fmt.Sprintf("%d", v2l)
+- v2Cap := fmt.Sprintf("%d", v2c)
+- v2t := "[6]testdata._Ctype_char"
+- v2s := "(len=" + v2Len + " cap=" + v2Cap + ") " +
+- "{\n 00000000 74 65 73 74 32 00 " +
+- " |test2.|\n}"
+- addDumpTest(v2, "("+v2t+") "+v2s+"\n")
+-
+- // C unsigned char array.
+- v3, v3l, v3c := testdata.GetCgoUnsignedCharArray()
+- v3Len := fmt.Sprintf("%d", v3l)
+- v3Cap := fmt.Sprintf("%d", v3c)
+- v3t := "[6]testdata._Ctype_unsignedchar"
+- v3s := "(len=" + v3Len + " cap=" + v3Cap + ") " +
+- "{\n 00000000 74 65 73 74 33 00 " +
+- " |test3.|\n}"
+- addDumpTest(v3, "("+v3t+") "+v3s+"\n")
+-
+- // C signed char array.
+- v4, v4l, v4c := testdata.GetCgoSignedCharArray()
+- v4Len := fmt.Sprintf("%d", v4l)
+- v4Cap := fmt.Sprintf("%d", v4c)
+- v4t := "[6]testdata._Ctype_schar"
+- v4t2 := "testdata._Ctype_schar"
+- v4s := "(len=" + v4Len + " cap=" + v4Cap + ") " +
+- "{\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 101,\n (" + v4t2 +
+- ") 115,\n (" + v4t2 + ") 116,\n (" + v4t2 + ") 52,\n (" + v4t2 +
+- ") 0\n}"
+- addDumpTest(v4, "("+v4t+") "+v4s+"\n")
+-
+- // C uint8_t array.
+- v5, v5l, v5c := testdata.GetCgoUint8tArray()
+- v5Len := fmt.Sprintf("%d", v5l)
+- v5Cap := fmt.Sprintf("%d", v5c)
+- v5t := "[6]testdata._Ctype_uint8_t"
+- v5s := "(len=" + v5Len + " cap=" + v5Cap + ") " +
+- "{\n 00000000 74 65 73 74 35 00 " +
+- " |test5.|\n}"
+- addDumpTest(v5, "("+v5t+") "+v5s+"\n")
+-
+- // C typedefed unsigned char array.
+- v6, v6l, v6c := testdata.GetCgoTypdefedUnsignedCharArray()
+- v6Len := fmt.Sprintf("%d", v6l)
+- v6Cap := fmt.Sprintf("%d", v6c)
+- v6t := "[6]testdata._Ctype_custom_uchar_t"
+- v6s := "(len=" + v6Len + " cap=" + v6Cap + ") " +
+- "{\n 00000000 74 65 73 74 36 00 " +
+- " |test6.|\n}"
+- addDumpTest(v6, "("+v6t+") "+v6s+"\n")
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpnocgo_test.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpnocgo_test.go
+deleted file mode 100644
+index 52a0971..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/dumpnocgo_test.go
++++ /dev/null
+@@ -1,26 +0,0 @@
+-// Copyright (c) 2013 Dave Collins <dave at davec.name>
+-//
+-// Permission to use, copy, modify, and distribute this software for any
+-// purpose with or without fee is hereby granted, provided that the above
+-// copyright notice and this permission notice appear in all copies.
+-//
+-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+-
+-// NOTE: Due to the following build constraints, this file will only be compiled
+-// when either cgo is not supported or "-tags testcgo" is not added to the go
+-// test command line. This file intentionally does not setup any cgo tests in
+-// this scenario.
+-// +build !cgo !testcgo
+-
+-package spew_test
+-
+-func addCgoDumpTests() {
+- // Don't add any tests for cgo since this file is only compiled when
+- // there should not be any cgo tests.
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/example_test.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/example_test.go
+deleted file mode 100644
+index a7acd14..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/example_test.go
++++ /dev/null
+@@ -1,230 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-package spew_test
+-
+-import (
+- "fmt"
+- "github.com/davecgh/go-spew/spew"
+-)
+-
+-type Flag int
+-
+-const (
+- flagOne Flag = iota
+- flagTwo
+-)
+-
+-var flagStrings = map[Flag]string{
+- flagOne: "flagOne",
+- flagTwo: "flagTwo",
+-}
+-
+-func (f Flag) String() string {
+- if s, ok := flagStrings[f]; ok {
+- return s
+- }
+- return fmt.Sprintf("Unknown flag (%d)", int(f))
+-}
+-
+-type Bar struct {
+- flag Flag
+- data uintptr
+-}
+-
+-type Foo struct {
+- unexportedField Bar
+- ExportedField map[interface{}]interface{}
+-}
+-
+-// This example demonstrates how to use Dump to dump variables to stdout.
+-func ExampleDump() {
+- // The following package level declarations are assumed for this example:
+- /*
+- type Flag int
+-
+- const (
+- flagOne Flag = iota
+- flagTwo
+- )
+-
+- var flagStrings = map[Flag]string{
+- flagOne: "flagOne",
+- flagTwo: "flagTwo",
+- }
+-
+- func (f Flag) String() string {
+- if s, ok := flagStrings[f]; ok {
+- return s
+- }
+- return fmt.Sprintf("Unknown flag (%d)", int(f))
+- }
+-
+- type Bar struct {
+- flag Flag
+- data uintptr
+- }
+-
+- type Foo struct {
+- unexportedField Bar
+- ExportedField map[interface{}]interface{}
+- }
+- */
+-
+- // Setup some sample data structures for the example.
+- bar := Bar{Flag(flagTwo), uintptr(0)}
+- s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
+- f := Flag(5)
+- b := []byte{
+- 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+- 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+- 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
+- 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
+- 0x31, 0x32,
+- }
+-
+- // Dump!
+- spew.Dump(s1, f, b)
+-
+- // Output:
+- // (spew_test.Foo) {
+- // unexportedField: (spew_test.Bar) {
+- // flag: (spew_test.Flag) flagTwo,
+- // data: (uintptr) <nil>
+- // },
+- // ExportedField: (map[interface {}]interface {}) (len=1) {
+- // (string) (len=3) "one": (bool) true
+- // }
+- // }
+- // (spew_test.Flag) Unknown flag (5)
+- // ([]uint8) (len=34 cap=34) {
+- // 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
+- // 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
+- // 00000020 31 32 |12|
+- // }
+- //
+-}
+-
+-// This example demonstrates how to use Printf to display a variable with a
+-// format string and inline formatting.
+-func ExamplePrintf() {
+- // Create a double pointer to a uint 8.
+- ui8 := uint8(5)
+- pui8 := &ui8
+- ppui8 := &pui8
+-
+- // Create a circular data type.
+- type circular struct {
+- ui8 uint8
+- c *circular
+- }
+- c := circular{ui8: 1}
+- c.c = &c
+-
+- // Print!
+- spew.Printf("ppui8: %v\n", ppui8)
+- spew.Printf("circular: %v\n", c)
+-
+- // Output:
+- // ppui8: <**>5
+- // circular: {1 <*>{1 <*><shown>}}
+-}
+-
+-// This example demonstrates how to use a ConfigState.
+-func ExampleConfigState() {
+- // Modify the indent level of the ConfigState only. The global
+- // configuration is not modified.
+- scs := spew.ConfigState{Indent: "\t"}
+-
+- // Output using the ConfigState instance.
+- v := map[string]int{"one": 1}
+- scs.Printf("v: %v\n", v)
+- scs.Dump(v)
+-
+- // Output:
+- // v: map[one:1]
+- // (map[string]int) (len=1) {
+- // (string) (len=3) "one": (int) 1
+- // }
+-}
+-
+-// This example demonstrates how to use ConfigState.Dump to dump variables to
+-// stdout
+-func ExampleConfigState_Dump() {
+- // See the top-level Dump example for details on the types used in this
+- // example.
+-
+- // Create two ConfigState instances with different indentation.
+- scs := spew.ConfigState{Indent: "\t"}
+- scs2 := spew.ConfigState{Indent: " "}
+-
+- // Setup some sample data structures for the example.
+- bar := Bar{Flag(flagTwo), uintptr(0)}
+- s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
+-
+- // Dump using the ConfigState instances.
+- scs.Dump(s1)
+- scs2.Dump(s1)
+-
+- // Output:
+- // (spew_test.Foo) {
+- // unexportedField: (spew_test.Bar) {
+- // flag: (spew_test.Flag) flagTwo,
+- // data: (uintptr) <nil>
+- // },
+- // ExportedField: (map[interface {}]interface {}) (len=1) {
+- // (string) (len=3) "one": (bool) true
+- // }
+- // }
+- // (spew_test.Foo) {
+- // unexportedField: (spew_test.Bar) {
+- // flag: (spew_test.Flag) flagTwo,
+- // data: (uintptr) <nil>
+- // },
+- // ExportedField: (map[interface {}]interface {}) (len=1) {
+- // (string) (len=3) "one": (bool) true
+- // }
+- // }
+- //
+-}
+-
+-// This example demonstrates how to use ConfigState.Printf to display a variable
+-// with a format string and inline formatting.
+-func ExampleConfigState_Printf() {
+- // See the top-level Dump example for details on the types used in this
+- // example.
+-
+- // Create two ConfigState instances and modify the method handling of the
+- // first ConfigState only.
+- scs := spew.NewDefaultConfig()
+- scs2 := spew.NewDefaultConfig()
+- scs.DisableMethods = true
+-
+- // Alternatively
+- // scs := spew.ConfigState{Indent: " ", DisableMethods: true}
+- // scs2 := spew.ConfigState{Indent: " "}
+-
+- // This is of type Flag which implements a Stringer and has raw value 1.
+- f := flagTwo
+-
+- // Dump using the ConfigState instances.
+- scs.Printf("f: %v\n", f)
+- scs2.Printf("f: %v\n", f)
+-
+- // Output:
+- // f: 1
+- // f: flagTwo
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format.go
+deleted file mode 100644
+index b6b1fb0..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format.go
++++ /dev/null
+@@ -1,413 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-package spew
+-
+-import (
+- "bytes"
+- "fmt"
+- "reflect"
+- "strconv"
+- "strings"
+-)
+-
+-// supportedFlags is a list of all the character flags supported by fmt package.
+-const supportedFlags = "0-+# "
+-
+-// formatState implements the fmt.Formatter interface and contains information
+-// about the state of a formatting operation. The NewFormatter function can
+-// be used to get a new Formatter which can be used directly as arguments
+-// in standard fmt package printing calls.
+-type formatState struct {
+- value interface{}
+- fs fmt.State
+- depth int
+- pointers map[uintptr]int
+- ignoreNextType bool
+- cs *ConfigState
+-}
+-
+-// buildDefaultFormat recreates the original format string without precision
+-// and width information to pass in to fmt.Sprintf in the case of an
+-// unrecognized type. Unless new types are added to the language, this
+-// function won't ever be called.
+-func (f *formatState) buildDefaultFormat() (format string) {
+- buf := bytes.NewBuffer(percentBytes)
+-
+- for _, flag := range supportedFlags {
+- if f.fs.Flag(int(flag)) {
+- buf.WriteRune(flag)
+- }
+- }
+-
+- buf.WriteRune('v')
+-
+- format = buf.String()
+- return format
+-}
+-
+-// constructOrigFormat recreates the original format string including precision
+-// and width information to pass along to the standard fmt package. This allows
+-// automatic deferral of all format strings this package doesn't support.
+-func (f *formatState) constructOrigFormat(verb rune) (format string) {
+- buf := bytes.NewBuffer(percentBytes)
+-
+- for _, flag := range supportedFlags {
+- if f.fs.Flag(int(flag)) {
+- buf.WriteRune(flag)
+- }
+- }
+-
+- if width, ok := f.fs.Width(); ok {
+- buf.WriteString(strconv.Itoa(width))
+- }
+-
+- if precision, ok := f.fs.Precision(); ok {
+- buf.Write(precisionBytes)
+- buf.WriteString(strconv.Itoa(precision))
+- }
+-
+- buf.WriteRune(verb)
+-
+- format = buf.String()
+- return format
+-}
+-
+-// unpackValue returns values inside of non-nil interfaces when possible and
+-// ensures that types for values which have been unpacked from an interface
+-// are displayed when the show types flag is also set.
+-// This is useful for data types like structs, arrays, slices, and maps which
+-// can contain varying types packed inside an interface.
+-func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
+- if v.Kind() == reflect.Interface {
+- f.ignoreNextType = false
+- if !v.IsNil() {
+- v = v.Elem()
+- }
+- }
+- return v
+-}
+-
+-// formatPtr handles formatting of pointers by indirecting them as necessary.
+-func (f *formatState) formatPtr(v reflect.Value) {
+- // Display nil if top level pointer is nil.
+- showTypes := f.fs.Flag('#')
+- if v.IsNil() && (!showTypes || f.ignoreNextType) {
+- f.fs.Write(nilAngleBytes)
+- return
+- }
+-
+- // Remove pointers at or below the current depth from map used to detect
+- // circular refs.
+- for k, depth := range f.pointers {
+- if depth >= f.depth {
+- delete(f.pointers, k)
+- }
+- }
+-
+- // Keep list of all dereferenced pointers to possibly show later.
+- pointerChain := make([]uintptr, 0)
+-
+- // Figure out how many levels of indirection there are by derferencing
+- // pointers and unpacking interfaces down the chain while detecting circular
+- // references.
+- nilFound := false
+- cycleFound := false
+- indirects := 0
+- ve := v
+- for ve.Kind() == reflect.Ptr {
+- if ve.IsNil() {
+- nilFound = true
+- break
+- }
+- indirects++
+- addr := ve.Pointer()
+- pointerChain = append(pointerChain, addr)
+- if pd, ok := f.pointers[addr]; ok && pd < f.depth {
+- cycleFound = true
+- indirects--
+- break
+- }
+- f.pointers[addr] = f.depth
+-
+- ve = ve.Elem()
+- if ve.Kind() == reflect.Interface {
+- if ve.IsNil() {
+- nilFound = true
+- break
+- }
+- ve = ve.Elem()
+- }
+- }
+-
+- // Display type or indirection level depending on flags.
+- if showTypes && !f.ignoreNextType {
+- f.fs.Write(openParenBytes)
+- f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
+- f.fs.Write([]byte(ve.Type().String()))
+- f.fs.Write(closeParenBytes)
+- } else {
+- if nilFound || cycleFound {
+- indirects += strings.Count(ve.Type().String(), "*")
+- }
+- f.fs.Write(openAngleBytes)
+- f.fs.Write([]byte(strings.Repeat("*", indirects)))
+- f.fs.Write(closeAngleBytes)
+- }
+-
+- // Display pointer information depending on flags.
+- if f.fs.Flag('+') && (len(pointerChain) > 0) {
+- f.fs.Write(openParenBytes)
+- for i, addr := range pointerChain {
+- if i > 0 {
+- f.fs.Write(pointerChainBytes)
+- }
+- printHexPtr(f.fs, addr)
+- }
+- f.fs.Write(closeParenBytes)
+- }
+-
+- // Display dereferenced value.
+- switch {
+- case nilFound == true:
+- f.fs.Write(nilAngleBytes)
+-
+- case cycleFound == true:
+- f.fs.Write(circularShortBytes)
+-
+- default:
+- f.ignoreNextType = true
+- f.format(ve)
+- }
+-}
+-
+-// format is the main workhorse for providing the Formatter interface. It
+-// uses the passed reflect value to figure out what kind of object we are
+-// dealing with and formats it appropriately. It is a recursive function,
+-// however circular data structures are detected and handled properly.
+-func (f *formatState) format(v reflect.Value) {
+- // Handle invalid reflect values immediately.
+- kind := v.Kind()
+- if kind == reflect.Invalid {
+- f.fs.Write(invalidAngleBytes)
+- return
+- }
+-
+- // Handle pointers specially.
+- if kind == reflect.Ptr {
+- f.formatPtr(v)
+- return
+- }
+-
+- // Print type information unless already handled elsewhere.
+- if !f.ignoreNextType && f.fs.Flag('#') {
+- f.fs.Write(openParenBytes)
+- f.fs.Write([]byte(v.Type().String()))
+- f.fs.Write(closeParenBytes)
+- }
+- f.ignoreNextType = false
+-
+- // Call Stringer/error interfaces if they exist and the handle methods
+- // flag is enabled.
+- if !f.cs.DisableMethods {
+- if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+- if handled := handleMethods(f.cs, f.fs, v); handled {
+- return
+- }
+- }
+- }
+-
+- switch kind {
+- case reflect.Invalid:
+- // Do nothing. We should never get here since invalid has already
+- // been handled above.
+-
+- case reflect.Bool:
+- printBool(f.fs, v.Bool())
+-
+- case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+- printInt(f.fs, v.Int(), 10)
+-
+- case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+- printUint(f.fs, v.Uint(), 10)
+-
+- case reflect.Float32:
+- printFloat(f.fs, v.Float(), 32)
+-
+- case reflect.Float64:
+- printFloat(f.fs, v.Float(), 64)
+-
+- case reflect.Complex64:
+- printComplex(f.fs, v.Complex(), 32)
+-
+- case reflect.Complex128:
+- printComplex(f.fs, v.Complex(), 64)
+-
+- case reflect.Slice:
+- if v.IsNil() {
+- f.fs.Write(nilAngleBytes)
+- break
+- }
+- fallthrough
+-
+- case reflect.Array:
+- f.fs.Write(openBracketBytes)
+- f.depth++
+- if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+- f.fs.Write(maxShortBytes)
+- } else {
+- numEntries := v.Len()
+- for i := 0; i < numEntries; i++ {
+- if i > 0 {
+- f.fs.Write(spaceBytes)
+- }
+- f.ignoreNextType = true
+- f.format(f.unpackValue(v.Index(i)))
+- }
+- }
+- f.depth--
+- f.fs.Write(closeBracketBytes)
+-
+- case reflect.String:
+- f.fs.Write([]byte(v.String()))
+-
+- case reflect.Interface:
+- // The only time we should get here is for nil interfaces due to
+- // unpackValue calls.
+- if v.IsNil() {
+- f.fs.Write(nilAngleBytes)
+- }
+-
+- case reflect.Ptr:
+- // Do nothing. We should never get here since pointers have already
+- // been handled above.
+-
+- case reflect.Map:
+- f.fs.Write(openMapBytes)
+- f.depth++
+- if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+- f.fs.Write(maxShortBytes)
+- } else {
+- keys := v.MapKeys()
+- if f.cs.SortKeys {
+- sortValues(keys)
+- }
+- for i, key := range keys {
+- if i > 0 {
+- f.fs.Write(spaceBytes)
+- }
+- f.ignoreNextType = true
+- f.format(f.unpackValue(key))
+- f.fs.Write(colonBytes)
+- f.ignoreNextType = true
+- f.format(f.unpackValue(v.MapIndex(key)))
+- }
+- }
+- f.depth--
+- f.fs.Write(closeMapBytes)
+-
+- case reflect.Struct:
+- numFields := v.NumField()
+- f.fs.Write(openBraceBytes)
+- f.depth++
+- if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+- f.fs.Write(maxShortBytes)
+- } else {
+- vt := v.Type()
+- for i := 0; i < numFields; i++ {
+- if i > 0 {
+- f.fs.Write(spaceBytes)
+- }
+- vtf := vt.Field(i)
+- if f.fs.Flag('+') || f.fs.Flag('#') {
+- f.fs.Write([]byte(vtf.Name))
+- f.fs.Write(colonBytes)
+- }
+- f.format(f.unpackValue(v.Field(i)))
+- }
+- }
+- f.depth--
+- f.fs.Write(closeBraceBytes)
+-
+- case reflect.Uintptr:
+- printHexPtr(f.fs, uintptr(v.Uint()))
+-
+- case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+- printHexPtr(f.fs, v.Pointer())
+-
+- // There were not any other types at the time this code was written, but
+- // fall back to letting the default fmt package handle it if any get added.
+- default:
+- format := f.buildDefaultFormat()
+- if v.CanInterface() {
+- fmt.Fprintf(f.fs, format, v.Interface())
+- } else {
+- fmt.Fprintf(f.fs, format, v.String())
+- }
+- }
+-}
+-
+-// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
+-// details.
+-func (f *formatState) Format(fs fmt.State, verb rune) {
+- f.fs = fs
+-
+- // Use standard formatting for verbs that are not v.
+- if verb != 'v' {
+- format := f.constructOrigFormat(verb)
+- fmt.Fprintf(fs, format, f.value)
+- return
+- }
+-
+- if f.value == nil {
+- if fs.Flag('#') {
+- fs.Write(interfaceBytes)
+- }
+- fs.Write(nilAngleBytes)
+- return
+- }
+-
+- f.format(reflect.ValueOf(f.value))
+-}
+-
+-// newFormatter is a helper function to consolidate the logic from the various
+-// public methods which take varying config states.
+-func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
+- fs := &formatState{value: v, cs: cs}
+- fs.pointers = make(map[uintptr]int)
+- return fs
+-}
+-
+-/*
+-NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+-interface. As a result, it integrates cleanly with standard fmt package
+-printing functions. The formatter is useful for inline printing of smaller data
+-types similar to the standard %v format specifier.
+-
+-The custom formatter only responds to the %v (most compact), %+v (adds pointer
+-addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+-combinations. Any other verbs such as %x and %q will be sent to the the
+-standard fmt package for formatting. In addition, the custom formatter ignores
+-the width and precision arguments (however they will still work on the format
+-specifiers not handled by the custom formatter).
+-
+-Typically this function shouldn't be called directly. It is much easier to make
+-use of the custom formatter by calling one of the convenience functions such as
+-Printf, Println, or Fprintf.
+-*/
+-func NewFormatter(v interface{}) fmt.Formatter {
+- return newFormatter(&Config, v)
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format_test.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format_test.go
+deleted file mode 100644
+index 80c5ef9..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/format_test.go
++++ /dev/null
+@@ -1,1483 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-/*
+-Test Summary:
+-NOTE: For each test, a nil pointer, a single pointer and double pointer to the
+-base test element are also tested to ensure proper indirection across all types.
+-
+-- Max int8, int16, int32, int64, int
+-- Max uint8, uint16, uint32, uint64, uint
+-- Boolean true and false
+-- Standard complex64 and complex128
+-- Array containing standard ints
+-- Array containing type with custom formatter on pointer receiver only
+-- Array containing interfaces
+-- Slice containing standard float32 values
+-- Slice containing type with custom formatter on pointer receiver only
+-- Slice containing interfaces
+-- Nil slice
+-- Standard string
+-- Nil interface
+-- Sub-interface
+-- Map with string keys and int vals
+-- Map with custom formatter type on pointer receiver only keys and vals
+-- Map with interface keys and values
+-- Map with nil interface value
+-- Struct with primitives
+-- Struct that contains another struct
+-- Struct that contains custom type with Stringer pointer interface via both
+- exported and unexported fields
+-- Struct that contains embedded struct and field to same struct
+-- Uintptr to 0 (null pointer)
+-- Uintptr address of real variable
+-- Unsafe.Pointer to 0 (null pointer)
+-- Unsafe.Pointer to address of real variable
+-- Nil channel
+-- Standard int channel
+-- Function with no params and no returns
+-- Function with param and no returns
+-- Function with multiple params and multiple returns
+-- Struct that is circular through self referencing
+-- Structs that are circular through cross referencing
+-- Structs that are indirectly circular
+-- Type that panics in its Stringer interface
+-- Type that has a custom Error interface
+-- %x passthrough with uint
+-- %#x passthrough with uint
+-- %f passthrough with precision
+-- %f passthrough with width and precision
+-- %d passthrough with width
+-- %q passthrough with string
+-*/
+-
+-package spew_test
+-
+-import (
+- "bytes"
+- "fmt"
+- "github.com/davecgh/go-spew/spew"
+- "testing"
+- "unsafe"
+-)
+-
+-// formatterTest is used to describe a test to be perfomed against NewFormatter.
+-type formatterTest struct {
+- format string
+- in interface{}
+- wants []string
+-}
+-
+-// formatterTests houses all of the tests to be performed against NewFormatter.
+-var formatterTests = make([]formatterTest, 0)
+-
+-// addFormatterTest is a helper method to append the passed input and desired
+-// result to formatterTests.
+-func addFormatterTest(format string, in interface{}, wants ...string) {
+- test := formatterTest{format, in, wants}
+- formatterTests = append(formatterTests, test)
+-}
+-
+-func addIntFormatterTests() {
+- // Max int8.
+- v := int8(127)
+- nv := (*int8)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "int8"
+- vs := "127"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Max int16.
+- v2 := int16(32767)
+- nv2 := (*int16)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "int16"
+- v2s := "32767"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-
+- // Max int32.
+- v3 := int32(2147483647)
+- nv3 := (*int32)(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "int32"
+- v3s := "2147483647"
+- addFormatterTest("%v", v3, v3s)
+- addFormatterTest("%v", pv3, "<*>"+v3s)
+- addFormatterTest("%v", &pv3, "<**>"+v3s)
+- addFormatterTest("%v", nv3, "<nil>")
+- addFormatterTest("%+v", v3, v3s)
+- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
+- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
+- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
+- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
+- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+-
+- // Max int64.
+- v4 := int64(9223372036854775807)
+- nv4 := (*int64)(nil)
+- pv4 := &v4
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "int64"
+- v4s := "9223372036854775807"
+- addFormatterTest("%v", v4, v4s)
+- addFormatterTest("%v", pv4, "<*>"+v4s)
+- addFormatterTest("%v", &pv4, "<**>"+v4s)
+- addFormatterTest("%v", nv4, "<nil>")
+- addFormatterTest("%+v", v4, v4s)
+- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
+- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
+- addFormatterTest("%+v", nv4, "<nil>")
+- addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
+- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
+- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
+- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
+- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
+- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
+- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+-
+- // Max int.
+- v5 := int(2147483647)
+- nv5 := (*int)(nil)
+- pv5 := &v5
+- v5Addr := fmt.Sprintf("%p", pv5)
+- pv5Addr := fmt.Sprintf("%p", &pv5)
+- v5t := "int"
+- v5s := "2147483647"
+- addFormatterTest("%v", v5, v5s)
+- addFormatterTest("%v", pv5, "<*>"+v5s)
+- addFormatterTest("%v", &pv5, "<**>"+v5s)
+- addFormatterTest("%v", nv5, "<nil>")
+- addFormatterTest("%+v", v5, v5s)
+- addFormatterTest("%+v", pv5, "<*>("+v5Addr+")"+v5s)
+- addFormatterTest("%+v", &pv5, "<**>("+pv5Addr+"->"+v5Addr+")"+v5s)
+- addFormatterTest("%+v", nv5, "<nil>")
+- addFormatterTest("%#v", v5, "("+v5t+")"+v5s)
+- addFormatterTest("%#v", pv5, "(*"+v5t+")"+v5s)
+- addFormatterTest("%#v", &pv5, "(**"+v5t+")"+v5s)
+- addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
+- addFormatterTest("%#+v", v5, "("+v5t+")"+v5s)
+- addFormatterTest("%#+v", pv5, "(*"+v5t+")("+v5Addr+")"+v5s)
+- addFormatterTest("%#+v", &pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")"+v5s)
+- addFormatterTest("%#+v", nv5, "(*"+v5t+")"+"<nil>")
+-}
+-
+-func addUintFormatterTests() {
+- // Max uint8.
+- v := uint8(255)
+- nv := (*uint8)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "uint8"
+- vs := "255"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Max uint16.
+- v2 := uint16(65535)
+- nv2 := (*uint16)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "uint16"
+- v2s := "65535"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-
+- // Max uint32.
+- v3 := uint32(4294967295)
+- nv3 := (*uint32)(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "uint32"
+- v3s := "4294967295"
+- addFormatterTest("%v", v3, v3s)
+- addFormatterTest("%v", pv3, "<*>"+v3s)
+- addFormatterTest("%v", &pv3, "<**>"+v3s)
+- addFormatterTest("%v", nv3, "<nil>")
+- addFormatterTest("%+v", v3, v3s)
+- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
+- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
+- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
+- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
+- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+-
+- // Max uint64.
+- v4 := uint64(18446744073709551615)
+- nv4 := (*uint64)(nil)
+- pv4 := &v4
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "uint64"
+- v4s := "18446744073709551615"
+- addFormatterTest("%v", v4, v4s)
+- addFormatterTest("%v", pv4, "<*>"+v4s)
+- addFormatterTest("%v", &pv4, "<**>"+v4s)
+- addFormatterTest("%v", nv4, "<nil>")
+- addFormatterTest("%+v", v4, v4s)
+- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
+- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
+- addFormatterTest("%+v", nv4, "<nil>")
+- addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
+- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
+- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
+- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
+- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
+- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
+- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+-
+- // Max uint.
+- v5 := uint(4294967295)
+- nv5 := (*uint)(nil)
+- pv5 := &v5
+- v5Addr := fmt.Sprintf("%p", pv5)
+- pv5Addr := fmt.Sprintf("%p", &pv5)
+- v5t := "uint"
+- v5s := "4294967295"
+- addFormatterTest("%v", v5, v5s)
+- addFormatterTest("%v", pv5, "<*>"+v5s)
+- addFormatterTest("%v", &pv5, "<**>"+v5s)
+- addFormatterTest("%v", nv5, "<nil>")
+- addFormatterTest("%+v", v5, v5s)
+- addFormatterTest("%+v", pv5, "<*>("+v5Addr+")"+v5s)
+- addFormatterTest("%+v", &pv5, "<**>("+pv5Addr+"->"+v5Addr+")"+v5s)
+- addFormatterTest("%+v", nv5, "<nil>")
+- addFormatterTest("%#v", v5, "("+v5t+")"+v5s)
+- addFormatterTest("%#v", pv5, "(*"+v5t+")"+v5s)
+- addFormatterTest("%#v", &pv5, "(**"+v5t+")"+v5s)
+- addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
+- addFormatterTest("%#+v", v5, "("+v5t+")"+v5s)
+- addFormatterTest("%#+v", pv5, "(*"+v5t+")("+v5Addr+")"+v5s)
+- addFormatterTest("%#+v", &pv5, "(**"+v5t+")("+pv5Addr+"->"+v5Addr+")"+v5s)
+- addFormatterTest("%#v", nv5, "(*"+v5t+")"+"<nil>")
+-}
+-
+-func addBoolFormatterTests() {
+- // Boolean true.
+- v := bool(true)
+- nv := (*bool)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "bool"
+- vs := "true"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Boolean false.
+- v2 := bool(false)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "bool"
+- v2s := "false"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+-}
+-
+-func addFloatFormatterTests() {
+- // Standard float32.
+- v := float32(3.1415)
+- nv := (*float32)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "float32"
+- vs := "3.1415"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Standard float64.
+- v2 := float64(3.1415926)
+- nv2 := (*float64)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "float64"
+- v2s := "3.1415926"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-}
+-
+-func addComplexFormatterTests() {
+- // Standard complex64.
+- v := complex(float32(6), -2)
+- nv := (*complex64)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "complex64"
+- vs := "(6-2i)"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Standard complex128.
+- v2 := complex(float64(-6), 2)
+- nv2 := (*complex128)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "complex128"
+- v2s := "(-6+2i)"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-}
+-
+-func addArrayFormatterTests() {
+- // Array containing standard ints.
+- v := [3]int{1, 2, 3}
+- nv := (*[3]int)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "[3]int"
+- vs := "[1 2 3]"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Array containing type with custom formatter on pointer receiver only.
+- v2 := [3]pstringer{"1", "2", "3"}
+- nv2 := (*[3]pstringer)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "[3]spew_test.pstringer"
+- v2s := "[stringer 1 stringer 2 stringer 3]"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-
+- // Array containing interfaces.
+- v3 := [3]interface{}{"one", int(2), uint(3)}
+- nv3 := (*[3]interface{})(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "[3]interface {}"
+- v3t2 := "string"
+- v3t3 := "int"
+- v3t4 := "uint"
+- v3s := "[one 2 3]"
+- v3s2 := "[(" + v3t2 + ")one (" + v3t3 + ")2 (" + v3t4 + ")3]"
+- addFormatterTest("%v", v3, v3s)
+- addFormatterTest("%v", pv3, "<*>"+v3s)
+- addFormatterTest("%v", &pv3, "<**>"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%+v", v3, v3s)
+- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
+- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
+- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
+- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
+- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
+- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+-}
+-
+-func addSliceFormatterTests() {
+- // Slice containing standard float32 values.
+- v := []float32{3.14, 6.28, 12.56}
+- nv := (*[]float32)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "[]float32"
+- vs := "[3.14 6.28 12.56]"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Slice containing type with custom formatter on pointer receiver only.
+- v2 := []pstringer{"1", "2", "3"}
+- nv2 := (*[]pstringer)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "[]spew_test.pstringer"
+- v2s := "[stringer 1 stringer 2 stringer 3]"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-
+- // Slice containing interfaces.
+- v3 := []interface{}{"one", int(2), uint(3), nil}
+- nv3 := (*[]interface{})(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "[]interface {}"
+- v3t2 := "string"
+- v3t3 := "int"
+- v3t4 := "uint"
+- v3t5 := "interface {}"
+- v3s := "[one 2 3 <nil>]"
+- v3s2 := "[(" + v3t2 + ")one (" + v3t3 + ")2 (" + v3t4 + ")3 (" + v3t5 +
+- ")<nil>]"
+- addFormatterTest("%v", v3, v3s)
+- addFormatterTest("%v", pv3, "<*>"+v3s)
+- addFormatterTest("%v", &pv3, "<**>"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%+v", v3, v3s)
+- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
+- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
+- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
+- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
+- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
+- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+-
+- // Nil slice.
+- var v4 []int
+- nv4 := (*[]int)(nil)
+- pv4 := &v4
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "[]int"
+- v4s := "<nil>"
+- addFormatterTest("%v", v4, v4s)
+- addFormatterTest("%v", pv4, "<*>"+v4s)
+- addFormatterTest("%v", &pv4, "<**>"+v4s)
+- addFormatterTest("%+v", nv4, "<nil>")
+- addFormatterTest("%+v", v4, v4s)
+- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
+- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
+- addFormatterTest("%+v", nv4, "<nil>")
+- addFormatterTest("%#v", v4, "("+v4t+")"+v4s)
+- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s)
+- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s)
+- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s)
+- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s)
+- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s)
+- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+-}
+-
+-func addStringFormatterTests() {
+- // Standard string.
+- v := "test"
+- nv := (*string)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "string"
+- vs := "test"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-}
+-
+-func addInterfaceFormatterTests() {
+- // Nil interface.
+- var v interface{}
+- nv := (*interface{})(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "interface {}"
+- vs := "<nil>"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Sub-interface.
+- v2 := interface{}(uint16(65535))
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "uint16"
+- v2s := "65535"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+-}
+-
+-func addMapFormatterTests() {
+- // Map with string keys and int vals.
+- v := map[string]int{"one": 1, "two": 2}
+- nv := (*map[string]int)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "map[string]int"
+- vs := "map[one:1 two:2]"
+- vs2 := "map[two:2 one:1]"
+- addFormatterTest("%v", v, vs, vs2)
+- addFormatterTest("%v", pv, "<*>"+vs, "<*>"+vs2)
+- addFormatterTest("%v", &pv, "<**>"+vs, "<**>"+vs2)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs, vs2)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs, "<*>("+vAddr+")"+vs2)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs,
+- "<**>("+pvAddr+"->"+vAddr+")"+vs2)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs, "("+vt+")"+vs2)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs, "(*"+vt+")"+vs2)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs, "(**"+vt+")"+vs2)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs, "("+vt+")"+vs2)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs,
+- "(*"+vt+")("+vAddr+")"+vs2)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs,
+- "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs2)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Map with custom formatter type on pointer receiver only keys and vals.
+- v2 := map[pstringer]pstringer{"one": "1"}
+- nv2 := (*map[pstringer]pstringer)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "map[spew_test.pstringer]spew_test.pstringer"
+- v2s := "map[stringer one:stringer 1]"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-
+- // Map with interface keys and values.
+- v3 := map[interface{}]interface{}{"one": 1}
+- nv3 := (*map[interface{}]interface{})(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "map[interface {}]interface {}"
+- v3t1 := "string"
+- v3t2 := "int"
+- v3s := "map[one:1]"
+- v3s2 := "map[(" + v3t1 + ")one:(" + v3t2 + ")1]"
+- addFormatterTest("%v", v3, v3s)
+- addFormatterTest("%v", pv3, "<*>"+v3s)
+- addFormatterTest("%v", &pv3, "<**>"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%+v", v3, v3s)
+- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%#v", v3, "("+v3t+")"+v3s2)
+- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s2)
+- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s2)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s2)
+- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s2)
+- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s2)
+- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+-
+- // Map with nil interface value
+- v4 := map[string]interface{}{"nil": nil}
+- nv4 := (*map[string]interface{})(nil)
+- pv4 := &v4
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "map[string]interface {}"
+- v4t1 := "interface {}"
+- v4s := "map[nil:<nil>]"
+- v4s2 := "map[nil:(" + v4t1 + ")<nil>]"
+- addFormatterTest("%v", v4, v4s)
+- addFormatterTest("%v", pv4, "<*>"+v4s)
+- addFormatterTest("%v", &pv4, "<**>"+v4s)
+- addFormatterTest("%+v", nv4, "<nil>")
+- addFormatterTest("%+v", v4, v4s)
+- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s)
+- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s)
+- addFormatterTest("%+v", nv4, "<nil>")
+- addFormatterTest("%#v", v4, "("+v4t+")"+v4s2)
+- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s2)
+- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s2)
+- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s2)
+- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s2)
+- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s2)
+- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+-}
+-
+-func addStructFormatterTests() {
+- // Struct with primitives.
+- type s1 struct {
+- a int8
+- b uint8
+- }
+- v := s1{127, 255}
+- nv := (*s1)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "spew_test.s1"
+- vt2 := "int8"
+- vt3 := "uint8"
+- vs := "{127 255}"
+- vs2 := "{a:127 b:255}"
+- vs3 := "{a:(" + vt2 + ")127 b:(" + vt3 + ")255}"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs2)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs2)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs2)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs3)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs3)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs3)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs3)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs3)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs3)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Struct that contains another struct.
+- type s2 struct {
+- s1 s1
+- b bool
+- }
+- v2 := s2{s1{127, 255}, true}
+- nv2 := (*s2)(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "spew_test.s2"
+- v2t2 := "spew_test.s1"
+- v2t3 := "int8"
+- v2t4 := "uint8"
+- v2t5 := "bool"
+- v2s := "{{127 255} true}"
+- v2s2 := "{s1:{a:127 b:255} b:true}"
+- v2s3 := "{s1:(" + v2t2 + "){a:(" + v2t3 + ")127 b:(" + v2t4 + ")255} b:(" +
+- v2t5 + ")true}"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s2)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s2)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s2)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s3)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s3)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s3)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s3)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s3)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s3)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-
+- // Struct that contains custom type with Stringer pointer interface via both
+- // exported and unexported fields.
+- type s3 struct {
+- s pstringer
+- S pstringer
+- }
+- v3 := s3{"test", "test2"}
+- nv3 := (*s3)(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "spew_test.s3"
+- v3t2 := "spew_test.pstringer"
+- v3s := "{stringer test stringer test2}"
+- v3s2 := "{s:stringer test S:stringer test2}"
+- v3s3 := "{s:(" + v3t2 + ")stringer test S:(" + v3t2 + ")stringer test2}"
+- addFormatterTest("%v", v3, v3s)
+- addFormatterTest("%v", pv3, "<*>"+v3s)
+- addFormatterTest("%v", &pv3, "<**>"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%+v", v3, v3s2)
+- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s2)
+- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s2)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%#v", v3, "("+v3t+")"+v3s3)
+- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s3)
+- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s3)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s3)
+- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s3)
+- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s3)
+- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+-
+- // Struct that contains embedded struct and field to same struct.
+- e := embed{"embedstr"}
+- v4 := embedwrap{embed: &e, e: &e}
+- nv4 := (*embedwrap)(nil)
+- pv4 := &v4
+- eAddr := fmt.Sprintf("%p", &e)
+- v4Addr := fmt.Sprintf("%p", pv4)
+- pv4Addr := fmt.Sprintf("%p", &pv4)
+- v4t := "spew_test.embedwrap"
+- v4t2 := "spew_test.embed"
+- v4t3 := "string"
+- v4s := "{<*>{embedstr} <*>{embedstr}}"
+- v4s2 := "{embed:<*>(" + eAddr + "){a:embedstr} e:<*>(" + eAddr +
+- "){a:embedstr}}"
+- v4s3 := "{embed:(*" + v4t2 + "){a:(" + v4t3 + ")embedstr} e:(*" + v4t2 +
+- "){a:(" + v4t3 + ")embedstr}}"
+- v4s4 := "{embed:(*" + v4t2 + ")(" + eAddr + "){a:(" + v4t3 +
+- ")embedstr} e:(*" + v4t2 + ")(" + eAddr + "){a:(" + v4t3 + ")embedstr}}"
+- addFormatterTest("%v", v4, v4s)
+- addFormatterTest("%v", pv4, "<*>"+v4s)
+- addFormatterTest("%v", &pv4, "<**>"+v4s)
+- addFormatterTest("%+v", nv4, "<nil>")
+- addFormatterTest("%+v", v4, v4s2)
+- addFormatterTest("%+v", pv4, "<*>("+v4Addr+")"+v4s2)
+- addFormatterTest("%+v", &pv4, "<**>("+pv4Addr+"->"+v4Addr+")"+v4s2)
+- addFormatterTest("%+v", nv4, "<nil>")
+- addFormatterTest("%#v", v4, "("+v4t+")"+v4s3)
+- addFormatterTest("%#v", pv4, "(*"+v4t+")"+v4s3)
+- addFormatterTest("%#v", &pv4, "(**"+v4t+")"+v4s3)
+- addFormatterTest("%#v", nv4, "(*"+v4t+")"+"<nil>")
+- addFormatterTest("%#+v", v4, "("+v4t+")"+v4s4)
+- addFormatterTest("%#+v", pv4, "(*"+v4t+")("+v4Addr+")"+v4s4)
+- addFormatterTest("%#+v", &pv4, "(**"+v4t+")("+pv4Addr+"->"+v4Addr+")"+v4s4)
+- addFormatterTest("%#+v", nv4, "(*"+v4t+")"+"<nil>")
+-}
+-
+-func addUintptrFormatterTests() {
+- // Null pointer.
+- v := uintptr(0)
+- nv := (*uintptr)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "uintptr"
+- vs := "<nil>"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Address of real variable.
+- i := 1
+- v2 := uintptr(unsafe.Pointer(&i))
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "uintptr"
+- v2s := fmt.Sprintf("%p", &i)
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+-}
+-
+-func addUnsafePointerFormatterTests() {
+- // Null pointer.
+- v := unsafe.Pointer(uintptr(0))
+- nv := (*unsafe.Pointer)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "unsafe.Pointer"
+- vs := "<nil>"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Address of real variable.
+- i := 1
+- v2 := unsafe.Pointer(&i)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "unsafe.Pointer"
+- v2s := fmt.Sprintf("%p", &i)
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+-}
+-
+-func addChanFormatterTests() {
+- // Nil channel.
+- var v chan int
+- pv := &v
+- nv := (*chan int)(nil)
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "chan int"
+- vs := "<nil>"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Real channel.
+- v2 := make(chan int)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "chan int"
+- v2s := fmt.Sprintf("%p", v2)
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+-}
+-
+-func addFuncFormatterTests() {
+- // Function with no params and no returns.
+- v := addIntFormatterTests
+- nv := (*func())(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "func()"
+- vs := fmt.Sprintf("%p", v)
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-
+- // Function with param and no returns.
+- v2 := TestFormatter
+- nv2 := (*func(*testing.T))(nil)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "func(*testing.T)"
+- v2s := fmt.Sprintf("%p", v2)
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s)
+- addFormatterTest("%v", &pv2, "<**>"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%+v", v2, v2s)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%+v", nv2, "<nil>")
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s)
+- addFormatterTest("%#v", nv2, "(*"+v2t+")"+"<nil>")
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s)
+- addFormatterTest("%#+v", nv2, "(*"+v2t+")"+"<nil>")
+-
+- // Function with multiple params and multiple returns.
+- var v3 = func(i int, s string) (b bool, err error) {
+- return true, nil
+- }
+- nv3 := (*func(int, string) (bool, error))(nil)
+- pv3 := &v3
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "func(int, string) (bool, error)"
+- v3s := fmt.Sprintf("%p", v3)
+- addFormatterTest("%v", v3, v3s)
+- addFormatterTest("%v", pv3, "<*>"+v3s)
+- addFormatterTest("%v", &pv3, "<**>"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%+v", v3, v3s)
+- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s)
+- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%+v", nv3, "<nil>")
+- addFormatterTest("%#v", v3, "("+v3t+")"+v3s)
+- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s)
+- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s)
+- addFormatterTest("%#v", nv3, "(*"+v3t+")"+"<nil>")
+- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s)
+- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s)
+- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s)
+- addFormatterTest("%#+v", nv3, "(*"+v3t+")"+"<nil>")
+-}
+-
+-func addCircularFormatterTests() {
+- // Struct that is circular through self referencing.
+- type circular struct {
+- c *circular
+- }
+- v := circular{nil}
+- v.c = &v
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "spew_test.circular"
+- vs := "{<*>{<*><shown>}}"
+- vs2 := "{<*><shown>}"
+- vs3 := "{c:<*>(" + vAddr + "){c:<*>(" + vAddr + ")<shown>}}"
+- vs4 := "{c:<*>(" + vAddr + ")<shown>}"
+- vs5 := "{c:(*" + vt + "){c:(*" + vt + ")<shown>}}"
+- vs6 := "{c:(*" + vt + ")<shown>}"
+- vs7 := "{c:(*" + vt + ")(" + vAddr + "){c:(*" + vt + ")(" + vAddr +
+- ")<shown>}}"
+- vs8 := "{c:(*" + vt + ")(" + vAddr + ")<shown>}"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs2)
+- addFormatterTest("%v", &pv, "<**>"+vs2)
+- addFormatterTest("%+v", v, vs3)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs4)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs4)
+- addFormatterTest("%#v", v, "("+vt+")"+vs5)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs6)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs6)
+- addFormatterTest("%#+v", v, "("+vt+")"+vs7)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs8)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs8)
+-
+- // Structs that are circular through cross referencing.
+- v2 := xref1{nil}
+- ts2 := xref2{&v2}
+- v2.ps2 = &ts2
+- pv2 := &v2
+- ts2Addr := fmt.Sprintf("%p", &ts2)
+- v2Addr := fmt.Sprintf("%p", pv2)
+- pv2Addr := fmt.Sprintf("%p", &pv2)
+- v2t := "spew_test.xref1"
+- v2t2 := "spew_test.xref2"
+- v2s := "{<*>{<*>{<*><shown>}}}"
+- v2s2 := "{<*>{<*><shown>}}"
+- v2s3 := "{ps2:<*>(" + ts2Addr + "){ps1:<*>(" + v2Addr + "){ps2:<*>(" +
+- ts2Addr + ")<shown>}}}"
+- v2s4 := "{ps2:<*>(" + ts2Addr + "){ps1:<*>(" + v2Addr + ")<shown>}}"
+- v2s5 := "{ps2:(*" + v2t2 + "){ps1:(*" + v2t + "){ps2:(*" + v2t2 +
+- ")<shown>}}}"
+- v2s6 := "{ps2:(*" + v2t2 + "){ps1:(*" + v2t + ")<shown>}}"
+- v2s7 := "{ps2:(*" + v2t2 + ")(" + ts2Addr + "){ps1:(*" + v2t +
+- ")(" + v2Addr + "){ps2:(*" + v2t2 + ")(" + ts2Addr +
+- ")<shown>}}}"
+- v2s8 := "{ps2:(*" + v2t2 + ")(" + ts2Addr + "){ps1:(*" + v2t +
+- ")(" + v2Addr + ")<shown>}}"
+- addFormatterTest("%v", v2, v2s)
+- addFormatterTest("%v", pv2, "<*>"+v2s2)
+- addFormatterTest("%v", &pv2, "<**>"+v2s2)
+- addFormatterTest("%+v", v2, v2s3)
+- addFormatterTest("%+v", pv2, "<*>("+v2Addr+")"+v2s4)
+- addFormatterTest("%+v", &pv2, "<**>("+pv2Addr+"->"+v2Addr+")"+v2s4)
+- addFormatterTest("%#v", v2, "("+v2t+")"+v2s5)
+- addFormatterTest("%#v", pv2, "(*"+v2t+")"+v2s6)
+- addFormatterTest("%#v", &pv2, "(**"+v2t+")"+v2s6)
+- addFormatterTest("%#+v", v2, "("+v2t+")"+v2s7)
+- addFormatterTest("%#+v", pv2, "(*"+v2t+")("+v2Addr+")"+v2s8)
+- addFormatterTest("%#+v", &pv2, "(**"+v2t+")("+pv2Addr+"->"+v2Addr+")"+v2s8)
+-
+- // Structs that are indirectly circular.
+- v3 := indirCir1{nil}
+- tic2 := indirCir2{nil}
+- tic3 := indirCir3{&v3}
+- tic2.ps3 = &tic3
+- v3.ps2 = &tic2
+- pv3 := &v3
+- tic2Addr := fmt.Sprintf("%p", &tic2)
+- tic3Addr := fmt.Sprintf("%p", &tic3)
+- v3Addr := fmt.Sprintf("%p", pv3)
+- pv3Addr := fmt.Sprintf("%p", &pv3)
+- v3t := "spew_test.indirCir1"
+- v3t2 := "spew_test.indirCir2"
+- v3t3 := "spew_test.indirCir3"
+- v3s := "{<*>{<*>{<*>{<*><shown>}}}}"
+- v3s2 := "{<*>{<*>{<*><shown>}}}"
+- v3s3 := "{ps2:<*>(" + tic2Addr + "){ps3:<*>(" + tic3Addr + "){ps1:<*>(" +
+- v3Addr + "){ps2:<*>(" + tic2Addr + ")<shown>}}}}"
+- v3s4 := "{ps2:<*>(" + tic2Addr + "){ps3:<*>(" + tic3Addr + "){ps1:<*>(" +
+- v3Addr + ")<shown>}}}"
+- v3s5 := "{ps2:(*" + v3t2 + "){ps3:(*" + v3t3 + "){ps1:(*" + v3t +
+- "){ps2:(*" + v3t2 + ")<shown>}}}}"
+- v3s6 := "{ps2:(*" + v3t2 + "){ps3:(*" + v3t3 + "){ps1:(*" + v3t +
+- ")<shown>}}}"
+- v3s7 := "{ps2:(*" + v3t2 + ")(" + tic2Addr + "){ps3:(*" + v3t3 + ")(" +
+- tic3Addr + "){ps1:(*" + v3t + ")(" + v3Addr + "){ps2:(*" + v3t2 +
+- ")(" + tic2Addr + ")<shown>}}}}"
+- v3s8 := "{ps2:(*" + v3t2 + ")(" + tic2Addr + "){ps3:(*" + v3t3 + ")(" +
+- tic3Addr + "){ps1:(*" + v3t + ")(" + v3Addr + ")<shown>}}}"
+- addFormatterTest("%v", v3, v3s)
+- addFormatterTest("%v", pv3, "<*>"+v3s2)
+- addFormatterTest("%v", &pv3, "<**>"+v3s2)
+- addFormatterTest("%+v", v3, v3s3)
+- addFormatterTest("%+v", pv3, "<*>("+v3Addr+")"+v3s4)
+- addFormatterTest("%+v", &pv3, "<**>("+pv3Addr+"->"+v3Addr+")"+v3s4)
+- addFormatterTest("%#v", v3, "("+v3t+")"+v3s5)
+- addFormatterTest("%#v", pv3, "(*"+v3t+")"+v3s6)
+- addFormatterTest("%#v", &pv3, "(**"+v3t+")"+v3s6)
+- addFormatterTest("%#+v", v3, "("+v3t+")"+v3s7)
+- addFormatterTest("%#+v", pv3, "(*"+v3t+")("+v3Addr+")"+v3s8)
+- addFormatterTest("%#+v", &pv3, "(**"+v3t+")("+pv3Addr+"->"+v3Addr+")"+v3s8)
+-}
+-
+-func addPanicFormatterTests() {
+- // Type that panics in its Stringer interface.
+- v := panicer(127)
+- nv := (*panicer)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "spew_test.panicer"
+- vs := "(PANIC=test panic)127"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-}
+-
+-func addErrorFormatterTests() {
+- // Type that has a custom Error interface.
+- v := customError(127)
+- nv := (*customError)(nil)
+- pv := &v
+- vAddr := fmt.Sprintf("%p", pv)
+- pvAddr := fmt.Sprintf("%p", &pv)
+- vt := "spew_test.customError"
+- vs := "error: 127"
+- addFormatterTest("%v", v, vs)
+- addFormatterTest("%v", pv, "<*>"+vs)
+- addFormatterTest("%v", &pv, "<**>"+vs)
+- addFormatterTest("%v", nv, "<nil>")
+- addFormatterTest("%+v", v, vs)
+- addFormatterTest("%+v", pv, "<*>("+vAddr+")"+vs)
+- addFormatterTest("%+v", &pv, "<**>("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%+v", nv, "<nil>")
+- addFormatterTest("%#v", v, "("+vt+")"+vs)
+- addFormatterTest("%#v", pv, "(*"+vt+")"+vs)
+- addFormatterTest("%#v", &pv, "(**"+vt+")"+vs)
+- addFormatterTest("%#v", nv, "(*"+vt+")"+"<nil>")
+- addFormatterTest("%#+v", v, "("+vt+")"+vs)
+- addFormatterTest("%#+v", pv, "(*"+vt+")("+vAddr+")"+vs)
+- addFormatterTest("%#+v", &pv, "(**"+vt+")("+pvAddr+"->"+vAddr+")"+vs)
+- addFormatterTest("%#+v", nv, "(*"+vt+")"+"<nil>")
+-}
+-
+-func addPassthroughFormatterTests() {
+- // %x passthrough with uint.
+- v := uint(4294967295)
+- pv := &v
+- vAddr := fmt.Sprintf("%x", pv)
+- pvAddr := fmt.Sprintf("%x", &pv)
+- vs := "ffffffff"
+- addFormatterTest("%x", v, vs)
+- addFormatterTest("%x", pv, vAddr)
+- addFormatterTest("%x", &pv, pvAddr)
+-
+- // %#x passthrough with uint.
+- v2 := int(2147483647)
+- pv2 := &v2
+- v2Addr := fmt.Sprintf("%#x", pv2)
+- pv2Addr := fmt.Sprintf("%#x", &pv2)
+- v2s := "0x7fffffff"
+- addFormatterTest("%#x", v2, v2s)
+- addFormatterTest("%#x", pv2, v2Addr)
+- addFormatterTest("%#x", &pv2, pv2Addr)
+-
+- // %f passthrough with precision.
+- addFormatterTest("%.2f", 3.1415, "3.14")
+- addFormatterTest("%.3f", 3.1415, "3.142")
+- addFormatterTest("%.4f", 3.1415, "3.1415")
+-
+- // %f passthrough with width and precision.
+- addFormatterTest("%5.2f", 3.1415, " 3.14")
+- addFormatterTest("%6.3f", 3.1415, " 3.142")
+- addFormatterTest("%7.4f", 3.1415, " 3.1415")
+-
+- // %d passthrough with width.
+- addFormatterTest("%3d", 127, "127")
+- addFormatterTest("%4d", 127, " 127")
+- addFormatterTest("%5d", 127, " 127")
+-
+- // %q passthrough with string.
+- addFormatterTest("%q", "test", "\"test\"")
+-}
+-
+-// TestFormatter executes all of the tests described by formatterTests.
+-func TestFormatter(t *testing.T) {
+- // Setup tests.
+- addIntFormatterTests()
+- addUintFormatterTests()
+- addBoolFormatterTests()
+- addFloatFormatterTests()
+- addComplexFormatterTests()
+- addArrayFormatterTests()
+- addSliceFormatterTests()
+- addStringFormatterTests()
+- addInterfaceFormatterTests()
+- addMapFormatterTests()
+- addStructFormatterTests()
+- addUintptrFormatterTests()
+- addUnsafePointerFormatterTests()
+- addChanFormatterTests()
+- addFuncFormatterTests()
+- addCircularFormatterTests()
+- addPanicFormatterTests()
+- addErrorFormatterTests()
+- addPassthroughFormatterTests()
+-
+- t.Logf("Running %d tests", len(formatterTests))
+- for i, test := range formatterTests {
+- buf := new(bytes.Buffer)
+- spew.Fprintf(buf, test.format, test.in)
+- s := buf.String()
+- if testFailed(s, test.wants) {
+- t.Errorf("Formatter #%d format: %s got: %s %s", i, test.format, s,
+- stringizeWants(test.wants))
+- continue
+- }
+- }
+-}
+-
+-func TestPrintSortedKeys(t *testing.T) {
+- cfg := spew.ConfigState{SortKeys: true}
+- s := cfg.Sprint(map[int]string{1: "1", 3: "3", 2: "2"})
+- expected := "map[1:1 2:2 3:3]"
+- if s != expected {
+- t.Errorf("Sorted keys mismatch:\n %v %v", s, expected)
+- }
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/internal_test.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/internal_test.go
+deleted file mode 100644
+index 10dc0b1..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/internal_test.go
++++ /dev/null
+@@ -1,156 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-/*
+-This test file is part of the spew package rather than than the spew_test
+-package because it needs access to internals to properly test certain cases
+-which are not possible via the public interface since they should never happen.
+-*/
+-
+-package spew
+-
+-import (
+- "bytes"
+- "reflect"
+- "testing"
+- "unsafe"
+-)
+-
+-// dummyFmtState implements a fake fmt.State to use for testing invalid
+-// reflect.Value handling. This is necessary because the fmt package catches
+-// invalid values before invoking the formatter on them.
+-type dummyFmtState struct {
+- bytes.Buffer
+-}
+-
+-func (dfs *dummyFmtState) Flag(f int) bool {
+- if f == int('+') {
+- return true
+- }
+- return false
+-}
+-
+-func (dfs *dummyFmtState) Precision() (int, bool) {
+- return 0, false
+-}
+-
+-func (dfs *dummyFmtState) Width() (int, bool) {
+- return 0, false
+-}
+-
+-// TestInvalidReflectValue ensures the dump and formatter code handles an
+-// invalid reflect value properly. This needs access to internal state since it
+-// should never happen in real code and therefore can't be tested via the public
+-// API.
+-func TestInvalidReflectValue(t *testing.T) {
+- i := 1
+-
+- // Dump invalid reflect value.
+- v := new(reflect.Value)
+- buf := new(bytes.Buffer)
+- d := dumpState{w: buf, cs: &Config}
+- d.dump(*v)
+- s := buf.String()
+- want := "<invalid>"
+- if s != want {
+- t.Errorf("InvalidReflectValue #%d\n got: %s want: %s", i, s, want)
+- }
+- i++
+-
+- // Formatter invalid reflect value.
+- buf2 := new(dummyFmtState)
+- f := formatState{value: *v, cs: &Config, fs: buf2}
+- f.format(*v)
+- s = buf2.String()
+- want = "<invalid>"
+- if s != want {
+- t.Errorf("InvalidReflectValue #%d got: %s want: %s", i, s, want)
+- }
+-}
+-
+-// changeKind uses unsafe to intentionally change the kind of a reflect.Value to
+-// the maximum kind value which does not exist. This is needed to test the
+-// fallback code which punts to the standard fmt library for new types that
+-// might get added to the language.
+-func changeKind(v *reflect.Value, readOnly bool) {
+- rvf := (*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + offsetFlag))
+- *rvf = *rvf | ((1<<flagKindWidth - 1) << flagKindShift)
+- if readOnly {
+- *rvf |= flagRO
+- } else {
+- *rvf &= ^uintptr(flagRO)
+- }
+-}
+-
+-// TestAddedReflectValue tests functionaly of the dump and formatter code which
+-// falls back to the standard fmt library for new types that might get added to
+-// the language.
+-func TestAddedReflectValue(t *testing.T) {
+- i := 1
+-
+- // Dump using a reflect.Value that is exported.
+- v := reflect.ValueOf(int8(5))
+- changeKind(&v, false)
+- buf := new(bytes.Buffer)
+- d := dumpState{w: buf, cs: &Config}
+- d.dump(v)
+- s := buf.String()
+- want := "(int8) 5"
+- if s != want {
+- t.Errorf("TestAddedReflectValue #%d\n got: %s want: %s", i, s, want)
+- }
+- i++
+-
+- // Dump using a reflect.Value that is not exported.
+- changeKind(&v, true)
+- buf.Reset()
+- d.dump(v)
+- s = buf.String()
+- want = "(int8) <int8 Value>"
+- if s != want {
+- t.Errorf("TestAddedReflectValue #%d\n got: %s want: %s", i, s, want)
+- }
+- i++
+-
+- // Formatter using a reflect.Value that is exported.
+- changeKind(&v, false)
+- buf2 := new(dummyFmtState)
+- f := formatState{value: v, cs: &Config, fs: buf2}
+- f.format(v)
+- s = buf2.String()
+- want = "5"
+- if s != want {
+- t.Errorf("TestAddedReflectValue #%d got: %s want: %s", i, s, want)
+- }
+- i++
+-
+- // Formatter using a reflect.Value that is not exported.
+- changeKind(&v, true)
+- buf2.Reset()
+- f = formatState{value: v, cs: &Config, fs: buf2}
+- f.format(v)
+- s = buf2.String()
+- want = "<int8 Value>"
+- if s != want {
+- t.Errorf("TestAddedReflectValue #%d got: %s want: %s", i, s, want)
+- }
+-}
+-
+-// SortValues makes the internal sortValues function available to the test
+-// package.
+-func SortValues(values []reflect.Value) {
+- sortValues(values)
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew.go
+deleted file mode 100644
+index d8233f5..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew.go
++++ /dev/null
+@@ -1,148 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-package spew
+-
+-import (
+- "fmt"
+- "io"
+-)
+-
+-// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+-// passed with a default Formatter interface returned by NewFormatter. It
+-// returns the formatted string as a value that satisfies error. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+-func Errorf(format string, a ...interface{}) (err error) {
+- return fmt.Errorf(format, convertArgs(a)...)
+-}
+-
+-// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+-// passed with a default Formatter interface returned by NewFormatter. It
+-// returns the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
+-func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+- return fmt.Fprint(w, convertArgs(a)...)
+-}
+-
+-// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+-// passed with a default Formatter interface returned by NewFormatter. It
+-// returns the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
+-func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+- return fmt.Fprintf(w, format, convertArgs(a)...)
+-}
+-
+-// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+-// passed with a default Formatter interface returned by NewFormatter. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
+-func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+- return fmt.Fprintln(w, convertArgs(a)...)
+-}
+-
+-// Print is a wrapper for fmt.Print that treats each argument as if it were
+-// passed with a default Formatter interface returned by NewFormatter. It
+-// returns the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
+-func Print(a ...interface{}) (n int, err error) {
+- return fmt.Print(convertArgs(a)...)
+-}
+-
+-// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+-// passed with a default Formatter interface returned by NewFormatter. It
+-// returns the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+-func Printf(format string, a ...interface{}) (n int, err error) {
+- return fmt.Printf(format, convertArgs(a)...)
+-}
+-
+-// Println is a wrapper for fmt.Println that treats each argument as if it were
+-// passed with a default Formatter interface returned by NewFormatter. It
+-// returns the number of bytes written and any write error encountered. See
+-// NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
+-func Println(a ...interface{}) (n int, err error) {
+- return fmt.Println(convertArgs(a)...)
+-}
+-
+-// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+-// passed with a default Formatter interface returned by NewFormatter. It
+-// returns the resulting string. See NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
+-func Sprint(a ...interface{}) string {
+- return fmt.Sprint(convertArgs(a)...)
+-}
+-
+-// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+-// passed with a default Formatter interface returned by NewFormatter. It
+-// returns the resulting string. See NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
+-func Sprintf(format string, a ...interface{}) string {
+- return fmt.Sprintf(format, convertArgs(a)...)
+-}
+-
+-// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+-// were passed with a default Formatter interface returned by NewFormatter. It
+-// returns the resulting string. See NewFormatter for formatting details.
+-//
+-// This function is shorthand for the following syntax:
+-//
+-// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
+-func Sprintln(a ...interface{}) string {
+- return fmt.Sprintln(convertArgs(a)...)
+-}
+-
+-// convertArgs accepts a slice of arguments and returns a slice of the same
+-// length with each argument converted to a default spew Formatter interface.
+-func convertArgs(args []interface{}) (formatters []interface{}) {
+- formatters = make([]interface{}, len(args))
+- for index, arg := range args {
+- formatters[index] = NewFormatter(arg)
+- }
+- return formatters
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew_test.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew_test.go
+deleted file mode 100644
+index 3831ed2..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/spew_test.go
++++ /dev/null
+@@ -1,308 +0,0 @@
+-/*
+- * Copyright (c) 2013 Dave Collins <dave at davec.name>
+- *
+- * Permission to use, copy, modify, and distribute this software for any
+- * purpose with or without fee is hereby granted, provided that the above
+- * copyright notice and this permission notice appear in all copies.
+- *
+- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+- */
+-
+-package spew_test
+-
+-import (
+- "bytes"
+- "fmt"
+- "github.com/davecgh/go-spew/spew"
+- "io/ioutil"
+- "os"
+- "testing"
+-)
+-
+-// spewFunc is used to identify which public function of the spew package or
+-// ConfigState a test applies to.
+-type spewFunc int
+-
+-const (
+- fCSFdump spewFunc = iota
+- fCSFprint
+- fCSFprintf
+- fCSFprintln
+- fCSPrint
+- fCSPrintln
+- fCSSdump
+- fCSSprint
+- fCSSprintf
+- fCSSprintln
+- fCSErrorf
+- fCSNewFormatter
+- fErrorf
+- fFprint
+- fFprintln
+- fPrint
+- fPrintln
+- fSdump
+- fSprint
+- fSprintf
+- fSprintln
+-)
+-
+-// Map of spewFunc values to names for pretty printing.
+-var spewFuncStrings = map[spewFunc]string{
+- fCSFdump: "ConfigState.Fdump",
+- fCSFprint: "ConfigState.Fprint",
+- fCSFprintf: "ConfigState.Fprintf",
+- fCSFprintln: "ConfigState.Fprintln",
+- fCSSdump: "ConfigState.Sdump",
+- fCSPrint: "ConfigState.Print",
+- fCSPrintln: "ConfigState.Println",
+- fCSSprint: "ConfigState.Sprint",
+- fCSSprintf: "ConfigState.Sprintf",
+- fCSSprintln: "ConfigState.Sprintln",
+- fCSErrorf: "ConfigState.Errorf",
+- fCSNewFormatter: "ConfigState.NewFormatter",
+- fErrorf: "spew.Errorf",
+- fFprint: "spew.Fprint",
+- fFprintln: "spew.Fprintln",
+- fPrint: "spew.Print",
+- fPrintln: "spew.Println",
+- fSdump: "spew.Sdump",
+- fSprint: "spew.Sprint",
+- fSprintf: "spew.Sprintf",
+- fSprintln: "spew.Sprintln",
+-}
+-
+-func (f spewFunc) String() string {
+- if s, ok := spewFuncStrings[f]; ok {
+- return s
+- }
+- return fmt.Sprintf("Unknown spewFunc (%d)", int(f))
+-}
+-
+-// spewTest is used to describe a test to be performed against the public
+-// functions of the spew package or ConfigState.
+-type spewTest struct {
+- cs *spew.ConfigState
+- f spewFunc
+- format string
+- in interface{}
+- want string
+-}
+-
+-// spewTests houses the tests to be performed against the public functions of
+-// the spew package and ConfigState.
+-//
+-// These tests are only intended to ensure the public functions are exercised
+-// and are intentionally not exhaustive of types. The exhaustive type
+-// tests are handled in the dump and format tests.
+-var spewTests []spewTest
+-
+-// redirStdout is a helper function to return the standard output from f as a
+-// byte slice.
+-func redirStdout(f func()) ([]byte, error) {
+- tempFile, err := ioutil.TempFile("", "ss-test")
+- if err != nil {
+- return nil, err
+- }
+- fileName := tempFile.Name()
+- defer os.Remove(fileName) // Ignore error
+-
+- origStdout := os.Stdout
+- os.Stdout = tempFile
+- f()
+- os.Stdout = origStdout
+- tempFile.Close()
+-
+- return ioutil.ReadFile(fileName)
+-}
+-
+-func initSpewTests() {
+- // Config states with various settings.
+- scsDefault := spew.NewDefaultConfig()
+- scsNoMethods := &spew.ConfigState{Indent: " ", DisableMethods: true}
+- scsNoPmethods := &spew.ConfigState{Indent: " ", DisablePointerMethods: true}
+- scsMaxDepth := &spew.ConfigState{Indent: " ", MaxDepth: 1}
+- scsContinue := &spew.ConfigState{Indent: " ", ContinueOnMethod: true}
+-
+- // Variables for tests on types which implement Stringer interface with and
+- // without a pointer receiver.
+- ts := stringer("test")
+- tps := pstringer("test")
+-
+- // depthTester is used to test max depth handling for structs, array, slices
+- // and maps.
+- type depthTester struct {
+- ic indirCir1
+- arr [1]string
+- slice []string
+- m map[string]int
+- }
+- dt := depthTester{indirCir1{nil}, [1]string{"arr"}, []string{"slice"},
+- map[string]int{"one": 1}}
+-
+- // Variable for tests on types which implement error interface.
+- te := customError(10)
+-
+- spewTests = []spewTest{
+- {scsDefault, fCSFdump, "", int8(127), "(int8) 127\n"},
+- {scsDefault, fCSFprint, "", int16(32767), "32767"},
+- {scsDefault, fCSFprintf, "%v", int32(2147483647), "2147483647"},
+- {scsDefault, fCSFprintln, "", int(2147483647), "2147483647\n"},
+- {scsDefault, fCSPrint, "", int64(9223372036854775807), "9223372036854775807"},
+- {scsDefault, fCSPrintln, "", uint8(255), "255\n"},
+- {scsDefault, fCSSdump, "", uint8(64), "(uint8) 64\n"},
+- {scsDefault, fCSSprint, "", complex(1, 2), "(1+2i)"},
+- {scsDefault, fCSSprintf, "%v", complex(float32(3), 4), "(3+4i)"},
+- {scsDefault, fCSSprintln, "", complex(float64(5), 6), "(5+6i)\n"},
+- {scsDefault, fCSErrorf, "%#v", uint16(65535), "(uint16)65535"},
+- {scsDefault, fCSNewFormatter, "%v", uint32(4294967295), "4294967295"},
+- {scsDefault, fErrorf, "%v", uint64(18446744073709551615), "18446744073709551615"},
+- {scsDefault, fFprint, "", float32(3.14), "3.14"},
+- {scsDefault, fFprintln, "", float64(6.28), "6.28\n"},
+- {scsDefault, fPrint, "", true, "true"},
+- {scsDefault, fPrintln, "", false, "false\n"},
+- {scsDefault, fSdump, "", complex(-10, -20), "(complex128) (-10-20i)\n"},
+- {scsDefault, fSprint, "", complex(-1, -2), "(-1-2i)"},
+- {scsDefault, fSprintf, "%v", complex(float32(-3), -4), "(-3-4i)"},
+- {scsDefault, fSprintln, "", complex(float64(-5), -6), "(-5-6i)\n"},
+- {scsNoMethods, fCSFprint, "", ts, "test"},
+- {scsNoMethods, fCSFprint, "", &ts, "<*>test"},
+- {scsNoMethods, fCSFprint, "", tps, "test"},
+- {scsNoMethods, fCSFprint, "", &tps, "<*>test"},
+- {scsNoPmethods, fCSFprint, "", ts, "stringer test"},
+- {scsNoPmethods, fCSFprint, "", &ts, "<*>stringer test"},
+- {scsNoPmethods, fCSFprint, "", tps, "test"},
+- {scsNoPmethods, fCSFprint, "", &tps, "<*>stringer test"},
+- {scsMaxDepth, fCSFprint, "", dt, "{{<max>} [<max>] [<max>] map[<max>]}"},
+- {scsMaxDepth, fCSFdump, "", dt, "(spew_test.depthTester) {\n" +
+- " ic: (spew_test.indirCir1) {\n <max depth reached>\n },\n" +
+- " arr: ([1]string) (len=1 cap=1) {\n <max depth reached>\n },\n" +
+- " slice: ([]string) (len=1 cap=1) {\n <max depth reached>\n },\n" +
+- " m: (map[string]int) (len=1) {\n <max depth reached>\n }\n}\n"},
+- {scsContinue, fCSFprint, "", ts, "(stringer test) test"},
+- {scsContinue, fCSFdump, "", ts, "(spew_test.stringer) " +
+- "(len=4) (stringer test) \"test\"\n"},
+- {scsContinue, fCSFprint, "", te, "(error: 10) 10"},
+- {scsContinue, fCSFdump, "", te, "(spew_test.customError) " +
+- "(error: 10) 10\n"},
+- }
+-}
+-
+-// TestSpew executes all of the tests described by spewTests.
+-func TestSpew(t *testing.T) {
+- initSpewTests()
+-
+- t.Logf("Running %d tests", len(spewTests))
+- for i, test := range spewTests {
+- buf := new(bytes.Buffer)
+- switch test.f {
+- case fCSFdump:
+- test.cs.Fdump(buf, test.in)
+-
+- case fCSFprint:
+- test.cs.Fprint(buf, test.in)
+-
+- case fCSFprintf:
+- test.cs.Fprintf(buf, test.format, test.in)
+-
+- case fCSFprintln:
+- test.cs.Fprintln(buf, test.in)
+-
+- case fCSPrint:
+- b, err := redirStdout(func() { test.cs.Print(test.in) })
+- if err != nil {
+- t.Errorf("%v #%d %v", test.f, i, err)
+- continue
+- }
+- buf.Write(b)
+-
+- case fCSPrintln:
+- b, err := redirStdout(func() { test.cs.Println(test.in) })
+- if err != nil {
+- t.Errorf("%v #%d %v", test.f, i, err)
+- continue
+- }
+- buf.Write(b)
+-
+- case fCSSdump:
+- str := test.cs.Sdump(test.in)
+- buf.WriteString(str)
+-
+- case fCSSprint:
+- str := test.cs.Sprint(test.in)
+- buf.WriteString(str)
+-
+- case fCSSprintf:
+- str := test.cs.Sprintf(test.format, test.in)
+- buf.WriteString(str)
+-
+- case fCSSprintln:
+- str := test.cs.Sprintln(test.in)
+- buf.WriteString(str)
+-
+- case fCSErrorf:
+- err := test.cs.Errorf(test.format, test.in)
+- buf.WriteString(err.Error())
+-
+- case fCSNewFormatter:
+- fmt.Fprintf(buf, test.format, test.cs.NewFormatter(test.in))
+-
+- case fErrorf:
+- err := spew.Errorf(test.format, test.in)
+- buf.WriteString(err.Error())
+-
+- case fFprint:
+- spew.Fprint(buf, test.in)
+-
+- case fFprintln:
+- spew.Fprintln(buf, test.in)
+-
+- case fPrint:
+- b, err := redirStdout(func() { spew.Print(test.in) })
+- if err != nil {
+- t.Errorf("%v #%d %v", test.f, i, err)
+- continue
+- }
+- buf.Write(b)
+-
+- case fPrintln:
+- b, err := redirStdout(func() { spew.Println(test.in) })
+- if err != nil {
+- t.Errorf("%v #%d %v", test.f, i, err)
+- continue
+- }
+- buf.Write(b)
+-
+- case fSdump:
+- str := spew.Sdump(test.in)
+- buf.WriteString(str)
+-
+- case fSprint:
+- str := spew.Sprint(test.in)
+- buf.WriteString(str)
+-
+- case fSprintf:
+- str := spew.Sprintf(test.format, test.in)
+- buf.WriteString(str)
+-
+- case fSprintln:
+- str := spew.Sprintln(test.in)
+- buf.WriteString(str)
+-
+- default:
+- t.Errorf("%v #%d unrecognized function", test.f, i)
+- continue
+- }
+- s := buf.String()
+- if test.want != s {
+- t.Errorf("ConfigState #%d\n got: %s want: %s", i, s, test.want)
+- continue
+- }
+- }
+-}
+diff --git a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/testdata/dumpcgo.go b/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/testdata/dumpcgo.go
+deleted file mode 100644
+index 5c87dd4..0000000
+--- a/Godeps/_workspace/src/github.com/davecgh/go-spew/spew/testdata/dumpcgo.go
++++ /dev/null
+@@ -1,82 +0,0 @@
+-// Copyright (c) 2013 Dave Collins <dave at davec.name>
+-//
+-// Permission to use, copy, modify, and distribute this software for any
+-// purpose with or without fee is hereby granted, provided that the above
+-// copyright notice and this permission notice appear in all copies.
+-//
+-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+-// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+-// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+-// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+-// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+-// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+-// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+-
+-// NOTE: Due to the following build constraints, this file will only be compiled
+-// when both cgo is supported and "-tags testcgo" is added to the go test
+-// command line. This code should really only be in the dumpcgo_test.go file,
+-// but unfortunately Go will not allow cgo in test files, so this is a
+-// workaround to allow cgo types to be tested. This configuration is used
+-// because spew itself does not require cgo to run even though it does handle
+-// certain cgo types specially. Rather than forcing all clients to require cgo
+-// and an external C compiler just to run the tests, this scheme makes them
+-// optional.
+-// +build cgo,testcgo
+-
+-package testdata
+-
+-/*
+-#include <stdint.h>
+-typedef unsigned char custom_uchar_t;
+-
+-char *ncp = 0;
+-char *cp = "test";
+-char ca[6] = {'t', 'e', 's', 't', '2', '\0'};
+-unsigned char uca[6] = {'t', 'e', 's', 't', '3', '\0'};
+-signed char sca[6] = {'t', 'e', 's', 't', '4', '\0'};
+-uint8_t ui8ta[6] = {'t', 'e', 's', 't', '5', '\0'};
+-custom_uchar_t tuca[6] = {'t', 'e', 's', 't', '6', '\0'};
+-*/
+-import "C"
+-
+-// GetCgoNullCharPointer returns a null char pointer via cgo. This is only
+-// used for tests.
+-func GetCgoNullCharPointer() interface{} {
+- return C.ncp
+-}
+-
+-// GetCgoCharPointer returns a char pointer via cgo. This is only used for
+-// tests.
+-func GetCgoCharPointer() interface{} {
+- return C.cp
+-}
+-
+-// GetCgoCharArray returns a char array via cgo and the array's len and cap.
+-// This is only used for tests.
+-func GetCgoCharArray() (interface{}, int, int) {
+- return C.ca, len(C.ca), cap(C.ca)
+-}
+-
+-// GetCgoUnsignedCharArray returns an unsigned char array via cgo and the
+-// array's len and cap. This is only used for tests.
+-func GetCgoUnsignedCharArray() (interface{}, int, int) {
+- return C.uca, len(C.uca), cap(C.uca)
+-}
+-
+-// GetCgoSignedCharArray returns a signed char array via cgo and the array's len
+-// and cap. This is only used for tests.
+-func GetCgoSignedCharArray() (interface{}, int, int) {
+- return C.sca, len(C.sca), cap(C.sca)
+-}
+-
+-// GetCgoUint8tArray returns a uint8_t array via cgo and the array's len and
+-// cap. This is only used for tests.
+-func GetCgoUint8tArray() (interface{}, int, int) {
+- return C.ui8ta, len(C.ui8ta), cap(C.ui8ta)
+-}
+-
+-// GetCgoTypdefedUnsignedCharArray returns a typedefed unsigned char array via
+-// cgo and the array's len and cap. This is only used for tests.
+-func GetCgoTypdefedUnsignedCharArray() (interface{}, int, int) {
+- return C.tuca, len(C.tuca), cap(C.tuca)
+-}
diff --git a/Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs/LICENSE b/Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs/LICENSE
deleted file mode 100644
index 5782c72..0000000
@@ -40517,12 +46123,15 @@ index cece7be..0000000
-restful-path-tail
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/CHANGES.md b/Godeps/_workspace/src/github.com/emicklei/go-restful/CHANGES.md
deleted file mode 100644
-index 4855402..0000000
+index 9c6de61..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/CHANGES.md
+++ /dev/null
-@@ -1,127 +0,0 @@
+@@ -1,130 +0,0 @@
-Change history of go-restful
-=
+-2014-11-27
+-- (api add) PrettyPrint per response. (as proposed in #167)
+-
-2014-11-12
-- (api add) ApiVersion(.) for documentation in Swagger UI
-
@@ -41074,10 +46683,10 @@ index 5e564d0..0000000
-)
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/container.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/container.go
deleted file mode 100644
-index b5b5b2d..0000000
+index 7aae565..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/container.go
+++ /dev/null
-@@ -1,257 +0,0 @@
+@@ -1,261 +0,0 @@
-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
@@ -41178,6 +46787,10 @@ index b5b5b2d..0000000
- log.Fatalf("[restful] WebService with duplicate root path detected:['%v']", each)
- }
- }
+- // if rootPath was not set then lazy initialize it
+- if len(service.rootPath) == 0 {
+- service.Path("/")
+- }
- c.webServices = append(c.webServices, service)
- return c
-}
@@ -41310,7 +46923,7 @@ index b5b5b2d..0000000
- methods := []string{}
- requestPath := req.Request.URL.Path
- for _, ws := range c.RegisteredWebServices() {
-- matches := ws.compiledPathExpression().Matcher.FindStringSubmatch(requestPath)
+- matches := ws.pathExpr.Matcher.FindStringSubmatch(requestPath)
- if matches != nil {
- finalMatch := matches[len(matches)-1]
- for _, rt := range ws.Routes() {
@@ -41653,7 +47266,7 @@ index e27dbf1..0000000
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/curly.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/curly.go
deleted file mode 100644
-index 1a29826..0000000
+index ce284f7..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/curly.go
+++ /dev/null
@@ -1,162 +0,0 @@
@@ -41780,7 +47393,7 @@ index 1a29826..0000000
- var best *WebService
- score := -1
- for _, each := range webServices {
-- matches, eachScore := c.computeWebserviceScore(requestTokens, each.compiledPathExpression().tokens)
+- matches, eachScore := c.computeWebserviceScore(requestTokens, each.pathExpr.tokens)
- if matches && (eachScore > score) {
- best = each
- score = eachScore
@@ -41881,10 +47494,10 @@ index 3edab72..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/curly_test.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/curly_test.go
deleted file mode 100644
-index 4291825..0000000
+index 31d66dc..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/curly_test.go
+++ /dev/null
-@@ -1,228 +0,0 @@
+@@ -1,231 +0,0 @@
-package restful
-
-import (
@@ -41919,7 +47532,7 @@ index 4291825..0000000
- var wss = []*WebService{ws1, ws2, ws3, ws4, ws5, ws7}
-
- for _, each := range wss {
-- t.Logf("path=%s,toks=%v\n", each.compiledPathExpression().Source, each.compiledPathExpression().tokens)
+- t.Logf("path=%s,toks=%v\n", each.pathExpr.Source, each.pathExpr.tokens)
- }
-
- router := CurlyRouter{}
@@ -41966,7 +47579,7 @@ index 4291825..0000000
- requestPath := fix.path
- requestTokens := tokenizePath(requestPath)
- for _, ws := range wss {
-- serviceTokens := ws.compiledPathExpression().tokens
+- serviceTokens := ws.pathExpr.tokens
- matches, score := router.computeWebserviceScore(requestTokens, serviceTokens)
- t.Logf("req=%s,toks:%v,ws=%s,toks:%v,score=%d,matches=%v", requestPath, requestTokens, ws.RootPath(), serviceTokens, score, matches)
- }
@@ -42076,6 +47689,7 @@ index 4291825..0000000
-// clear && go test -v -test.run TestCurly_JsonHtml ...restful
-func TestCurly_JsonHtml(t *testing.T) {
- ws1 := new(WebService)
+- ws1.Path("/")
- ws1.Route(ws1.GET("/some.html").To(curlyDummy).Consumes("*/*").Produces("text/html"))
- req, _ := http.NewRequest("GET", "/some.html", nil)
- req.Header.Set("Accept", "application/json")
@@ -42092,6 +47706,7 @@ index 4291825..0000000
-func TestCurly_ISSUE_137(t *testing.T) {
- ws1 := new(WebService)
- ws1.Route(ws1.GET("/hello").To(curlyDummy))
+- ws1.Path("/")
- req, _ := http.NewRequest("GET", "/", nil)
- _, route, _ := CurlyRouter{}.SelectRoute([]*WebService{ws1}, req)
- t.Log(route)
@@ -42104,6 +47719,7 @@ index 4291825..0000000
-func TestCurly_ISSUE_137_2(t *testing.T) {
- ws1 := new(WebService)
- ws1.Route(ws1.GET("/hello").To(curlyDummy))
+- ws1.Path("/")
- req, _ := http.NewRequest("GET", "/hello/bob", nil)
- _, route, _ := CurlyRouter{}.SelectRoute([]*WebService{ws1}, req)
- t.Log(route)
@@ -44516,10 +50132,10 @@ index b5de8a2..0000000
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311.go
deleted file mode 100644
-index affeee7..0000000
+index 3d9d7d8..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311.go
+++ /dev/null
-@@ -1,248 +0,0 @@
+@@ -1,247 +0,0 @@
-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
@@ -44657,11 +50273,10 @@ index affeee7..0000000
-func (r RouterJSR311) detectDispatcher(requestPath string, dispatchers []*WebService) (*WebService, string, error) {
- filtered := &sortableDispatcherCandidates{}
- for _, each := range dispatchers {
-- pathExpr := each.compiledPathExpression()
-- matches := pathExpr.Matcher.FindStringSubmatch(requestPath)
+- matches := each.pathExpr.Matcher.FindStringSubmatch(requestPath)
- if matches != nil {
- filtered.candidates = append(filtered.candidates,
-- dispatcherCandidate{each, matches[len(matches)-1], len(matches), pathExpr.LiteralCount, pathExpr.VarCount})
+- dispatcherCandidate{each, matches[len(matches)-1], len(matches), each.pathExpr.LiteralCount, each.pathExpr.VarCount})
- }
- }
- if len(filtered.candidates) == 0 {
@@ -44770,10 +50385,10 @@ index affeee7..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311_test.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311_test.go
deleted file mode 100644
-index 8d54ed9..0000000
+index b531b7f..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/jsr311_test.go
+++ /dev/null
-@@ -1,231 +0,0 @@
+@@ -1,236 +0,0 @@
-package restful
-
-import (
@@ -44810,6 +50425,11 @@ index 8d54ed9..0000000
- ws7 := new(WebService).Path("/{p}/q")
- var dispatchers = []*WebService{ws1, ws2, ws3, ws4, ws5, ws6, ws7}
-
+- wc := NewContainer()
+- for _, each := range dispatchers {
+- wc.Add(each)
+- }
+-
- router := RouterJSR311{}
-
- ok := true
@@ -45613,10 +51233,10 @@ index 6e7c55b..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/response.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/response.go
deleted file mode 100644
-index 2b6d762..0000000
+index 0a3cbd5..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/response.go
+++ /dev/null
-@@ -1,233 +0,0 @@
+@@ -1,241 +0,0 @@
-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
@@ -45646,11 +51266,12 @@ index 2b6d762..0000000
- routeProduces []string // mime-types what the Route says it can produce
- statusCode int // HTTP status code that has been written explicity (if zero then net/http has written 200)
- contentLength int // number of bytes written for the response body
+- prettyPrint bool // controls the indentation feature of XML and JSON serialization. It is initialized using var PrettyPrintResponses.
-}
-
-// Creates a new response based on a http ResponseWriter.
-func NewResponse(httpWriter http.ResponseWriter) *Response {
-- return &Response{httpWriter, "", []string{}, http.StatusOK, 0} // empty content-types
+- return &Response{httpWriter, "", []string{}, http.StatusOK, 0, PrettyPrintResponses} // empty content-types
-}
-
-// If Accept header matching fails, fall back to this type, otherwise
@@ -45669,6 +51290,11 @@ index 2b6d762..0000000
- return r
-}
-
+-// PrettyPrint changes whether this response must produce pretty (line-by-line, indented) JSON or XML output.
+-func (r *Response) PrettyPrint(bePretty bool) {
+- r.prettyPrint = bePretty
+-}
+-
-// AddHeader is a shortcut for .Header().Add(header,value)
-func (r Response) AddHeader(header string, value string) Response {
- r.Header().Add(header, value)
@@ -45738,7 +51364,7 @@ index 2b6d762..0000000
- if value == nil { // do not write a nil representation
- return nil
- }
-- if PrettyPrintResponses {
+- if r.prettyPrint {
- output, err = xml.MarshalIndent(value, " ", " ")
- } else {
- output, err = xml.Marshal(value)
@@ -45769,7 +51395,7 @@ index 2b6d762..0000000
- if value == nil { // do not write a nil representation
- return nil
- }
-- if PrettyPrintResponses {
+- if r.prettyPrint {
- output, err = json.MarshalIndent(value, " ", " ")
- } else {
- output, err = json.Marshal(value)
@@ -45811,13 +51437,15 @@ index 2b6d762..0000000
-
-// WriteHeader is overridden to remember the Status Code that has been written.
-// Note that using this method, the status value is only written when
--// - calling WriteEntity
--// - or directly WriteAsXml,WriteAsJson.
--// - or if the status is 204 (http.StatusNoContent)
+-// - calling WriteEntity,
+-// - or directly calling WriteAsXml or WriteAsJson,
+-// - or if the status is one for which no response is allowed (i.e.,
+-// 204 (http.StatusNoContent) or 304 (http.StatusNotModified))
-func (r *Response) WriteHeader(httpStatus int) {
- r.statusCode = httpStatus
- // if 204 then WriteEntity will not be called so we need to pass this code
-- if http.StatusNoContent == httpStatus {
+- if http.StatusNoContent == httpStatus ||
+- http.StatusNotModified == httpStatus {
- r.ResponseWriter.WriteHeader(httpStatus)
- }
-}
@@ -45852,10 +51480,10 @@ index 2b6d762..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/response_test.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/response_test.go
deleted file mode 100644
-index 314a95a..0000000
+index ee9a74f..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/response_test.go
+++ /dev/null
-@@ -1,137 +0,0 @@
+@@ -1,157 +0,0 @@
-package restful
-
-import (
@@ -45867,7 +51495,7 @@ index 314a95a..0000000
-
-func TestWriteHeader(t *testing.T) {
- httpWriter := httptest.NewRecorder()
-- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0}
+- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0, true}
- resp.WriteHeader(123)
- if resp.StatusCode() != 123 {
- t.Errorf("Unexpected status code:%d", resp.StatusCode())
@@ -45876,7 +51504,7 @@ index 314a95a..0000000
-
-func TestNoWriteHeader(t *testing.T) {
- httpWriter := httptest.NewRecorder()
-- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0}
+- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0, true}
- if resp.StatusCode() != http.StatusOK {
- t.Errorf("Unexpected status code:%d", resp.StatusCode())
- }
@@ -45889,7 +51517,7 @@ index 314a95a..0000000
-// go test -v -test.run TestMeasureContentLengthXml ...restful
-func TestMeasureContentLengthXml(t *testing.T) {
- httpWriter := httptest.NewRecorder()
-- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0}
+- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0, true}
- resp.WriteAsXml(food{"apple"})
- if resp.ContentLength() != 76 {
- t.Errorf("Incorrect measured length:%d", resp.ContentLength())
@@ -45899,17 +51527,27 @@ index 314a95a..0000000
-// go test -v -test.run TestMeasureContentLengthJson ...restful
-func TestMeasureContentLengthJson(t *testing.T) {
- httpWriter := httptest.NewRecorder()
-- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0}
+- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0, true}
- resp.WriteAsJson(food{"apple"})
- if resp.ContentLength() != 22 {
- t.Errorf("Incorrect measured length:%d", resp.ContentLength())
- }
-}
-
+-// go test -v -test.run TestMeasureContentLengthJsonNotPretty ...restful
+-func TestMeasureContentLengthJsonNotPretty(t *testing.T) {
+- httpWriter := httptest.NewRecorder()
+- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0, false}
+- resp.WriteAsJson(food{"apple"})
+- if resp.ContentLength() != 16 {
+- t.Errorf("Incorrect measured length:%d", resp.ContentLength())
+- }
+-}
+-
-// go test -v -test.run TestMeasureContentLengthWriteErrorString ...restful
-func TestMeasureContentLengthWriteErrorString(t *testing.T) {
- httpWriter := httptest.NewRecorder()
-- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0}
+- resp := Response{httpWriter, "*/*", []string{"*/*"}, 0, 0, true}
- resp.WriteErrorString(404, "Invalid")
- if resp.ContentLength() != len("Invalid") {
- t.Errorf("Incorrect measured length:%d", resp.ContentLength())
@@ -45919,7 +51557,7 @@ index 314a95a..0000000
-// go test -v -test.run TestStatusCreatedAndContentTypeJson_Issue54 ...restful
-func TestStatusCreatedAndContentTypeJson_Issue54(t *testing.T) {
- httpWriter := httptest.NewRecorder()
-- resp := Response{httpWriter, "application/json", []string{"application/json"}, 0, 0}
+- resp := Response{httpWriter, "application/json", []string{"application/json"}, 0, 0, true}
- resp.WriteHeader(201)
- resp.WriteAsJson(food{"Juicy"})
- if httpWriter.HeaderMap.Get("Content-Type") != "application/json" {
@@ -45941,7 +51579,7 @@ index 314a95a..0000000
-// go test -v -test.run TestLastWriteErrorCaught ...restful
-func TestLastWriteErrorCaught(t *testing.T) {
- httpWriter := errorOnWriteRecorder{httptest.NewRecorder()}
-- resp := Response{httpWriter, "application/json", []string{"application/json"}, 0, 0}
+- resp := Response{httpWriter, "application/json", []string{"application/json"}, 0, 0, true}
- err := resp.WriteAsJson(food{"Juicy"})
- if err.Error() != "fail" {
- t.Errorf("Unexpected error message:%v", err)
@@ -45952,7 +51590,7 @@ index 314a95a..0000000
-func TestAcceptStarStar_Issue83(t *testing.T) {
- httpWriter := httptest.NewRecorder()
- // Accept Produces
-- resp := Response{httpWriter, "application/bogus,*/*;q=0.8", []string{"application/json"}, 0, 0}
+- resp := Response{httpWriter, "application/bogus,*/*;q=0.8", []string{"application/json"}, 0, 0, true}
- resp.WriteEntity(food{"Juicy"})
- ct := httpWriter.Header().Get("Content-Type")
- if "application/json" != ct {
@@ -45964,7 +51602,7 @@ index 314a95a..0000000
-func TestAcceptSkipStarStar_Issue83(t *testing.T) {
- httpWriter := httptest.NewRecorder()
- // Accept Produces
-- resp := Response{httpWriter, " application/xml ,*/* ; q=0.8", []string{"application/json", "application/xml"}, 0, 0}
+- resp := Response{httpWriter, " application/xml ,*/* ; q=0.8", []string{"application/json", "application/xml"}, 0, 0, true}
- resp.WriteEntity(food{"Juicy"})
- ct := httpWriter.Header().Get("Content-Type")
- if "application/xml" != ct {
@@ -45976,7 +51614,7 @@ index 314a95a..0000000
-func TestAcceptXmlBeforeStarStar_Issue83(t *testing.T) {
- httpWriter := httptest.NewRecorder()
- // Accept Produces
-- resp := Response{httpWriter, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", []string{"application/json"}, 0, 0}
+- resp := Response{httpWriter, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", []string{"application/json"}, 0, 0, true}
- resp.WriteEntity(food{"Juicy"})
- ct := httpWriter.Header().Get("Content-Type")
- if "application/json" != ct {
@@ -45987,12 +51625,22 @@ index 314a95a..0000000
-// go test -v -test.run TestWriteHeaderNoContent_Issue124 ...restful
-func TestWriteHeaderNoContent_Issue124(t *testing.T) {
- httpWriter := httptest.NewRecorder()
-- resp := Response{httpWriter, "text/plain", []string{"text/plain"}, 0, 0}
+- resp := Response{httpWriter, "text/plain", []string{"text/plain"}, 0, 0, true}
- resp.WriteHeader(http.StatusNoContent)
- if httpWriter.Code != http.StatusNoContent {
- t.Errorf("got %d want %d", httpWriter.Code, http.StatusNoContent)
- }
-}
+-
+-// go test -v -test.run TestStatusCreatedAndContentTypeJson_Issue163 ...restful
+-func TestStatusCreatedAndContentTypeJson_Issue163(t *testing.T) {
+- httpWriter := httptest.NewRecorder()
+- resp := Response{httpWriter, "application/json", []string{"application/json"}, 0, 0, true}
+- resp.WriteHeader(http.StatusNotModified)
+- if httpWriter.Code != http.StatusNotModified {
+- t.Errorf("Got %d want %d", httpWriter.Code, http.StatusNotModified)
+- }
+-}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/route.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/route.go
deleted file mode 100644
index 59d6e23..0000000
@@ -46167,7 +51815,7 @@ index 59d6e23..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/route_builder.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/route_builder.go
deleted file mode 100644
-index 0046afb..0000000
+index 8f46619..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/route_builder.go
+++ /dev/null
@@ -1,208 +0,0 @@
@@ -46257,7 +51905,7 @@ index 0046afb..0000000
-func (b *RouteBuilder) Reads(sample interface{}) *RouteBuilder {
- b.readSample = sample
- typeAsName := reflect.TypeOf(sample).String()
-- bodyParameter := &Parameter{&ParameterData{Name: typeAsName}}
+- bodyParameter := &Parameter{&ParameterData{Name: "body"}}
- bodyParameter.beBody()
- bodyParameter.Required(true)
- bodyParameter.DataType(typeAsName)
@@ -48567,19 +54215,17 @@ index 6127bd5..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/emicklei/go-restful/web_service.go b/Godeps/_workspace/src/github.com/emicklei/go-restful/web_service.go
deleted file mode 100644
-index 323676f..0000000
+index f3c10e0..0000000
--- a/Godeps/_workspace/src/github.com/emicklei/go-restful/web_service.go
+++ /dev/null
-@@ -1,194 +0,0 @@
+@@ -1,190 +0,0 @@
-package restful
-
-// Copyright 2013 Ernest Micklei. All rights reserved.
-// Use of this source code is governed by a license
-// that can be found in the LICENSE file.
-
--import (
-- "log"
--)
+-import "log"
-
-// WebService holds a collection of Route values that bind a Http Method + URL Path to a function.
-type WebService struct {
@@ -48594,19 +54240,16 @@ index 323676f..0000000
- apiVersion string
-}
-
--// compiledPathExpression ensures that the path is compiled into a RegEx for those routers that need it.
--func (w *WebService) compiledPathExpression() *pathExpression {
-- if w.pathExpr == nil {
-- if len(w.rootPath) == 0 {
-- w.Path("/") // lazy initialize path
-- }
-- compiled, err := newPathExpression(w.rootPath)
-- if err != nil {
-- log.Fatalf("[restful] Invalid path:%s because:%v", w.rootPath, err)
-- }
-- w.pathExpr = compiled
+-// compilePathExpression ensures that the path is compiled into a RegEx for those routers that need it.
+-func (w *WebService) compilePathExpression() {
+- if len(w.rootPath) == 0 {
+- w.Path("/") // lazy initialize path
+- }
+- compiled, err := newPathExpression(w.rootPath)
+- if err != nil {
+- log.Fatalf("[restful] invalid path:%s because:%v", w.rootPath, err)
- }
-- return w.pathExpr
+- w.pathExpr = compiled
-}
-
-// ApiVersion sets the API version for documentation purposes.
@@ -48622,6 +54265,7 @@ index 323676f..0000000
-// All Routes will be relative to this path.
-func (w *WebService) Path(root string) *WebService {
- w.rootPath = root
+- w.compilePathExpression()
- return w
-}
-
@@ -57354,6 +62998,1216 @@ index 42752b0..0000000
- }
- return &stdWriter{Writer: w, prefix: t, sizeBuf: make([]byte, 4)}
-}
+diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/.gitignore b/Godeps/_workspace/src/github.com/ghodss/yaml/.gitignore
+deleted file mode 100644
+index e256a31..0000000
+--- a/Godeps/_workspace/src/github.com/ghodss/yaml/.gitignore
++++ /dev/null
+@@ -1,20 +0,0 @@
+-# OSX leaves these everywhere on SMB shares
+-._*
+-
+-# Eclipse files
+-.classpath
+-.project
+-.settings/**
+-
+-# Emacs save files
+-*~
+-
+-# Vim-related files
+-[._]*.s[a-w][a-z]
+-[._]s[a-w][a-z]
+-*.un~
+-Session.vim
+-.netrwhist
+-
+-# Go test binaries
+-*.test
+diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/LICENSE b/Godeps/_workspace/src/github.com/ghodss/yaml/LICENSE
+deleted file mode 100644
+index 7805d36..0000000
+--- a/Godeps/_workspace/src/github.com/ghodss/yaml/LICENSE
++++ /dev/null
+@@ -1,50 +0,0 @@
+-The MIT License (MIT)
+-
+-Copyright (c) 2014 Sam Ghods
+-
+-Permission is hereby granted, free of charge, to any person obtaining a copy
+-of this software and associated documentation files (the "Software"), to deal
+-in the Software without restriction, including without limitation the rights
+-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+-copies of the Software, and to permit persons to whom the Software is
+-furnished to do so, subject to the following conditions:
+-
+-The above copyright notice and this permission notice shall be included in all
+-copies or substantial portions of the Software.
+-
+-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+-SOFTWARE.
+-
+-
+-Copyright (c) 2012 The Go Authors. All rights reserved.
+-
+-Redistribution and use in source and binary forms, with or without
+-modification, are permitted provided that the following conditions are
+-met:
+-
+- * Redistributions of source code must retain the above copyright
+-notice, this list of conditions and the following disclaimer.
+- * Redistributions in binary form must reproduce the above
+-copyright notice, this list of conditions and the following disclaimer
+-in the documentation and/or other materials provided with the
+-distribution.
+- * Neither the name of Google Inc. nor the names of its
+-contributors may be used to endorse or promote products derived from
+-this software without specific prior written permission.
+-
+-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/README.md b/Godeps/_workspace/src/github.com/ghodss/yaml/README.md
+deleted file mode 100644
+index 2d60309..0000000
+--- a/Godeps/_workspace/src/github.com/ghodss/yaml/README.md
++++ /dev/null
+@@ -1,114 +0,0 @@
+-# YAML marshaling and unmarshaling support for Go
+-
+-## Introduction
+-
+-A wrapper around [go-yaml](https://github.com/go-yaml/yaml) designed to enable a better way of handling YAML when marshaling to and from structs.
+-
+-In short, this library first converts YAML to JSON using go-yaml and then uses `json.Marshal` and `json.Unmarshal` to convert to or from the struct. This means that it effectively reuses the JSON struct tags as well as the custom JSON methods `MarshalJSON` and `UnmarshalJSON` unlike go-yaml. For a detailed overview of the rationale behind this method, [see this blog post](http://ghodss.com/2014/the-right-way-to-handle-yaml-in-golang/).
+-
+-## Compatibility
+-
+-This package uses [go-yaml v2](https://github.com/go-yaml/yaml) and therefore supports [everything go-yaml supports](https://github.com/go-yaml/yaml#compatibility).
+-
+-## Caveats
+-
+-**Caveat #1:** When using `yaml.Marshal` and `yaml.Unmarshal`, binary data should NOT be preceded with the `!!binary` YAML tag. If you do, go-yaml will convert the binary data from base64 to native binary data, which is not compatible with JSON. You can still use binary in your YAML files though - just store them without the `!!binary` tag and decode the base64 in your code (e.g. in the custom JSON methods `MarshalJSON` and `UnmarshalJSON`). This also has the benefit that your YAML and your JSON binary data will be decoded exactly the same way. As an example:
+-
+-```
+-BAD:
+- exampleKey: !!binary gIGC
+-
+-GOOD:
+- exampleKey: gIGC
+-... and decode the base64 data in your code.
+-```
+-
+-**Caveat #2:** When using `YAMLToJSON` directly, maps with keys that are maps will result in an error since this is not supported by JSON. This error will occur in `Unmarshal` as well since you can't unmarshal map keys anyways since struct fields can't be keys.
+-
+-## Installation and usage
+-
+-To install, run:
+-
+-```
+-$ go get github.com/ghodss/yaml
+-```
+-
+-And import using:
+-
+-```
+-import "github.com/ghodss/yaml"
+-```
+-
+-Usage is very similar to the JSON library:
+-
+-```go
+-import (
+- "fmt"
+-
+- "github.com/ghodss/yaml"
+-)
+-
+-type Person struct {
+- Name string `json:"name"` // Affects YAML field names too.
+- Age int `json:"name"`
+-}
+-
+-func main() {
+- // Marshal a Person struct to YAML.
+- p := Person{"John", 30}
+- y, err := yaml.Marshal(p)
+- if err != nil {
+- fmt.Printf("err: %v\n", err)
+- return
+- }
+- fmt.Println(string(y))
+- /* Output:
+- name: John
+- age: 30
+- */
+-
+- // Unmarshal the YAML back into a Person struct.
+- var p2 Person
+- err := yaml.Unmarshal(y, &p2)
+- if err != nil {
+- fmt.Printf("err: %v\n", err)
+- return
+- }
+- fmt.Println(p2)
+- /* Output:
+- {John 30}
+- */
+-}
+-```
+-
+-`yaml.YAMLToJSON` and `yaml.JSONToYAML` methods are also available:
+-
+-```go
+-import (
+- "fmt"
+-
+- "github.com/ghodss/yaml"
+-)
+-func main() {
+- j := []byte(`{"name": "John", "age": 30}`)
+- y, err := yaml.JSONToYAML(j)
+- if err != nil {
+- fmt.Printf("err: %v\n", err)
+- return
+- }
+- fmt.Println(string(y))
+- /* Output:
+- name: John
+- age: 30
+- */
+- j2, err := yaml.YAMLToJSON(y)
+- if err != nil {
+- fmt.Printf("err: %v\n", err)
+- return
+- }
+- fmt.Println(string(j2))
+- /* Output:
+- {"age":30,"name":"John"}
+- */
+-}
+-```
+diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/fields.go b/Godeps/_workspace/src/github.com/ghodss/yaml/fields.go
+deleted file mode 100644
+index 0bd3c2b..0000000
+--- a/Godeps/_workspace/src/github.com/ghodss/yaml/fields.go
++++ /dev/null
+@@ -1,497 +0,0 @@
+-// Copyright 2013 The Go Authors. All rights reserved.
+-// Use of this source code is governed by a BSD-style
+-// license that can be found in the LICENSE file.
+-package yaml
+-
+-import (
+- "bytes"
+- "encoding"
+- "encoding/json"
+- "reflect"
+- "sort"
+- "strings"
+- "sync"
+- "unicode"
+- "unicode/utf8"
+-)
+-
+-// indirect walks down v allocating pointers as needed,
+-// until it gets to a non-pointer.
+-// if it encounters an Unmarshaler, indirect stops and returns that.
+-// if decodingNull is true, indirect stops at the last pointer so it can be set to nil.
+-func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
+- // If v is a named type and is addressable,
+- // start with its address, so that if the type has pointer methods,
+- // we find them.
+- if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
+- v = v.Addr()
+- }
+- for {
+- // Load value from interface, but only if the result will be
+- // usefully addressable.
+- if v.Kind() == reflect.Interface && !v.IsNil() {
+- e := v.Elem()
+- if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
+- v = e
+- continue
+- }
+- }
+-
+- if v.Kind() != reflect.Ptr {
+- break
+- }
+-
+- if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
+- break
+- }
+- if v.IsNil() {
+- v.Set(reflect.New(v.Type().Elem()))
+- }
+- if v.Type().NumMethod() > 0 {
+- if u, ok := v.Interface().(json.Unmarshaler); ok {
+- return u, nil, reflect.Value{}
+- }
+- if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
+- return nil, u, reflect.Value{}
+- }
+- }
+- v = v.Elem()
+- }
+- return nil, nil, v
+-}
+-
+-// A field represents a single field found in a struct.
+-type field struct {
+- name string
+- nameBytes []byte // []byte(name)
+- equalFold func(s, t []byte) bool // bytes.EqualFold or equivalent
+-
+- tag bool
+- index []int
+- typ reflect.Type
+- omitEmpty bool
+- quoted bool
+-}
+-
+-func fillField(f field) field {
+- f.nameBytes = []byte(f.name)
+- f.equalFold = foldFunc(f.nameBytes)
+- return f
+-}
+-
+-// byName sorts field by name, breaking ties with depth,
+-// then breaking ties with "name came from json tag", then
+-// breaking ties with index sequence.
+-type byName []field
+-
+-func (x byName) Len() int { return len(x) }
+-
+-func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+-
+-func (x byName) Less(i, j int) bool {
+- if x[i].name != x[j].name {
+- return x[i].name < x[j].name
+- }
+- if len(x[i].index) != len(x[j].index) {
+- return len(x[i].index) < len(x[j].index)
+- }
+- if x[i].tag != x[j].tag {
+- return x[i].tag
+- }
+- return byIndex(x).Less(i, j)
+-}
+-
+-// byIndex sorts field by index sequence.
+-type byIndex []field
+-
+-func (x byIndex) Len() int { return len(x) }
+-
+-func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+-
+-func (x byIndex) Less(i, j int) bool {
+- for k, xik := range x[i].index {
+- if k >= len(x[j].index) {
+- return false
+- }
+- if xik != x[j].index[k] {
+- return xik < x[j].index[k]
+- }
+- }
+- return len(x[i].index) < len(x[j].index)
+-}
+-
+-// typeFields returns a list of fields that JSON should recognize for the given type.
+-// The algorithm is breadth-first search over the set of structs to include - the top struct
+-// and then any reachable anonymous structs.
+-func typeFields(t reflect.Type) []field {
+- // Anonymous fields to explore at the current level and the next.
+- current := []field{}
+- next := []field{{typ: t}}
+-
+- // Count of queued names for current level and the next.
+- count := map[reflect.Type]int{}
+- nextCount := map[reflect.Type]int{}
+-
+- // Types already visited at an earlier level.
+- visited := map[reflect.Type]bool{}
+-
+- // Fields found.
+- var fields []field
+-
+- for len(next) > 0 {
+- current, next = next, current[:0]
+- count, nextCount = nextCount, map[reflect.Type]int{}
+-
+- for _, f := range current {
+- if visited[f.typ] {
+- continue
+- }
+- visited[f.typ] = true
+-
+- // Scan f.typ for fields to include.
+- for i := 0; i < f.typ.NumField(); i++ {
+- sf := f.typ.Field(i)
+- if sf.PkgPath != "" { // unexported
+- continue
+- }
+- tag := sf.Tag.Get("json")
+- if tag == "-" {
+- continue
+- }
+- name, opts := parseTag(tag)
+- if !isValidTag(name) {
+- name = ""
+- }
+- index := make([]int, len(f.index)+1)
+- copy(index, f.index)
+- index[len(f.index)] = i
+-
+- ft := sf.Type
+- if ft.Name() == "" && ft.Kind() == reflect.Ptr {
+- // Follow pointer.
+- ft = ft.Elem()
+- }
+-
+- // Record found field and index sequence.
+- if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
+- tagged := name != ""
+- if name == "" {
+- name = sf.Name
+- }
+- fields = append(fields, fillField(field{
+- name: name,
+- tag: tagged,
+- index: index,
+- typ: ft,
+- omitEmpty: opts.Contains("omitempty"),
+- quoted: opts.Contains("string"),
+- }))
+- if count[f.typ] > 1 {
+- // If there were multiple instances, add a second,
+- // so that the annihilation code will see a duplicate.
+- // It only cares about the distinction between 1 or 2,
+- // so don't bother generating any more copies.
+- fields = append(fields, fields[len(fields)-1])
+- }
+- continue
+- }
+-
+- // Record new anonymous struct to explore in next round.
+- nextCount[ft]++
+- if nextCount[ft] == 1 {
+- next = append(next, fillField(field{name: ft.Name(), index: index, typ: ft}))
+- }
+- }
+- }
+- }
+-
+- sort.Sort(byName(fields))
+-
+- // Delete all fields that are hidden by the Go rules for embedded fields,
+- // except that fields with JSON tags are promoted.
+-
+- // The fields are sorted in primary order of name, secondary order
+- // of field index length. Loop over names; for each name, delete
+- // hidden fields by choosing the one dominant field that survives.
+- out := fields[:0]
+- for advance, i := 0, 0; i < len(fields); i += advance {
+- // One iteration per name.
+- // Find the sequence of fields with the name of this first field.
+- fi := fields[i]
+- name := fi.name
+- for advance = 1; i+advance < len(fields); advance++ {
+- fj := fields[i+advance]
+- if fj.name != name {
+- break
+- }
+- }
+- if advance == 1 { // Only one field with this name
+- out = append(out, fi)
+- continue
+- }
+- dominant, ok := dominantField(fields[i : i+advance])
+- if ok {
+- out = append(out, dominant)
+- }
+- }
+-
+- fields = out
+- sort.Sort(byIndex(fields))
+-
+- return fields
+-}
+-
+-// dominantField looks through the fields, all of which are known to
+-// have the same name, to find the single field that dominates the
+-// others using Go's embedding rules, modified by the presence of
+-// JSON tags. If there are multiple top-level fields, the boolean
+-// will be false: This condition is an error in Go and we skip all
+-// the fields.
+-func dominantField(fields []field) (field, bool) {
+- // The fields are sorted in increasing index-length order. The winner
+- // must therefore be one with the shortest index length. Drop all
+- // longer entries, which is easy: just truncate the slice.
+- length := len(fields[0].index)
+- tagged := -1 // Index of first tagged field.
+- for i, f := range fields {
+- if len(f.index) > length {
+- fields = fields[:i]
+- break
+- }
+- if f.tag {
+- if tagged >= 0 {
+- // Multiple tagged fields at the same level: conflict.
+- // Return no field.
+- return field{}, false
+- }
+- tagged = i
+- }
+- }
+- if tagged >= 0 {
+- return fields[tagged], true
+- }
+- // All remaining fields have the same length. If there's more than one,
+- // we have a conflict (two fields named "X" at the same level) and we
+- // return no field.
+- if len(fields) > 1 {
+- return field{}, false
+- }
+- return fields[0], true
+-}
+-
+-var fieldCache struct {
+- sync.RWMutex
+- m map[reflect.Type][]field
+-}
+-
+-// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
+-func cachedTypeFields(t reflect.Type) []field {
+- fieldCache.RLock()
+- f := fieldCache.m[t]
+- fieldCache.RUnlock()
+- if f != nil {
+- return f
+- }
+-
+- // Compute fields without lock.
+- // Might duplicate effort but won't hold other computations back.
+- f = typeFields(t)
+- if f == nil {
+- f = []field{}
+- }
+-
+- fieldCache.Lock()
+- if fieldCache.m == nil {
+- fieldCache.m = map[reflect.Type][]field{}
+- }
+- fieldCache.m[t] = f
+- fieldCache.Unlock()
+- return f
+-}
+-
+-func isValidTag(s string) bool {
+- if s == "" {
+- return false
+- }
+- for _, c := range s {
+- switch {
+- case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
+- // Backslash and quote chars are reserved, but
+- // otherwise any punctuation chars are allowed
+- // in a tag name.
+- default:
+- if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
+- return false
+- }
+- }
+- }
+- return true
+-}
+-
+-const (
+- caseMask = ^byte(0x20) // Mask to ignore case in ASCII.
+- kelvin = '\u212a'
+- smallLongEss = '\u017f'
+-)
+-
+-// foldFunc returns one of four different case folding equivalence
+-// functions, from most general (and slow) to fastest:
+-//
+-// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8
+-// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S')
+-// 3) asciiEqualFold, no special, but includes non-letters (including _)
+-// 4) simpleLetterEqualFold, no specials, no non-letters.
+-//
+-// The letters S and K are special because they map to 3 runes, not just 2:
+-// * S maps to s and to U+017F 'ſ' Latin small letter long s
+-// * k maps to K and to U+212A 'K' Kelvin sign
+-// See http://play.golang.org/p/tTxjOc0OGo
+-//
+-// The returned function is specialized for matching against s and
+-// should only be given s. It's not curried for performance reasons.
+-func foldFunc(s []byte) func(s, t []byte) bool {
+- nonLetter := false
+- special := false // special letter
+- for _, b := range s {
+- if b >= utf8.RuneSelf {
+- return bytes.EqualFold
+- }
+- upper := b & caseMask
+- if upper < 'A' || upper > 'Z' {
+- nonLetter = true
+- } else if upper == 'K' || upper == 'S' {
+- // See above for why these letters are special.
+- special = true
+- }
+- }
+- if special {
+- return equalFoldRight
+- }
+- if nonLetter {
+- return asciiEqualFold
+- }
+- return simpleLetterEqualFold
+-}
+-
+-// equalFoldRight is a specialization of bytes.EqualFold when s is
+-// known to be all ASCII (including punctuation), but contains an 's',
+-// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t.
+-// See comments on foldFunc.
+-func equalFoldRight(s, t []byte) bool {
+- for _, sb := range s {
+- if len(t) == 0 {
+- return false
+- }
+- tb := t[0]
+- if tb < utf8.RuneSelf {
+- if sb != tb {
+- sbUpper := sb & caseMask
+- if 'A' <= sbUpper && sbUpper <= 'Z' {
+- if sbUpper != tb&caseMask {
+- return false
+- }
+- } else {
+- return false
+- }
+- }
+- t = t[1:]
+- continue
+- }
+- // sb is ASCII and t is not. t must be either kelvin
+- // sign or long s; sb must be s, S, k, or K.
+- tr, size := utf8.DecodeRune(t)
+- switch sb {
+- case 's', 'S':
+- if tr != smallLongEss {
+- return false
+- }
+- case 'k', 'K':
+- if tr != kelvin {
+- return false
+- }
+- default:
+- return false
+- }
+- t = t[size:]
+-
+- }
+- if len(t) > 0 {
+- return false
+- }
+- return true
+-}
+-
+-// asciiEqualFold is a specialization of bytes.EqualFold for use when
+-// s is all ASCII (but may contain non-letters) and contains no
+-// special-folding letters.
+-// See comments on foldFunc.
+-func asciiEqualFold(s, t []byte) bool {
+- if len(s) != len(t) {
+- return false
+- }
+- for i, sb := range s {
+- tb := t[i]
+- if sb == tb {
+- continue
+- }
+- if ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') {
+- if sb&caseMask != tb&caseMask {
+- return false
+- }
+- } else {
+- return false
+- }
+- }
+- return true
+-}
+-
+-// simpleLetterEqualFold is a specialization of bytes.EqualFold for
+-// use when s is all ASCII letters (no underscores, etc) and also
+-// doesn't contain 'k', 'K', 's', or 'S'.
+-// See comments on foldFunc.
+-func simpleLetterEqualFold(s, t []byte) bool {
+- if len(s) != len(t) {
+- return false
+- }
+- for i, b := range s {
+- if b&caseMask != t[i]&caseMask {
+- return false
+- }
+- }
+- return true
+-}
+-
+-// tagOptions is the string following a comma in a struct field's "json"
+-// tag, or the empty string. It does not include the leading comma.
+-type tagOptions string
+-
+-// parseTag splits a struct field's json tag into its name and
+-// comma-separated options.
+-func parseTag(tag string) (string, tagOptions) {
+- if idx := strings.Index(tag, ","); idx != -1 {
+- return tag[:idx], tagOptions(tag[idx+1:])
+- }
+- return tag, tagOptions("")
+-}
+-
+-// Contains reports whether a comma-separated list of options
+-// contains a particular substr flag. substr must be surrounded by a
+-// string boundary or commas.
+-func (o tagOptions) Contains(optionName string) bool {
+- if len(o) == 0 {
+- return false
+- }
+- s := string(o)
+- for s != "" {
+- var next string
+- i := strings.Index(s, ",")
+- if i >= 0 {
+- s, next = s[:i], s[i+1:]
+- }
+- if s == optionName {
+- return true
+- }
+- s = next
+- }
+- return false
+-}
+diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/yaml.go b/Godeps/_workspace/src/github.com/ghodss/yaml/yaml.go
+deleted file mode 100644
+index feab226..0000000
+--- a/Godeps/_workspace/src/github.com/ghodss/yaml/yaml.go
++++ /dev/null
+@@ -1,250 +0,0 @@
+-package yaml
+-
+-import (
+- "bytes"
+- "encoding/json"
+- "fmt"
+- "reflect"
+- "strconv"
+-
+- "gopkg.in/v2/yaml"
+-)
+-
+-// Marshals the object into JSON then converts JSON to YAML and returns the
+-// YAML.
+-func Marshal(o interface{}) ([]byte, error) {
+- j, err := json.Marshal(o)
+- if err != nil {
+- return nil, fmt.Errorf("error marshaling into JSON: ", err)
+- }
+-
+- y, err := JSONToYAML(j)
+- if err != nil {
+- return nil, fmt.Errorf("error converting JSON to YAML: ", err)
+- }
+-
+- return y, nil
+-}
+-
+-// Converts YAML to JSON then uses JSON to unmarshal into an object.
+-func Unmarshal(y []byte, o interface{}) error {
+- vo := reflect.ValueOf(o)
+- j, err := yamlToJSON(y, &vo)
+- if err != nil {
+- return fmt.Errorf("error converting YAML to JSON: %v", err)
+- }
+-
+- err = json.Unmarshal(j, o)
+- if err != nil {
+- return fmt.Errorf("error unmarshaling JSON: %v", err)
+- }
+-
+- return nil
+-}
+-
+-// Convert JSON to YAML.
+-func JSONToYAML(j []byte) ([]byte, error) {
+- // Convert the JSON to an object.
+- var jsonObj interface{}
+- err := json.Unmarshal(j, &jsonObj)
+- if err != nil {
+- return nil, err
+- }
+-
+- // Marshal this object into YAML.
+- return yaml.Marshal(jsonObj)
+-}
+-
+-// Convert YAML to JSON. Since JSON is a subset of YAML, passing JSON through
+-// this method should be a no-op.
+-//
+-// Things YAML can do that are not supported by JSON:
+-// * In YAML you can have binary and null keys in your maps. These are invalid
+-// in JSON. (int and float keys are converted to strings.)
+-// * Binary data in YAML with the !!binary tag is not supported. If you want to
+-// use binary data with this library, encode the data as base64 as usual but do
+-// not use the !!binary tag in your YAML. This will ensure the original base64
+-// encoded data makes it all the way through to the JSON.
+-func YAMLToJSON(y []byte) ([]byte, error) {
+- return yamlToJSON(y, nil)
+-}
+-
+-func yamlToJSON(y []byte, jsonTarget *reflect.Value) ([]byte, error) {
+- // Convert the YAML to an object.
+- var yamlObj interface{}
+- err := yaml.Unmarshal(y, &yamlObj)
+- if err != nil {
+- return nil, err
+- }
+-
+- // YAML objects are not completely compatible with JSON objects (e.g. you
+- // can have non-string keys in YAML). So, convert the YAML-compatible object
+- // to a JSON-compatible object, failing with an error if irrecoverable
+- // incompatibilties happen along the way.
+- jsonObj, err := convertToJSONableObject(yamlObj, jsonTarget)
+- if err != nil {
+- return nil, err
+- }
+-
+- // Convert this object to JSON and return the data.
+- return json.Marshal(jsonObj)
+-}
+-
+-func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) {
+- var err error
+-
+- // Resolve jsonTarget to a concrete value (i.e. not a pointer or an
+- // interface). We pass decodingNull as false because we're not actually
+- // decoding into the value, we're just checking if the ultimate target is a
+- // string.
+- if jsonTarget != nil {
+- ju, tu, pv := indirect(*jsonTarget, false)
+- // We have a JSON or Text Umarshaler at this level, so we can't be trying
+- // to decode into a string.
+- if ju != nil || tu != nil {
+- jsonTarget = nil
+- } else {
+- jsonTarget = &pv
+- }
+- }
+-
+- // If yamlObj is a number, check if jsonTarget is a string - if so, coerce.
+- // Else return normal.
+- // If yamlObj is a map or array, find the field that each key is
+- // unmarshaling to, and when you recurse pass the reflect.Value for that
+- // field back into this function.
+-
+- switch typedYAMLObj := yamlObj.(type) {
+- case map[interface{}]interface{}:
+- // JSON does not support arbitrary keys in a map, so we must convert
+- // these keys to strings.
+- //
+- // From my reading of go-yaml v2 (specifically the resolve function),
+- // keys can only have the types string, int, int64, float64, binary
+- // (unsupported), or null (unsupported).
+- strMap := make(map[string]interface{})
+- for k, v := range typedYAMLObj {
+- // Resolve the key to a string first.
+- var keyString string
+- switch typedKey := k.(type) {
+- case string:
+- keyString = typedKey
+- case int:
+- keyString = strconv.Itoa(typedKey)
+- case int64:
+- // go-yaml will only return an int64 as a key if the system
+- // architecture is 32-bit and the key's value is between 32-bit
+- // and 64-bit. Otherwise the key type will simply be int.
+- keyString = strconv.FormatInt(typedKey, 10)
+- case float64:
+- // Stolen from go-yaml to use the same conversion to string as
+- // the go-yaml library uses to convert float to string when
+- // Marshaling.
+- s := strconv.FormatFloat(typedKey, 'g', -1, 32)
+- switch s {
+- case "+Inf":
+- s = ".inf"
+- case "-Inf":
+- s = "-.inf"
+- case "NaN":
+- s = ".nan"
+- }
+- keyString = s
+- default:
+- return nil, fmt.Errorf("Unsupported map key of type: %s, key: %+#v, value: %+#v",
+- reflect.TypeOf(k), k, v)
+- }
+-
+- // If jsonTarget is a struct (which it really should be), find the
+- // field it's going to map to. If it's not a struct, just pass nil
+- // - JSON conversion will error for us if it's a real issue.
+- if jsonTarget != nil {
+- t := *jsonTarget
+- if t.Kind() == reflect.Struct {
+- keyBytes := []byte(keyString)
+- // Find the field that the JSON library would use.
+- var f *field
+- fields := cachedTypeFields(t.Type())
+- for i := range fields {
+- ff := &fields[i]
+- if bytes.Equal(ff.nameBytes, keyBytes) {
+- f = ff
+- break
+- }
+- // Do case-insensitive comparison.
+- if f == nil && ff.equalFold(ff.nameBytes, keyBytes) {
+- f = ff
+- }
+- }
+- if f != nil {
+- // Find the reflect.Value of the most preferential
+- // struct field.
+- jtf := t.Field(f.index[0])
+- strMap[keyString], err = convertToJSONableObject(v, &jtf)
+- if err != nil {
+- return nil, err
+- }
+- continue
+- }
+- }
+- }
+- strMap[keyString], err = convertToJSONableObject(v, nil)
+- if err != nil {
+- return nil, err
+- }
+- }
+- return strMap, nil
+- case []interface{}:
+- // We need to recurse into arrays in case there are any
+- // map[interface{}]interface{}'s inside and to convert any
+- // numbers to strings.
+-
+- // If jsonTarget is a slice (which it really should be), find the
+- // thing it's going to map to. If it's not a slice, just pass nil
+- // - JSON conversion will error for us if it's a real issue.
+- var jsonSliceElemValue *reflect.Value
+- if jsonTarget != nil {
+- t := *jsonTarget
+- if t.Kind() == reflect.Slice {
+- // By default slices point to nil, but we need a reflect.Value
+- // pointing to a value of the slice type, so we create one here.
+- ev := reflect.Indirect(reflect.New(t.Type().Elem()))
+- jsonSliceElemValue = &ev
+- }
+- }
+-
+- // Make and use a new array.
+- arr := make([]interface{}, len(typedYAMLObj))
+- for i, v := range typedYAMLObj {
+- arr[i], err = convertToJSONableObject(v, jsonSliceElemValue)
+- if err != nil {
+- return nil, err
+- }
+- }
+- return arr, nil
+- default:
+- // If the target type is a string and the YAML type is a number,
+- // convert the YAML type to a string.
+- if jsonTarget != nil && (*jsonTarget).Kind() == reflect.String {
+- // Based on my reading of go-yaml, it may return int, int64,
+- // float64, or uint64.
+- var s string
+- switch num := typedYAMLObj.(type) {
+- case int:
+- s = strconv.FormatInt(int64(num), 10)
+- case int64:
+- s = strconv.FormatInt(num, 10)
+- case float64:
+- s = strconv.FormatFloat(num, 'g', -1, 32)
+- case uint64:
+- s = strconv.FormatUint(num, 10)
+- }
+- if len(s) > 0 {
+- yamlObj = interface{}(s)
+- }
+- }
+- return yamlObj, nil
+- }
+-
+- return nil, nil
+-}
+diff --git a/Godeps/_workspace/src/github.com/ghodss/yaml/yaml_test.go b/Godeps/_workspace/src/github.com/ghodss/yaml/yaml_test.go
+deleted file mode 100644
+index c569ebd..0000000
+--- a/Godeps/_workspace/src/github.com/ghodss/yaml/yaml_test.go
++++ /dev/null
+@@ -1,243 +0,0 @@
+-package yaml
+-
+-import (
+- "reflect"
+- "testing"
+-)
+-
+-type MarshalTest struct {
+- A string
+-}
+-
+-func TestMarshal(t *testing.T) {
+- s := MarshalTest{"a"}
+- e := []byte("A: a\n")
+-
+- y, err := Marshal(s)
+- if err != nil {
+- t.Errorf("error marshaling YAML: %v", err)
+- }
+-
+- if !reflect.DeepEqual(y, e) {
+- t.Errorf("marshal YAML was unsuccessful, expected: %#v, got: %#v",
+- string(e), string(y))
+- }
+-}
+-
+-type UnmarshalString struct {
+- A string
+-}
+-
+-type UnmarshalNestedString struct {
+- A NestedString
+-}
+-
+-type NestedString struct {
+- A string
+-}
+-
+-type UnmarshalSlice struct {
+- A []NestedSlice
+-}
+-
+-type NestedSlice struct {
+- B string
+- C *string
+-}
+-
+-func TestUnmarshal(t *testing.T) {
+- y := []byte("a: 1")
+- s1 := UnmarshalString{}
+- e1 := UnmarshalString{"1"}
+- unmarshal(t, y, &s1, &e1)
+-
+- y = []byte("a:\n a: 1")
+- s2 := UnmarshalNestedString{}
+- e2 := UnmarshalNestedString{NestedString{"1"}}
+- unmarshal(t, y, &s2, &e2)
+-
+- y = []byte("a:\n - b: abc\n c: def\n - b: 123\n c: 456\n")
+- s3 := UnmarshalSlice{}
+- e3 := UnmarshalSlice{[]NestedSlice{NestedSlice{"abc", strPtr("def")}, NestedSlice{"123", strPtr("456")}}}
+- unmarshal(t, y, &s3, &e3)
+-}
+-
+-func unmarshal(t *testing.T, y []byte, s, e interface{}) {
+- err := Unmarshal(y, s)
+- if err != nil {
+- t.Errorf("error unmarshaling YAML: %v", err)
+- }
+-
+- if !reflect.DeepEqual(s, e) {
+- t.Errorf("unmarshal YAML was unsuccessful, expected: %+#v, got: %+#v",
+- e, s)
+- }
+-}
+-
+-type Case struct {
+- input string
+- output string
+- // By default we test that reversing the output == input. But if there is a
+- // difference in the reversed output, you can optionally specify it here.
+- reverse *string
+-}
+-
+-type RunType int
+-
+-const (
+- RunTypeJSONToYAML RunType = iota
+- RunTypeYAMLToJSON
+-)
+-
+-func TestJSONToYAML(t *testing.T) {
+- cases := []Case{
+- {
+- `{"t":"a"}`,
+- "t: a\n",
+- nil,
+- }, {
+- `{"t":null}`,
+- "t: null\n",
+- nil,
+- },
+- }
+-
+- runCases(t, RunTypeJSONToYAML, cases)
+-}
+-
+-func TestYAMLToJSON(t *testing.T) {
+- cases := []Case{
+- {
+- "t: a\n",
+- `{"t":"a"}`,
+- nil,
+- }, {
+- "t: \n",
+- `{"t":null}`,
+- strPtr("t: null\n"),
+- }, {
+- "t: null\n",
+- `{"t":null}`,
+- nil,
+- }, {
+- "1: a\n",
+- `{"1":"a"}`,
+- strPtr("\"1\": a\n"),
+- }, {
+- "1000000000000000000000000000000000000: a\n",
+- `{"1e+36":"a"}`,
+- strPtr("\"1e+36\": a\n"),
+- }, {
+- "1e+36: a\n",
+- `{"1e+36":"a"}`,
+- strPtr("\"1e+36\": a\n"),
+- }, {
+- "\"1e+36\": a\n",
+- `{"1e+36":"a"}`,
+- nil,
+- }, {
+- "\"1.2\": a\n",
+- `{"1.2":"a"}`,
+- nil,
+- }, {
+- "- t: a\n",
+- `[{"t":"a"}]`,
+- nil,
+- }, {
+- "- t: a\n" +
+- "- t:\n" +
+- " b: 1\n" +
+- " c: 2\n",
+- `[{"t":"a"},{"t":{"b":1,"c":2}}]`,
+- nil,
+- }, {
+- `[{t: a}, {t: {b: 1, c: 2}}]`,
+- `[{"t":"a"},{"t":{"b":1,"c":2}}]`,
+- strPtr("- t: a\n" +
+- "- t:\n" +
+- " b: 1\n" +
+- " c: 2\n"),
+- }, {
+- "- t: \n",
+- `[{"t":null}]`,
+- strPtr("- t: null\n"),
+- }, {
+- "- t: null\n",
+- `[{"t":null}]`,
+- nil,
+- },
+- }
+-
+- // Cases that should produce errors.
+- _ = []Case{
+- {
+- "~: a",
+- `{"null":"a"}`,
+- nil,
+- }, {
+- "a: !!binary gIGC\n",
+- "{\"a\":\"\x80\x81\x82\"}",
+- nil,
+- },
+- }
+-
+- runCases(t, RunTypeYAMLToJSON, cases)
+-}
+-
+-func runCases(t *testing.T, runType RunType, cases []Case) {
+- var f func([]byte) ([]byte, error)
+- var invF func([]byte) ([]byte, error)
+- var msg string
+- var invMsg string
+- if runType == RunTypeJSONToYAML {
+- f = JSONToYAML
+- invF = YAMLToJSON
+- msg = "JSON to YAML"
+- invMsg = "YAML back to JSON"
+- } else {
+- f = YAMLToJSON
+- invF = JSONToYAML
+- msg = "YAML to JSON"
+- invMsg = "JSON back to YAML"
+- }
+-
+- for _, c := range cases {
+- // Convert the string.
+- t.Logf("converting %s\n", c.input)
+- output, err := f([]byte(c.input))
+- if err != nil {
+- t.Errorf("Failed to convert %s, input: `%s`, err: %v", msg, c.input, err)
+- }
+-
+- // Check it against the expected output.
+- if string(output) != c.output {
+- t.Errorf("Failed to convert %s, input: `%s`, expected `%s`, got `%s`",
+- msg, c.input, c.output, string(output))
+- }
+-
+- // Set the string that we will compare the reversed output to.
+- reverse := c.input
+- // If a special reverse string was specified, use that instead.
+- if c.reverse != nil {
+- reverse = *c.reverse
+- }
+-
+- // Reverse the output.
+- input, err := invF(output)
+- if err != nil {
+- t.Errorf("Failed to convert %s, input: `%s`, err: %v", invMsg, string(output), err)
+- }
+-
+- // Check the reverse is equal to the input (or to *c.reverse).
+- if string(input) != reverse {
+- t.Errorf("Failed to convert %s, input: `%s`, expected `%s`, got `%s`",
+- invMsg, string(output), reverse, string(input))
+- }
+- }
+-
+-}
+-
+-// To be able to easily fill in the *Case.reverse string above.
+-func strPtr(s string) *string {
+- return &s
+-}
diff --git a/Godeps/_workspace/src/github.com/golang/glog/LICENSE b/Godeps/_workspace/src/github.com/golang/glog/LICENSE
deleted file mode 100644
index 37ec93a..0000000
@@ -59397,10 +66251,10 @@ index fededef..0000000
-Returns a [ContainerInfo struct](../info/container.go) with the Subcontainers field populated.
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/client/client.go b/Godeps/_workspace/src/github.com/google/cadvisor/client/client.go
deleted file mode 100644
-index c1117d2..0000000
+index 5c016e0..0000000
--- a/Godeps/_workspace/src/github.com/google/cadvisor/client/client.go
+++ /dev/null
-@@ -1,123 +0,0 @@
+@@ -1,161 +0,0 @@
-// Copyright 2014 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
@@ -59442,7 +66296,7 @@ index c1117d2..0000000
- }
-
- return &Client{
-- baseUrl: fmt.Sprintf("%sapi/v1.1/", url),
+- baseUrl: fmt.Sprintf("%sapi/v1.2/", url),
- }, nil
-}
-
@@ -59483,6 +66337,38 @@ index c1117d2..0000000
- return response, nil
-}
-
+-// Returns the JSON container information for the specified
+-// Docker container and request.
+-func (self *Client) DockerContainer(name string, query *info.ContainerInfoRequest) (cinfo info.ContainerInfo, err error) {
+- u := self.dockerInfoUrl(name)
+- ret := make(map[string]info.ContainerInfo)
+- if err = self.httpGetJsonData(&ret, query, u, fmt.Sprintf("Docker container info for %q", name)); err != nil {
+- return
+- }
+- if len(ret) != 1 {
+- err = fmt.Errorf("expected to only receive 1 Docker container: %+v", ret)
+- return
+- }
+- for _, cont := range ret {
+- cinfo = cont
+- }
+- return
+-}
+-
+-// Returns the JSON container information for all Docker containers.
+-func (self *Client) AllDockerContainers(query *info.ContainerInfoRequest) (cinfo []info.ContainerInfo, err error) {
+- u := self.dockerInfoUrl("/")
+- ret := make(map[string]info.ContainerInfo)
+- if err = self.httpGetJsonData(&ret, query, u, "all Docker containers info"); err != nil {
+- return
+- }
+- cinfo = make([]info.ContainerInfo, 0, len(ret))
+- for _, cont := range ret {
+- cinfo = append(cinfo, cont)
+- }
+- return
+-}
+-
-func (self *Client) machineInfoUrl() string {
- return self.baseUrl + path.Join("machine")
-}
@@ -59495,6 +66381,10 @@ index c1117d2..0000000
- return self.baseUrl + path.Join("subcontainers", name)
-}
-
+-func (self *Client) dockerInfoUrl(name string) string {
+- return self.baseUrl + path.Join("docker", name)
+-}
+-
-func (self *Client) httpGetJsonData(data, postData interface{}, url, infoName string) error {
- var resp *http.Response
- var err error
@@ -59509,24 +66399,26 @@ index c1117d2..0000000
- resp, err = http.Get(url)
- }
- if err != nil {
-- err = fmt.Errorf("unable to get %v: %v", infoName, err)
-- return err
+- return fmt.Errorf("unable to get %q: %v", infoName, err)
+- }
+- if resp == nil {
+- return fmt.Errorf("received empty response from %q", infoName)
- }
- defer resp.Body.Close()
- body, err := ioutil.ReadAll(resp.Body)
- if err != nil {
-- err = fmt.Errorf("unable to read all %v: %v", infoName, err)
+- err = fmt.Errorf("unable to read all %q: %v", infoName, err)
- return err
- }
- if err = json.Unmarshal(body, data); err != nil {
-- err = fmt.Errorf("unable to unmarshal %v (%v): %v", infoName, string(body), err)
+- err = fmt.Errorf("unable to unmarshal %q (%v): %v", infoName, string(body), err)
- return err
- }
- return nil
-}
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/client/client_test.go b/Godeps/_workspace/src/github.com/google/cadvisor/client/client_test.go
deleted file mode 100644
-index 35a75ad..0000000
+index 67bf3c2..0000000
--- a/Godeps/_workspace/src/github.com/google/cadvisor/client/client_test.go
+++ /dev/null
@@ -1,154 +0,0 @@
@@ -59589,7 +66481,7 @@ index 35a75ad..0000000
- }
- encoder := json.NewEncoder(w)
- encoder.Encode(replyObj)
-- } else if r.URL.Path == "/api/v1.1/machine" {
+- } else if r.URL.Path == "/api/v1.2/machine" {
- fmt.Fprint(w, `{"num_cores":8,"memory_capacity":31625871360}`)
- } else {
- w.WriteHeader(http.StatusNotFound)
@@ -59611,7 +66503,7 @@ index 35a75ad..0000000
- NumCores: 8,
- MemoryCapacity: 31625871360,
- }
-- client, server, err := cadvisorTestClient("/api/v1.1/machine", nil, nil, minfo, t)
+- client, server, err := cadvisorTestClient("/api/v1.2/machine", nil, nil, minfo, t)
- if err != nil {
- t.Fatalf("unable to get a client %v", err)
- }
@@ -59633,7 +66525,7 @@ index 35a75ad..0000000
- }
- containerName := "/some/container"
- cinfo := itest.GenerateRandomContainerInfo(containerName, 4, query, 1*time.Second)
-- client, server, err := cadvisorTestClient(fmt.Sprintf("/api/v1.1/containers%v", containerName), query, &info.ContainerInfoRequest{}, cinfo, t)
+- client, server, err := cadvisorTestClient(fmt.Sprintf("/api/v1.2/containers%v", containerName), query, &info.ContainerInfoRequest{}, cinfo, t)
- if err != nil {
- t.Fatalf("unable to get a client %v", err)
- }
@@ -59661,7 +66553,7 @@ index 35a75ad..0000000
- *cinfo1,
- *cinfo2,
- }
-- client, server, err := cadvisorTestClient(fmt.Sprintf("/api/v1.1/subcontainers%v", containerName), query, &info.ContainerInfoRequest{}, response, t)
+- client, server, err := cadvisorTestClient(fmt.Sprintf("/api/v1.2/subcontainers%v", containerName), query, &info.ContainerInfoRequest{}, response, t)
- if err != nil {
- t.Fatalf("unable to get a client %v", err)
- }
@@ -59684,52 +66576,12 @@ index 35a75ad..0000000
- t.Error("received unexpected ContainerInfo")
- }
-}
-diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/advice.go b/Godeps/_workspace/src/github.com/google/cadvisor/info/advice.go
-deleted file mode 100644
-index 8084cf4..0000000
---- a/Godeps/_workspace/src/github.com/google/cadvisor/info/advice.go
-+++ /dev/null
-@@ -1,34 +0,0 @@
--// Copyright 2014 Google Inc. All Rights Reserved.
--//
--// 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 info
--
--// This struct describes one type of relationship between containers: One
--// container, antagonist, interferes the performance of other
--// containers, victims.
--type Interference struct {
-- // Absolute name of the antagonist container name. This field
-- // should not be empty.
-- Antagonist string `json:"antagonist"`
--
-- // The absolute path of the victims. This field should not be empty.
-- Victims []string `json:"victims"`
--
-- // The name of the detector used to detect this antagonism. This field
-- // should not be empty
-- Detector string `json:"detector"`
--
-- // Human readable description of this interference
-- Description string `json:"description,omitempty"`
--}
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/container.go b/Godeps/_workspace/src/github.com/google/cadvisor/info/container.go
deleted file mode 100644
-index 5eaacb5..0000000
+index 5a4fbbd..0000000
--- a/Godeps/_workspace/src/github.com/google/cadvisor/info/container.go
+++ /dev/null
-@@ -1,346 +0,0 @@
+@@ -1,379 +0,0 @@
-// Copyright 2014 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
@@ -59785,10 +66637,16 @@ index 5eaacb5..0000000
-
-// Container reference contains enough information to uniquely identify a container
-type ContainerReference struct {
-- // The absolute name of the container.
+- // The absolute name of the container. This is unique on the machine.
- Name string `json:"name"`
-
+- // Other names by which the container is known within a certain namespace.
+- // This is unique within that namespace.
- Aliases []string `json:"aliases,omitempty"`
+-
+- // Namespace under which the aliases of a container are unique.
+- // An example of a namespace is "docker" for Docker containers.
+- Namespace string `json:"namespace,omitempty"`
-}
-
-// ContainerInfoQuery is used when users check a container info from the REST api.
@@ -59916,32 +66774,30 @@ index 5eaacb5..0000000
- IoServiced []PerDiskStats `json:"io_serviced,omitempty"`
- IoQueued []PerDiskStats `json:"io_queued,omitempty"`
- Sectors []PerDiskStats `json:"sectors,omitempty"`
+- IoServiceTime []PerDiskStats `json:"io_service_time,omitempty"`
+- IoWaitTime []PerDiskStats `json:"io_wait_time,omitempty"`
+- IoMerged []PerDiskStats `json:"io_merged,omitempty"`
+- IoTime []PerDiskStats `json:"io_time,omitempty"`
-}
-
-type MemoryStats struct {
-- // Memory limit, equivalent to "limit" in MemorySpec.
-- // Units: Bytes.
-- Limit uint64 `json:"limit,omitempty"`
--
-- // Usage statistics.
--
- // Current memory usage, this includes all memory regardless of when it was
- // accessed.
- // Units: Bytes.
-- Usage uint64 `json:"usage,omitempty"`
+- Usage uint64 `json:"usage"`
-
- // The amount of working set memory, this includes recently accessed memory,
- // dirty memory, and kernel memory. Working set is <= "usage".
- // Units: Bytes.
-- WorkingSet uint64 `json:"working_set,omitempty"`
+- WorkingSet uint64 `json:"working_set"`
-
- ContainerData MemoryStatsMemoryData `json:"container_data,omitempty"`
- HierarchicalData MemoryStatsMemoryData `json:"hierarchical_data,omitempty"`
-}
-
-type MemoryStatsMemoryData struct {
-- Pgfault uint64 `json:"pgfault,omitempty"`
-- Pgmajfault uint64 `json:"pgmajfault,omitempty"`
+- Pgfault uint64 `json:"pgfault"`
+- Pgmajfault uint64 `json:"pgmajfault"`
-}
-
-type NetworkStats struct {
@@ -59972,55 +66828,74 @@ index 5eaacb5..0000000
-
- // Number of bytes that is consumed by the container on this filesystem.
- Usage uint64 `json:"usage"`
+-
+- // Number of reads completed
+- // This is the total number of reads completed successfully.
+- ReadsCompleted uint64 `json:"reads_completed"`
+-
+- // Number of reads merged
+- // Reads and writes which are adjacent to each other may be merged for
+- // efficiency. Thus two 4K reads may become one 8K read before it is
+- // ultimately handed to the disk, and so it will be counted (and queued)
+- // as only one I/O. This field lets you know how often this was done.
+- ReadsMerged uint64 `json:"reads_merged"`
+-
+- // Number of sectors read
+- // This is the total number of sectors read successfully.
+- SectorsRead uint64 `json:"sectors_read"`
+-
+- // Number of milliseconds spent reading
+- // This is the total number of milliseconds spent by all reads (as
+- // measured from __make_request() to end_that_request_last()).
+- ReadTime uint64 `json:"read_time"`
+-
+- // Number of writes completed
+- // This is the total number of writes completed successfully.
+- WritesCompleted uint64 `json:"writes_completed"`
+-
+- // Number of writes merged
+- // See the description of reads merged.
+- WritesMerged uint64 `json:"writes_merged"`
+-
+- // Number of sectors written
+- // This is the total number of sectors written successfully.
+- SectorsWritten uint64 `json:"sectors_written"`
+-
+- // Number of milliseconds spent writing
+- // This is the total number of milliseconds spent by all writes (as
+- // measured from __make_request() to end_that_request_last()).
+- WriteTime uint64 `json:"write_time"`
+-
+- // Number of I/Os currently in progress
+- // The only field that should go to zero. Incremented as requests are
+- // given to appropriate struct request_queue and decremented as they finish.
+- IoInProgress uint64 `json:"io_in_progress"`
+-
+- // Number of milliseconds spent doing I/Os
+- // This field increases so long as field 9 is nonzero.
+- IoTime uint64 `json:"io_time"`
+-
+- // weighted number of milliseconds spent doing I/Os
+- // This field is incremented at each I/O start, I/O completion, I/O
+- // merge, or read of these stats by the number of I/Os in progress
+- // (field 9) times the number of milliseconds spent doing I/O since the
+- // last update of this field. This can provide an easy measure of both
+- // I/O completion time and the backlog that may be accumulating.
+- WeightedIoTime uint64 `json:"weighted_io_time"`
-}
-
-type ContainerStats struct {
- // The time of this stat point.
-- Timestamp time.Time `json:"timestamp"`
-- Cpu *CpuStats `json:"cpu,omitempty"`
-- DiskIo DiskIoStats `json:"diskio,omitempty"`
-- Memory *MemoryStats `json:"memory,omitempty"`
-- Network *NetworkStats `json:"network,omitempty"`
+- Timestamp time.Time `json:"timestamp"`
+- Cpu CpuStats `json:"cpu,omitempty"`
+- DiskIo DiskIoStats `json:"diskio,omitempty"`
+- Memory MemoryStats `json:"memory,omitempty"`
+- Network NetworkStats `json:"network,omitempty"`
+-
- // Filesystem statistics
- Filesystem []FsStats `json:"filesystem,omitempty"`
-}
-
--// Makes a deep copy of the ContainerStats and returns a pointer to the new
--// copy. Copy() will allocate a new ContainerStats object if dst is nil.
--func (self *ContainerStats) Copy(dst *ContainerStats) *ContainerStats {
-- if dst == nil {
-- dst = new(ContainerStats)
-- }
-- dst.Timestamp = self.Timestamp
-- if self.Cpu != nil {
-- if dst.Cpu == nil {
-- dst.Cpu = new(CpuStats)
-- }
-- // To make a deep copy of a slice, we need to copy every value
-- // in the slice. To make less memory allocation, we would like
-- // to reuse the slice in dst if possible.
-- percpu := dst.Cpu.Usage.PerCpu
-- if len(percpu) != len(self.Cpu.Usage.PerCpu) {
-- percpu = make([]uint64, len(self.Cpu.Usage.PerCpu))
-- }
-- dst.Cpu.Usage = self.Cpu.Usage
-- dst.Cpu.Load = self.Cpu.Load
-- copy(percpu, self.Cpu.Usage.PerCpu)
-- dst.Cpu.Usage.PerCpu = percpu
-- } else {
-- dst.Cpu = nil
-- }
-- if self.Memory != nil {
-- if dst.Memory == nil {
-- dst.Memory = new(MemoryStats)
-- }
-- *dst.Memory = *self.Memory
-- } else {
-- dst.Memory = nil
-- }
-- return dst
--}
--
-func timeEq(t1, t2 time.Time, tolerance time.Duration) bool {
- // t1 should not be later than t2
- if t1.After(t2) {
@@ -60060,12 +66935,22 @@ index 5eaacb5..0000000
-
-// Checks equality of the stats values.
-func (a *ContainerStats) StatsEq(b *ContainerStats) bool {
+- // TODO(vmarmol): Consider using this through reflection.
- if !reflect.DeepEqual(a.Cpu, b.Cpu) {
- return false
- }
- if !reflect.DeepEqual(a.Memory, b.Memory) {
- return false
- }
+- if !reflect.DeepEqual(a.DiskIo, b.DiskIo) {
+- return false
+- }
+- if !reflect.DeepEqual(a.Network, b.Network) {
+- return false
+- }
+- if !reflect.DeepEqual(a.Filesystem, b.Filesystem) {
+- return false
+- }
- return true
-}
-
@@ -60078,10 +66963,10 @@ index 5eaacb5..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/container_test.go b/Godeps/_workspace/src/github.com/google/cadvisor/info/container_test.go
deleted file mode 100644
-index bd730c1..0000000
+index 2ff38e6..0000000
--- a/Godeps/_workspace/src/github.com/google/cadvisor/info/container_test.go
+++ /dev/null
-@@ -1,101 +0,0 @@
+@@ -1,79 +0,0 @@
-// Copyright 2014 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
@@ -60099,7 +66984,6 @@ index bd730c1..0000000
-package info
-
-import (
-- "reflect"
- "testing"
- "time"
-)
@@ -60153,10 +67037,7 @@ index bd730c1..0000000
-}
-
-func createStats(cpuUsage, memUsage uint64, timestamp time.Time) *ContainerStats {
-- stats := &ContainerStats{
-- Cpu: &CpuStats{},
-- Memory: &MemoryStats{},
-- }
+- stats := &ContainerStats{}
- stats.Cpu.Usage.PerCpu = []uint64{cpuUsage}
- stats.Cpu.Usage.Total = cpuUsage
- stats.Cpu.Usage.System = 0
@@ -60165,24 +67046,6 @@ index bd730c1..0000000
- stats.Timestamp = timestamp
- return stats
-}
--
--func TestContainerStatsCopy(t *testing.T) {
-- stats := createStats(100, 101, time.Now())
-- shadowStats := stats.Copy(nil)
-- if !reflect.DeepEqual(stats, shadowStats) {
-- t.Errorf("Copy() returned different object")
-- }
-- stats.Cpu.Usage.PerCpu[0] = shadowStats.Cpu.Usage.PerCpu[0] + 1
-- stats.Cpu.Load = shadowStats.Cpu.Load + 1
-- stats.Memory.Usage = shadowStats.Memory.Usage + 1
-- if reflect.DeepEqual(stats, shadowStats) {
-- t.Errorf("Copy() did not deeply copy the object")
-- }
-- stats = shadowStats.Copy(stats)
-- if !reflect.DeepEqual(stats, shadowStats) {
-- t.Errorf("Copy() returned different object")
-- }
--}
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/machine.go b/Godeps/_workspace/src/github.com/google/cadvisor/info/machine.go
deleted file mode 100644
index 0e73a8e..0000000
@@ -60244,10 +67107,10 @@ index 0e73a8e..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/test/datagen.go b/Godeps/_workspace/src/github.com/google/cadvisor/info/test/datagen.go
deleted file mode 100644
-index bb0b2ff..0000000
+index 519e28c..0000000
--- a/Godeps/_workspace/src/github.com/google/cadvisor/info/test/datagen.go
+++ /dev/null
-@@ -1,78 +0,0 @@
+@@ -1,76 +0,0 @@
-// Copyright 2014 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
@@ -60281,8 +67144,6 @@ index bb0b2ff..0000000
- }
- for i := 0; i < numStats; i++ {
- stats := new(info.ContainerStats)
-- stats.Cpu = new(info.CpuStats)
-- stats.Memory = new(info.MemoryStats)
- stats.Timestamp = currentTime
- currentTime = currentTime.Add(duration)
-
@@ -60328,7 +67189,7 @@ index bb0b2ff..0000000
-}
diff --git a/Godeps/_workspace/src/github.com/google/cadvisor/info/version.go b/Godeps/_workspace/src/github.com/google/cadvisor/info/version.go
deleted file mode 100644
-index 8ae9b22..0000000
+index 771382a..0000000
--- a/Godeps/_workspace/src/github.com/google/cadvisor/info/version.go
+++ /dev/null
@@ -1,18 +0,0 @@
@@ -60349,7 +67210,7 @@ index 8ae9b22..0000000
-package info
-
-// Version of cAdvisor.
--const VERSION = "0.5.0"
+-const VERSION = "0.6.2"
diff --git a/Godeps/_workspace/src/github.com/google/gofuzz/.travis.yml b/Godeps/_workspace/src/github.com/google/gofuzz/.travis.yml
deleted file mode 100644
index 9384a54..0000000
@@ -128562,12 +135423,15 @@ index 48f14b6..0000000
- }
- conn.Close()
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE b/Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE b/Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE
deleted file mode 100644
-index 53320c3..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE
+index a68e67f..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE
+++ /dev/null
-@@ -1,185 +0,0 @@
+@@ -1,188 +0,0 @@
+-
+-Copyright (c) 2011-2014 - Canonical Inc.
+-
-This software is licensed under the LGPLv3, included below.
-
-As a special exception to the GNU Lesser General Public License version 3
@@ -128753,10 +135617,10 @@ index 53320c3..0000000
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE.libyaml b/Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE.libyaml
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE.libyaml b/Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE.libyaml
deleted file mode 100644
index 8da58fb..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/LICENSE.libyaml
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/LICENSE.libyaml
+++ /dev/null
@@ -1,31 +0,0 @@
-The following files were ported to Go from C files of libyaml, and thus
@@ -128790,10 +135654,10 @@ index 8da58fb..0000000
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/README.md b/Godeps/_workspace/src/gopkg.in/v1/yaml/README.md
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/README.md b/Godeps/_workspace/src/gopkg.in/v2/yaml/README.md
deleted file mode 100644
-index 896687b..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/README.md
+index d6c919e..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/README.md
+++ /dev/null
@@ -1,128 +0,0 @@
-# YAML support for the Go language
@@ -128810,31 +135674,31 @@ index 896687b..0000000
-Compatibility
--------------
-
--The yaml package is almost compatible with YAML 1.1, including support for
--anchors, tags, etc. There are still a few missing bits, such as document
--merging, base-60 floats (huh?), and multi-document unmarshalling. These
--features are not hard to add, and will be introduced as necessary.
+-The yaml package supports most of YAML 1.1 and 1.2, including support for
+-anchors, tags, map merging, etc. Multi-document unmarshalling is not yet
+-implemented, and base-60 floats from YAML 1.1 are purposefully not
+-supported since they're a poor design and are gone in YAML 1.2.
-
-Installation and usage
-----------------------
-
--The import path for the package is *gopkg.in/yaml.v1*.
+-The import path for the package is *gopkg.in/yaml.v2*.
-
-To install it, run:
-
-- go get gopkg.in/yaml.v1
+- go get gopkg.in/yaml.v2
-
-API documentation
------------------
-
-If opened in a browser, the import path itself leads to the API documentation:
-
-- * [https://gopkg.in/yaml.v1](https://gopkg.in/yaml.v1)
+- * [https://gopkg.in/yaml.v2](https://gopkg.in/yaml.v2)
-
-API stability
--------------
-
--The package API for yaml v1 will remain stable as described in [gopkg.in](https://gopkg.in).
+-The package API for yaml v2 will remain stable as described in [gopkg.in](https://gopkg.in).
-
-
-License
@@ -128853,7 +135717,7 @@ index 896687b..0000000
- "fmt"
- "log"
-
-- "gopkg.in/yaml.v1"
+- "gopkg.in/yaml.v2"
-)
-
-var data = `
@@ -128924,10 +135788,10 @@ index 896687b..0000000
- - 4
-```
-
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/apic.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/apic.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/apic.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/apic.go
deleted file mode 100644
index 95ec014..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/apic.go
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/apic.go
+++ /dev/null
@@ -1,742 +0,0 @@
-package yaml
@@ -129672,15 +136536,19 @@ index 95ec014..0000000
-//}
-//
-//
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/decode.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/decode.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/decode.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/decode.go
deleted file mode 100644
-index 74eda3c..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/decode.go
+index c50c629..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/decode.go
+++ /dev/null
-@@ -1,538 +0,0 @@
+@@ -1,665 +0,0 @@
-package yaml
-
-import (
+- "encoding"
+- "encoding/base64"
+- "fmt"
+- "math"
- "reflect"
- "strconv"
- "time"
@@ -129708,15 +136576,15 @@ index 74eda3c..0000000
-// Parser, produces a node tree out of a libyaml event stream.
-
-type parser struct {
-- parser yaml_parser_t
-- event yaml_event_t
-- doc *node
+- parser yaml_parser_t
+- event yaml_event_t
+- doc *node
-}
-
-func newParser(b []byte) *parser {
- p := parser{}
- if !yaml_parser_initialize(&p.parser) {
-- panic("Failed to initialize YAML emitter")
+- panic("failed to initialize YAML emitter")
- }
-
- if len(b) == 0 {
@@ -129727,7 +136595,7 @@ index 74eda3c..0000000
-
- p.skip()
- if p.event.typ != yaml_STREAM_START_EVENT {
-- panic("Expected stream start event, got " + strconv.Itoa(int(p.event.typ)))
+- panic("expected stream start event, got " + strconv.Itoa(int(p.event.typ)))
- }
- p.skip()
- return &p
@@ -129743,7 +136611,7 @@ index 74eda3c..0000000
-func (p *parser) skip() {
- if p.event.typ != yaml_NO_EVENT {
- if p.event.typ == yaml_STREAM_END_EVENT {
-- panic("Attempted to go past the end of stream. Corrupted value?")
+- failf("attempted to go past the end of stream; corrupted value?")
- }
- yaml_event_delete(&p.event)
- }
@@ -129767,9 +136635,9 @@ index 74eda3c..0000000
- if len(p.parser.problem) > 0 {
- msg = p.parser.problem
- } else {
-- msg = "Unknown problem parsing YAML content"
+- msg = "unknown problem parsing YAML content"
- }
-- panic(where + msg)
+- failf("%s%s", where, msg)
-}
-
-func (p *parser) anchor(n *node, anchor []byte) {
@@ -129794,10 +136662,9 @@ index 74eda3c..0000000
- // Happens when attempting to decode an empty buffer.
- return nil
- default:
-- panic("Attempted to parse unknown event: " +
-- strconv.Itoa(int(p.event.typ)))
+- panic("attempted to parse unknown event: " + strconv.Itoa(int(p.event.typ)))
- }
-- panic("Unreachable")
+- panic("unreachable")
-}
-
-func (p *parser) node(kind int) *node {
@@ -129815,8 +136682,7 @@ index 74eda3c..0000000
- p.skip()
- n.children = append(n.children, p.parse())
- if p.event.typ != yaml_DOCUMENT_END_EVENT {
-- panic("Expected end of document event but got " +
-- strconv.Itoa(int(p.event.typ)))
+- panic("expected end of document event but got " + strconv.Itoa(int(p.event.typ)))
- }
- p.skip()
- return n
@@ -129867,84 +136733,113 @@ index 74eda3c..0000000
-type decoder struct {
- doc *node
- aliases map[string]bool
+- mapType reflect.Type
+- terrors []string
-}
-
+-var (
+- mapItemType = reflect.TypeOf(MapItem{})
+- durationType = reflect.TypeOf(time.Duration(0))
+- defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
+- ifaceType = defaultMapType.Elem()
+-)
+-
-func newDecoder() *decoder {
-- d := &decoder{}
+- d := &decoder{mapType: defaultMapType}
- d.aliases = make(map[string]bool)
- return d
-}
-
--// d.setter deals with setters and pointer dereferencing and initialization.
--//
--// It's a slightly convoluted case to handle properly:
--//
--// - nil pointers should be initialized, unless being set to nil
--// - we don't know at this point yet what's the value to SetYAML() with.
--// - we can't separate pointer deref/init and setter checking, because
--// a setter may be found while going down a pointer chain.
--//
--// Thus, here is how it takes care of it:
--//
--// - out is provided as a pointer, so that it can be replaced.
--// - when looking at a non-setter ptr, *out=ptr.Elem(), unless tag=!!null
--// - when a setter is found, *out=interface{}, and a set() function is
--// returned to call SetYAML() with the value of *out once it's defined.
--//
--func (d *decoder) setter(tag string, out *reflect.Value, good *bool) (set func()) {
-- if (*out).Kind() != reflect.Ptr && (*out).CanAddr() {
-- setter, _ := (*out).Addr().Interface().(Setter)
-- if setter != nil {
-- var arg interface{}
-- *out = reflect.ValueOf(&arg).Elem()
-- return func() {
-- *good = setter.SetYAML(tag, arg)
-- }
+-func (d *decoder) terror(n *node, tag string, out reflect.Value) {
+- if n.tag != "" {
+- tag = n.tag
+- }
+- value := n.value
+- if tag != yaml_SEQ_TAG && tag != yaml_MAP_TAG {
+- if len(value) > 10 {
+- value = " `" + value[:7] + "...`"
+- } else {
+- value = " `" + value + "`"
- }
- }
+- d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type()))
+-}
+-
+-func (d *decoder) callUnmarshaler(n *node, u Unmarshaler) (good bool) {
+- terrlen := len(d.terrors)
+- err := u.UnmarshalYAML(func(v interface{}) (err error) {
+- defer handleErr(&err)
+- d.unmarshal(n, reflect.ValueOf(v))
+- if len(d.terrors) > terrlen {
+- issues := d.terrors[terrlen:]
+- d.terrors = d.terrors[:terrlen]
+- return &TypeError{issues}
+- }
+- return nil
+- })
+- if e, ok := err.(*TypeError); ok {
+- d.terrors = append(d.terrors, e.Errors...)
+- return false
+- }
+- if err != nil {
+- fail(err)
+- }
+- return true
+-}
+-
+-// d.prepare initializes and dereferences pointers and calls UnmarshalYAML
+-// if a value is found to implement it.
+-// It returns the initialized and dereferenced out value, whether
+-// unmarshalling was already done by UnmarshalYAML, and if so whether
+-// its types unmarshalled appropriately.
+-//
+-// If n holds a null value, prepare returns before doing anything.
+-func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
+- if n.tag == yaml_NULL_TAG || n.kind == scalarNode && n.tag == "" && (n.value == "null" || n.value == "") {
+- return out, false, false
+- }
- again := true
- for again {
- again = false
-- setter, _ := (*out).Interface().(Setter)
-- if tag != "!!null" || setter != nil {
-- if pv := (*out); pv.Kind() == reflect.Ptr {
-- if pv.IsNil() {
-- *out = reflect.New(pv.Type().Elem()).Elem()
-- pv.Set((*out).Addr())
-- } else {
-- *out = pv.Elem()
-- }
-- setter, _ = pv.Interface().(Setter)
-- again = true
+- if out.Kind() == reflect.Ptr {
+- if out.IsNil() {
+- out.Set(reflect.New(out.Type().Elem()))
- }
+- out = out.Elem()
+- again = true
- }
-- if setter != nil {
-- var arg interface{}
-- *out = reflect.ValueOf(&arg).Elem()
-- return func() {
-- *good = setter.SetYAML(tag, arg)
+- if out.CanAddr() {
+- if u, ok := out.Addr().Interface().(Unmarshaler); ok {
+- good = d.callUnmarshaler(n, u)
+- return out, true, good
- }
- }
- }
-- return nil
+- return out, false, false
-}
-
-func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
- switch n.kind {
- case documentNode:
-- good = d.document(n, out)
+- return d.document(n, out)
+- case aliasNode:
+- return d.alias(n, out)
+- }
+- out, unmarshaled, good := d.prepare(n, out)
+- if unmarshaled {
+- return good
+- }
+- switch n.kind {
- case scalarNode:
- good = d.scalar(n, out)
-- case aliasNode:
-- good = d.alias(n, out)
- case mappingNode:
- good = d.mapping(n, out)
- case sequenceNode:
- good = d.sequence(n, out)
- default:
-- panic("Internal error: unknown node kind: " + strconv.Itoa(n.kind))
+- panic("internal error: unknown node kind: " + strconv.Itoa(n.kind))
- }
-- return
+- return good
-}
-
-func (d *decoder) document(n *node, out reflect.Value) (good bool) {
@@ -129959,10 +136854,10 @@ index 74eda3c..0000000
-func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
- an, ok := d.doc.anchors[n.value]
- if !ok {
-- panic("Unknown anchor '" + n.value + "' referenced")
+- failf("unknown anchor '%s' referenced", n.value)
- }
- if d.aliases[n.value] {
-- panic("Anchor '" + n.value + "' value contains itself")
+- failf("anchor '%s' value contains itself", n.value)
- }
- d.aliases[n.value] = true
- good = d.unmarshal(an, out)
@@ -129970,23 +136865,53 @@ index 74eda3c..0000000
- return good
-}
-
--var durationType = reflect.TypeOf(time.Duration(0))
+-var zeroValue reflect.Value
+-
+-func resetMap(out reflect.Value) {
+- for _, k := range out.MapKeys() {
+- out.SetMapIndex(k, zeroValue)
+- }
+-}
-
-func (d *decoder) scalar(n *node, out reflect.Value) (good bool) {
- var tag string
- var resolved interface{}
- if n.tag == "" && !n.implicit {
-- tag = "!!str"
+- tag = yaml_STR_TAG
- resolved = n.value
- } else {
- tag, resolved = resolve(n.tag, n.value)
+- if tag == yaml_BINARY_TAG {
+- data, err := base64.StdEncoding.DecodeString(resolved.(string))
+- if err != nil {
+- failf("!!binary value contains invalid base64 data")
+- }
+- resolved = string(data)
+- }
- }
-- if set := d.setter(tag, &out, &good); set != nil {
-- defer set()
+- if resolved == nil {
+- if out.Kind() == reflect.Map && !out.CanAddr() {
+- resetMap(out)
+- } else {
+- out.Set(reflect.Zero(out.Type()))
+- }
+- return true
+- }
+- if s, ok := resolved.(string); ok && out.CanAddr() {
+- if u, ok := out.Addr().Interface().(encoding.TextUnmarshaler); ok {
+- err := u.UnmarshalText([]byte(s))
+- if err != nil {
+- fail(err)
+- }
+- return true
+- }
- }
- switch out.Kind() {
- case reflect.String:
-- if resolved != nil {
+- if tag == yaml_BINARY_TAG {
+- out.SetString(resolved.(string))
+- good = true
+- } else if resolved != nil {
- out.SetString(n.value)
- good = true
- }
@@ -130009,8 +136934,13 @@ index 74eda3c..0000000
- out.SetInt(resolved)
- good = true
- }
+- case uint64:
+- if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+- out.SetInt(int64(resolved))
+- good = true
+- }
- case float64:
-- if resolved < 1<<63-1 && !out.OverflowInt(int64(resolved)) {
+- if resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
- out.SetInt(int64(resolved))
- good = true
- }
@@ -130026,17 +136956,22 @@ index 74eda3c..0000000
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- switch resolved := resolved.(type) {
- case int:
-- if resolved >= 0 {
+- if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
- out.SetUint(uint64(resolved))
- good = true
- }
- case int64:
-- if resolved >= 0 {
+- if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+- out.SetUint(uint64(resolved))
+- good = true
+- }
+- case uint64:
+- if !out.OverflowUint(uint64(resolved)) {
- out.SetUint(uint64(resolved))
- good = true
- }
- case float64:
-- if resolved < 1<<64-1 && !out.OverflowUint(uint64(resolved)) {
+- if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) {
- out.SetUint(uint64(resolved))
- good = true
- }
@@ -130055,24 +136990,25 @@ index 74eda3c..0000000
- case int64:
- out.SetFloat(float64(resolved))
- good = true
+- case uint64:
+- out.SetFloat(float64(resolved))
+- good = true
- case float64:
- out.SetFloat(resolved)
- good = true
- }
- case reflect.Ptr:
-- switch resolved.(type) {
-- case nil:
-- out.Set(reflect.Zero(out.Type()))
+- if out.Type().Elem() == reflect.TypeOf(resolved) {
+- // TODO DOes this make sense? When is out a Ptr except when decoding a nil value?
+- elem := reflect.New(out.Type().Elem())
+- elem.Elem().Set(reflect.ValueOf(resolved))
+- out.Set(elem)
- good = true
-- default:
-- if out.Type().Elem() == reflect.TypeOf(resolved) {
-- elem := reflect.New(out.Type().Elem())
-- elem.Elem().Set(reflect.ValueOf(resolved))
-- out.Set(elem)
-- good = true
-- }
- }
- }
+- if !good {
+- d.terror(n, tag, out)
+- }
- return good
-}
-
@@ -130084,17 +137020,16 @@ index 74eda3c..0000000
-}
-
-func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
-- if set := d.setter("!!seq", &out, &good); set != nil {
-- defer set()
-- }
- var iface reflect.Value
-- if out.Kind() == reflect.Interface {
+- switch out.Kind() {
+- case reflect.Slice:
+- // okay
+- case reflect.Interface:
- // No type hints. Will have to use a generic sequence.
- iface = out
- out = settableValueOf(make([]interface{}, 0))
-- }
--
-- if out.Kind() != reflect.Slice {
+- default:
+- d.terror(n, yaml_SEQ_TAG, out)
- return false
- }
- et := out.Type().Elem()
@@ -130112,28 +137047,42 @@ index 74eda3c..0000000
- return true
-}
-
--func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
-- if set := d.setter("!!map", &out, &good); set != nil {
-- defer set()
-- }
-- if out.Kind() == reflect.Struct {
-- return d.mappingStruct(n, out)
-- }
-
-- if out.Kind() == reflect.Interface {
-- // No type hints. Will have to use a generic map.
-- iface := out
-- out = settableValueOf(make(map[interface{}]interface{}))
-- iface.Set(out)
-- }
-
-- if out.Kind() != reflect.Map {
+-func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
+- switch out.Kind() {
+- case reflect.Struct:
+- return d.mappingStruct(n, out)
+- case reflect.Slice:
+- return d.mappingSlice(n, out)
+- case reflect.Map:
+- // okay
+- case reflect.Interface:
+- if d.mapType.Kind() == reflect.Map {
+- iface := out
+- out = reflect.MakeMap(d.mapType)
+- iface.Set(out)
+- } else {
+- slicev := reflect.New(d.mapType).Elem()
+- if !d.mappingSlice(n, slicev) {
+- return false
+- }
+- out.Set(slicev)
+- return true
+- }
+- default:
+- d.terror(n, yaml_MAP_TAG, out)
- return false
- }
- outt := out.Type()
- kt := outt.Key()
- et := outt.Elem()
-
+- mapType := d.mapType
+- if outt.Key() == ifaceType && outt.Elem() == ifaceType {
+- d.mapType = outt
+- }
+-
- if out.IsNil() {
- out.Set(reflect.MakeMap(outt))
- }
@@ -130145,12 +137094,51 @@ index 74eda3c..0000000
- }
- k := reflect.New(kt).Elem()
- if d.unmarshal(n.children[i], k) {
+- kkind := k.Kind()
+- if kkind == reflect.Interface {
+- kkind = k.Elem().Kind()
+- }
+- if kkind == reflect.Map || kkind == reflect.Slice {
+- failf("invalid map key: %#v", k.Interface())
+- }
- e := reflect.New(et).Elem()
- if d.unmarshal(n.children[i+1], e) {
- out.SetMapIndex(k, e)
- }
- }
- }
+- d.mapType = mapType
+- return true
+-}
+-
+-func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) {
+- outt := out.Type()
+- if outt.Elem() != mapItemType {
+- d.terror(n, yaml_MAP_TAG, out)
+- return false
+- }
+-
+- mapType := d.mapType
+- d.mapType = outt
+-
+- var slice []MapItem
+- var l = len(n.children)
+- for i := 0; i < l; i += 2 {
+- if isMerge(n.children[i]) {
+- d.merge(n.children[i+1], out)
+- continue
+- }
+- item := MapItem{}
+- k := reflect.ValueOf(&item.Key).Elem()
+- if d.unmarshal(n.children[i], k) {
+- v := reflect.ValueOf(&item.Value).Elem()
+- if d.unmarshal(n.children[i+1], v) {
+- slice = append(slice, item)
+- }
+- }
+- }
+- out.Set(reflect.ValueOf(slice))
+- d.mapType = mapType
- return true
-}
-
@@ -130183,52 +137171,58 @@ index 74eda3c..0000000
- return true
-}
-
+-func failWantMap() {
+- failf("map merge requires map or sequence of maps as the value")
+-}
+-
-func (d *decoder) merge(n *node, out reflect.Value) {
-- const wantMap = "map merge requires map or sequence of maps as the value"
- switch n.kind {
- case mappingNode:
- d.unmarshal(n, out)
- case aliasNode:
- an, ok := d.doc.anchors[n.value]
- if ok && an.kind != mappingNode {
-- panic(wantMap)
+- failWantMap()
- }
- d.unmarshal(n, out)
- case sequenceNode:
- // Step backwards as earlier nodes take precedence.
-- for i := len(n.children)-1; i >= 0; i-- {
+- for i := len(n.children) - 1; i >= 0; i-- {
- ni := n.children[i]
- if ni.kind == aliasNode {
- an, ok := d.doc.anchors[ni.value]
- if ok && an.kind != mappingNode {
-- panic(wantMap)
+- failWantMap()
- }
- } else if ni.kind != mappingNode {
-- panic(wantMap)
+- failWantMap()
- }
- d.unmarshal(ni, out)
- }
- default:
-- panic(wantMap)
+- failWantMap()
- }
-}
-
-func isMerge(n *node) bool {
-- return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == "!!merge" || n.tag == "tag:yaml.org,2002:merge")
+- return n.kind == scalarNode && n.value == "<<" && (n.implicit == true || n.tag == yaml_MERGE_TAG)
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/decode_test.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/decode_test.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/decode_test.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/decode_test.go
deleted file mode 100644
-index d2b45b3..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/decode_test.go
+index 90ffcc0..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/decode_test.go
+++ /dev/null
-@@ -1,648 +0,0 @@
+@@ -1,902 +0,0 @@
-package yaml_test
-
-import (
+- "errors"
- . "gopkg.in/check.v1"
-- "gopkg.in/yaml.v1"
+- "gopkg.in/yaml.v2"
- "math"
+- "net"
- "reflect"
+- "strings"
- "time"
-)
-
@@ -130423,7 +137417,7 @@ index d2b45b3..0000000
- // Map inside interface with no type hints.
- {
- "a: {b: c}",
-- map[string]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
+- map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": "c"}},
- },
-
- // Structs and type conversions.
@@ -130488,6 +137482,114 @@ index d2b45b3..0000000
- map[string]uint64{},
- },
-
+- // int
+- {
+- "int_max: 2147483647",
+- map[string]int{"int_max": math.MaxInt32},
+- },
+- {
+- "int_min: -2147483648",
+- map[string]int{"int_min": math.MinInt32},
+- },
+- {
+- "int_overflow: 9223372036854775808", // math.MaxInt64 + 1
+- map[string]int{},
+- },
+-
+- // int64
+- {
+- "int64_max: 9223372036854775807",
+- map[string]int64{"int64_max": math.MaxInt64},
+- },
+- {
+- "int64_max_base2: 0b111111111111111111111111111111111111111111111111111111111111111",
+- map[string]int64{"int64_max_base2": math.MaxInt64},
+- },
+- {
+- "int64_min: -9223372036854775808",
+- map[string]int64{"int64_min": math.MinInt64},
+- },
+- {
+- "int64_neg_base2: -0b111111111111111111111111111111111111111111111111111111111111111",
+- map[string]int64{"int64_neg_base2": -math.MaxInt64},
+- },
+- {
+- "int64_overflow: 9223372036854775808", // math.MaxInt64 + 1
+- map[string]int64{},
+- },
+-
+- // uint
+- {
+- "uint_min: 0",
+- map[string]uint{"uint_min": 0},
+- },
+- {
+- "uint_max: 4294967295",
+- map[string]uint{"uint_max": math.MaxUint32},
+- },
+- {
+- "uint_underflow: -1",
+- map[string]uint{},
+- },
+-
+- // uint64
+- {
+- "uint64_min: 0",
+- map[string]uint{"uint64_min": 0},
+- },
+- {
+- "uint64_max: 18446744073709551615",
+- map[string]uint64{"uint64_max": math.MaxUint64},
+- },
+- {
+- "uint64_max_base2: 0b1111111111111111111111111111111111111111111111111111111111111111",
+- map[string]uint64{"uint64_max_base2": math.MaxUint64},
+- },
+- {
+- "uint64_maxint64: 9223372036854775807",
+- map[string]uint64{"uint64_maxint64": math.MaxInt64},
+- },
+- {
+- "uint64_underflow: -1",
+- map[string]uint64{},
+- },
+-
+- // float32
+- {
+- "float32_max: 3.40282346638528859811704183484516925440e+38",
+- map[string]float32{"float32_max": math.MaxFloat32},
+- },
+- {
+- "float32_nonzero: 1.401298464324817070923729583289916131280e-45",
+- map[string]float32{"float32_nonzero": math.SmallestNonzeroFloat32},
+- },
+- {
+- "float32_maxuint64: 18446744073709551615",
+- map[string]float32{"float32_maxuint64": float32(math.MaxUint64)},
+- },
+- {
+- "float32_maxuint64+1: 18446744073709551616",
+- map[string]float32{"float32_maxuint64+1": float32(math.MaxUint64 + 1)},
+- },
+-
+- // float64
+- {
+- "float64_max: 1.797693134862315708145274237317043567981e+308",
+- map[string]float64{"float64_max": math.MaxFloat64},
+- },
+- {
+- "float64_nonzero: 4.940656458412465441765687928682213723651e-324",
+- map[string]float64{"float64_nonzero": math.SmallestNonzeroFloat64},
+- },
+- {
+- "float64_maxuint64: 18446744073709551615",
+- map[string]float64{"float64_maxuint64": float64(math.MaxUint64)},
+- },
+- {
+- "float64_maxuint64+1: 18446744073709551616",
+- map[string]float64{"float64_maxuint64+1": float64(math.MaxUint64 + 1)},
+- },
+-
- // Overflow cases.
- {
- "v: 4294967297",
@@ -130540,7 +137642,10 @@ index d2b45b3..0000000
- map[string]*string{"foo": new(string)},
- }, {
- "foo: null",
-- map[string]string{},
+- map[string]string{"foo": ""},
+- }, {
+- "foo: null",
+- map[string]interface{}{"foo": nil},
- },
-
- // Ignored field
@@ -130595,8 +137700,58 @@ index d2b45b3..0000000
- "a: 3s",
- map[string]time.Duration{"a": 3 * time.Second},
- },
+-
+- // Issue #24.
+- {
+- "a: <foo>",
+- map[string]string{"a": "<foo>"},
+- },
+-
+- // Base 60 floats are obsolete and unsupported.
+- {
+- "a: 1:1\n",
+- map[string]string{"a": "1:1"},
+- },
+-
+- // Binary data.
+- {
+- "a: !!binary gIGC\n",
+- map[string]string{"a": "\x80\x81\x82"},
+- }, {
+- "a: !!binary |\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n",
+- map[string]string{"a": strings.Repeat("\x90", 54)},
+- }, {
+- "a: !!binary |\n " + strings.Repeat("A", 70) + "\n ==\n",
+- map[string]string{"a": strings.Repeat("\x00", 52)},
+- },
+-
+- // Ordered maps.
+- {
+- "{b: 2, a: 1, d: 4, c: 3, sub: {e: 5}}",
+- &yaml.MapSlice{{"b", 2}, {"a", 1}, {"d", 4}, {"c", 3}, {"sub", yaml.MapSlice{{"e", 5}}}},
+- },
+-
+- // Issue #39.
+- {
+- "a:\n b:\n c: d\n",
+- map[string]struct{ B interface{} }{"a": {map[interface{}]interface{}{"c": "d"}}},
+- },
+-
+- // Custom map type.
+- {
+- "a: {b: c}",
+- M{"a": M{"b": "c"}},
+- },
+-
+- // Support encoding.TextUnmarshaler.
+- {
+- "a: 1.2.3.4\n",
+- map[string]net.IP{"a": net.IPv4(1, 2, 3, 4)},
+- },
-}
-
+-type M map[interface{}]interface{}
+-
-type inlineB struct {
- B int
- inlineC `yaml:",inline"`
@@ -130607,27 +137762,27 @@ index d2b45b3..0000000
-}
-
-func (s *S) TestUnmarshal(c *C) {
-- for i, item := range unmarshalTests {
+- for _, item := range unmarshalTests {
- t := reflect.ValueOf(item.value).Type()
- var value interface{}
- switch t.Kind() {
- case reflect.Map:
- value = reflect.MakeMap(t).Interface()
- case reflect.String:
-- t := reflect.ValueOf(item.value).Type()
-- v := reflect.New(t)
-- value = v.Interface()
+- value = reflect.New(t).Interface()
+- case reflect.Ptr:
+- value = reflect.New(t.Elem()).Interface()
- default:
-- pt := reflect.ValueOf(item.value).Type()
-- pv := reflect.New(pt.Elem())
-- value = pv.Interface()
+- c.Fatalf("missing case for %s", t)
- }
- err := yaml.Unmarshal([]byte(item.data), value)
-- c.Assert(err, IsNil, Commentf("Item #%d", i))
+- if _, ok := err.(*yaml.TypeError); !ok {
+- c.Assert(err, IsNil)
+- }
- if t.Kind() == reflect.String {
-- c.Assert(*value.(*string), Equals, item.value, Commentf("Item #%d", i))
+- c.Assert(*value.(*string), Equals, item.value)
- } else {
-- c.Assert(value, DeepEquals, item.value, Commentf("Item #%d", i))
+- c.Assert(value, DeepEquals, item.value)
- }
- }
-}
@@ -130642,12 +137797,15 @@ index d2b45b3..0000000
-var unmarshalErrorTests = []struct {
- data, error string
-}{
-- {"v: !!float 'error'", "YAML error: Can't decode !!str 'error' as a !!float"},
-- {"v: [A,", "YAML error: line 1: did not find expected node content"},
-- {"v:\n- [A,", "YAML error: line 2: did not find expected node content"},
-- {"a: *b\n", "YAML error: Unknown anchor 'b' referenced"},
-- {"a: &a\n b: *a\n", "YAML error: Anchor 'a' value contains itself"},
-- {"value: -", "YAML error: block sequence entries are not allowed in this context"},
+- {"v: !!float 'error'", "yaml: cannot decode !!str `error` as a !!float"},
+- {"v: [A,", "yaml: line 1: did not find expected node content"},
+- {"v:\n- [A,", "yaml: line 2: did not find expected node content"},
+- {"a: *b\n", "yaml: unknown anchor 'b' referenced"},
+- {"a: &a\n b: *a\n", "yaml: anchor 'a' value contains itself"},
+- {"value: -", "yaml: block sequence entries are not allowed in this context"},
+- {"a: !!binary ==", "yaml: !!binary value contains invalid base64 data"},
+- {"{[.]}", `yaml: invalid map key: \[\]interface \{\}\{"\."\}`},
+- {"{{.}}", `yaml: invalid map key: map\[interface\ \{\}\]interface \{\}\{".":interface \{\}\(nil\)\}`},
-}
-
-func (s *S) TestUnmarshalErrors(c *C) {
@@ -130658,7 +137816,7 @@ index d2b45b3..0000000
- }
-}
-
--var setterTests = []struct {
+-var unmarshalerTests = []struct {
- data, tag string
- value interface{}
-}{
@@ -130671,92 +137829,155 @@ index d2b45b3..0000000
- {"_: !!foo 'BAR!'", "!!foo", "BAR!"},
-}
-
--var setterResult = map[int]bool{}
+-var unmarshalerResult = map[int]error{}
-
--type typeWithSetter struct {
-- tag string
+-type unmarshalerType struct {
- value interface{}
-}
-
--func (o *typeWithSetter) SetYAML(tag string, value interface{}) (ok bool) {
-- o.tag = tag
-- o.value = value
-- if i, ok := value.(int); ok {
-- if result, ok := setterResult[i]; ok {
+-func (o *unmarshalerType) UnmarshalYAML(unmarshal func(v interface{}) error) error {
+- if err := unmarshal(&o.value); err != nil {
+- return err
+- }
+- if i, ok := o.value.(int); ok {
+- if result, ok := unmarshalerResult[i]; ok {
- return result
- }
- }
-- return true
+- return nil
-}
-
--type setterPointerType struct {
-- Field *typeWithSetter "_"
+-type unmarshalerPointer struct {
+- Field *unmarshalerType "_"
-}
-
--type setterValueType struct {
-- Field typeWithSetter "_"
+-type unmarshalerValue struct {
+- Field unmarshalerType "_"
-}
-
--func (s *S) TestUnmarshalWithPointerSetter(c *C) {
-- for _, item := range setterTests {
-- obj := &setterPointerType{}
+-func (s *S) TestUnmarshalerPointerField(c *C) {
+- for _, item := range unmarshalerTests {
+- obj := &unmarshalerPointer{}
- err := yaml.Unmarshal([]byte(item.data), obj)
- c.Assert(err, IsNil)
-- c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
-- c.Assert(obj.Field.tag, Equals, item.tag)
-- c.Assert(obj.Field.value, DeepEquals, item.value)
+- if item.value == nil {
+- c.Assert(obj.Field, IsNil)
+- } else {
+- c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
+- c.Assert(obj.Field.value, DeepEquals, item.value)
+- }
- }
-}
-
--func (s *S) TestUnmarshalWithValueSetter(c *C) {
-- for _, item := range setterTests {
-- obj := &setterValueType{}
+-func (s *S) TestUnmarshalerValueField(c *C) {
+- for _, item := range unmarshalerTests {
+- obj := &unmarshalerValue{}
- err := yaml.Unmarshal([]byte(item.data), obj)
- c.Assert(err, IsNil)
- c.Assert(obj.Field, NotNil, Commentf("Pointer not initialized (%#v)", item.value))
-- c.Assert(obj.Field.tag, Equals, item.tag)
- c.Assert(obj.Field.value, DeepEquals, item.value)
- }
-}
-
--func (s *S) TestUnmarshalWholeDocumentWithSetter(c *C) {
-- obj := &typeWithSetter{}
-- err := yaml.Unmarshal([]byte(setterTests[0].data), obj)
+-func (s *S) TestUnmarshalerWholeDocument(c *C) {
+- obj := &unmarshalerType{}
+- err := yaml.Unmarshal([]byte(unmarshalerTests[0].data), obj)
- c.Assert(err, IsNil)
-- c.Assert(obj.tag, Equals, setterTests[0].tag)
- value, ok := obj.value.(map[interface{}]interface{})
-- c.Assert(ok, Equals, true)
-- c.Assert(value["_"], DeepEquals, setterTests[0].value)
+- c.Assert(ok, Equals, true, Commentf("value: %#v", obj.value))
+- c.Assert(value["_"], DeepEquals, unmarshalerTests[0].value)
-}
-
--func (s *S) TestUnmarshalWithFalseSetterIgnoresValue(c *C) {
-- setterResult[2] = false
-- setterResult[4] = false
+-func (s *S) TestUnmarshalerTypeError(c *C) {
+- unmarshalerResult[2] = &yaml.TypeError{[]string{"foo"}}
+- unmarshalerResult[4] = &yaml.TypeError{[]string{"bar"}}
- defer func() {
-- delete(setterResult, 2)
-- delete(setterResult, 4)
+- delete(unmarshalerResult, 2)
+- delete(unmarshalerResult, 4)
- }()
-
-- m := map[string]*typeWithSetter{}
-- data := `{abc: 1, def: 2, ghi: 3, jkl: 4}`
-- err := yaml.Unmarshal([]byte(data), m)
-- c.Assert(err, IsNil)
-- c.Assert(m["abc"], NotNil)
-- c.Assert(m["def"], IsNil)
-- c.Assert(m["ghi"], NotNil)
-- c.Assert(m["jkl"], IsNil)
+- type T struct {
+- Before int
+- After int
+- M map[string]*unmarshalerType
+- }
+- var v T
+- data := `{before: A, m: {abc: 1, def: 2, ghi: 3, jkl: 4}, after: B}`
+- err := yaml.Unmarshal([]byte(data), &v)
+- c.Assert(err, ErrorMatches, ""+
+- "yaml: unmarshal errors:\n"+
+- " line 1: cannot unmarshal !!str `A` into int\n"+
+- " foo\n"+
+- " bar\n"+
+- " line 1: cannot unmarshal !!str `B` into int")
+- c.Assert(v.M["abc"], NotNil)
+- c.Assert(v.M["def"], IsNil)
+- c.Assert(v.M["ghi"], NotNil)
+- c.Assert(v.M["jkl"], IsNil)
+-
+- c.Assert(v.M["abc"].value, Equals, 1)
+- c.Assert(v.M["ghi"].value, Equals, 3)
+-}
+-
+-type proxyTypeError struct{}
+-
+-func (v *proxyTypeError) UnmarshalYAML(unmarshal func(interface{}) error) error {
+- var s string
+- var a int32
+- var b int64
+- if err := unmarshal(&s); err != nil {
+- panic(err)
+- }
+- if s == "a" {
+- if err := unmarshal(&b); err == nil {
+- panic("should have failed")
+- }
+- return unmarshal(&a)
+- }
+- if err := unmarshal(&a); err == nil {
+- panic("should have failed")
+- }
+- return unmarshal(&b)
+-}
-
-- c.Assert(m["abc"].value, Equals, 1)
-- c.Assert(m["ghi"].value, Equals, 3)
+-func (s *S) TestUnmarshalerTypeErrorProxying(c *C) {
+- type T struct {
+- Before int
+- After int
+- M map[string]*proxyTypeError
+- }
+- var v T
+- data := `{before: A, m: {abc: a, def: b}, after: B}`
+- err := yaml.Unmarshal([]byte(data), &v)
+- c.Assert(err, ErrorMatches, ""+
+- "yaml: unmarshal errors:\n"+
+- " line 1: cannot unmarshal !!str `A` into int\n"+
+- " line 1: cannot unmarshal !!str `a` into int32\n"+
+- " line 1: cannot unmarshal !!str `b` into int64\n"+
+- " line 1: cannot unmarshal !!str `B` into int")
+-}
+-
+-type failingUnmarshaler struct{}
+-
+-var failingErr = errors.New("failingErr")
+-
+-func (ft *failingUnmarshaler) UnmarshalYAML(unmarshal func(interface{}) error) error {
+- return failingErr
+-}
+-
+-func (s *S) TestUnmarshalerError(c *C) {
+- err := yaml.Unmarshal([]byte("a: b"), &failingUnmarshaler{})
+- c.Assert(err, Equals, failingErr)
-}
-
-// From http://yaml.org/type/merge.html
-var mergeTests = `
-anchors:
-- - &CENTER { "x": 1, "y": 2 }
-- - &LEFT { "x": 0, "y": 2 }
-- - &BIG { "r": 10 }
-- - &SMALL { "r": 1 }
+- list:
+- - &CENTER { "x": 1, "y": 2 }
+- - &LEFT { "x": 0, "y": 2 }
+- - &BIG { "r": 10 }
+- - &SMALL { "r": 1 }
-
-# All the following maps are equal:
-
@@ -130813,7 +138034,7 @@ index d2b45b3..0000000
- "label": "center/big",
- }
-
-- var m map[string]interface{}
+- var m map[interface{}]interface{}
- err := yaml.Unmarshal([]byte(mergeTests), &m)
- c.Assert(err, IsNil)
- for name, test := range m {
@@ -130842,6 +138063,30 @@ index d2b45b3..0000000
- }
-}
-
+-var unmarshalNullTests = []func() interface{}{
+- func() interface{} { var v interface{}; v = "v"; return &v },
+- func() interface{} { var s = "s"; return &s },
+- func() interface{} { var s = "s"; sptr := &s; return &sptr },
+- func() interface{} { var i = 1; return &i },
+- func() interface{} { var i = 1; iptr := &i; return &iptr },
+- func() interface{} { m := map[string]int{"s": 1}; return &m },
+- func() interface{} { m := map[string]int{"s": 1}; return m },
+-}
+-
+-func (s *S) TestUnmarshalNull(c *C) {
+- for _, test := range unmarshalNullTests {
+- item := test()
+- zero := reflect.Zero(reflect.TypeOf(item).Elem()).Interface()
+- err := yaml.Unmarshal([]byte("null"), item)
+- c.Assert(err, IsNil)
+- if reflect.TypeOf(item).Kind() == reflect.Map {
+- c.Assert(reflect.ValueOf(item).Interface(), DeepEquals, reflect.MakeMap(reflect.TypeOf(item)).Interface())
+- } else {
+- c.Assert(reflect.ValueOf(item).Elem().Interface(), DeepEquals, zero)
+- }
+- }
+-}
+-
-//var data []byte
-//func init() {
-// var err error
@@ -130870,12 +138115,12 @@ index d2b45b3..0000000
-// yaml.Marshal(&v)
-// }
-//}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/emitterc.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/emitterc.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/emitterc.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/emitterc.go
deleted file mode 100644
-index 542ffd2..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/emitterc.go
+index 9b3dc4a..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/emitterc.go
+++ /dev/null
-@@ -1,1682 +0,0 @@
+@@ -1,1685 +0,0 @@
-package yaml
-
-import (
@@ -131851,8 +139096,8 @@ index 542ffd2..0000000
- if bytes.HasPrefix(tag, tag_directive.prefix) {
- emitter.tag_data.handle = tag_directive.handle
- emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
+- return true
- }
-- return true
- }
- emitter.tag_data.suffix = tag
- return true
@@ -132157,6 +139402,9 @@ index 542ffd2..0000000
- for k := 0; k < w; k++ {
- octet := value[i]
- i++
+- if !put(emitter, '%') {
+- return false
+- }
-
- c := octet >> 4
- if c < 10 {
@@ -132558,18 +139806,21 @@ index 542ffd2..0000000
- }
- return true
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/encode.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/encode.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/encode.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/encode.go
deleted file mode 100644
-index 1d928b0..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/encode.go
+index 972bc03..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/encode.go
+++ /dev/null
-@@ -1,226 +0,0 @@
+@@ -1,290 +0,0 @@
-package yaml
-
-import (
+- "encoding"
- "reflect"
+- "regexp"
- "sort"
- "strconv"
+- "strings"
- "time"
-)
-
@@ -132584,6 +139835,7 @@ index 1d928b0..0000000
- e = &encoder{}
- e.must(yaml_emitter_initialize(&e.emitter))
- yaml_emitter_set_output_string(&e.emitter, &e.out)
+- yaml_emitter_set_unicode(&e.emitter, true)
- e.must(yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING))
- e.emit()
- e.must(yaml_document_start_event_initialize(&e.event, nil, nil, true))
@@ -132614,21 +139866,35 @@ index 1d928b0..0000000
- if !ok {
- msg := e.emitter.problem
- if msg == "" {
-- msg = "Unknown problem generating YAML content"
+- msg = "unknown problem generating YAML content"
- }
-- panic(msg)
+- failf("%s", msg)
- }
-}
-
-func (e *encoder) marshal(tag string, in reflect.Value) {
-- var value interface{}
-- if getter, ok := in.Interface().(Getter); ok {
-- tag, value = getter.GetYAML()
-- if value == nil {
+- if !in.IsValid() {
+- e.nilv()
+- return
+- }
+- iface := in.Interface()
+- if m, ok := iface.(Marshaler); ok {
+- v, err := m.MarshalYAML()
+- if err != nil {
+- fail(err)
+- }
+- if v == nil {
- e.nilv()
- return
- }
-- in = reflect.ValueOf(value)
+- in = reflect.ValueOf(v)
+- }
+- if m, ok := iface.(encoding.TextMarshaler); ok {
+- text, err := m.MarshalText()
+- if err != nil {
+- fail(err)
+- }
+- in = reflect.ValueOf(string(text))
- }
- switch in.Kind() {
- case reflect.Interface:
@@ -132648,12 +139914,16 @@ index 1d928b0..0000000
- case reflect.Struct:
- e.structv(tag, in)
- case reflect.Slice:
-- e.slicev(tag, in)
+- if in.Type().Elem() == mapItemType {
+- e.itemsv(tag, in)
+- } else {
+- e.slicev(tag, in)
+- }
- case reflect.String:
- e.stringv(tag, in)
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- if in.Type() == durationType {
-- e.stringv(tag, reflect.ValueOf(in.Interface().(time.Duration).String()))
+- e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String()))
- } else {
- e.intv(tag, in)
- }
@@ -132664,7 +139934,7 @@ index 1d928b0..0000000
- case reflect.Bool:
- e.boolv(tag, in)
- default:
-- panic("Can't marshal type yet: " + in.Type().String())
+- panic("cannot marshal type: " + in.Type().String())
- }
-}
-
@@ -132679,6 +139949,16 @@ index 1d928b0..0000000
- })
-}
-
+-func (e *encoder) itemsv(tag string, in reflect.Value) {
+- e.mappingv(tag, func() {
+- slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
+- for _, item := range slice {
+- e.marshal("", reflect.ValueOf(item.Key))
+- e.marshal("", reflect.ValueOf(item.Value))
+- }
+- })
+-}
+-
-func (e *encoder) structv(tag string, in reflect.Value) {
- sinfo, err := getStructInfo(in.Type())
- if err != nil {
@@ -132733,11 +140013,46 @@ index 1d928b0..0000000
- e.emit()
-}
-
+-// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
+-//
+-// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
+-// in YAML 1.2 and by this package, but these should be marshalled quoted for
+-// the time being for compatibility with other parsers.
+-func isBase60Float(s string) (result bool) {
+- // Fast path.
+- if s == "" {
+- return false
+- }
+- c := s[0]
+- if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
+- return false
+- }
+- // Do the full match.
+- return base60float.MatchString(s)
+-}
+-
+-// From http://yaml.org/type/float.html, except the regular expression there
+-// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
+-var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
+-
-func (e *encoder) stringv(tag string, in reflect.Value) {
- var style yaml_scalar_style_t
- s := in.String()
-- if rtag, _ := resolve("", s); rtag != "!!str" {
+- rtag, rs := resolve("", s)
+- if rtag == yaml_BINARY_TAG {
+- if tag == "" || tag == yaml_STR_TAG {
+- tag = rtag
+- s = rs.(string)
+- } else if tag == yaml_BINARY_TAG {
+- failf("explicitly tagged !!binary data must be base64-encoded")
+- } else {
+- failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
+- }
+- }
+- if tag == "" && (rtag != yaml_STR_TAG || isBase60Float(s)) {
- style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+- } else if strings.Contains(s, "\n") {
+- style = yaml_LITERAL_SCALAR_STYLE
- } else {
- style = yaml_PLAIN_SCALAR_STYLE
- }
@@ -132784,28 +140099,27 @@ index 1d928b0..0000000
-
-func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) {
- implicit := tag == ""
-- if !implicit {
-- style = yaml_PLAIN_SCALAR_STYLE
-- }
- e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
- e.emit()
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/encode_test.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/encode_test.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/encode_test.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/encode_test.go
deleted file mode 100644
-index c7461d5..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/encode_test.go
+index cdbf64a..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/encode_test.go
+++ /dev/null
-@@ -1,386 +0,0 @@
+@@ -1,434 +0,0 @@
-package yaml_test
-
-import (
- "fmt"
-- "gopkg.in/yaml.v1"
-- . "gopkg.in/check.v1"
- "math"
- "strconv"
- "strings"
- "time"
+-
+- . "gopkg.in/check.v1"
+- "gopkg.in/yaml.v2"
+- "net"
-)
-
-var marshalIntTest = 123
@@ -132815,6 +140129,9 @@ index c7461d5..0000000
- data string
-}{
- {
+- nil,
+- "null\n",
+- }, {
- &struct{}{},
- "{}\n",
- }, {
@@ -132885,7 +140202,7 @@ index c7461d5..0000000
- "v:\n- A\n- B\n",
- }, {
- map[string][]string{"v": []string{"A", "B\nC"}},
-- "v:\n- A\n- 'B\n\n C'\n",
+- "v:\n- A\n- |-\n B\n C\n",
- }, {
- map[string][]interface{}{"v": []interface{}{"A", 1, map[string][]int{"B": []int{2, 3}}}},
- "v:\n- A\n- 1\n- B:\n - 2\n - 3\n",
@@ -133017,6 +140334,49 @@ index c7461d5..0000000
- map[string]time.Duration{"a": 3 * time.Second},
- "a: 3s\n",
- },
+-
+- // Issue #24: bug in map merging logic.
+- {
+- map[string]string{"a": "<foo>"},
+- "a: <foo>\n",
+- },
+-
+- // Issue #34: marshal unsupported base 60 floats quoted for compatibility
+- // with old YAML 1.1 parsers.
+- {
+- map[string]string{"a": "1:1"},
+- "a: \"1:1\"\n",
+- },
+-
+- // Binary data.
+- {
+- map[string]string{"a": "\x00"},
+- "a: \"\\0\"\n",
+- }, {
+- map[string]string{"a": "\x80\x81\x82"},
+- "a: !!binary gIGC\n",
+- }, {
+- map[string]string{"a": strings.Repeat("\x90", 54)},
+- "a: !!binary |\n " + strings.Repeat("kJCQ", 17) + "kJ\n CQ\n",
+- },
+-
+- // Ordered maps.
+- {
+- &yaml.MapSlice{{"b", 2}, {"a", 1}, {"d", 4}, {"c", 3}, {"sub", yaml.MapSlice{{"e", 5}}}},
+- "b: 2\na: 1\nd: 4\nc: 3\nsub:\n e: 5\n",
+- },
+-
+- // Encode unicode as utf-8 rather than in escaped form.
+- {
+- map[string]string{"a": "你好"},
+- "a: 你好\n",
+- },
+-
+- // Support encoding.TextMarshaler.
+- {
+- map[string]net.IP{"a": net.IPv4(1, 2, 3, 4)},
+- "a: 1.2.3.4\n",
+- },
-}
-
-func (s *S) TestMarshal(c *C) {
@@ -133030,45 +140390,26 @@ index c7461d5..0000000
-var marshalErrorTests = []struct {
- value interface{}
- error string
--}{
-- {
-- &struct {
-- B int
-- inlineB ",inline"
-- }{1, inlineB{2, inlineC{3}}},
-- `Duplicated key 'b' in struct struct \{ B int; .*`,
-- },
--}
+- panic string
+-}{{
+- value: &struct {
+- B int
+- inlineB ",inline"
+- }{1, inlineB{2, inlineC{3}}},
+- panic: `Duplicated key 'b' in struct struct \{ B int; .*`,
+-}}
-
-func (s *S) TestMarshalErrors(c *C) {
- for _, item := range marshalErrorTests {
-- _, err := yaml.Marshal(item.value)
-- c.Assert(err, ErrorMatches, item.error)
+- if item.panic != "" {
+- c.Assert(func() { yaml.Marshal(item.value) }, PanicMatches, item.panic)
+- } else {
+- _, err := yaml.Marshal(item.value)
+- c.Assert(err, ErrorMatches, item.error)
+- }
- }
-}
-
--var marshalTaggedIfaceTest interface{} = &struct{ A string }{"B"}
--
--var getterTests = []struct {
-- data, tag string
-- value interface{}
--}{
-- {"_:\n hi: there\n", "", map[interface{}]interface{}{"hi": "there"}},
-- {"_:\n- 1\n- A\n", "", []interface{}{1, "A"}},
-- {"_: 10\n", "", 10},
-- {"_: null\n", "", nil},
-- {"_: !foo BAR!\n", "!foo", "BAR!"},
-- {"_: !foo 1\n", "!foo", "1"},
-- {"_: !foo '\"1\"'\n", "!foo", "\"1\""},
-- {"_: !foo 1.1\n", "!foo", 1.1},
-- {"_: !foo 1\n", "!foo", 1},
-- {"_: !foo 1\n", "!foo", uint(1)},
-- {"_: !foo true\n", "!foo", true},
-- {"_: !foo\n- A\n- B\n", "!foo", []string{"A", "B"}},
-- {"_: !foo\n A: B\n", "!foo", map[string]string{"A": "B"}},
-- {"_: !foo\n a: B\n", "!foo", &marshalTaggedIfaceTest},
--}
--
-func (s *S) TestMarshalTypeCache(c *C) {
- var data []byte
- var err error
@@ -133085,23 +140426,32 @@ index c7461d5..0000000
- c.Assert(string(data), Equals, "b: 0\n")
-}
-
--type typeWithGetter struct {
-- tag string
+-var marshalerTests = []struct {
+- data string
+- value interface{}
+-}{
+- {"_:\n hi: there\n", map[interface{}]interface{}{"hi": "there"}},
+- {"_:\n- 1\n- A\n", []interface{}{1, "A"}},
+- {"_: 10\n", 10},
+- {"_: null\n", nil},
+- {"_: BAR!\n", "BAR!"},
+-}
+-
+-type marshalerType struct {
- value interface{}
-}
-
--func (o typeWithGetter) GetYAML() (tag string, value interface{}) {
-- return o.tag, o.value
+-func (o marshalerType) MarshalYAML() (interface{}, error) {
+- return o.value, nil
-}
-
--type typeWithGetterField struct {
-- Field typeWithGetter "_"
+-type marshalerValue struct {
+- Field marshalerType "_"
-}
-
--func (s *S) TestMashalWithGetter(c *C) {
-- for _, item := range getterTests {
-- obj := &typeWithGetterField{}
-- obj.Field.tag = item.tag
+-func (s *S) TestMarshaler(c *C) {
+- for _, item := range marshalerTests {
+- obj := &marshalerValue{}
- obj.Field.value = item.value
- data, err := yaml.Marshal(obj)
- c.Assert(err, IsNil)
@@ -133109,15 +140459,25 @@ index c7461d5..0000000
- }
-}
-
--func (s *S) TestUnmarshalWholeDocumentWithGetter(c *C) {
-- obj := &typeWithGetter{}
-- obj.tag = ""
+-func (s *S) TestMarshalerWholeDocument(c *C) {
+- obj := &marshalerType{}
- obj.value = map[string]string{"hello": "world!"}
- data, err := yaml.Marshal(obj)
- c.Assert(err, IsNil)
- c.Assert(string(data), Equals, "hello: world!\n")
-}
-
+-type failingMarshaler struct{}
+-
+-func (ft *failingMarshaler) MarshalYAML() (interface{}, error) {
+- return nil, failingErr
+-}
+-
+-func (s *S) TestMarshalerError(c *C) {
+- _, err := yaml.Marshal(&failingMarshaler{})
+- c.Assert(err, Equals, failingErr)
+-}
+-
-func (s *S) TestSortedOutput(c *C) {
- order := []interface{}{
- false,
@@ -133182,10 +140542,10 @@ index c7461d5..0000000
- last = index
- }
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/parserc.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/parserc.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/parserc.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/parserc.go
deleted file mode 100644
index 0a7037a..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/parserc.go
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/parserc.go
+++ /dev/null
@@ -1,1096 +0,0 @@
-package yaml
@@ -134284,10 +141644,10 @@ index 0a7037a..0000000
- parser.tag_directives = append(parser.tag_directives, value_copy)
- return true
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/readerc.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/readerc.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/readerc.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/readerc.go
deleted file mode 100644
index d5fb097..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/readerc.go
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/readerc.go
+++ /dev/null
@@ -1,391 +0,0 @@
-package yaml
@@ -134681,22 +142041,22 @@ index d5fb097..0000000
- parser.buffer = parser.buffer[:buffer_len]
- return true
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/resolve.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/resolve.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/resolve.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/resolve.go
deleted file mode 100644
-index fdc4909..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/resolve.go
+index 93a8632..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/resolve.go
+++ /dev/null
-@@ -1,148 +0,0 @@
+@@ -1,203 +0,0 @@
-package yaml
-
-import (
+- "encoding/base64"
- "math"
- "strconv"
- "strings"
+- "unicode/utf8"
-)
-
--// TODO: merge, timestamps, base 60 floats, omap.
--
-type resolveMapItem struct {
- value interface{}
- tag string
@@ -134716,25 +142076,24 @@ index fdc4909..0000000
- t[int(c)] = 'M' // In map
- }
- t[int('.')] = '.' // Float (potentially in map)
-- t[int('<')] = '<' // Merge
-
- var resolveMapList = []struct {
- v interface{}
- tag string
- l []string
- }{
-- {true, "!!bool", []string{"y", "Y", "yes", "Yes", "YES"}},
-- {true, "!!bool", []string{"true", "True", "TRUE"}},
-- {true, "!!bool", []string{"on", "On", "ON"}},
-- {false, "!!bool", []string{"n", "N", "no", "No", "NO"}},
-- {false, "!!bool", []string{"false", "False", "FALSE"}},
-- {false, "!!bool", []string{"off", "Off", "OFF"}},
-- {nil, "!!null", []string{"~", "null", "Null", "NULL"}},
-- {math.NaN(), "!!float", []string{".nan", ".NaN", ".NAN"}},
-- {math.Inf(+1), "!!float", []string{".inf", ".Inf", ".INF"}},
-- {math.Inf(+1), "!!float", []string{"+.inf", "+.Inf", "+.INF"}},
-- {math.Inf(-1), "!!float", []string{"-.inf", "-.Inf", "-.INF"}},
-- {"<<", "!!merge", []string{"<<"}},
+- {true, yaml_BOOL_TAG, []string{"y", "Y", "yes", "Yes", "YES"}},
+- {true, yaml_BOOL_TAG, []string{"true", "True", "TRUE"}},
+- {true, yaml_BOOL_TAG, []string{"on", "On", "ON"}},
+- {false, yaml_BOOL_TAG, []string{"n", "N", "no", "No", "NO"}},
+- {false, yaml_BOOL_TAG, []string{"false", "False", "FALSE"}},
+- {false, yaml_BOOL_TAG, []string{"off", "Off", "OFF"}},
+- {nil, yaml_NULL_TAG, []string{"", "~", "null", "Null", "NULL"}},
+- {math.NaN(), yaml_FLOAT_TAG, []string{".nan", ".NaN", ".NAN"}},
+- {math.Inf(+1), yaml_FLOAT_TAG, []string{".inf", ".Inf", ".INF"}},
+- {math.Inf(+1), yaml_FLOAT_TAG, []string{"+.inf", "+.Inf", "+.INF"}},
+- {math.Inf(-1), yaml_FLOAT_TAG, []string{"-.inf", "-.Inf", "-.INF"}},
+- {"<<", yaml_MERGE_TAG, []string{"<<"}},
- }
-
- m := resolveMap
@@ -134748,97 +142107,153 @@ index fdc4909..0000000
-const longTagPrefix = "tag:yaml.org,2002:"
-
-func shortTag(tag string) string {
+- // TODO This can easily be made faster and produce less garbage.
- if strings.HasPrefix(tag, longTagPrefix) {
- return "!!" + tag[len(longTagPrefix):]
- }
- return tag
-}
-
+-func longTag(tag string) string {
+- if strings.HasPrefix(tag, "!!") {
+- return longTagPrefix + tag[2:]
+- }
+- return tag
+-}
+-
-func resolvableTag(tag string) bool {
- switch tag {
-- case "", "!!str", "!!bool", "!!int", "!!float", "!!null":
+- case "", yaml_STR_TAG, yaml_BOOL_TAG, yaml_INT_TAG, yaml_FLOAT_TAG, yaml_NULL_TAG:
- return true
- }
- return false
-}
-
-func resolve(tag string, in string) (rtag string, out interface{}) {
-- tag = shortTag(tag)
- if !resolvableTag(tag) {
- return tag, in
- }
-
- defer func() {
-- if tag != "" && tag != rtag {
-- panic("Can't decode " + rtag + " '" + in + "' as a " + tag)
+- switch tag {
+- case "", rtag, yaml_STR_TAG, yaml_BINARY_TAG:
+- return
- }
+- failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag))
- }()
-
-- if in == "" {
-- return "!!null", nil
+- // Any data is accepted as a !!str or !!binary.
+- // Otherwise, the prefix is enough of a hint about what it might be.
+- hint := byte('N')
+- if in != "" {
+- hint = resolveTable[in[0]]
- }
+- if hint != 0 && tag != yaml_STR_TAG && tag != yaml_BINARY_TAG {
+- // Handle things we can lookup in a map.
+- if item, ok := resolveMap[in]; ok {
+- return item.tag, item.value
+- }
-
-- c := resolveTable[in[0]]
-- if c == 0 {
-- // It's a string for sure. Nothing to do.
-- return "!!str", in
-- }
+- // Base 60 floats are a bad idea, were dropped in YAML 1.2, and
+- // are purposefully unsupported here. They're still quoted on
+- // the way out for compatibility with other parser, though.
-
-- // Handle things we can lookup in a map.
-- if item, ok := resolveMap[in]; ok {
-- return item.tag, item.value
-- }
+- switch hint {
+- case 'M':
+- // We've already checked the map above.
-
-- switch c {
-- case 'M':
-- // We've already checked the map above.
--
-- case '.':
-- // Not in the map, so maybe a normal float.
-- floatv, err := strconv.ParseFloat(in, 64)
-- if err == nil {
-- return "!!float", floatv
-- }
-- // XXX Handle base 60 floats here (WTF!)
+- case '.':
+- // Not in the map, so maybe a normal float.
+- floatv, err := strconv.ParseFloat(in, 64)
+- if err == nil {
+- return yaml_FLOAT_TAG, floatv
+- }
-
-- case 'D', 'S':
-- // Int, float, or timestamp.
-- plain := strings.Replace(in, "_", "", -1)
-- intv, err := strconv.ParseInt(plain, 0, 64)
-- if err == nil {
-- if intv == int64(int(intv)) {
-- return "!!int", int(intv)
-- } else {
-- return "!!int", intv
+- case 'D', 'S':
+- // Int, float, or timestamp.
+- plain := strings.Replace(in, "_", "", -1)
+- intv, err := strconv.ParseInt(plain, 0, 64)
+- if err == nil {
+- if intv == int64(int(intv)) {
+- return yaml_INT_TAG, int(intv)
+- } else {
+- return yaml_INT_TAG, intv
+- }
- }
-- }
-- floatv, err := strconv.ParseFloat(plain, 64)
-- if err == nil {
-- return "!!float", floatv
-- }
-- if strings.HasPrefix(plain, "0b") {
-- intv, err := strconv.ParseInt(plain[2:], 2, 64)
+- uintv, err := strconv.ParseUint(plain, 0, 64)
- if err == nil {
-- return "!!int", int(intv)
+- return yaml_INT_TAG, uintv
- }
-- } else if strings.HasPrefix(plain, "-0b") {
-- intv, err := strconv.ParseInt(plain[3:], 2, 64)
+- floatv, err := strconv.ParseFloat(plain, 64)
- if err == nil {
-- return "!!int", -int(intv)
+- return yaml_FLOAT_TAG, floatv
+- }
+- if strings.HasPrefix(plain, "0b") {
+- intv, err := strconv.ParseInt(plain[2:], 2, 64)
+- if err == nil {
+- if intv == int64(int(intv)) {
+- return yaml_INT_TAG, int(intv)
+- } else {
+- return yaml_INT_TAG, intv
+- }
+- }
+- uintv, err := strconv.ParseUint(plain[2:], 2, 64)
+- if err == nil {
+- return yaml_INT_TAG, uintv
+- }
+- } else if strings.HasPrefix(plain, "-0b") {
+- intv, err := strconv.ParseInt(plain[3:], 2, 64)
+- if err == nil {
+- if intv == int64(int(intv)) {
+- return yaml_INT_TAG, -int(intv)
+- } else {
+- return yaml_INT_TAG, -intv
+- }
+- }
- }
+- // XXX Handle timestamps here.
+-
+- default:
+- panic("resolveTable item not yet handled: " + string(rune(hint)) + " (with " + in + ")")
- }
-- // XXX Handle timestamps here.
+- }
+- if tag == yaml_BINARY_TAG {
+- return yaml_BINARY_TAG, in
+- }
+- if utf8.ValidString(in) {
+- return yaml_STR_TAG, in
+- }
+- return yaml_BINARY_TAG, encodeBase64(in)
+-}
-
-- default:
-- panic("resolveTable item not yet handled: " +
-- string([]byte{c}) + " (with " + in + ")")
+-// encodeBase64 encodes s as base64 that is broken up into multiple lines
+-// as appropriate for the resulting length.
+-func encodeBase64(s string) string {
+- const lineLen = 70
+- encLen := base64.StdEncoding.EncodedLen(len(s))
+- lines := encLen/lineLen + 1
+- buf := make([]byte, encLen*2+lines)
+- in := buf[0:encLen]
+- out := buf[encLen:]
+- base64.StdEncoding.Encode(in, []byte(s))
+- k := 0
+- for i := 0; i < len(in); i += lineLen {
+- j := i + lineLen
+- if j > len(in) {
+- j = len(in)
+- }
+- k += copy(out[k:], in[i:j])
+- if lines > 1 {
+- out[k] = '\n'
+- k++
+- }
- }
-- return "!!str", in
+- return string(out[:k])
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/scannerc.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/scannerc.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/scannerc.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/scannerc.go
deleted file mode 100644
index fe93b19..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/scannerc.go
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/scannerc.go
+++ /dev/null
@@ -1,2710 +0,0 @@
-package yaml
@@ -137551,10 +144966,10 @@ index fe93b19..0000000
- }
- return true
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/sorter.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/sorter.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/sorter.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/sorter.go
deleted file mode 100644
index 5958822..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/sorter.go
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/sorter.go
+++ /dev/null
@@ -1,104 +0,0 @@
-package yaml
@@ -137661,10 +145076,10 @@ index 5958822..0000000
- }
- panic("not a number")
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/suite_test.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/suite_test.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/suite_test.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/suite_test.go
deleted file mode 100644
index c5cf1ed..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/suite_test.go
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/suite_test.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package yaml_test
@@ -137679,10 +145094,10 @@ index c5cf1ed..0000000
-type S struct{}
-
-var _ = Suite(&S{})
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/writerc.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/writerc.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/writerc.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/writerc.go
deleted file mode 100644
index 190362f..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/writerc.go
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/writerc.go
+++ /dev/null
@@ -1,89 +0,0 @@
-package yaml
@@ -137774,12 +145189,12 @@ index 190362f..0000000
- emitter.raw_buffer = emitter.raw_buffer[:0]
- return true
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/yaml.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/yaml.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/yaml.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/yaml.go
deleted file mode 100644
-index 44b0cc6..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/yaml.go
+index 5d1b86c..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/yaml.go
+++ /dev/null
-@@ -1,306 +0,0 @@
+@@ -1,334 +0,0 @@
-// Package yaml implements YAML support for the Go language.
-//
-// Source code and other details for the project are available at GitHub:
@@ -137792,59 +145207,52 @@ index 44b0cc6..0000000
- "errors"
- "fmt"
- "reflect"
-- "runtime"
- "strings"
- "sync"
-)
-
--func handleErr(err *error) {
-- if r := recover(); r != nil {
-- if _, ok := r.(runtime.Error); ok {
-- panic(r)
-- } else if _, ok := r.(*reflect.ValueError); ok {
-- panic(r)
-- } else if _, ok := r.(externalPanic); ok {
-- panic(r)
-- } else if s, ok := r.(string); ok {
-- *err = errors.New("YAML error: " + s)
-- } else if e, ok := r.(error); ok {
-- *err = e
-- } else {
-- panic(r)
-- }
-- }
+-// MapSlice encodes and decodes as a YAML map.
+-// The order of keys is preserved when encoding and decoding.
+-type MapSlice []MapItem
+-
+-// MapItem is an item in a MapSlice.
+-type MapItem struct {
+- Key, Value interface{}
-}
-
--// The Setter interface may be implemented by types to do their own custom
--// unmarshalling of YAML values, rather than being implicitly assigned by
--// the yaml package machinery. If setting the value works, the method should
--// return true. If it returns false, the value is considered unsupported
--// and is omitted from maps and slices.
--type Setter interface {
-- SetYAML(tag string, value interface{}) bool
+-// The Unmarshaler interface may be implemented by types to customize their
+-// behavior when being unmarshaled from a YAML document. The UnmarshalYAML
+-// method receives a function that may be called to unmarshal the original
+-// YAML value into a field or variable. It is safe to call the unmarshal
+-// function parameter more than once if necessary.
+-type Unmarshaler interface {
+- UnmarshalYAML(unmarshal func(interface{}) error) error
-}
-
--// The Getter interface is implemented by types to do their own custom
--// marshalling into a YAML tag and value.
--type Getter interface {
-- GetYAML() (tag string, value interface{})
+-
+-// The Marshaler interface may be implemented by types to customize their
+-// behavior when being marshaled into a YAML document. The returned value
+-// is marshaled in place of the original value implementing Marshaler.
+-//
+-// If an error is returned by MarshalYAML, the marshaling procedure stops
+-// and returns with the provided error.
+-type Marshaler interface {
+- MarshalYAML() (interface{}, error)
-}
-
-// Unmarshal decodes the first document found within the in byte slice
-// and assigns decoded values into the out value.
-//
-// Maps and pointers (to a struct, string, int, etc) are accepted as out
--// values. If an internal pointer within a struct is not initialized,
+-// values. If an internal pointer within a struct is not initialized,
-// the yaml package will initialize it if necessary for unmarshalling
-// the provided data. The out parameter must not be nil.
-//
--// The type of the decoded values and the type of out will be considered,
--// and Unmarshal will do the best possible job to unmarshal values
--// appropriately. It is NOT considered an error, though, to skip values
--// because they are not available in the decoded YAML, or if they are not
--// compatible with the out value. To ensure something was properly
--// unmarshaled use a map or compare against the previous value for the
--// field (usually the zero value).
+-// The type of the decoded values should be compatible with the respective
+-// values in out. If one or more values cannot be decoded due to a type
+-// mismatches, decoding continues partially until the end of the YAML
+-// content, and a *yaml.TypeError is returned with details for all
+-// missed values.
-//
-// Struct fields are only unmarshalled if they are exported (have an
-// upper case first letter), and are unmarshalled using the field name
@@ -137860,7 +145268,7 @@ index 44b0cc6..0000000
-// F int `yaml:"a,omitempty"`
-// B int
-// }
--// var T t
+-// var t T
-// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
-//
-// See the documentation of Marshal for the format of tags and a list of
@@ -137873,7 +145281,14 @@ index 44b0cc6..0000000
- defer p.destroy()
- node := p.parse()
- if node != nil {
-- d.unmarshal(node, reflect.ValueOf(out))
+- v := reflect.ValueOf(out)
+- if v.Kind() == reflect.Ptr && !v.IsNil() {
+- v = v.Elem()
+- }
+- d.unmarshal(node, v)
+- }
+- if d.terrors != nil {
+- return &TypeError{d.terrors}
- }
- return nil
-}
@@ -137927,6 +145342,40 @@ index 44b0cc6..0000000
- return
-}
-
+-func handleErr(err *error) {
+- if v := recover(); v != nil {
+- if e, ok := v.(yamlError); ok {
+- *err = e.err
+- } else {
+- panic(v)
+- }
+- }
+-}
+-
+-type yamlError struct {
+- err error
+-}
+-
+-func fail(err error) {
+- panic(yamlError{err})
+-}
+-
+-func failf(format string, args ...interface{}) {
+- panic(yamlError{fmt.Errorf("yaml: " + format, args...)})
+-}
+-
+-// A TypeError is returned by Unmarshal when one or more fields in
+-// the YAML document cannot be properly decoded into the requested
+-// types. When this error is returned, the value is still
+-// unmarshaled partially.
+-type TypeError struct {
+- Errors []string
+-}
+-
+-func (e *TypeError) Error() string {
+- return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n "))
+-}
+-
-// --------------------------------------------------------------------------
-// Maintain a mapping of keys to structure field indexes
-
@@ -137956,12 +145405,6 @@ index 44b0cc6..0000000
-var structMap = make(map[reflect.Type]*structInfo)
-var fieldMapMutex sync.RWMutex
-
--type externalPanic string
--
--func (e externalPanic) String() string {
-- return string(e)
--}
--
-func getStructInfo(st reflect.Type) (*structInfo, error) {
- fieldMapMutex.RLock()
- sinfo, found := structMap[st]
@@ -138002,8 +145445,7 @@ index 44b0cc6..0000000
- case "inline":
- inline = true
- default:
-- msg := fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st)
-- panic(externalPanic(msg))
+- return nil, errors.New(fmt.Sprintf("Unsupported flag %q in tag %q of type %s", flag, tag, st))
- }
- }
- tag = fields[0]
@@ -138011,6 +145453,7 @@ index 44b0cc6..0000000
-
- if inline {
- switch field.Type.Kind() {
+- // TODO: Implement support for inline maps.
- //case reflect.Map:
- // if inlineMap >= 0 {
- // return nil, errors.New("Multiple ,inline maps in struct " + st.String())
@@ -138038,8 +145481,8 @@ index 44b0cc6..0000000
- fieldsList = append(fieldsList, finfo)
- }
- default:
-- //panic("Option ,inline needs a struct value or map field")
-- panic("Option ,inline needs a struct value field")
+- //return nil, errors.New("Option ,inline needs a struct value or map field")
+- return nil, errors.New("Option ,inline needs a struct value field")
- }
- continue
- }
@@ -138086,12 +145529,12 @@ index 44b0cc6..0000000
- }
- return false
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/yamlh.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/yamlh.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/yamlh.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/yamlh.go
deleted file mode 100644
-index 6624d6c..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/yamlh.go
+index 4b020b1..0000000
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/yamlh.go
+++ /dev/null
-@@ -1,712 +0,0 @@
+@@ -1,716 +0,0 @@
-package yaml
-
-import (
@@ -138388,6 +145831,10 @@ index 6624d6c..0000000
- yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences.
- yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping.
-
+- // Not in original libyaml.
+- yaml_BINARY_TAG = "tag:yaml.org,2002:binary"
+- yaml_MERGE_TAG = "tag:yaml.org,2002:merge"
+-
- yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str.
- yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq.
- yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG // The default mapping tag is !!map.
@@ -138804,10 +146251,10 @@ index 6624d6c..0000000
-
- document *yaml_document_t // The currently emitted document.
-}
-diff --git a/Godeps/_workspace/src/gopkg.in/v1/yaml/yamlprivateh.go b/Godeps/_workspace/src/gopkg.in/v1/yaml/yamlprivateh.go
+diff --git a/Godeps/_workspace/src/gopkg.in/v2/yaml/yamlprivateh.go b/Godeps/_workspace/src/gopkg.in/v2/yaml/yamlprivateh.go
deleted file mode 100644
index 8110ce3..0000000
---- a/Godeps/_workspace/src/gopkg.in/v1/yaml/yamlprivateh.go
+--- a/Godeps/_workspace/src/gopkg.in/v2/yaml/yamlprivateh.go
+++ /dev/null
@@ -1,173 +0,0 @@
-package yaml
diff --git a/getsource.sh b/getsource.sh
index e3ee6cd..11f4dec 100755
--- a/getsource.sh
+++ b/getsource.sh
@@ -1,41 +1,46 @@
#!/bin/sh
-KUBE_GIT_COMMIT="$1"
-KUBE_GIT_SHORT="${KUBE_GIT_COMMIT:0:7}"
-KUBE_GIT_VERSION="$2"
+GIT_COMMIT="$1"
+GIT_SHORT="${GIT_COMMIT:0:7}"
+GIT_VERSION="$2"
set -o errexit
set -o nounset
set -o pipefail
-SPEC=kubernetes.spec
+NAME=kubernetes
+SPEC=${NAME}.spec
-curl -s -L https://github.com/GoogleCloudPlatform/kubernetes/archive/${KUBE_GIT_COMMIT}.tar.gz > kubernetes-${KUBE_GIT_SHORT}.tar.gz
+curl -s -L https://github.com/GoogleCloudPlatform/${NAME}/archive/${GIT_COMMIT}.tar.gz > ${NAME}-${GIT_SHORT}.tar.gz
since_tag=0
-if [[ "${KUBE_GIT_VERSION}" =~ ^v([0-9]+)\.([0-9]+)\-([0-9]+)\-(.*)?$ ]]; then
+if [[ "${GIT_VERSION}" =~ ^v([0-9]+)\.([0-9]+)\-([0-9]+)\-(.*)?$ ]]; then
git_major=${BASH_REMATCH[1]}
git_minor=${BASH_REMATCH[2]}
+ version="${git_major}.${git_minor}"
since_tag=${BASH_REMATCH[3]}
# handle version like 0.4.2 (although we just ignore the .2 portion...)
-elif [[ "${KUBE_GIT_VERSION}" =~ ^v([0-9]+)\.([0-9]+)\.([0-9]+)\-([0-9]+)\-(.*)?$ ]]; then
+elif [[ "${GIT_VERSION}" =~ ^v([0-9]+)\.([0-9]+)\.([0-9]+)\-([0-9]+)\-(.*)?$ ]]; then
git_major=${BASH_REMATCH[1]}
git_minor=${BASH_REMATCH[2]}
+ git_really_minor=${BASH_REMATCH[3]}
+ version="${git_major}.${git_minor}.${git_really_minor}"
since_tag=${BASH_REMATCH[4]}
fi
+
#put the git hash in as the commit
-sed -i -e "s/%global commit\t\t[[:xdigit:]]\{40\}/%global commit\t\t${KUBE_GIT_COMMIT}/" ${SPEC}
+sed -i -e "s/%global commit\t\t[[:xdigit:]]\{40\}/%global commit\t\t${GIT_COMMIT}/" ${SPEC}
#update the version with the latest tag
-sed -i -e "s/Version:\t[[:digit:]]\+\.[[:digit:]]\++\?/Version:\t${git_major}.${git_minor}/" ${SPEC}
+sed -i -e "s/Version:\t[[:digit:]]\+\.[[:digit:]]\+\(\.[[:digit:]]\+\)\?/Version:\t${version}/" ${SPEC}
#update the release with since_tag
sed -i -e "s/Release:\t[[:digit:]]\+\.[[:digit:]]\+/Release:\t${since_tag}.0/" ${SPEC}
#update the git Version inside the built binaries
-sed -i -e "s/export KUBE_GIT_VERSION=v.*/export KUBE_GIT_VERSION=${KUBE_GIT_VERSION}/" ${SPEC}
+sed -i -e "s/export KUBE_GIT_VERSION=v.*/export KUBE_GIT_VERSION=${GIT_VERSION}/" ${SPEC}
#increment the version number
-./add-chglog --comment="Bump to upstream ${KUBE_GIT_COMMIT}" --userstring="Eric Paris <eparis at redhat.com>" ${SPEC}
+./add-chglog --comment="Bump to upstream ${GIT_COMMIT}" --userstring="Eric Paris <eparis at redhat.com>" ${SPEC}
fedpkg clog
-echo "****Don't forget to run: fedpkg new-sources kubernetes-${KUBE_GIT_SHORT}.tar.gz"
+echo "****Don't forget to run: fedpkg new-sources ${NAME}-${GIT_SHORT}.tar.gz"
diff --git a/kubernetes.spec b/kubernetes.spec
index 39972d4..d3fe276 100644
--- a/kubernetes.spec
+++ b/kubernetes.spec
@@ -1,7 +1,7 @@
#debuginfo not supported with Go
%global debug_package %{nil}
%global import_path github.com/GoogleCloudPlatform/kubernetes
-%global commit 993ef88eec9012b221f79abe8f2932ee97997d28
+%global commit 52e165a4fd720d1703ebc31bd6660e01334227b8
%global shortcommit %(c=%{commit}; echo ${c:0:7})
#I really need this, otherwise "version_ldflags=$(kube::version_ldflags)"
@@ -10,8 +10,8 @@
%global _checkshell /bin/bash
Name: kubernetes
-Version: 0.6
-Release: 4.0.git%{shortcommit}%{?dist}
+Version: 0.7.0
+Release: 18.0.git%{shortcommit}%{?dist}
Summary: Container cluster management
License: ASL 2.0
URL: https://github.com/GoogleCloudPlatform/kubernetes
@@ -20,7 +20,6 @@ Source0: https://github.com/GoogleCloudPlatform/kubernetes/archive/%{commit}/kub
%if 0%{?fedora}
Patch1: 0001-remove-all-third-party-software.patch
-Patch2: 0002-revert-to-code.google.com-p-go.net-until-fedora-pack.patch
%endif
%if 0%{?fedora} >= 21 || 0%{?rhel}
@@ -44,17 +43,16 @@ BuildRequires: golang-cover
BuildRequires: golang(code.google.com/p/gcfg)
BuildRequires: golang(code.google.com/p/goauth2)
-BuildRequires: golang(code.google.com/p/go.net/context)
-BuildRequires: golang(code.google.com/p/go.net/html)
-BuildRequires: golang(code.google.com/p/go.net/websocket)
BuildRequires: golang(code.google.com/p/google-api-go-client) > 0-0.3
BuildRequires: golang(code.google.com/p/go-uuid)
BuildRequires: golang(github.com/coreos/go-etcd/etcd)
+BuildRequires: golang(github.com/davecgh/go-spew/spew)
BuildRequires: golang(github.com/elazarl/go-bindata-assetfs)
BuildRequires: golang(github.com/emicklei/go-restful)
BuildRequires: golang(github.com/fsouza/go-dockerclient) > 0-0.6
+BuildRequires: golang(github.com/ghodss/yaml)
BuildRequires: golang(github.com/golang/glog)
-BuildRequires: golang(github.com/google/cadvisor)
+BuildRequires: golang(github.com/google/cadvisor) >= 0.6.2
BuildRequires: golang(github.com/google/gofuzz)
BuildRequires: golang(github.com/kr/text)
BuildRequires: golang(github.com/mitchellh/goamz/aws)
@@ -69,7 +67,10 @@ BuildRequires: golang(github.com/stretchr/objx)
BuildRequires: golang(github.com/stretchr/testify)
BuildRequires: golang(github.com/tonnerre/golang-pretty)
BuildRequires: golang(github.com/vaughan0/go-ini)
-BuildRequires: golang(gopkg.in/v1/yaml)
+BuildRequires: golang(golang.org/x/net/context)
+BuildRequires: golang(golang.org/x/net/html)
+BuildRequires: golang(golang.org/x/net/websocket)
+BuildRequires: golang(gopkg.in/v2/yaml)
%endif
%description
@@ -81,7 +82,7 @@ BuildRequires: golang(gopkg.in/v1/yaml)
%build
export KUBE_GIT_TREE_STATE="clean"
export KUBE_GIT_COMMIT=%{commit}
-export KUBE_GIT_VERSION=v0.6.0-4-g993ef88eec9012
+export KUBE_GIT_VERSION=v0.7.0-18-g52e165a4fd720d
%if 0%{?fedora}
export KUBE_GIT_TREE_STATE="dirty"
@@ -180,6 +181,15 @@ getent passwd kube >/dev/null || useradd -r -g kube -d / -s /sbin/nologin \
%systemd_postun
%changelog
+* Tue Dec 16 2014 Eric Paris <eparis at redhat.com> - 0.7.0-18.0.git52e165a
+- Bump to upstream 52e165a4fd720d1703ebc31bd6660e01334227b8
+
+* Mon Dec 15 2014 Eric Paris <eparis at redhat.com> - 0.6-297.0.git5ef34bf
+- Bump to upstream 5ef34bf52311901b997119cc49eff944c610081b
+
+* Wed Dec 03 2014 Eric Paris <eparis at redhat.com>
+- Replace patch to use old googlecode/go.net/ with BuildRequires on golang.org/x/net/
+
* Tue Dec 02 2014 Eric Paris <eparis at redhat.com> - 0.6-4.0.git993ef88
- Bump to upstream 993ef88eec9012b221f79abe8f2932ee97997d28
diff --git a/sources b/sources
index da6d8b9..7ff3bfd 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-c3e0eb40b413ddcff06b2f9e3754e4be kubernetes-993ef88.tar.gz
+c52274fb797691d1c9532e9ac5f2658c kubernetes-52e165a.tar.gz
More information about the scm-commits
mailing list