bumped version to v4-beta2

fix(notifications): failed image upload should not stop notification
closes #6638
2016-11-21 09:51:59 +01:00 · 2016-11-21 09:47:59 +01:00 · 2016-11-21 09:42:46 +01:00 · 2016-11-21 09:39:35 +01:00 · 2016-11-19 09:12:10 +01:00 · 2016-11-18 19:14:12 +01:00
3896 changed files with 986494 additions and 69297 deletions
@@ -2,7 +2,7 @@
 root = true

 [*.go]
-indent_style = tabs
+indent_style = tab
 indent_size = 2
 charset = utf-8
 trim_trailing_whitespace = true
@@ -0,0 +1,3 @@
+{
+  "url": "https://floobits.com/raintank/grafana"
+}
@@ -0,0 +1,12 @@
+#*
+*.o
+*.pyc
+*.pyo
+*~
+extern/
+node_modules/
+tmp/
+data/
+vendor/
+public_gen/
+dist/
@@ -12,11 +12,11 @@ grunt karma:dev

 ### Run tests for backend assets before commit
 ```
-test -z "$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)"
+test -z "$(gofmt -s -l . | grep -v -E 'vendor/(github.com|golang.org|gopkg.in)' | tee /dev/stderr)"
 ```

 ### Run tests for frontend assets before commit
 ```
-grunt test
-godep go test -v ./pkg/...
+npm test
+go test -v ./pkg/...
 ```
@@ -1,20 +1,17 @@
-Thank you! For helping us make Grafana even better.
+* **I'm submitting a ...**
+- [ ] Bug report
+- [ ] Feature request
+- [ ] Question / Support request: **Please do not** open a github issue. [Support Options](http://grafana.org/support/)

-To help us respond to your issues faster, please make sure to add as much information as possible.
-
-If this issue is about a plugin, please open the issue in that repository.
-
-Start your issues title with [Feature Request] / [Bug] / [Question] or no tag if your unsure. Also, please be aware that GitHub now supports uploading of screenshots; look at the bottom of this input field.
-
-Please include some basic information:
- What grafana version are you using?
+Please include this information:
+- What Grafana version are you using?
 - What datasource are you using?
 - What OS are you running grafana on?
 - What did you do?
 - What was the expected result?
- What happenend instead?
+- What happened instead?

-If you question/bug relates to a metric query / unexpected data visualization, please include:
+**IMPORTANT** If it relates to metric data viz:
 - An image or text representation of your metric query
- The raw query and response from your data source (check this in chrome dev tools network tab)
+- The raw query and response for the network request (check this in chrome dev tools network tab, here you can see metric requests and other request, please include the request body and request response)

@@ -25,6 +25,7 @@ public/css/*.min.css
 *.swp
 .idea/
 *.iml
+.vscode/

 /data/*
 /bin/*
@@ -37,4 +38,4 @@ profile.cov
 .notouch
 /pkg/cmd/grafana-cli/grafana-cli
 /pkg/cmd/grafana-server/grafana-server
-/examples/*/dist
+/examples/*/dist
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash

-test -z "$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)"
+test -z "$(gofmt -s -l . | grep -v vendor/src/ | tee /dev/stderr)"
 if [ $? -gt 0 ]; then
    echo "Some files aren't formatted, please run 'go fmt ./pkg/...' to format your source code before committing"
    exit 1
@@ -10,4 +10,4 @@
    "disallowSpacesInsideArrayBrackets": true,
    "disallowSpacesInsideParentheses": true,
    "validateIndentation": 2
-}
+}
@@ -1,4 +1,124 @@
-# 3.0.2 Stable (unreleased)
+# 4.0-beta2 (unrelased)
+
+### Bugfixes
+* **Graph Panel**: Log base scale on right Y-axis had no effect, max value calc was not applied, [#6534](https://github.com/grafana/grafana/issues/6534)
+* **Graph Panel**: Bar width if bars was only used in series override, [#6528](https://github.com/grafana/grafana/issues/6528)
+* **UI/Browser**: Fixed issue with page/view header gradient border not showing in Safari, [#6530](https://github.com/grafana/grafana/issues/6530)
+* **Cloudwatch**: Fixed cloudwatch datasource requesting to many datapoints, [#6544](https://github.com/grafana/grafana/issues/6544)
+* **UX**: Panel Drop zone visible after duplicating panel, and when entering fullscreen/edit view, [#6598](https://github.com/grafana/grafana/issues/6598)
+* **Templating**: Newly added variable was not visible directly only after dashboard reload, [#6622](https://github.com/grafana/grafana/issues/6622)
+
+### Enhancements
+* **Singlestat**: Support repeated template variables in prefix/postfix [#6595](https://github.com/grafana/grafana/issues/6595)
+* **Templating**: Don't persist variable options with refresh option [#6586](https://github.com/grafana/grafana/issues/6586)
+* **Alerting**: Add ability to have OR conditions (and mixing AND & OR) [#6579](https://github.com/grafana/grafana/issues/6579)
+
+# 4.0-beta1 (2016-11-09)
+
+### Enhancements
+* **Login**: Adds option to disable username/password logins, closes [#4674](https://github.com/grafana/grafana/issues/4674)
+* **SingleStat**: Add seriename as option in singlestat panel, closes [#4740](https://github.com/grafana/grafana/issues/4740)
+* **Localization**: Week start day now dependant on browser locale setting, closes [#3003](https://github.com/grafana/grafana/issues/3003)
+* **Templating**: Update panel repeats for variables that change on time refresh, closes [#5021](https://github.com/grafana/grafana/issues/5021)
+* **Templating**: Add support for numeric and alphabetical sorting of variable values, closes [#2839](https://github.com/grafana/grafana/issues/2839)
+* **Elasticsearch**: Support to set Precision Threshold for Unique Count metric, closes [#4689](https://github.com/grafana/grafana/issues/4689)
+* **Navigation**: Add search to org swithcer, closes [#2609](https://github.com/grafana/grafana/issues/2609)
+* **Database**: Allow database config using one propertie, closes [#5456](https://github.com/grafana/grafana/pull/5456)
+* **Graphite**: Add support for groupByNodes, closes [#5613](https://github.com/grafana/grafana/pull/5613)
+* **Influxdb**: Add support for elapsed(), closes [#5827](https://github.com/grafana/grafana/pull/5827)
+* **OpenTSDB**: Add support for explicitTags for OpenTSDB>=2.3, closes [#6360](https://github.com/grafana/grafana/pull/6361)
+* **OAuth**: Add support for generic oauth, closes [#4718](https://github.com/grafana/grafana/pull/4718)
+* **Cloudwatch**: Add support to expand multi select template variable, closes [#5003](https://github.com/grafana/grafana/pull/5003)
+* **Background Tasks**: Now support automatic purging of old snapshots, closes [#4087](https://github.com/grafana/grafana/issues/4087)
+* **Background Tasks**: Now support automatic purging of old rendered images, closes [#2172](https://github.com/grafana/grafana/issues/2172)
+* **Dashboard**: After inactivity hide nav/row actions, fade to nice clean view, can be toggled with `d v`, also added kiosk mode, toggled via `d k` [#6476](https://github.com/grafana/grafana/issues/6476)
+* **Dashboard**: Improved dashboard row menu & add panel UX [#6442](https://github.com/grafana/grafana/issues/6442)
+* **Graph Panel**: Support for stacking null values [#2912](https://github.com/grafana/grafana/issues/2912), [#6287](https://github.com/grafana/grafana/issues/6287), thanks @benrubson!
+
+### Breaking changes
+* **SystemD**: Change systemd description, closes [#5971](https://github.com/grafana/grafana/pull/5971)
+* **lodash upgrade**: Upgraded lodash from 2.4.2 to 4.15.0, this contains a number of breaking changes that could effect plugins. closes [#6021](https://github.com/grafana/grafana/pull/6021)
+
+### Bug fixes
+* **Table Panel**: Fixed problem when switching to Mixed datasource in metrics tab, fixes [#5999](https://github.com/grafana/grafana/pull/5999)
+* **Playlist**: Fixed problem with play order not matching order defined in playlist, fixes [#5467](https://github.com/grafana/grafana/pull/5467)
+* **Graph panel**: Fixed problem with auto decimals on y axis when datamin=datamax, fixes [#6070](https://github.com/grafana/grafana/pull/6070)
+* **Snapshot**: Can view embedded panels/png rendered panels in snapshots without login, fixes [#3769](https://github.com/grafana/grafana/pull/3769)
+* **Elasticsearch**: Fix for query template variable when looking up terms without query, no longer relies on elasticsearch default field, fixes [#3887](https://github.com/grafana/grafana/pull/3887)
+* **Elasticsearch**: Fix for displaying IP address used in terms aggregations, fixes [#4393](https://github.com/grafana/grafana/pull/4393)
+* **PNG Rendering**: Fix for server side rendering when using auth proxy, fixes [#5906](https://github.com/grafana/grafana/pull/5906)
+* **OpenTSDB**: Fixed multi-value nested templating for opentsdb, fixes [#6455](https://github.com/grafana/grafana/pull/6455)
+* **Playlist**: Remove playlist items when dashboard is removed, fixes [#6292](https://github.com/grafana/grafana/issues/6292)
+
+# 3.1.2 (unreleased)
+* **Templating**: Fixed issue when combining row & panel repeats, fixes [#5790](https://github.com/grafana/grafana/issues/5790)
+* **Drag&Drop**: Fixed issue with drag and drop in latest Chrome(51+), fixes [#5767](https://github.com/grafana/grafana/issues/5767)
+* **Internal Metrics**: Fixed issue with dots in instance_name when sending internal metrics to Graphite, fixes [#5739](https://github.com/grafana/grafana/issues/5739)
+* **Grafana-CLI**: Add default plugin path for MAC OS, fixes [#5806](https://github.com/grafana/grafana/issues/5806)
+* **Grafana-CLI**: Improve error message for upgrade-all command, fixes [#5885](https://github.com/grafana/grafana/issues/5885)
+
+# 3.1.1 (2016-08-01)
+* **IFrame embedding**: Fixed issue of using full iframe height, fixes [#5605](https://github.com/grafana/grafana/issues/5606)
+* **Panel PNG rendering**: Fixed issue detecting render completion, fixes [#5605](https://github.com/grafana/grafana/issues/5606)
+* **Elasticsearch**: Fixed issue with templating query and json parse error, fixes [#5615](https://github.com/grafana/grafana/issues/5615)
+* **Tech**: Upgraded JQuery to 2.2.4 to fix Security vulnerabilitie in 2.1.4, fixes [#5627](https://github.com/grafana/grafana/issues/5627)
+* **Graphite**: Fixed issue with mixed data sources and Graphite, fixes [#5617](https://github.com/grafana/grafana/issues/5617)
+* **Templating**: Fixed issue with template variable query was issued multiple times during dashboard load, fixes [#5637](https://github.com/grafana/grafana/issues/5637)
+* **Zoom**: Fixed issues with zoom in and out on embedded (iframed) panel, fixes [#4489](https://github.com/grafana/grafana/issues/4489), [#5666](https://github.com/grafana/grafana/issues/5666)
+
+# 3.1.0 stable (2016-07-12)
+
+### Bugfixes & Enhancements,
+* **User Alert Notices**: Backend error alert popups did not show properly, fixes [#5435](https://github.com/grafana/grafana/issues/5435)
+* **Table**: Added sanitize HTML option to allow links in table cells, fixes [#4596](https://github.com/grafana/grafana/issues/4596)
+* **Apps**: App dashboards are automatically synced to DB at startup after plugin update, fixes [#5529](https://github.com/grafana/grafana/issues/5529)
+
+# 3.1.0-beta1 (2016-06-23)
+
+### Enhancements
+* **Dashboard Export/Import**: Dashboard export now templetize data sources and constant variables, users pick these on import, closes [#5084](https://github.com/grafana/grafana/issues/5084)
+* **Dashboard Url**: Time range changes updates url, closes [#458](https://github.com/grafana/grafana/issues/458)
+* **Dashboard Url**: Template variable change updates url, closes [#5002](https://github.com/grafana/grafana/issues/5002)
+* **Singlestat**: Add support for range to text mappings, closes [#1319](https://github.com/grafana/grafana/issues/1319)
+* **Graph**: Adds sort order options for graph tooltip, closes  [#1189](https://github.com/grafana/grafana/issues/1189)
+* **Theme**: Add default theme to config file [#5011](https://github.com/grafana/grafana/pull/5011)
+* **Page Footer**: Added page footer with links to docs, shows Grafana version and info if new version is available, closes [#4889](https://github.com/grafana/grafana/pull/4889)
+* **InfluxDB**: Add spread function, closes [#5211](https://github.com/grafana/grafana/issues/5211)
+* **Scripts**: Use restart instead of start for deb package script, closes [#5282](https://github.com/grafana/grafana/pull/5282)
+* **Logging**: Moved to structured logging lib, and moved to component specific level filters via config file, closes [#4590](https://github.com/grafana/grafana/issues/4590)
+* **OpenTSDB**: Support nested template variables in tag_values function, closes [#4398](https://github.com/grafana/grafana/issues/4398)
+* **Datasource**: Pending data source requests are cancelled before new ones are issues (Graphite & Prometheus), closes [#5321](https://github.com/grafana/grafana/issues/5321)
+
+### Breaking changes
+* **Logging** : Changed default logging output format (now structured into message, and key value pairs, with logger key acting as component). You can also no change in config to json log ouput.
+* **Graphite** : The Graph panel no longer have a Graphite PNG option. closes [#5367](https://github.com/grafana/grafana/issues/5367)
+
+### Bug fixes
+* **PNG rendering**: Fixed phantomjs rendering and y-axis label rotation. fixes [#5220](https://github.com/grafana/grafana/issues/5220)
+* **CLI**: The cli tool now supports reading plugin.json from dist/plugin.json. fixes [#5410](https://github.com/grafana/grafana/issues/5410)
+
+# 3.0.4 Patch release (2016-05-25)
+* **Panel**: Fixed blank dashboard issue when switching to other dashboard while in fullscreen edit mode, fixes [#5163](https://github.com/grafana/grafana/pull/5163)
+* **Templating**: Fixed issue with nested multi select variables and cascading and updating child variable selection state, fixes [#4861](https://github.com/grafana/grafana/pull/4861)
+* **Templating**: Fixed issue with using templated data source in another template variable query, fixes [#5165](https://github.com/grafana/grafana/pull/5165)
+* **Singlestat gauge**: Fixed issue with gauge render position, fixes [#5143](https://github.com/grafana/grafana/pull/5143)
+* **Home dashboard**: Fixes broken home dashboard api, fixes [#5167](https://github.com/grafana/grafana/issues/5167)
+
+# 3.0.3 Patch release (2016-05-23)
+* **Annotations**: Annotations can now use a template variable as data source, closes [#5054](https://github.com/grafana/grafana/issues/5054)
+* **Time picker**: Fixed issue timepicker and UTC when reading time from URL, fixes [#5078](https://github.com/grafana/grafana/issues/5078)
+* **CloudWatch**: Support for Multiple Account by AssumeRole, closes [#3522](https://github.com/grafana/grafana/issues/3522)
+* **Singlestat**: Fixed alignment and minium height issue, fixes [#5113](https://github.com/grafana/grafana/issues/5113), fixes [#4679](https://github.com/grafana/grafana/issues/4679)
+* **Share modal**: Fixed link when using grafana under dashboard sub url, fixes [#5109](https://github.com/grafana/grafana/issues/5109)
+* **Prometheus**: Fixed bug in query editor that caused it not to load when reloading page, fixes [#5107](https://github.com/grafana/grafana/issues/5107)
+* **Elasticsearch**: Fixed bug when template variable query returns numeric values, fixes [#5097](https://github.com/grafana/grafana/issues/5097), fixes [#5088](https://github.com/grafana/grafana/issues/5088)
+* **Logging**: Fixed issue with reading logging level value, fixes [#5079](https://github.com/grafana/grafana/issues/5079)
+* **Timepicker**: Fixed issue with timepicker and UTC when reading time from URL, fixes [#5078](https://github.com/grafana/grafana/issues/5078)
+* **Docs**: Added docs for org & user preferences HTTP API, closes [#5069](https://github.com/grafana/grafana/issues/5069)
+* **Plugin list panel**: Now shows correct enable state for apps when not enabled, fixes [#5068](https://github.com/grafana/grafana/issues/5068)
+* **Elasticsearch**: Templating & Annotation queries that use template variables are now formatted correctly, fixes [#5135](https://github.com/grafana/grafana/issues/5135)
+
+# 3.0.2 Patch release (2016-05-16)

 * **Templating**: Fixed issue mixing row repeat and panel repeats, fixes [#4988](https://github.com/grafana/grafana/issues/4988)
 * **Templating**: Fixed issue detecting dependencies in nested variables, fixes [#4987](https://github.com/grafana/grafana/issues/4987), fixes [#4986](https://github.com/grafana/grafana/issues/4986)
@@ -9,6 +129,7 @@

 # 3.0.1 Stable (2016-05-11)

+### Bug fixes
 * **Templating**: Fixed issue with new data source variable not persisting current selected value, fixes [#4934](https://github.com/grafana/grafana/issues/4934)

 # 3.0.0-beta7 (2016-05-02)
@@ -1,351 +0,0 @@
-{
-	"ImportPath": "github.com/grafana/grafana",
-	"GoVersion": "go1.5.1",
-	"Packages": [
-		"./pkg/..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "github.com/BurntSushi/toml",
-			"Comment": "v0.1.0-21-g056c9bc",
-			"Rev": "056c9bc7be7190eaa7715723883caffa5f8fa3e4"
-		},
-		{
-			"ImportPath": "github.com/Unknwon/com",
-			"Rev": "d9bcf409c8a368d06c9b347705c381e7c12d54df"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/awserr",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/awsutil",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/client",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/client/metadata",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/corehandlers",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/defaults",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/ec2metadata",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/request",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/aws/session",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/endpoints",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/ec2query",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query/queryutil",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/rest",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/signer/v4",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/private/waiter",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/service/cloudwatch",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/aws/aws-sdk-go/service/ec2",
-			"Comment": "v1.0.0",
-			"Rev": "abb928e07c4108683d6b4d0b6ca08fe6bc0eee5f"
-		},
-		{
-			"ImportPath": "github.com/bmizerany/assert",
-			"Comment": "release.r60-6-ge17e998",
-			"Rev": "e17e99893cb6509f428e1728281c2ad60a6b31e3"
-		},
-		{
-			"ImportPath": "github.com/bradfitz/gomemcache/memcache",
-			"Comment": "release.r60-40-g72a6864",
-			"Rev": "72a68649ba712ee7c4b5b4a943a626bcd7d90eb8"
-		},
-		{
-			"ImportPath": "github.com/codegangsta/cli",
-			"Comment": "1.2.0-187-gc31a797",
-			"Rev": "c31a7975863e7810c92e2e288a9ab074f9a88f29"
-		},
-		{
-			"ImportPath": "github.com/davecgh/go-spew/spew",
-			"Rev": "2df174808ee097f90d259e432cc04442cf60be21"
-		},
-		{
-			"ImportPath": "github.com/fatih/color",
-			"Comment": "v0.1-16-g4f7bcef",
-			"Rev": "4f7bcef27eec7925456d0c30c5e7b0408b3339be"
-		},
-		{
-			"ImportPath": "github.com/franela/goreq",
-			"Rev": "3ddeded65be21dacb5a2e2d0b95af9ff6862a2b5"
-		},
-		{
-			"ImportPath": "github.com/go-ini/ini",
-			"Comment": "v0-48-g060d7da",
-			"Rev": "060d7da055ba6ec5ea7a31f116332fe5efa04ce0"
-		},
-		{
-			"ImportPath": "github.com/go-ldap/ldap",
-			"Comment": "v2.2.1",
-			"Rev": "07a7330929b9ee80495c88a4439657d89c7dbd87"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/binding",
-			"Rev": "2502aaf4bce3a4e6451b4610847bfb8dffdb6266"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/gzip",
-			"Rev": "4938e9be6b279d8426cb1c89a6bcf7af70b0c21d"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/inject",
-			"Rev": "c5ab7bf3a307593cd44cb272d1a5beea473dd072"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session/memcache",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session/mysql",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session/postgres",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-macaron/session/redis",
-			"Rev": "66031fcb37a0fff002a1f028eb0b3a815c78306b"
-		},
-		{
-			"ImportPath": "github.com/go-sql-driver/mysql",
-			"Comment": "v1.2-171-g267b128",
-			"Rev": "267b128680c46286b9ca13475c3cca5de8f79bd7"
-		},
-		{
-			"ImportPath": "github.com/go-xorm/core",
-			"Comment": "v0.4.4-7-g9e608f7",
-			"Rev": "9e608f7330b9d16fe2818cfe731128b3f156cb9a"
-		},
-		{
-			"ImportPath": "github.com/go-xorm/xorm",
-			"Comment": "v0.4.4-44-gf561133",
-			"Rev": "f56113384f2c63dfe4cd8e768e349f1c35122b58"
-		},
-		{
-			"ImportPath": "github.com/gorilla/websocket",
-			"Rev": "c45a635370221f34fea2d5163fd156fcb4e38e8a"
-		},
-		{
-			"ImportPath": "github.com/gosimple/slug",
-			"Rev": "8d258463b4459f161f51d6a357edacd3eef9d663"
-		},
-		{
-			"ImportPath": "github.com/hashicorp/go-version",
-			"Rev": "7e3c02b30806fa5779d3bdfc152ce4c6f40e7b38"
-		},
-		{
-			"ImportPath": "github.com/jmespath/go-jmespath",
-			"Comment": "0.2.2",
-			"Rev": "3433f3ea46d9f8019119e7dd41274e112a2359a9"
-		},
-		{
-			"ImportPath": "github.com/jtolds/gls",
-			"Rev": "f1ac7f4f24f50328e6bc838ca4437d1612a0243c"
-		},
-		{
-			"ImportPath": "github.com/klauspost/compress/flate",
-			"Rev": "7b02889a2005228347aef0e76beeaee564d82f8c"
-		},
-		{
-			"ImportPath": "github.com/klauspost/compress/gzip",
-			"Rev": "7b02889a2005228347aef0e76beeaee564d82f8c"
-		},
-		{
-			"ImportPath": "github.com/klauspost/cpuid",
-			"Rev": "349c675778172472f5e8f3a3e0fe187e302e5a10"
-		},
-		{
-			"ImportPath": "github.com/klauspost/crc32",
-			"Rev": "6834731faf32e62a2dd809d99fb24d1e4ae5a92d"
-		},
-		{
-			"ImportPath": "github.com/kr/pretty",
-			"Comment": "go.weekly.2011-12-22-27-ge6ac2fc",
-			"Rev": "e6ac2fc51e89a3249e82157fa0bb7a18ef9dd5bb"
-		},
-		{
-			"ImportPath": "github.com/kr/text",
-			"Rev": "bb797dc4fb8320488f47bf11de07a733d7233e1f"
-		},
-		{
-			"ImportPath": "github.com/lib/pq",
-			"Comment": "go1.0-cutoff-13-g19eeca3",
-			"Rev": "19eeca3e30d2577b1761db471ec130810e67f532"
-		},
-		{
-			"ImportPath": "github.com/lib/pq/oid",
-			"Comment": "go1.0-cutoff-13-g19eeca3",
-			"Rev": "19eeca3e30d2577b1761db471ec130810e67f532"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-colorable",
-			"Rev": "9cbef7c35391cca05f15f8181dc0b18bc9736dbb"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-isatty",
-			"Rev": "56b76bdf51f7708750eac80fa38b952bb9f32639"
-		},
-		{
-			"ImportPath": "github.com/mattn/go-sqlite3",
-			"Comment": "v1.1.0-67-g7204887",
-			"Rev": "7204887cf3a42df1cfaa5505dc3a3427f6dded8b"
-		},
-		{
-			"ImportPath": "github.com/rainycape/unidecode",
-			"Rev": "836ef0a715aedf08a12d595ed73ec8ed5b288cac"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey/assertions",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey/assertions/oglematchers",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey/gotest",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/smartystreets/goconvey/convey/reporting",
-			"Comment": "1.5.0-356-gfbc0a1c",
-			"Rev": "fbc0a1c888f9f96263f9a559d1769905245f1123"
-		},
-		{
-			"ImportPath": "github.com/streadway/amqp",
-			"Rev": "150b7f24d6ad507e6026c13d85ce1f1391ac7400"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context",
-			"Rev": "972f0c5fbe4ae29e666c3f78c3ed42ae7a448b0a"
-		},
-		{
-			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "c58fcf0ffc1c772aa2e1ee4894bc19f2649263b2"
-		},
-		{
-			"ImportPath": "golang.org/x/sys/unix",
-			"Rev": "7a56174f0086b32866ebd746a794417edbc678a1"
-		},
-		{
-			"ImportPath": "gopkg.in/asn1-ber.v1",
-			"Comment": "v1",
-			"Rev": "9eae18c3681ae3d3c677ac2b80a8fe57de45fc09"
-		},
-		{
-			"ImportPath": "gopkg.in/bufio.v1",
-			"Comment": "v1",
-			"Rev": "567b2bfa514e796916c4747494d6ff5132a1dfce"
-		},
-		{
-			"ImportPath": "gopkg.in/ini.v1",
-			"Comment": "v0-16-g1772191",
-			"Rev": "177219109c97e7920c933e21c9b25f874357b237"
-		},
-		{
-			"ImportPath": "gopkg.in/macaron.v1",
-			"Rev": "1c6dd87797ae9319b4658cbd48d1d0420b279fd5"
-		},
-		{
-			"ImportPath": "gopkg.in/redis.v2",
-			"Comment": "v2.3.2",
-			"Rev": "e6179049628164864e6e84e973cfb56335748dea"
-		}
-	]
-}
@@ -1,2 +0,0 @@
-/pkg
-/bin
@@ -1,45 +0,0 @@
-package client
-
-import (
-	"math"
-	"math/rand"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-// DefaultRetryer implements basic retry logic using exponential backoff for
-// most services. If you want to implement custom retry logic, implement the
-// request.Retryer interface or create a structure type that composes this
-// struct and override the specific methods. For example, to override only
-// the MaxRetries method:
-//
-//		type retryer struct {
-//      service.DefaultRetryer
-//    }
-//
-//    // This implementation always has 100 max retries
-//    func (d retryer) MaxRetries() uint { return 100 }
-type DefaultRetryer struct {
-	NumMaxRetries int
-}
-
-// MaxRetries returns the number of maximum returns the service will use to make
-// an individual API request.
-func (d DefaultRetryer) MaxRetries() int {
-	return d.NumMaxRetries
-}
-
-// RetryRules returns the delay duration before retrying this request again
-func (d DefaultRetryer) RetryRules(r *request.Request) time.Duration {
-	delay := int(math.Pow(2, float64(r.RetryCount))) * (rand.Intn(30) + 30)
-	return time.Duration(delay) * time.Millisecond
-}
-
-// ShouldRetry returns if the request should be retried.
-func (d DefaultRetryer) ShouldRetry(r *request.Request) bool {
-	if r.HTTPResponse.StatusCode >= 500 {
-		return true
-	}
-	return r.IsErrorRetryable()
-}
@@ -1,144 +0,0 @@
-package corehandlers
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-// ValidateParametersHandler is a request handler to validate the input parameters.
-// Validating parameters only has meaning if done prior to the request being sent.
-var ValidateParametersHandler = request.NamedHandler{Name: "core.ValidateParametersHandler", Fn: func(r *request.Request) {
-	if r.ParamsFilled() {
-		v := validator{errors: []string{}}
-		v.validateAny(reflect.ValueOf(r.Params), "")
-
-		if count := len(v.errors); count > 0 {
-			format := "%d validation errors:\n- %s"
-			msg := fmt.Sprintf(format, count, strings.Join(v.errors, "\n- "))
-			r.Error = awserr.New("InvalidParameter", msg, nil)
-		}
-	}
-}}
-
-// A validator validates values. Collects validations errors which occurs.
-type validator struct {
-	errors []string
-}
-
-// validateAny will validate any struct, slice or map type. All validations
-// are also performed recursively for nested types.
-func (v *validator) validateAny(value reflect.Value, path string) {
-	value = reflect.Indirect(value)
-	if !value.IsValid() {
-		return
-	}
-
-	switch value.Kind() {
-	case reflect.Struct:
-		v.validateStruct(value, path)
-	case reflect.Slice:
-		for i := 0; i < value.Len(); i++ {
-			v.validateAny(value.Index(i), path+fmt.Sprintf("[%d]", i))
-		}
-	case reflect.Map:
-		for _, n := range value.MapKeys() {
-			v.validateAny(value.MapIndex(n), path+fmt.Sprintf("[%q]", n.String()))
-		}
-	}
-}
-
-// validateStruct will validate the struct value's fields. If the structure has
-// nested types those types will be validated also.
-func (v *validator) validateStruct(value reflect.Value, path string) {
-	prefix := "."
-	if path == "" {
-		prefix = ""
-	}
-
-	for i := 0; i < value.Type().NumField(); i++ {
-		f := value.Type().Field(i)
-		if strings.ToLower(f.Name[0:1]) == f.Name[0:1] {
-			continue
-		}
-		fvalue := value.FieldByName(f.Name)
-
-		err := validateField(f, fvalue, validateFieldRequired, validateFieldMin)
-		if err != nil {
-			v.errors = append(v.errors, fmt.Sprintf("%s: %s", err.Error(), path+prefix+f.Name))
-			continue
-		}
-
-		v.validateAny(fvalue, path+prefix+f.Name)
-	}
-}
-
-type validatorFunc func(f reflect.StructField, fvalue reflect.Value) error
-
-func validateField(f reflect.StructField, fvalue reflect.Value, funcs ...validatorFunc) error {
-	for _, fn := range funcs {
-		if err := fn(f, fvalue); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Validates that a field has a valid value provided for required fields.
-func validateFieldRequired(f reflect.StructField, fvalue reflect.Value) error {
-	if f.Tag.Get("required") == "" {
-		return nil
-	}
-
-	switch fvalue.Kind() {
-	case reflect.Ptr, reflect.Slice, reflect.Map:
-		if fvalue.IsNil() {
-			return fmt.Errorf("missing required parameter")
-		}
-	default:
-		if !fvalue.IsValid() {
-			return fmt.Errorf("missing required parameter")
-		}
-	}
-	return nil
-}
-
-// Validates that if a value is provided for a field, that value must be at
-// least a minimum length.
-func validateFieldMin(f reflect.StructField, fvalue reflect.Value) error {
-	minStr := f.Tag.Get("min")
-	if minStr == "" {
-		return nil
-	}
-	min, _ := strconv.ParseInt(minStr, 10, 64)
-
-	kind := fvalue.Kind()
-	if kind == reflect.Ptr {
-		if fvalue.IsNil() {
-			return nil
-		}
-		fvalue = fvalue.Elem()
-	}
-
-	switch fvalue.Kind() {
-	case reflect.String:
-		if int64(fvalue.Len()) < min {
-			return fmt.Errorf("field too short, minimum length %d", min)
-		}
-	case reflect.Slice, reflect.Map:
-		if fvalue.IsNil() {
-			return nil
-		}
-		if int64(fvalue.Len()) < min {
-			return fmt.Errorf("field too short, minimum length %d", min)
-		}
-
-		// TODO min can also apply to number minimum value.
-
-	}
-	return nil
-}
@@ -1,134 +0,0 @@
-package corehandlers_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/aws/client/metadata"
-	"github.com/aws/aws-sdk-go/aws/corehandlers"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/stretchr/testify/require"
-)
-
-var testSvc = func() *client.Client {
-	s := &client.Client{
-		Config: aws.Config{},
-		ClientInfo: metadata.ClientInfo{
-			ServiceName: "mock-service",
-			APIVersion:  "2015-01-01",
-		},
-	}
-	return s
-}()
-
-type StructShape struct {
-	RequiredList   []*ConditionalStructShape          `required:"true"`
-	RequiredMap    map[string]*ConditionalStructShape `required:"true"`
-	RequiredBool   *bool                              `required:"true"`
-	OptionalStruct *ConditionalStructShape
-
-	hiddenParameter *string
-
-	metadataStructureShape
-}
-
-type metadataStructureShape struct {
-	SDKShapeTraits bool
-}
-
-type ConditionalStructShape struct {
-	Name           *string `required:"true"`
-	SDKShapeTraits bool
-}
-
-func TestNoErrors(t *testing.T) {
-	input := &StructShape{
-		RequiredList: []*ConditionalStructShape{},
-		RequiredMap: map[string]*ConditionalStructShape{
-			"key1": {Name: aws.String("Name")},
-			"key2": {Name: aws.String("Name")},
-		},
-		RequiredBool:   aws.Bool(true),
-		OptionalStruct: &ConditionalStructShape{Name: aws.String("Name")},
-	}
-
-	req := testSvc.NewRequest(&request.Operation{}, input, nil)
-	corehandlers.ValidateParametersHandler.Fn(req)
-	require.NoError(t, req.Error)
-}
-
-func TestMissingRequiredParameters(t *testing.T) {
-	input := &StructShape{}
-	req := testSvc.NewRequest(&request.Operation{}, input, nil)
-	corehandlers.ValidateParametersHandler.Fn(req)
-
-	require.Error(t, req.Error)
-	assert.Equal(t, "InvalidParameter", req.Error.(awserr.Error).Code())
-	assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList\n- missing required parameter: RequiredMap\n- missing required parameter: RequiredBool", req.Error.(awserr.Error).Message())
-}
-
-func TestNestedMissingRequiredParameters(t *testing.T) {
-	input := &StructShape{
-		RequiredList: []*ConditionalStructShape{{}},
-		RequiredMap: map[string]*ConditionalStructShape{
-			"key1": {Name: aws.String("Name")},
-			"key2": {},
-		},
-		RequiredBool:   aws.Bool(true),
-		OptionalStruct: &ConditionalStructShape{},
-	}
-
-	req := testSvc.NewRequest(&request.Operation{}, input, nil)
-	corehandlers.ValidateParametersHandler.Fn(req)
-
-	require.Error(t, req.Error)
-	assert.Equal(t, "InvalidParameter", req.Error.(awserr.Error).Code())
-	assert.Equal(t, "3 validation errors:\n- missing required parameter: RequiredList[0].Name\n- missing required parameter: RequiredMap[\"key2\"].Name\n- missing required parameter: OptionalStruct.Name", req.Error.(awserr.Error).Message())
-}
-
-type testInput struct {
-	StringField string            `min:"5"`
-	PtrStrField *string           `min:"2"`
-	ListField   []string          `min:"3"`
-	MapField    map[string]string `min:"4"`
-}
-
-var testsFieldMin = []struct {
-	err awserr.Error
-	in  testInput
-}{
-	{
-		err: awserr.New("InvalidParameter", "1 validation errors:\n- field too short, minimum length 5: StringField", nil),
-		in:  testInput{StringField: "abcd"},
-	},
-	{
-		err: awserr.New("InvalidParameter", "2 validation errors:\n- field too short, minimum length 5: StringField\n- field too short, minimum length 3: ListField", nil),
-		in:  testInput{StringField: "abcd", ListField: []string{"a", "b"}},
-	},
-	{
-		err: awserr.New("InvalidParameter", "3 validation errors:\n- field too short, minimum length 5: StringField\n- field too short, minimum length 3: ListField\n- field too short, minimum length 4: MapField", nil),
-		in:  testInput{StringField: "abcd", ListField: []string{"a", "b"}, MapField: map[string]string{"a": "a", "b": "b"}},
-	},
-	{
-		err: awserr.New("InvalidParameter", "1 validation errors:\n- field too short, minimum length 2: PtrStrField", nil),
-		in:  testInput{StringField: "abcde", PtrStrField: aws.String("v")},
-	},
-	{
-		err: nil,
-		in: testInput{StringField: "abcde", PtrStrField: aws.String("value"),
-			ListField: []string{"a", "b", "c"}, MapField: map[string]string{"a": "a", "b": "b", "c": "c", "d": "d"}},
-	},
-}
-
-func TestValidateFieldMinParameter(t *testing.T) {
-	for i, c := range testsFieldMin {
-		req := testSvc.NewRequest(&request.Operation{}, &c.in, nil)
-		corehandlers.ValidateParametersHandler.Fn(req)
-
-		require.Equal(t, c.err, req.Error, "%d case failed", i)
-	}
-}
@@ -1,73 +0,0 @@
-package credentials
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestChainProviderGet(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{
-			&stubProvider{err: awserr.New("FirstError", "first provider error", nil)},
-			&stubProvider{err: awserr.New("SecondError", "second provider error", nil)},
-			&stubProvider{
-				creds: Value{
-					AccessKeyID:     "AKID",
-					SecretAccessKey: "SECRET",
-					SessionToken:    "",
-				},
-			},
-		},
-	}
-
-	creds, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-	assert.Equal(t, "AKID", creds.AccessKeyID, "Expect access key ID to match")
-	assert.Equal(t, "SECRET", creds.SecretAccessKey, "Expect secret access key to match")
-	assert.Empty(t, creds.SessionToken, "Expect session token to be empty")
-}
-
-func TestChainProviderIsExpired(t *testing.T) {
-	stubProvider := &stubProvider{expired: true}
-	p := &ChainProvider{
-		Providers: []Provider{
-			stubProvider,
-		},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired to be true before any Retrieve")
-	_, err := p.Retrieve()
-	assert.Nil(t, err, "Expect no error")
-	assert.False(t, p.IsExpired(), "Expect not expired after retrieve")
-
-	stubProvider.expired = true
-	assert.True(t, p.IsExpired(), "Expect return of expired provider")
-
-	_, err = p.Retrieve()
-	assert.False(t, p.IsExpired(), "Expect not expired after retrieve")
-}
-
-func TestChainProviderWithNoProvider(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired with no providers")
-	_, err := p.Retrieve()
-	assert.Equal(t, ErrNoValidProvidersFoundInChain, err, "Expect no providers error returned")
-}
-
-func TestChainProviderWithNoValidProvider(t *testing.T) {
-	p := &ChainProvider{
-		Providers: []Provider{
-			&stubProvider{err: awserr.New("FirstError", "first provider error", nil)},
-			&stubProvider{err: awserr.New("SecondError", "second provider error", nil)},
-		},
-	}
-
-	assert.True(t, p.IsExpired(), "Expect expired with no providers")
-	_, err := p.Retrieve()
-	assert.Equal(t, ErrNoValidProvidersFoundInChain, err, "Expect no providers error returned")
-}
@@ -1,76 +0,0 @@
-// Package defaults is a collection of helpers to retrieve the SDK's default
-// configuration and handlers.
-package defaults
-
-import (
-	"net/http"
-	"os"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/corehandlers"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"
-	"github.com/aws/aws-sdk-go/aws/ec2metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/endpoints"
-)
-
-// A Defaults provides a collection of default values for SDK clients.
-type Defaults struct {
-	Config   *aws.Config
-	Handlers request.Handlers
-}
-
-// Get returns the SDK's default values with Config and handlers pre-configured.
-func Get() Defaults {
-	cfg := Config()
-	handlers := Handlers()
-	cfg.Credentials = CredChain(cfg, handlers)
-
-	return Defaults{
-		Config:   cfg,
-		Handlers: handlers,
-	}
-}
-
-// Config returns the default configuration.
-func Config() *aws.Config {
-	return aws.NewConfig().
-		WithCredentials(credentials.AnonymousCredentials).
-		WithRegion(os.Getenv("AWS_REGION")).
-		WithHTTPClient(http.DefaultClient).
-		WithMaxRetries(aws.UseServiceDefaultRetries).
-		WithLogger(aws.NewDefaultLogger()).
-		WithLogLevel(aws.LogOff).
-		WithSleepDelay(time.Sleep)
-}
-
-// Handlers returns the default request handlers.
-func Handlers() request.Handlers {
-	var handlers request.Handlers
-
-	handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler)
-	handlers.Build.PushBackNamed(corehandlers.SDKVersionUserAgentHandler)
-	handlers.Sign.PushBackNamed(corehandlers.BuildContentLengthHandler)
-	handlers.Send.PushBackNamed(corehandlers.SendHandler)
-	handlers.AfterRetry.PushBackNamed(corehandlers.AfterRetryHandler)
-	handlers.ValidateResponse.PushBackNamed(corehandlers.ValidateResponseHandler)
-
-	return handlers
-}
-
-// CredChain returns the default credential chain.
-func CredChain(cfg *aws.Config, handlers request.Handlers) *credentials.Credentials {
-	endpoint, signingRegion := endpoints.EndpointForRegion(ec2metadata.ServiceName, *cfg.Region, true)
-
-	return credentials.NewChainCredentials(
-		[]credentials.Provider{
-			&credentials.EnvProvider{},
-			&credentials.SharedCredentialsProvider{Filename: "", Profile: ""},
-			&ec2rolecreds.EC2RoleProvider{
-				Client:       ec2metadata.NewClient(*cfg, handlers, endpoint, signingRegion),
-				ExpiryWindow: 5 * time.Minute,
-			},
-		})
-}
@@ -1,43 +0,0 @@
-package ec2metadata
-
-import (
-	"path"
-
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-// GetMetadata uses the path provided to request
-func (c *EC2Metadata) GetMetadata(p string) (string, error) {
-	op := &request.Operation{
-		Name:       "GetMetadata",
-		HTTPMethod: "GET",
-		HTTPPath:   path.Join("/", "meta-data", p),
-	}
-
-	output := &metadataOutput{}
-	req := c.NewRequest(op, nil, output)
-
-	return output.Content, req.Send()
-}
-
-// Region returns the region the instance is running in.
-func (c *EC2Metadata) Region() (string, error) {
-	resp, err := c.GetMetadata("placement/availability-zone")
-	if err != nil {
-		return "", err
-	}
-
-	// returns region without the suffix. Eg: us-west-2a becomes us-west-2
-	return resp[:len(resp)-1], nil
-}
-
-// Available returns if the application has access to the EC2 Metadata service.
-// Can be used to determine if application is running within an EC2 Instance and
-// the metadata service is available.
-func (c *EC2Metadata) Available() bool {
-	if _, err := c.GetMetadata("instance-id"); err != nil {
-		return false
-	}
-
-	return true
-}
@@ -1,101 +0,0 @@
-package ec2metadata_test
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"path"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/ec2metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/aws/session"
-)
-
-func initTestServer(path string, resp string) *httptest.Server {
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.RequestURI != path {
-			http.Error(w, "not found", http.StatusNotFound)
-			return
-		}
-
-		w.Write([]byte(resp))
-	}))
-}
-
-func TestEndpoint(t *testing.T) {
-	c := ec2metadata.New(session.New())
-	op := &request.Operation{
-		Name:       "GetMetadata",
-		HTTPMethod: "GET",
-		HTTPPath:   path.Join("/", "meta-data", "testpath"),
-	}
-
-	req := c.NewRequest(op, nil, nil)
-	assert.Equal(t, "http://169.254.169.254/latest", req.ClientInfo.Endpoint)
-	assert.Equal(t, "http://169.254.169.254/latest/meta-data/testpath", req.HTTPRequest.URL.String())
-}
-
-func TestGetMetadata(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/some/path",
-		"success", // real response includes suffix
-	)
-	defer server.Close()
-	c := ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	resp, err := c.GetMetadata("some/path")
-
-	assert.NoError(t, err)
-	assert.Equal(t, "success", resp)
-}
-
-func TestGetRegion(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/placement/availability-zone",
-		"us-west-2a", // real response includes suffix
-	)
-	defer server.Close()
-	c := ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	region, err := c.Region()
-
-	assert.NoError(t, err)
-	assert.Equal(t, "us-west-2", region)
-}
-
-func TestMetadataAvailable(t *testing.T) {
-	server := initTestServer(
-		"/latest/meta-data/instance-id",
-		"instance-id",
-	)
-	defer server.Close()
-	c := ec2metadata.New(session.New(), &aws.Config{Endpoint: aws.String(server.URL + "/latest")})
-
-	available := c.Available()
-
-	assert.True(t, available)
-}
-
-func TestMetadataNotAvailable(t *testing.T) {
-	c := ec2metadata.New(session.New())
-	c.Handlers.Send.Clear()
-	c.Handlers.Send.PushBack(func(r *request.Request) {
-		r.HTTPResponse = &http.Response{
-			StatusCode: int(0),
-			Status:     http.StatusText(int(0)),
-			Body:       ioutil.NopCloser(bytes.NewReader([]byte{})),
-		}
-		r.Error = awserr.New("RequestError", "send request failed", nil)
-		r.Retryable = aws.Bool(true) // network errors are retryable
-	})
-
-	available := c.Available()
-
-	assert.False(t, available)
-}
@@ -1,47 +0,0 @@
-package request_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-func TestHandlerList(t *testing.T) {
-	s := ""
-	r := &request.Request{}
-	l := request.HandlerList{}
-	l.PushBack(func(r *request.Request) {
-		s += "a"
-		r.Data = s
-	})
-	l.Run(r)
-	assert.Equal(t, "a", s)
-	assert.Equal(t, "a", r.Data)
-}
-
-func TestMultipleHandlers(t *testing.T) {
-	r := &request.Request{}
-	l := request.HandlerList{}
-	l.PushBack(func(r *request.Request) { r.Data = nil })
-	l.PushFront(func(r *request.Request) { r.Data = aws.Bool(true) })
-	l.Run(r)
-	if r.Data != nil {
-		t.Error("Expected handler to execute")
-	}
-}
-
-func TestNamedHandlers(t *testing.T) {
-	l := request.HandlerList{}
-	named := request.NamedHandler{Name: "Name", Fn: func(r *request.Request) {}}
-	named2 := request.NamedHandler{Name: "NotName", Fn: func(r *request.Request) {}}
-	l.PushBackNamed(named)
-	l.PushBackNamed(named)
-	l.PushBackNamed(named2)
-	l.PushBack(func(r *request.Request) {})
-	assert.Equal(t, 4, l.Len())
-	l.Remove(named)
-	assert.Equal(t, 2, l.Len())
-}
@@ -1,105 +0,0 @@
-// Package session provides a way to create service clients with shared configuration
-// and handlers.
-package session
-
-import (
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/aws/corehandlers"
-	"github.com/aws/aws-sdk-go/aws/defaults"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/endpoints"
-)
-
-// A Session provides a central location to create service clients from and
-// store configurations and request handlers for those services.
-//
-// Sessions are safe to create service clients concurrently, but it is not safe
-// to mutate the session concurrently.
-type Session struct {
-	Config   *aws.Config
-	Handlers request.Handlers
-}
-
-// New creates a new instance of the handlers merging in the provided Configs
-// on top of the SDK's default configurations. Once the session is created it
-// can be mutated to modify Configs or Handlers. The session is safe to be read
-// concurrently, but it should not be written to concurrently.
-//
-// Example:
-//     // Create a session with the default config and request handlers.
-//     sess := session.New()
-//
-//     // Create a session with a custom region
-//     sess := session.New(&aws.Config{Region: aws.String("us-east-1")})
-//
-//     // Create a session, and add additional handlers for all service
-//     // clients created with the session to inherit. Adds logging handler.
-//     sess := session.New()
-//     sess.Handlers.Send.PushFront(func(r *request.Request) {
-//          // Log every request made and its payload
-//          logger.Println("Request: %s/%s, Payload: %s", r.ClientInfo.ServiceName, r.Operation, r.Params)
-//     })
-//
-//     // Create a S3 client instance from a session
-//     sess := session.New()
-//     svc := s3.New(sess)
-func New(cfgs ...*aws.Config) *Session {
-	def := defaults.Get()
-	s := &Session{
-		Config:   def.Config,
-		Handlers: def.Handlers,
-	}
-	s.Config.MergeIn(cfgs...)
-
-	initHandlers(s)
-
-	return s
-}
-
-func initHandlers(s *Session) {
-	// Add the Validate parameter handler if it is not disabled.
-	s.Handlers.Validate.Remove(corehandlers.ValidateParametersHandler)
-	if !aws.BoolValue(s.Config.DisableParamValidation) {
-		s.Handlers.Validate.PushBackNamed(corehandlers.ValidateParametersHandler)
-	}
-}
-
-// Copy creates and returns a copy of the current session, coping the config
-// and handlers. If any additional configs are provided they will be merged
-// on top of the session's copied config.
-//
-// Example:
-//     // Create a copy of the current session, configured for the us-west-2 region.
-//     sess.Copy(&aws.Config{Region: aws.String("us-west-2"})
-func (s *Session) Copy(cfgs ...*aws.Config) *Session {
-	newSession := &Session{
-		Config:   s.Config.Copy(cfgs...),
-		Handlers: s.Handlers.Copy(),
-	}
-
-	initHandlers(newSession)
-
-	return newSession
-}
-
-// ClientConfig satisfies the client.ConfigProvider interface and is used to
-// configure the service client instances. Passing the Session to the service
-// client's constructor (New) will use this method to configure the client.
-//
-// Example:
-//     sess := session.New()
-//     s3.New(sess)
-func (s *Session) ClientConfig(serviceName string, cfgs ...*aws.Config) client.Config {
-	s = s.Copy(cfgs...)
-	endpoint, signingRegion := endpoints.NormalizeEndpoint(
-		aws.StringValue(s.Config.Endpoint), serviceName,
-		aws.StringValue(s.Config.Region), aws.BoolValue(s.Config.DisableSSL))
-
-	return client.Config{
-		Config:        s.Config,
-		Handlers:      s.Handlers,
-		Endpoint:      endpoint,
-		SigningRegion: signingRegion,
-	}
-}
@@ -1,20 +0,0 @@
-package session_test
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/session"
-)
-
-func TestNewDefaultSession(t *testing.T) {
-	s := session.New(&aws.Config{Region: aws.String("region")})
-
-	assert.Equal(t, "region", *s.Config.Region)
-	assert.Equal(t, http.DefaultClient, s.Config.HTTPClient)
-	assert.NotNil(t, s.Config.Logger)
-	assert.Equal(t, aws.LogOff, *s.Config.LogLevel)
-}
@@ -1,31 +0,0 @@
-// Package endpoints validates regional endpoints for services.
-package endpoints
-
-//go:generate go run ../model/cli/gen-endpoints/main.go endpoints.json endpoints_map.go
-//go:generate gofmt -s -w endpoints_map.go
-
-import "strings"
-
-// EndpointForRegion returns an endpoint and its signing region for a service and region.
-// if the service and region pair are not found endpoint and signingRegion will be empty.
-func EndpointForRegion(svcName, region string) (endpoint, signingRegion string) {
-	derivedKeys := []string{
-		region + "/" + svcName,
-		region + "/*",
-		"*/" + svcName,
-		"*/*",
-	}
-
-	for _, key := range derivedKeys {
-		if val, ok := endpointsMap.Endpoints[key]; ok {
-			ep := val.Endpoint
-			ep = strings.Replace(ep, "{region}", region, -1)
-			ep = strings.Replace(ep, "{service}", svcName, -1)
-
-			endpoint = ep
-			signingRegion = val.SigningRegion
-			return
-		}
-	}
-	return
-}
@@ -1,89 +0,0 @@
-package endpoints
-
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-type endpointStruct struct {
-	Version   int
-	Endpoints map[string]endpointEntry
-}
-
-type endpointEntry struct {
-	Endpoint      string
-	SigningRegion string
-}
-
-var endpointsMap = endpointStruct{
-	Version: 2,
-	Endpoints: map[string]endpointEntry{
-		"*/*": {
-			Endpoint: "{service}.{region}.amazonaws.com",
-		},
-		"*/cloudfront": {
-			Endpoint:      "cloudfront.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/cloudsearchdomain": {
-			Endpoint:      "",
-			SigningRegion: "us-east-1",
-		},
-		"*/iam": {
-			Endpoint:      "iam.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/importexport": {
-			Endpoint:      "importexport.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/route53": {
-			Endpoint:      "route53.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"*/sts": {
-			Endpoint:      "sts.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"ap-northeast-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"ap-southeast-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"ap-southeast-2/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"cn-north-1/*": {
-			Endpoint: "{service}.{region}.amazonaws.com.cn",
-		},
-		"eu-central-1/s3": {
-			Endpoint: "{service}.{region}.amazonaws.com",
-		},
-		"eu-west-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"sa-east-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"us-east-1/s3": {
-			Endpoint: "s3.amazonaws.com",
-		},
-		"us-east-1/sdb": {
-			Endpoint:      "sdb.amazonaws.com",
-			SigningRegion: "us-east-1",
-		},
-		"us-gov-west-1/iam": {
-			Endpoint: "iam.us-gov.amazonaws.com",
-		},
-		"us-gov-west-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"us-gov-west-1/sts": {
-			Endpoint: "sts.us-gov-west-1.amazonaws.com",
-		},
-		"us-west-1/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-		"us-west-2/s3": {
-			Endpoint: "s3-{region}.amazonaws.com",
-		},
-	},
-}
@@ -1,28 +0,0 @@
-package endpoints
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGlobalEndpoints(t *testing.T) {
-	region := "mock-region-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts"}
-
-	for _, name := range svcs {
-		ep, sr := EndpointForRegion(name, region)
-		assert.Equal(t, name+".amazonaws.com", ep)
-		assert.Equal(t, "us-east-1", sr)
-	}
-}
-
-func TestServicesInCN(t *testing.T) {
-	region := "cn-north-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts", "s3"}
-
-	for _, name := range svcs {
-		ep, _ := EndpointForRegion(name, region)
-		assert.Equal(t, name+"."+region+".amazonaws.com.cn", ep)
-	}
-}
@@ -1,32 +0,0 @@
-// Package ec2query provides serialisation of AWS EC2 requests and responses.
-package ec2query
-
-//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/ec2.json build_test.go
-
-import (
-	"net/url"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/protocol/query/queryutil"
-)
-
-// Build builds a request for the EC2 protocol.
-func Build(r *aws.Request) {
-	body := url.Values{
-		"Action":  {r.Operation.Name},
-		"Version": {r.Service.APIVersion},
-	}
-	if err := queryutil.Parse(body, r.Params, true); err != nil {
-		r.Error = awserr.New("SerializationError", "failed encoding EC2 Query request", err)
-	}
-
-	if r.ExpireTime == 0 {
-		r.HTTPRequest.Method = "POST"
-		r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
-		r.SetBufferBody([]byte(body.Encode()))
-	} else { // This is a pre-signed request
-		r.HTTPRequest.Method = "GET"
-		r.HTTPRequest.URL.RawQuery = body.Encode()
-	}
-}
@@ -1,860 +0,0 @@
-package ec2query_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/xml"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-	"github.com/aws/aws-sdk-go/internal/signer/v4"
-	"github.com/aws/aws-sdk-go/internal/util"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ bytes.Buffer // always import bytes
-var _ http.Request
-var _ json.Marshaler
-var _ time.Time
-var _ xmlutil.XMLNode
-var _ xml.Attr
-var _ = ioutil.Discard
-var _ = util.Trim("")
-var _ = url.Values{}
-var _ = io.EOF
-
-type InputService1ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService1ProtocolTest client.
-func NewInputService1ProtocolTest(config *aws.Config) *InputService1ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice1protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService1ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService1ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService1ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService1TestCaseOperation1 = "OperationName"
-
-// InputService1TestCaseOperation1Request generates a request for the InputService1TestCaseOperation1 operation.
-func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputShape) (req *aws.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService1TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService1TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService1TestShapeInputService1TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputShape) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) {
-	req, out := c.InputService1TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService1TestShapeInputService1TestCaseOperation1Output struct {
-	metadataInputService1TestShapeInputService1TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService1TestShapeInputService1TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService1TestShapeInputShape struct {
-	Bar *string `type:"string"`
-
-	Foo *string `type:"string"`
-
-	metadataInputService1TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService1TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService2ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService2ProtocolTest client.
-func NewInputService2ProtocolTest(config *aws.Config) *InputService2ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice2protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService2ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService2ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService2ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService2TestCaseOperation1 = "OperationName"
-
-// InputService2TestCaseOperation1Request generates a request for the InputService2TestCaseOperation1 operation.
-func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputShape) (req *aws.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService2TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService2TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService2TestShapeInputService2TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputShape) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) {
-	req, out := c.InputService2TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService2TestShapeInputService2TestCaseOperation1Output struct {
-	metadataInputService2TestShapeInputService2TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService2TestShapeInputService2TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService2TestShapeInputShape struct {
-	Bar *string `locationName:"barLocationName" type:"string"`
-
-	Foo *string `type:"string"`
-
-	Yuck *string `locationName:"yuckLocationName" queryName:"yuckQueryName" type:"string"`
-
-	metadataInputService2TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService2TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService3ProtocolTest client.
-func NewInputService3ProtocolTest(config *aws.Config) *InputService3ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice3protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService3ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService3ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService3ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService3TestCaseOperation1 = "OperationName"
-
-// InputService3TestCaseOperation1Request generates a request for the InputService3TestCaseOperation1 operation.
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputShape) (req *aws.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService3TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService3TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService3TestShapeInputService3TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputShape) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) {
-	req, out := c.InputService3TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService3TestShapeInputService3TestCaseOperation1Output struct {
-	metadataInputService3TestShapeInputService3TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeInputService3TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3TestShapeInputShape struct {
-	StructArg *InputService3TestShapeStructType `locationName:"Struct" type:"structure"`
-
-	metadataInputService3TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService3TestShapeStructType struct {
-	ScalarArg *string `locationName:"Scalar" type:"string"`
-
-	metadataInputService3TestShapeStructType `json:"-" xml:"-"`
-}
-
-type metadataInputService3TestShapeStructType struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService4ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService4ProtocolTest client.
-func NewInputService4ProtocolTest(config *aws.Config) *InputService4ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice4protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService4ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService4ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService4ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService4TestCaseOperation1 = "OperationName"
-
-// InputService4TestCaseOperation1Request generates a request for the InputService4TestCaseOperation1 operation.
-func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputShape) (req *aws.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService4TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService4TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService4TestShapeInputService4TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputShape) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) {
-	req, out := c.InputService4TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService4TestShapeInputService4TestCaseOperation1Output struct {
-	metadataInputService4TestShapeInputService4TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService4TestShapeInputService4TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService4TestShapeInputShape struct {
-	ListArg []*string `type:"list"`
-
-	metadataInputService4TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService4TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService5ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService5ProtocolTest client.
-func NewInputService5ProtocolTest(config *aws.Config) *InputService5ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice5protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService5ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService5ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService5ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService5TestCaseOperation1 = "OperationName"
-
-// InputService5TestCaseOperation1Request generates a request for the InputService5TestCaseOperation1 operation.
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputShape) (req *aws.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService5TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService5TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService5TestShapeInputService5TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputShape) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) {
-	req, out := c.InputService5TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService5TestShapeInputService5TestCaseOperation1Output struct {
-	metadataInputService5TestShapeInputService5TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService5TestShapeInputService5TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService5TestShapeInputShape struct {
-	ListArg []*string `locationName:"ListMemberName" locationNameList:"item" type:"list"`
-
-	metadataInputService5TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService5TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService6ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService6ProtocolTest client.
-func NewInputService6ProtocolTest(config *aws.Config) *InputService6ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice6protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService6ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService6ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService6ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService6TestCaseOperation1 = "OperationName"
-
-// InputService6TestCaseOperation1Request generates a request for the InputService6TestCaseOperation1 operation.
-func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputShape) (req *aws.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService6TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService6TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService6TestShapeInputService6TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputShape) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) {
-	req, out := c.InputService6TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService6TestShapeInputService6TestCaseOperation1Output struct {
-	metadataInputService6TestShapeInputService6TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService6TestShapeInputService6TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService6TestShapeInputShape struct {
-	ListArg []*string `locationName:"ListMemberName" queryName:"ListQueryName" locationNameList:"item" type:"list"`
-
-	metadataInputService6TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService6TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService7ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService7ProtocolTest client.
-func NewInputService7ProtocolTest(config *aws.Config) *InputService7ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice7protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService7ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService7ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService7ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService7TestCaseOperation1 = "OperationName"
-
-// InputService7TestCaseOperation1Request generates a request for the InputService7TestCaseOperation1 operation.
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputShape) (req *aws.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService7TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService7TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService7TestShapeInputService7TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputShape) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) {
-	req, out := c.InputService7TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService7TestShapeInputService7TestCaseOperation1Output struct {
-	metadataInputService7TestShapeInputService7TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService7TestShapeInputService7TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService7TestShapeInputShape struct {
-	BlobArg []byte `type:"blob"`
-
-	metadataInputService7TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService7TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService8ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new InputService8ProtocolTest client.
-func NewInputService8ProtocolTest(config *aws.Config) *InputService8ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "inputservice8protocoltest",
-		APIVersion:  "2014-01-01",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &InputService8ProtocolTest{service}
-}
-
-// newRequest creates a new request for a InputService8ProtocolTest operation and runs any
-// custom request initialization.
-func (c *InputService8ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opInputService8TestCaseOperation1 = "OperationName"
-
-// InputService8TestCaseOperation1Request generates a request for the InputService8TestCaseOperation1 operation.
-func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputShape) (req *aws.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) {
-	op := &aws.Operation{
-		Name: opInputService8TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &InputService8TestShapeInputShape{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &InputService8TestShapeInputService8TestCaseOperation1Output{}
-	req.Data = output
-	return
-}
-
-func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputShape) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) {
-	req, out := c.InputService8TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type InputService8TestShapeInputService8TestCaseOperation1Output struct {
-	metadataInputService8TestShapeInputService8TestCaseOperation1Output `json:"-" xml:"-"`
-}
-
-type metadataInputService8TestShapeInputService8TestCaseOperation1Output struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type InputService8TestShapeInputShape struct {
-	TimeArg *time.Time `type:"timestamp" timestampFormat:"iso8601"`
-
-	metadataInputService8TestShapeInputShape `json:"-" xml:"-"`
-}
-
-type metadataInputService8TestShapeInputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-//
-// Tests begin here
-//
-
-func TestInputService1ProtocolTestScalarMembersCase1(t *testing.T) {
-	svc := NewInputService1ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService1TestShapeInputShape{
-		Bar: aws.String("val2"),
-		Foo: aws.String("val1"),
-	}
-	req, _ := svc.InputService1TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&Bar=val2&Foo=val1&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService2ProtocolTestStructureWithLocationNameAndQueryNameAppliedToMembersCase1(t *testing.T) {
-	svc := NewInputService2ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService2TestShapeInputShape{
-		Bar:  aws.String("val2"),
-		Foo:  aws.String("val1"),
-		Yuck: aws.String("val3"),
-	}
-	req, _ := svc.InputService2TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&BarLocationName=val2&Foo=val1&Version=2014-01-01&yuckQueryName=val3`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService3ProtocolTestNestedStructureMembersCase1(t *testing.T) {
-	svc := NewInputService3ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService3TestShapeInputShape{
-		StructArg: &InputService3TestShapeStructType{
-			ScalarArg: aws.String("foo"),
-		},
-	}
-	req, _ := svc.InputService3TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&Struct.Scalar=foo&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService4ProtocolTestListTypesCase1(t *testing.T) {
-	svc := NewInputService4ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService4TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("foo"),
-			aws.String("bar"),
-			aws.String("baz"),
-		},
-	}
-	req, _ := svc.InputService4TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListArg.1=foo&ListArg.2=bar&ListArg.3=baz&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService5ProtocolTestListWithLocationNameAppliedToMemberCase1(t *testing.T) {
-	svc := NewInputService5ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService5TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("a"),
-			aws.String("b"),
-			aws.String("c"),
-		},
-	}
-	req, _ := svc.InputService5TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListMemberName.1=a&ListMemberName.2=b&ListMemberName.3=c&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService6ProtocolTestListWithLocationNameAndQueryNameCase1(t *testing.T) {
-	svc := NewInputService6ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService6TestShapeInputShape{
-		ListArg: []*string{
-			aws.String("a"),
-			aws.String("b"),
-			aws.String("c"),
-		},
-	}
-	req, _ := svc.InputService6TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&ListQueryName.1=a&ListQueryName.2=b&ListQueryName.3=c&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService7ProtocolTestBase64EncodedBlobsCase1(t *testing.T) {
-	svc := NewInputService7ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService7TestShapeInputShape{
-		BlobArg: []byte("foo"),
-	}
-	req, _ := svc.InputService7TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&BlobArg=Zm9v&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
-
-func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) {
-	svc := NewInputService8ProtocolTest(nil)
-	svc.Endpoint = "https://test"
-
-	input := &InputService8TestShapeInputShape{
-		TimeArg: aws.Time(time.Unix(1422172800, 0)),
-	}
-	req, _ := svc.InputService8TestCaseOperation1Request(input)
-	r := req.HTTPRequest
-
-	// build request
-	ec2query.Build(req)
-	assert.NoError(t, req.Error)
-
-	// assert body
-	assert.NotNil(t, r.Body)
-	body, _ := ioutil.ReadAll(r.Body)
-	assert.Equal(t, util.Trim(`Action=OperationName&TimeArg=2015-01-25T08%3A00%3A00Z&Version=2014-01-01`), util.Trim(string(body)))
-
-	// assert URL
-	assert.Equal(t, "https://test/", r.URL.String())
-
-	// assert headers
-
-}
@@ -1,54 +0,0 @@
-package ec2query
-
-//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/output/ec2.json unmarshal_test.go
-
-import (
-	"encoding/xml"
-	"io"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-)
-
-// Unmarshal unmarshals a response body for the EC2 protocol.
-func Unmarshal(r *aws.Request) {
-	defer r.HTTPResponse.Body.Close()
-	if r.DataFilled() {
-		decoder := xml.NewDecoder(r.HTTPResponse.Body)
-		err := xmlutil.UnmarshalXML(r.Data, decoder, "")
-		if err != nil {
-			r.Error = awserr.New("SerializationError", "failed decoding EC2 Query response", err)
-			return
-		}
-	}
-}
-
-// UnmarshalMeta unmarshals response headers for the EC2 protocol.
-func UnmarshalMeta(r *aws.Request) {
-	// TODO implement unmarshaling of request IDs
-}
-
-type xmlErrorResponse struct {
-	XMLName   xml.Name `xml:"Response"`
-	Code      string   `xml:"Errors>Error>Code"`
-	Message   string   `xml:"Errors>Error>Message"`
-	RequestID string   `xml:"RequestId"`
-}
-
-// UnmarshalError unmarshals a response error for the EC2 protocol.
-func UnmarshalError(r *aws.Request) {
-	defer r.HTTPResponse.Body.Close()
-
-	resp := &xmlErrorResponse{}
-	err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
-	if err != nil && err != io.EOF {
-		r.Error = awserr.New("SerializationError", "failed decoding EC2 Query error response", err)
-	} else {
-		r.Error = awserr.NewRequestFailure(
-			awserr.New(resp.Code, resp.Message, nil),
-			r.HTTPResponse.StatusCode,
-			resp.RequestID,
-		)
-	}
-}
@@ -1,816 +0,0 @@
-package ec2query_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"encoding/xml"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-	"github.com/aws/aws-sdk-go/internal/signer/v4"
-	"github.com/aws/aws-sdk-go/internal/util"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ bytes.Buffer // always import bytes
-var _ http.Request
-var _ json.Marshaler
-var _ time.Time
-var _ xmlutil.XMLNode
-var _ xml.Attr
-var _ = ioutil.Discard
-var _ = util.Trim("")
-var _ = url.Values{}
-var _ = io.EOF
-
-type OutputService1ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService1ProtocolTest client.
-func NewOutputService1ProtocolTest(config *aws.Config) *OutputService1ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice1protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService1ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService1ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService1ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService1TestCaseOperation1 = "OperationName"
-
-// OutputService1TestCaseOperation1Request generates a request for the OutputService1TestCaseOperation1 operation.
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *aws.Request, output *OutputService1TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService1TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService1TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (*OutputService1TestShapeOutputShape, error) {
-	req, out := c.OutputService1TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService1TestShapeOutputService1TestCaseOperation1Input struct {
-	metadataOutputService1TestShapeOutputService1TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService1TestShapeOutputService1TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService1TestShapeOutputShape struct {
-	Char *string `type:"character"`
-
-	Double *float64 `type:"double"`
-
-	FalseBool *bool `type:"boolean"`
-
-	Float *float64 `type:"float"`
-
-	Long *int64 `type:"long"`
-
-	Num *int64 `locationName:"FooNum" type:"integer"`
-
-	Str *string `type:"string"`
-
-	TrueBool *bool `type:"boolean"`
-
-	metadataOutputService1TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService1TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService2ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService2ProtocolTest client.
-func NewOutputService2ProtocolTest(config *aws.Config) *OutputService2ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice2protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService2ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService2ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService2ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService2TestCaseOperation1 = "OperationName"
-
-// OutputService2TestCaseOperation1Request generates a request for the OutputService2TestCaseOperation1 operation.
-func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *aws.Request, output *OutputService2TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService2TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService2TestShapeOutputService2TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService2TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (*OutputService2TestShapeOutputShape, error) {
-	req, out := c.OutputService2TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService2TestShapeOutputService2TestCaseOperation1Input struct {
-	metadataOutputService2TestShapeOutputService2TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService2TestShapeOutputService2TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService2TestShapeOutputShape struct {
-	Blob []byte `type:"blob"`
-
-	metadataOutputService2TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService2TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService3ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService3ProtocolTest client.
-func NewOutputService3ProtocolTest(config *aws.Config) *OutputService3ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice3protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService3ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService3ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService3ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService3TestCaseOperation1 = "OperationName"
-
-// OutputService3TestCaseOperation1Request generates a request for the OutputService3TestCaseOperation1 operation.
-func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *aws.Request, output *OutputService3TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService3TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService3TestShapeOutputService3TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService3TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (*OutputService3TestShapeOutputShape, error) {
-	req, out := c.OutputService3TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService3TestShapeOutputService3TestCaseOperation1Input struct {
-	metadataOutputService3TestShapeOutputService3TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService3TestShapeOutputService3TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService3TestShapeOutputShape struct {
-	ListMember []*string `type:"list"`
-
-	metadataOutputService3TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService3TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService4ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService4ProtocolTest client.
-func NewOutputService4ProtocolTest(config *aws.Config) *OutputService4ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice4protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService4ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService4ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService4ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService4TestCaseOperation1 = "OperationName"
-
-// OutputService4TestCaseOperation1Request generates a request for the OutputService4TestCaseOperation1 operation.
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *aws.Request, output *OutputService4TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService4TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService4TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputShape, error) {
-	req, out := c.OutputService4TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService4TestShapeOutputService4TestCaseOperation1Input struct {
-	metadataOutputService4TestShapeOutputService4TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService4TestShapeOutputService4TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService4TestShapeOutputShape struct {
-	ListMember []*string `locationNameList:"item" type:"list"`
-
-	metadataOutputService4TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService4TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService5ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService5ProtocolTest client.
-func NewOutputService5ProtocolTest(config *aws.Config) *OutputService5ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice5protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService5ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService5ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService5ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService5TestCaseOperation1 = "OperationName"
-
-// OutputService5TestCaseOperation1Request generates a request for the OutputService5TestCaseOperation1 operation.
-func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *aws.Request, output *OutputService5TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService5TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService5TestShapeOutputService5TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService5TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (*OutputService5TestShapeOutputShape, error) {
-	req, out := c.OutputService5TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService5TestShapeOutputService5TestCaseOperation1Input struct {
-	metadataOutputService5TestShapeOutputService5TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService5TestShapeOutputService5TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService5TestShapeOutputShape struct {
-	ListMember []*string `type:"list" flattened:"true"`
-
-	metadataOutputService5TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService5TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService6ProtocolTest client.
-func NewOutputService6ProtocolTest(config *aws.Config) *OutputService6ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice6protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService6ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService6ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService6ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService6TestCaseOperation1 = "OperationName"
-
-// OutputService6TestCaseOperation1Request generates a request for the OutputService6TestCaseOperation1 operation.
-func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *aws.Request, output *OutputService6TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService6TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService6TestShapeOutputService6TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService6TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (*OutputService6TestShapeOutputShape, error) {
-	req, out := c.OutputService6TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService6TestShapeOutputService6TestCaseOperation1Input struct {
-	metadataOutputService6TestShapeOutputService6TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeOutputService6TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6TestShapeOutputShape struct {
-	Map map[string]*OutputService6TestShapeStructureType `type:"map"`
-
-	metadataOutputService6TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService6TestShapeStructureType struct {
-	Foo *string `locationName:"foo" type:"string"`
-
-	metadataOutputService6TestShapeStructureType `json:"-" xml:"-"`
-}
-
-type metadataOutputService6TestShapeStructureType struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService7ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService7ProtocolTest client.
-func NewOutputService7ProtocolTest(config *aws.Config) *OutputService7ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice7protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService7ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService7ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService7ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService7TestCaseOperation1 = "OperationName"
-
-// OutputService7TestCaseOperation1Request generates a request for the OutputService7TestCaseOperation1 operation.
-func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *aws.Request, output *OutputService7TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService7TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService7TestShapeOutputService7TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService7TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (*OutputService7TestShapeOutputShape, error) {
-	req, out := c.OutputService7TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService7TestShapeOutputService7TestCaseOperation1Input struct {
-	metadataOutputService7TestShapeOutputService7TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService7TestShapeOutputService7TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService7TestShapeOutputShape struct {
-	Map map[string]*string `type:"map" flattened:"true"`
-
-	metadataOutputService7TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService7TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService8ProtocolTest struct {
-	*aws.Service
-}
-
-// New returns a new OutputService8ProtocolTest client.
-func NewOutputService8ProtocolTest(config *aws.Config) *OutputService8ProtocolTest {
-	service := &aws.Service{
-		Config:      aws.DefaultConfig.Merge(config),
-		ServiceName: "outputservice8protocoltest",
-		APIVersion:  "",
-	}
-	service.Initialize()
-
-	// Handlers
-	service.Handlers.Sign.PushBack(v4.Sign)
-	service.Handlers.Build.PushBack(ec2query.Build)
-	service.Handlers.Unmarshal.PushBack(ec2query.Unmarshal)
-	service.Handlers.UnmarshalMeta.PushBack(ec2query.UnmarshalMeta)
-	service.Handlers.UnmarshalError.PushBack(ec2query.UnmarshalError)
-
-	return &OutputService8ProtocolTest{service}
-}
-
-// newRequest creates a new request for a OutputService8ProtocolTest operation and runs any
-// custom request initialization.
-func (c *OutputService8ProtocolTest) newRequest(op *aws.Operation, params, data interface{}) *aws.Request {
-	req := aws.NewRequest(c.Service, op, params, data)
-
-	return req
-}
-
-const opOutputService8TestCaseOperation1 = "OperationName"
-
-// OutputService8TestCaseOperation1Request generates a request for the OutputService8TestCaseOperation1 operation.
-func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *aws.Request, output *OutputService8TestShapeOutputShape) {
-	op := &aws.Operation{
-		Name: opOutputService8TestCaseOperation1,
-	}
-
-	if input == nil {
-		input = &OutputService8TestShapeOutputService8TestCaseOperation1Input{}
-	}
-
-	req = c.newRequest(op, input, output)
-	output = &OutputService8TestShapeOutputShape{}
-	req.Data = output
-	return
-}
-
-func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (*OutputService8TestShapeOutputShape, error) {
-	req, out := c.OutputService8TestCaseOperation1Request(input)
-	err := req.Send()
-	return out, err
-}
-
-type OutputService8TestShapeOutputService8TestCaseOperation1Input struct {
-	metadataOutputService8TestShapeOutputService8TestCaseOperation1Input `json:"-" xml:"-"`
-}
-
-type metadataOutputService8TestShapeOutputService8TestCaseOperation1Input struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-type OutputService8TestShapeOutputShape struct {
-	Map map[string]*string `locationNameKey:"foo" locationNameValue:"bar" type:"map" flattened:"true"`
-
-	metadataOutputService8TestShapeOutputShape `json:"-" xml:"-"`
-}
-
-type metadataOutputService8TestShapeOutputShape struct {
-	SDKShapeTraits bool `type:"structure"`
-}
-
-//
-// Tests begin here
-//
-
-func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
-	svc := NewOutputService1ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Str>myname</Str><FooNum>123</FooNum><FalseBool>false</FalseBool><TrueBool>true</TrueBool><Float>1.2</Float><Double>1.3</Double><Long>200</Long><Char>a</Char><RequestId>request-id</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService1TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "a", *out.Char)
-	assert.Equal(t, 1.3, *out.Double)
-	assert.Equal(t, false, *out.FalseBool)
-	assert.Equal(t, 1.2, *out.Float)
-	assert.Equal(t, int64(200), *out.Long)
-	assert.Equal(t, int64(123), *out.Num)
-	assert.Equal(t, "myname", *out.Str)
-	assert.Equal(t, true, *out.TrueBool)
-
-}
-
-func TestOutputService2ProtocolTestBlobCase1(t *testing.T) {
-	svc := NewOutputService2ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Blob>dmFsdWU=</Blob><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService2TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "value", string(out.Blob))
-
-}
-
-func TestOutputService3ProtocolTestListsCase1(t *testing.T) {
-	svc := NewOutputService3ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember><member>abc</member><member>123</member></ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService3TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService4ProtocolTestListWithCustomMemberNameCase1(t *testing.T) {
-	svc := NewOutputService4ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember><item>abc</item><item>123</item></ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService4TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService5ProtocolTestFlattenedListCase1(t *testing.T) {
-	svc := NewOutputService5ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><ListMember>abc</ListMember><ListMember>123</ListMember><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService5TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "abc", *out.ListMember[0])
-	assert.Equal(t, "123", *out.ListMember[1])
-
-}
-
-func TestOutputService6ProtocolTestNormalMapCase1(t *testing.T) {
-	svc := NewOutputService6ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><entry><key>qux</key><value><foo>bar</foo></value></entry><entry><key>baz</key><value><foo>bam</foo></value></entry></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService6TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"].Foo)
-	assert.Equal(t, "bar", *out.Map["qux"].Foo)
-
-}
-
-func TestOutputService7ProtocolTestFlattenedMapCase1(t *testing.T) {
-	svc := NewOutputService7ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><key>qux</key><value>bar</value></Map><Map><key>baz</key><value>bam</value></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService7TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"])
-	assert.Equal(t, "bar", *out.Map["qux"])
-
-}
-
-func TestOutputService8ProtocolTestNamedMapCase1(t *testing.T) {
-	svc := NewOutputService8ProtocolTest(nil)
-
-	buf := bytes.NewReader([]byte("<OperationNameResponse><Map><foo>qux</foo><bar>bar</bar></Map><Map><foo>baz</foo><bar>bam</bar></Map><RequestId>requestid</RequestId></OperationNameResponse>"))
-	req, out := svc.OutputService8TestCaseOperation1Request(nil)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
-
-	// set headers
-
-	// unmarshal response
-	ec2query.UnmarshalMeta(req)
-	ec2query.Unmarshal(req)
-	assert.NoError(t, req.Error)
-
-	// assert response
-	assert.NotNil(t, out) // ensure out variable is used
-	assert.Equal(t, "bam", *out.Map["baz"])
-	assert.Equal(t, "bar", *out.Map["qux"])
-
-}
@@ -1,33 +0,0 @@
-// Package query provides serialisation of AWS query requests, and responses.
-package query
-
-//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/input/query.json build_test.go
-
-import (
-	"net/url"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/protocol/query/queryutil"
-)
-
-// Build builds a request for an AWS Query service.
-func Build(r *aws.Request) {
-	body := url.Values{
-		"Action":  {r.Operation.Name},
-		"Version": {r.Service.APIVersion},
-	}
-	if err := queryutil.Parse(body, r.Params, false); err != nil {
-		r.Error = awserr.New("SerializationError", "failed encoding Query request", err)
-		return
-	}
-
-	if r.ExpireTime == 0 {
-		r.HTTPRequest.Method = "POST"
-		r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8")
-		r.SetBufferBody([]byte(body.Encode()))
-	} else { // This is a pre-signed request
-		r.HTTPRequest.Method = "GET"
-		r.HTTPRequest.URL.RawQuery = body.Encode()
-	}
-}
@@ -1,223 +0,0 @@
-package queryutil
-
-import (
-	"encoding/base64"
-	"fmt"
-	"net/url"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Parse parses an object i and fills a url.Values object. The isEC2 flag
-// indicates if this is the EC2 Query sub-protocol.
-func Parse(body url.Values, i interface{}, isEC2 bool) error {
-	q := queryParser{isEC2: isEC2}
-	return q.parseValue(body, reflect.ValueOf(i), "", "")
-}
-
-func elemOf(value reflect.Value) reflect.Value {
-	for value.Kind() == reflect.Ptr {
-		value = value.Elem()
-	}
-	return value
-}
-
-type queryParser struct {
-	isEC2 bool
-}
-
-func (q *queryParser) parseValue(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
-	value = elemOf(value)
-
-	// no need to handle zero values
-	if !value.IsValid() {
-		return nil
-	}
-
-	t := tag.Get("type")
-	if t == "" {
-		switch value.Kind() {
-		case reflect.Struct:
-			t = "structure"
-		case reflect.Slice:
-			t = "list"
-		case reflect.Map:
-			t = "map"
-		}
-	}
-
-	switch t {
-	case "structure":
-		return q.parseStruct(v, value, prefix)
-	case "list":
-		return q.parseList(v, value, prefix, tag)
-	case "map":
-		return q.parseMap(v, value, prefix, tag)
-	default:
-		return q.parseScalar(v, value, prefix, tag)
-	}
-}
-
-func (q *queryParser) parseStruct(v url.Values, value reflect.Value, prefix string) error {
-	if !value.IsValid() {
-		return nil
-	}
-
-	t := value.Type()
-	for i := 0; i < value.NumField(); i++ {
-		if c := t.Field(i).Name[0:1]; strings.ToLower(c) == c {
-			continue // ignore unexported fields
-		}
-
-		value := elemOf(value.Field(i))
-		field := t.Field(i)
-		var name string
-
-		if q.isEC2 {
-			name = field.Tag.Get("queryName")
-		}
-		if name == "" {
-			if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
-				name = field.Tag.Get("locationNameList")
-			} else if locName := field.Tag.Get("locationName"); locName != "" {
-				name = locName
-			}
-			if name != "" && q.isEC2 {
-				name = strings.ToUpper(name[0:1]) + name[1:]
-			}
-		}
-		if name == "" {
-			name = field.Name
-		}
-
-		if prefix != "" {
-			name = prefix + "." + name
-		}
-
-		if err := q.parseValue(v, value, name, field.Tag); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (q *queryParser) parseList(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
-	// If it's empty, generate an empty value
-	if !value.IsNil() && value.Len() == 0 {
-		v.Set(prefix, "")
-		return nil
-	}
-
-	// check for unflattened list member
-	if !q.isEC2 && tag.Get("flattened") == "" {
-		prefix += ".member"
-	}
-
-	for i := 0; i < value.Len(); i++ {
-		slicePrefix := prefix
-		if slicePrefix == "" {
-			slicePrefix = strconv.Itoa(i + 1)
-		} else {
-			slicePrefix = slicePrefix + "." + strconv.Itoa(i+1)
-		}
-		if err := q.parseValue(v, value.Index(i), slicePrefix, ""); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (q *queryParser) parseMap(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
-	// If it's empty, generate an empty value
-	if !value.IsNil() && value.Len() == 0 {
-		v.Set(prefix, "")
-		return nil
-	}
-
-	// check for unflattened list member
-	if !q.isEC2 && tag.Get("flattened") == "" {
-		prefix += ".entry"
-	}
-
-	// sort keys for improved serialization consistency.
-	// this is not strictly necessary for protocol support.
-	mapKeyValues := value.MapKeys()
-	mapKeys := map[string]reflect.Value{}
-	mapKeyNames := make([]string, len(mapKeyValues))
-	for i, mapKey := range mapKeyValues {
-		name := mapKey.String()
-		mapKeys[name] = mapKey
-		mapKeyNames[i] = name
-	}
-	sort.Strings(mapKeyNames)
-
-	for i, mapKeyName := range mapKeyNames {
-		mapKey := mapKeys[mapKeyName]
-		mapValue := value.MapIndex(mapKey)
-
-		kname := tag.Get("locationNameKey")
-		if kname == "" {
-			kname = "key"
-		}
-		vname := tag.Get("locationNameValue")
-		if vname == "" {
-			vname = "value"
-		}
-
-		// serialize key
-		var keyName string
-		if prefix == "" {
-			keyName = strconv.Itoa(i+1) + "." + kname
-		} else {
-			keyName = prefix + "." + strconv.Itoa(i+1) + "." + kname
-		}
-
-		if err := q.parseValue(v, mapKey, keyName, ""); err != nil {
-			return err
-		}
-
-		// serialize value
-		var valueName string
-		if prefix == "" {
-			valueName = strconv.Itoa(i+1) + "." + vname
-		} else {
-			valueName = prefix + "." + strconv.Itoa(i+1) + "." + vname
-		}
-
-		if err := q.parseValue(v, mapValue, valueName, ""); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (q *queryParser) parseScalar(v url.Values, r reflect.Value, name string, tag reflect.StructTag) error {
-	switch value := r.Interface().(type) {
-	case string:
-		v.Set(name, value)
-	case []byte:
-		if !r.IsNil() {
-			v.Set(name, base64.StdEncoding.EncodeToString(value))
-		}
-	case bool:
-		v.Set(name, strconv.FormatBool(value))
-	case int64:
-		v.Set(name, strconv.FormatInt(value, 10))
-	case int:
-		v.Set(name, strconv.Itoa(value))
-	case float64:
-		v.Set(name, strconv.FormatFloat(value, 'f', -1, 64))
-	case float32:
-		v.Set(name, strconv.FormatFloat(float64(value), 'f', -1, 32))
-	case time.Time:
-		const ISO8601UTC = "2006-01-02T15:04:05Z"
-		v.Set(name, value.UTC().Format(ISO8601UTC))
-	default:
-		return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name())
-	}
-	return nil
-}
@@ -1,29 +0,0 @@
-package query
-
-//go:generate go run ../../fixtures/protocol/generate.go ../../fixtures/protocol/output/query.json unmarshal_test.go
-
-import (
-	"encoding/xml"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil"
-)
-
-// Unmarshal unmarshals a response for an AWS Query service.
-func Unmarshal(r *aws.Request) {
-	defer r.HTTPResponse.Body.Close()
-	if r.DataFilled() {
-		decoder := xml.NewDecoder(r.HTTPResponse.Body)
-		err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result")
-		if err != nil {
-			r.Error = awserr.New("SerializationError", "failed decoding Query response", err)
-			return
-		}
-	}
-}
-
-// UnmarshalMeta unmarshals header response values for an AWS Query service.
-func UnmarshalMeta(r *aws.Request) {
-	// TODO implement unmarshaling of request IDs
-}
@@ -1,33 +0,0 @@
-package query
-
-import (
-	"encoding/xml"
-	"io"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-type xmlErrorResponse struct {
-	XMLName   xml.Name `xml:"ErrorResponse"`
-	Code      string   `xml:"Error>Code"`
-	Message   string   `xml:"Error>Message"`
-	RequestID string   `xml:"RequestId"`
-}
-
-// UnmarshalError unmarshals an error response for an AWS Query service.
-func UnmarshalError(r *aws.Request) {
-	defer r.HTTPResponse.Body.Close()
-
-	resp := &xmlErrorResponse{}
-	err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
-	if err != nil && err != io.EOF {
-		r.Error = awserr.New("SerializationError", "failed to decode query XML error response", err)
-	} else {
-		r.Error = awserr.NewRequestFailure(
-			awserr.New(resp.Code, resp.Message, nil),
-			r.HTTPResponse.StatusCode,
-			resp.RequestID,
-		)
-	}
-}
@@ -1,217 +0,0 @@
-// Package rest provides RESTful serialisation of AWS requests and responses.
-package rest
-
-import (
-	"bytes"
-	"encoding/base64"
-	"fmt"
-	"io"
-	"net/url"
-	"path"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-// RFC822 returns an RFC822 formatted timestamp for AWS protocols
-const RFC822 = "Mon, 2 Jan 2006 15:04:05 GMT"
-
-// Whether the byte value can be sent without escaping in AWS URLs
-var noEscape [256]bool
-
-func init() {
-	for i := 0; i < len(noEscape); i++ {
-		// AWS expects every character except these to be escaped
-		noEscape[i] = (i >= 'A' && i <= 'Z') ||
-			(i >= 'a' && i <= 'z') ||
-			(i >= '0' && i <= '9') ||
-			i == '-' ||
-			i == '.' ||
-			i == '_' ||
-			i == '~'
-	}
-}
-
-// Build builds the REST component of a service request.
-func Build(r *aws.Request) {
-	if r.ParamsFilled() {
-		v := reflect.ValueOf(r.Params).Elem()
-		buildLocationElements(r, v)
-		buildBody(r, v)
-	}
-}
-
-func buildLocationElements(r *aws.Request, v reflect.Value) {
-	query := r.HTTPRequest.URL.Query()
-
-	for i := 0; i < v.NumField(); i++ {
-		m := v.Field(i)
-		if n := v.Type().Field(i).Name; n[0:1] == strings.ToLower(n[0:1]) {
-			continue
-		}
-
-		if m.IsValid() {
-			field := v.Type().Field(i)
-			name := field.Tag.Get("locationName")
-			if name == "" {
-				name = field.Name
-			}
-			if m.Kind() == reflect.Ptr {
-				m = m.Elem()
-			}
-			if !m.IsValid() {
-				continue
-			}
-
-			switch field.Tag.Get("location") {
-			case "headers": // header maps
-				buildHeaderMap(r, m, field.Tag.Get("locationName"))
-			case "header":
-				buildHeader(r, m, name)
-			case "uri":
-				buildURI(r, m, name)
-			case "querystring":
-				buildQueryString(r, m, name, query)
-			}
-		}
-		if r.Error != nil {
-			return
-		}
-	}
-
-	r.HTTPRequest.URL.RawQuery = query.Encode()
-	updatePath(r.HTTPRequest.URL, r.HTTPRequest.URL.Path)
-}
-
-func buildBody(r *aws.Request, v reflect.Value) {
-	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
-		if payloadName := field.Tag.Get("payload"); payloadName != "" {
-			pfield, _ := v.Type().FieldByName(payloadName)
-			if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {
-				payload := reflect.Indirect(v.FieldByName(payloadName))
-				if payload.IsValid() && payload.Interface() != nil {
-					switch reader := payload.Interface().(type) {
-					case io.ReadSeeker:
-						r.SetReaderBody(reader)
-					case []byte:
-						r.SetBufferBody(reader)
-					case string:
-						r.SetStringBody(reader)
-					default:
-						r.Error = awserr.New("SerializationError",
-							"failed to encode REST request",
-							fmt.Errorf("unknown payload type %s", payload.Type()))
-					}
-				}
-			}
-		}
-	}
-}
-
-func buildHeader(r *aws.Request, v reflect.Value, name string) {
-	str, err := convertType(v)
-	if err != nil {
-		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
-	} else if str != nil {
-		r.HTTPRequest.Header.Add(name, *str)
-	}
-}
-
-func buildHeaderMap(r *aws.Request, v reflect.Value, prefix string) {
-	for _, key := range v.MapKeys() {
-		str, err := convertType(v.MapIndex(key))
-		if err != nil {
-			r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
-		} else if str != nil {
-			r.HTTPRequest.Header.Add(prefix+key.String(), *str)
-		}
-	}
-}
-
-func buildURI(r *aws.Request, v reflect.Value, name string) {
-	value, err := convertType(v)
-	if err != nil {
-		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
-	} else if value != nil {
-		uri := r.HTTPRequest.URL.Path
-		uri = strings.Replace(uri, "{"+name+"}", EscapePath(*value, true), -1)
-		uri = strings.Replace(uri, "{"+name+"+}", EscapePath(*value, false), -1)
-		r.HTTPRequest.URL.Path = uri
-	}
-}
-
-func buildQueryString(r *aws.Request, v reflect.Value, name string, query url.Values) {
-	str, err := convertType(v)
-	if err != nil {
-		r.Error = awserr.New("SerializationError", "failed to encode REST request", err)
-	} else if str != nil {
-		query.Set(name, *str)
-	}
-}
-
-func updatePath(url *url.URL, urlPath string) {
-	scheme, query := url.Scheme, url.RawQuery
-
-	hasSlash := strings.HasSuffix(urlPath, "/")
-
-	// clean up path
-	urlPath = path.Clean(urlPath)
-	if hasSlash && !strings.HasSuffix(urlPath, "/") {
-		urlPath += "/"
-	}
-
-	// get formatted URL minus scheme so we can build this into Opaque
-	url.Scheme, url.Path, url.RawQuery = "", "", ""
-	s := url.String()
-	url.Scheme = scheme
-	url.RawQuery = query
-
-	// build opaque URI
-	url.Opaque = s + urlPath
-}
-
-// EscapePath escapes part of a URL path in Amazon style
-func EscapePath(path string, encodeSep bool) string {
-	var buf bytes.Buffer
-	for i := 0; i < len(path); i++ {
-		c := path[i]
-		if noEscape[c] || (c == '/' && !encodeSep) {
-			buf.WriteByte(c)
-		} else {
-			buf.WriteByte('%')
-			buf.WriteString(strings.ToUpper(strconv.FormatUint(uint64(c), 16)))
-		}
-	}
-	return buf.String()
-}
-
-func convertType(v reflect.Value) (*string, error) {
-	v = reflect.Indirect(v)
-	if !v.IsValid() {
-		return nil, nil
-	}
-
-	var str string
-	switch value := v.Interface().(type) {
-	case string:
-		str = value
-	case []byte:
-		str = base64.StdEncoding.EncodeToString(value)
-	case bool:
-		str = strconv.FormatBool(value)
-	case int64:
-		str = strconv.FormatInt(value, 10)
-	case float64:
-		str = strconv.FormatFloat(value, 'f', -1, 64)
-	case time.Time:
-		str = value.UTC().Format(RFC822)
-	default:
-		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
-		return nil, err
-	}
-	return &str, nil
-}
@@ -1,174 +0,0 @@
-package rest
-
-import (
-	"encoding/base64"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awserr"
-)
-
-// Unmarshal unmarshals the REST component of a response in a REST service.
-func Unmarshal(r *aws.Request) {
-	if r.DataFilled() {
-		v := reflect.Indirect(reflect.ValueOf(r.Data))
-		unmarshalBody(r, v)
-		unmarshalLocationElements(r, v)
-	}
-}
-
-func unmarshalBody(r *aws.Request, v reflect.Value) {
-	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
-		if payloadName := field.Tag.Get("payload"); payloadName != "" {
-			pfield, _ := v.Type().FieldByName(payloadName)
-			if ptag := pfield.Tag.Get("type"); ptag != "" && ptag != "structure" {
-				payload := v.FieldByName(payloadName)
-				if payload.IsValid() {
-					switch payload.Interface().(type) {
-					case []byte:
-						b, err := ioutil.ReadAll(r.HTTPResponse.Body)
-						if err != nil {
-							r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
-						} else {
-							payload.Set(reflect.ValueOf(b))
-						}
-					case *string:
-						b, err := ioutil.ReadAll(r.HTTPResponse.Body)
-						if err != nil {
-							r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
-						} else {
-							str := string(b)
-							payload.Set(reflect.ValueOf(&str))
-						}
-					default:
-						switch payload.Type().String() {
-						case "io.ReadSeeker":
-							payload.Set(reflect.ValueOf(aws.ReadSeekCloser(r.HTTPResponse.Body)))
-						case "aws.ReadSeekCloser", "io.ReadCloser":
-							payload.Set(reflect.ValueOf(r.HTTPResponse.Body))
-						default:
-							r.Error = awserr.New("SerializationError",
-								"failed to decode REST response",
-								fmt.Errorf("unknown payload type %s", payload.Type()))
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-func unmarshalLocationElements(r *aws.Request, v reflect.Value) {
-	for i := 0; i < v.NumField(); i++ {
-		m, field := v.Field(i), v.Type().Field(i)
-		if n := field.Name; n[0:1] == strings.ToLower(n[0:1]) {
-			continue
-		}
-
-		if m.IsValid() {
-			name := field.Tag.Get("locationName")
-			if name == "" {
-				name = field.Name
-			}
-
-			switch field.Tag.Get("location") {
-			case "statusCode":
-				unmarshalStatusCode(m, r.HTTPResponse.StatusCode)
-			case "header":
-				err := unmarshalHeader(m, r.HTTPResponse.Header.Get(name))
-				if err != nil {
-					r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
-					break
-				}
-			case "headers":
-				prefix := field.Tag.Get("locationName")
-				err := unmarshalHeaderMap(m, r.HTTPResponse.Header, prefix)
-				if err != nil {
-					r.Error = awserr.New("SerializationError", "failed to decode REST response", err)
-					break
-				}
-			}
-		}
-		if r.Error != nil {
-			return
-		}
-	}
-}
-
-func unmarshalStatusCode(v reflect.Value, statusCode int) {
-	if !v.IsValid() {
-		return
-	}
-
-	switch v.Interface().(type) {
-	case *int64:
-		s := int64(statusCode)
-		v.Set(reflect.ValueOf(&s))
-	}
-}
-
-func unmarshalHeaderMap(r reflect.Value, headers http.Header, prefix string) error {
-	switch r.Interface().(type) {
-	case map[string]*string: // we only support string map value types
-		out := map[string]*string{}
-		for k, v := range headers {
-			k = http.CanonicalHeaderKey(k)
-			if strings.HasPrefix(strings.ToLower(k), strings.ToLower(prefix)) {
-				out[k[len(prefix):]] = &v[0]
-			}
-		}
-		r.Set(reflect.ValueOf(out))
-	}
-	return nil
-}
-
-func unmarshalHeader(v reflect.Value, header string) error {
-	if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {
-		return nil
-	}
-
-	switch v.Interface().(type) {
-	case *string:
-		v.Set(reflect.ValueOf(&header))
-	case []byte:
-		b, err := base64.StdEncoding.DecodeString(header)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&b))
-	case *bool:
-		b, err := strconv.ParseBool(header)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&b))
-	case *int64:
-		i, err := strconv.ParseInt(header, 10, 64)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&i))
-	case *float64:
-		f, err := strconv.ParseFloat(header, 64)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&f))
-	case *time.Time:
-		t, err := time.Parse(RFC822, header)
-		if err != nil {
-			return err
-		}
-		v.Set(reflect.ValueOf(&t))
-	default:
-		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
-		return err
-	}
-	return nil
-}
@@ -1,43 +0,0 @@
-package v4_test
-
-import (
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/internal/test/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-	"github.com/stretchr/testify/assert"
-)
-
-var _ = unit.Imported
-
-func TestPresignHandler(t *testing.T) {
-	svc := s3.New(nil)
-	req, _ := svc.PutObjectRequest(&s3.PutObjectInput{
-		Bucket:             aws.String("bucket"),
-		Key:                aws.String("key"),
-		ContentDisposition: aws.String("a+b c$d"),
-		ACL:                aws.String("public-read"),
-	})
-	req.Time = time.Unix(0, 0)
-	urlstr, err := req.Presign(5 * time.Minute)
-
-	assert.NoError(t, err)
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-acl"
-	expectedSig := "7edcb4e3a1bf12f4989018d75acbe3a7f03df24bd6f3112602d59fc551f0e4e2"
-	expectedCred := "AKID/19700101/mock-region/s3/aws4_request"
-
-	u, _ := url.Parse(urlstr)
-	urlQ := u.Query()
-	assert.Equal(t, expectedSig, urlQ.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, urlQ.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, urlQ.Get("X-Amz-Date"))
-	assert.Equal(t, "300", urlQ.Get("X-Amz-Expires"))
-
-	assert.NotContains(t, urlstr, "+") // + encoded as %20
-}
@@ -1,364 +0,0 @@
-// Package v4 implements signing for AWS V4 signer
-package v4
-
-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/internal/protocol/rest"
-)
-
-const (
-	authHeaderPrefix = "AWS4-HMAC-SHA256"
-	timeFormat       = "20060102T150405Z"
-	shortTimeFormat  = "20060102"
-)
-
-var ignoredHeaders = map[string]bool{
-	"Authorization":  true,
-	"Content-Type":   true,
-	"Content-Length": true,
-	"User-Agent":     true,
-}
-
-type signer struct {
-	Request     *http.Request
-	Time        time.Time
-	ExpireTime  time.Duration
-	ServiceName string
-	Region      string
-	CredValues  credentials.Value
-	Credentials *credentials.Credentials
-	Query       url.Values
-	Body        io.ReadSeeker
-	Debug       aws.LogLevelType
-	Logger      aws.Logger
-
-	isPresign          bool
-	formattedTime      string
-	formattedShortTime string
-
-	signedHeaders    string
-	canonicalHeaders string
-	canonicalString  string
-	credentialString string
-	stringToSign     string
-	signature        string
-	authorization    string
-}
-
-// Sign requests with signature version 4.
-//
-// Will sign the requests with the service config's Credentials object
-// Signing is skipped if the credentials is the credentials.AnonymousCredentials
-// object.
-func Sign(req *aws.Request) {
-	// If the request does not need to be signed ignore the signing of the
-	// request if the AnonymousCredentials object is used.
-	if req.Service.Config.Credentials == credentials.AnonymousCredentials {
-		return
-	}
-
-	region := req.Service.SigningRegion
-	if region == "" {
-		region = aws.StringValue(req.Service.Config.Region)
-	}
-
-	name := req.Service.SigningName
-	if name == "" {
-		name = req.Service.ServiceName
-	}
-
-	s := signer{
-		Request:     req.HTTPRequest,
-		Time:        req.Time,
-		ExpireTime:  req.ExpireTime,
-		Query:       req.HTTPRequest.URL.Query(),
-		Body:        req.Body,
-		ServiceName: name,
-		Region:      region,
-		Credentials: req.Service.Config.Credentials,
-		Debug:       req.Service.Config.LogLevel.Value(),
-		Logger:      req.Service.Config.Logger,
-	}
-
-	req.Error = s.sign()
-}
-
-func (v4 *signer) sign() error {
-	if v4.ExpireTime != 0 {
-		v4.isPresign = true
-	}
-
-	if v4.isRequestSigned() {
-		if !v4.Credentials.IsExpired() {
-			// If the request is already signed, and the credentials have not
-			// expired yet ignore the signing request.
-			return nil
-		}
-
-		// The credentials have expired for this request. The current signing
-		// is invalid, and needs to be request because the request will fail.
-		if v4.isPresign {
-			v4.removePresign()
-			// Update the request's query string to ensure the values stays in
-			// sync in the case retrieving the new credentials fails.
-			v4.Request.URL.RawQuery = v4.Query.Encode()
-		}
-	}
-
-	var err error
-	v4.CredValues, err = v4.Credentials.Get()
-	if err != nil {
-		return err
-	}
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-Algorithm", authHeaderPrefix)
-		if v4.CredValues.SessionToken != "" {
-			v4.Query.Set("X-Amz-Security-Token", v4.CredValues.SessionToken)
-		} else {
-			v4.Query.Del("X-Amz-Security-Token")
-		}
-	} else if v4.CredValues.SessionToken != "" {
-		v4.Request.Header.Set("X-Amz-Security-Token", v4.CredValues.SessionToken)
-	}
-
-	v4.build()
-
-	if v4.Debug.Matches(aws.LogDebugWithSigning) {
-		v4.logSigningInfo()
-	}
-
-	return nil
-}
-
-const logSignInfoMsg = `DEBUG: Request Signiture:
---[ CANONICAL STRING  ]-----------------------------
-%s
---[ STRING TO SIGN ]--------------------------------
-%s%s
-----------------------------------------------------`
-const logSignedURLMsg = `
---[ SIGNED URL ]------------------------------------
-%s`
-
-func (v4 *signer) logSigningInfo() {
-	signedURLMsg := ""
-	if v4.isPresign {
-		signedURLMsg = fmt.Sprintf(logSignedURLMsg, v4.Request.URL.String())
-	}
-	msg := fmt.Sprintf(logSignInfoMsg, v4.canonicalString, v4.stringToSign, signedURLMsg)
-	v4.Logger.Log(msg)
-}
-
-func (v4 *signer) build() {
-	v4.buildTime()             // no depends
-	v4.buildCredentialString() // no depends
-	if v4.isPresign {
-		v4.buildQuery() // no depends
-	}
-	v4.buildCanonicalHeaders() // depends on cred string
-	v4.buildCanonicalString()  // depends on canon headers / signed headers
-	v4.buildStringToSign()     // depends on canon string
-	v4.buildSignature()        // depends on string to sign
-
-	if v4.isPresign {
-		v4.Request.URL.RawQuery += "&X-Amz-Signature=" + v4.signature
-	} else {
-		parts := []string{
-			authHeaderPrefix + " Credential=" + v4.CredValues.AccessKeyID + "/" + v4.credentialString,
-			"SignedHeaders=" + v4.signedHeaders,
-			"Signature=" + v4.signature,
-		}
-		v4.Request.Header.Set("Authorization", strings.Join(parts, ", "))
-	}
-}
-
-func (v4 *signer) buildTime() {
-	v4.formattedTime = v4.Time.UTC().Format(timeFormat)
-	v4.formattedShortTime = v4.Time.UTC().Format(shortTimeFormat)
-
-	if v4.isPresign {
-		duration := int64(v4.ExpireTime / time.Second)
-		v4.Query.Set("X-Amz-Date", v4.formattedTime)
-		v4.Query.Set("X-Amz-Expires", strconv.FormatInt(duration, 10))
-	} else {
-		v4.Request.Header.Set("X-Amz-Date", v4.formattedTime)
-	}
-}
-
-func (v4 *signer) buildCredentialString() {
-	v4.credentialString = strings.Join([]string{
-		v4.formattedShortTime,
-		v4.Region,
-		v4.ServiceName,
-		"aws4_request",
-	}, "/")
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-Credential", v4.CredValues.AccessKeyID+"/"+v4.credentialString)
-	}
-}
-
-func (v4 *signer) buildQuery() {
-	for k, h := range v4.Request.Header {
-		if strings.HasPrefix(http.CanonicalHeaderKey(k), "X-Amz-") {
-			continue // never hoist x-amz-* headers, they must be signed
-		}
-		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
-			continue // never hoist ignored headers
-		}
-
-		v4.Request.Header.Del(k)
-		v4.Query.Del(k)
-		for _, v := range h {
-			v4.Query.Add(k, v)
-		}
-	}
-}
-
-func (v4 *signer) buildCanonicalHeaders() {
-	var headers []string
-	headers = append(headers, "host")
-	for k := range v4.Request.Header {
-		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
-			continue // ignored header
-		}
-		headers = append(headers, strings.ToLower(k))
-	}
-	sort.Strings(headers)
-
-	v4.signedHeaders = strings.Join(headers, ";")
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-SignedHeaders", v4.signedHeaders)
-	}
-
-	headerValues := make([]string, len(headers))
-	for i, k := range headers {
-		if k == "host" {
-			headerValues[i] = "host:" + v4.Request.URL.Host
-		} else {
-			headerValues[i] = k + ":" +
-				strings.Join(v4.Request.Header[http.CanonicalHeaderKey(k)], ",")
-		}
-	}
-
-	v4.canonicalHeaders = strings.Join(headerValues, "\n")
-}
-
-func (v4 *signer) buildCanonicalString() {
-	v4.Request.URL.RawQuery = strings.Replace(v4.Query.Encode(), "+", "%20", -1)
-	uri := v4.Request.URL.Opaque
-	if uri != "" {
-		uri = "/" + strings.Join(strings.Split(uri, "/")[3:], "/")
-	} else {
-		uri = v4.Request.URL.Path
-	}
-	if uri == "" {
-		uri = "/"
-	}
-
-	if v4.ServiceName != "s3" {
-		uri = rest.EscapePath(uri, false)
-	}
-
-	v4.canonicalString = strings.Join([]string{
-		v4.Request.Method,
-		uri,
-		v4.Request.URL.RawQuery,
-		v4.canonicalHeaders + "\n",
-		v4.signedHeaders,
-		v4.bodyDigest(),
-	}, "\n")
-}
-
-func (v4 *signer) buildStringToSign() {
-	v4.stringToSign = strings.Join([]string{
-		authHeaderPrefix,
-		v4.formattedTime,
-		v4.credentialString,
-		hex.EncodeToString(makeSha256([]byte(v4.canonicalString))),
-	}, "\n")
-}
-
-func (v4 *signer) buildSignature() {
-	secret := v4.CredValues.SecretAccessKey
-	date := makeHmac([]byte("AWS4"+secret), []byte(v4.formattedShortTime))
-	region := makeHmac(date, []byte(v4.Region))
-	service := makeHmac(region, []byte(v4.ServiceName))
-	credentials := makeHmac(service, []byte("aws4_request"))
-	signature := makeHmac(credentials, []byte(v4.stringToSign))
-	v4.signature = hex.EncodeToString(signature)
-}
-
-func (v4 *signer) bodyDigest() string {
-	hash := v4.Request.Header.Get("X-Amz-Content-Sha256")
-	if hash == "" {
-		if v4.isPresign && v4.ServiceName == "s3" {
-			hash = "UNSIGNED-PAYLOAD"
-		} else if v4.Body == nil {
-			hash = hex.EncodeToString(makeSha256([]byte{}))
-		} else {
-			hash = hex.EncodeToString(makeSha256Reader(v4.Body))
-		}
-		v4.Request.Header.Add("X-Amz-Content-Sha256", hash)
-	}
-	return hash
-}
-
-// isRequestSigned returns if the request is currently signed or presigned
-func (v4 *signer) isRequestSigned() bool {
-	if v4.isPresign && v4.Query.Get("X-Amz-Signature") != "" {
-		return true
-	}
-	if v4.Request.Header.Get("Authorization") != "" {
-		return true
-	}
-
-	return false
-}
-
-// unsign removes signing flags for both signed and presigned requests.
-func (v4 *signer) removePresign() {
-	v4.Query.Del("X-Amz-Algorithm")
-	v4.Query.Del("X-Amz-Signature")
-	v4.Query.Del("X-Amz-Security-Token")
-	v4.Query.Del("X-Amz-Date")
-	v4.Query.Del("X-Amz-Expires")
-	v4.Query.Del("X-Amz-Credential")
-	v4.Query.Del("X-Amz-SignedHeaders")
-}
-
-func makeHmac(key []byte, data []byte) []byte {
-	hash := hmac.New(sha256.New, key)
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-func makeSha256(data []byte) []byte {
-	hash := sha256.New()
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-func makeSha256Reader(reader io.ReadSeeker) []byte {
-	hash := sha256.New()
-	start, _ := reader.Seek(0, 1)
-	defer reader.Seek(start, 0)
-
-	io.Copy(hash, reader)
-	return hash.Sum(nil)
-}
@@ -1,245 +0,0 @@
-package v4
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/stretchr/testify/assert"
-)
-
-func buildSigner(serviceName string, region string, signTime time.Time, expireTime time.Duration, body string) signer {
-	endpoint := "https://" + serviceName + "." + region + ".amazonaws.com"
-	reader := strings.NewReader(body)
-	req, _ := http.NewRequest("POST", endpoint, reader)
-	req.URL.Opaque = "//example.org/bucket/key-._~,!@#$%^&*()"
-	req.Header.Add("X-Amz-Target", "prefix.Operation")
-	req.Header.Add("Content-Type", "application/x-amz-json-1.0")
-	req.Header.Add("Content-Length", string(len(body)))
-	req.Header.Add("X-Amz-Meta-Other-Header", "some-value=!@#$%^&* (+)")
-
-	return signer{
-		Request:     req,
-		Time:        signTime,
-		ExpireTime:  expireTime,
-		Query:       req.URL.Query(),
-		Body:        reader,
-		ServiceName: serviceName,
-		Region:      region,
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-	}
-}
-
-func removeWS(text string) string {
-	text = strings.Replace(text, " ", "", -1)
-	text = strings.Replace(text, "\n", "", -1)
-	text = strings.Replace(text, "\t", "", -1)
-	return text
-}
-
-func assertEqual(t *testing.T, expected, given string) {
-	if removeWS(expected) != removeWS(given) {
-		t.Errorf("\nExpected: %s\nGiven:    %s", expected, given)
-	}
-}
-
-func TestPresignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 300*time.Second, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-meta-other-header;x-amz-target"
-	expectedSig := "5eeedebf6f995145ce56daa02902d10485246d3defb34f97b973c1f40ab82d36"
-	expectedCred := "AKID/19700101/us-east-1/dynamodb/aws4_request"
-
-	q := signer.Request.URL.Query()
-	assert.Equal(t, expectedSig, q.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, q.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, q.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 0, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedSig := "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/dynamodb/aws4_request, SignedHeaders=host;x-amz-date;x-amz-meta-other-header;x-amz-security-token;x-amz-target, Signature=69ada33fec48180dab153576e4dd80c4e04124f80dda3eccfed8a67c2b91ed5e"
-
-	q := signer.Request.Header
-	assert.Equal(t, expectedSig, q.Get("Authorization"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignEmptyBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "")
-	signer.Body = nil
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hash)
-}
-
-func TestSignBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-}
-
-func TestSignSeekedBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "   hello")
-	signer.Body.Read(make([]byte, 3)) // consume first 3 bytes so body is now "hello"
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-
-	start, _ := signer.Body.Seek(0, 1)
-	assert.Equal(t, int64(3), start)
-}
-
-func TestPresignEmptyBodyS3(t *testing.T) {
-	signer := buildSigner("s3", "us-east-1", time.Now(), 5*time.Minute, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "UNSIGNED-PAYLOAD", hash)
-}
-
-func TestSignPrecomputedBodyChecksum(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.Request.Header.Set("X-Amz-Content-Sha256", "PRECOMPUTED")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "PRECOMPUTED", hash)
-}
-
-func TestAnonymousCredentials(t *testing.T) {
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{Credentials: credentials.AnonymousCredentials}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-
-	urlQ := r.HTTPRequest.URL.Query()
-	assert.Empty(t, urlQ.Get("X-Amz-Signature"))
-	assert.Empty(t, urlQ.Get("X-Amz-Credential"))
-	assert.Empty(t, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Empty(t, urlQ.Get("X-Amz-Date"))
-
-	hQ := r.HTTPRequest.Header
-	assert.Empty(t, hQ.Get("Authorization"))
-	assert.Empty(t, hQ.Get("X-Amz-Date"))
-}
-
-func TestIgnoreResignRequestWithValidCreds(t *testing.T) {
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{
-			Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-			Region:      aws.String("us-west-2"),
-		}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("Authorization")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestIgnorePreResignRequestWithValidCreds(t *testing.T) {
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{
-			Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-			Region:      aws.String("us-west-2"),
-		}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("X-Amz-Signature")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("X-Amz-Signature"))
-}
-
-func TestResignRequestExpiredCreds(t *testing.T) {
-	creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION")
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{Credentials: creds}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-	querySig := r.HTTPRequest.Header.Get("Authorization")
-
-	creds.Expire()
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestPreResignRequestExpiredCreds(t *testing.T) {
-	provider := &credentials.StaticProvider{credentials.Value{"AKID", "SECRET", "SESSION"}}
-	creds := credentials.NewCredentials(provider)
-	r := aws.NewRequest(
-		aws.NewService(&aws.Config{Credentials: creds}),
-		&aws.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	querySig := r.HTTPRequest.URL.Query().Get("X-Amz-Signature")
-
-	creds.Expire()
-	r.Time = time.Now().Add(time.Hour * 48)
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.URL.Query().Get("X-Amz-Signature"))
-}
-
-func BenchmarkPresignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 300*time.Second, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
-
-func BenchmarkSignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
@@ -1,89 +0,0 @@
-{
-  "version": 2,
-  "endpoints": {
-    "*/*": {
-      "endpoint": "{service}.{region}.amazonaws.com"
-    },
-    "cn-north-1/*": {
-      "endpoint": "{service}.{region}.amazonaws.com.cn",
-      "signatureVersion": "v4"
-    },
-    "us-gov-west-1/iam": {
-      "endpoint": "iam.us-gov.amazonaws.com"
-    },
-    "us-gov-west-1/sts": {
-      "endpoint": "sts.us-gov-west-1.amazonaws.com"
-    },
-    "us-gov-west-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "*/cloudfront": {
-      "endpoint": "cloudfront.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/cloudsearchdomain": {
-      "endpoint": "",
-      "signingRegion": "us-east-1"
-    },
-    "*/data.iot": {
-      "endpoint": "",
-      "signingRegion": "us-east-1"
-    },
-    "*/ec2metadata": {
-      "endpoint": "http://169.254.169.254/latest",
-      "signingRegion": "us-east-1"
-    },
-    "*/iam": {
-      "endpoint": "iam.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/importexport": {
-      "endpoint": "importexport.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/route53": {
-      "endpoint": "route53.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/sts": {
-      "endpoint": "sts.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "*/waf": {
-      "endpoint": "waf.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "us-east-1/sdb": {
-      "endpoint": "sdb.amazonaws.com",
-      "signingRegion": "us-east-1"
-    },
-    "us-east-1/s3": {
-      "endpoint": "s3.amazonaws.com"
-    },
-    "us-west-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "us-west-2/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "eu-west-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "ap-southeast-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "ap-southeast-2/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "ap-northeast-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "sa-east-1/s3": {
-      "endpoint": "s3-{region}.amazonaws.com"
-    },
-    "eu-central-1/s3": {
-      "endpoint": "{service}.{region}.amazonaws.com",
-      "signatureVersion": "v4"
-    }
-  }
-}
@@ -1,41 +0,0 @@
-package endpoints_test
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/private/endpoints"
-)
-
-func TestGenericEndpoint(t *testing.T) {
-	name := "service"
-	region := "mock-region-1"
-
-	ep, sr := endpoints.EndpointForRegion(name, region, false)
-	assert.Equal(t, fmt.Sprintf("https://%s.%s.amazonaws.com", name, region), ep)
-	assert.Empty(t, sr)
-}
-
-func TestGlobalEndpoints(t *testing.T) {
-	region := "mock-region-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts", "waf"}
-
-	for _, name := range svcs {
-		ep, sr := endpoints.EndpointForRegion(name, region, false)
-		assert.Equal(t, fmt.Sprintf("https://%s.amazonaws.com", name), ep)
-		assert.Equal(t, "us-east-1", sr)
-	}
-}
-
-func TestServicesInCN(t *testing.T) {
-	region := "cn-north-1"
-	svcs := []string{"cloudfront", "iam", "importexport", "route53", "sts", "s3", "waf"}
-
-	for _, name := range svcs {
-		ep, sr := endpoints.EndpointForRegion(name, region, false)
-		assert.Equal(t, fmt.Sprintf("https://%s.%s.amazonaws.com.cn", name, region), ep)
-		assert.Empty(t, sr)
-	}
-}
@@ -1,33 +0,0 @@
-package query
-
-import (
-	"encoding/xml"
-	"io"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-type xmlErrorResponse struct {
-	XMLName   xml.Name `xml:"ErrorResponse"`
-	Code      string   `xml:"Error>Code"`
-	Message   string   `xml:"Error>Message"`
-	RequestID string   `xml:"RequestId"`
-}
-
-// UnmarshalError unmarshals an error response for an AWS Query service.
-func UnmarshalError(r *request.Request) {
-	defer r.HTTPResponse.Body.Close()
-
-	resp := &xmlErrorResponse{}
-	err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp)
-	if err != nil && err != io.EOF {
-		r.Error = awserr.New("SerializationError", "failed to decode query XML error response", err)
-	} else {
-		r.Error = awserr.NewRequestFailure(
-			awserr.New(resp.Code, resp.Message, nil),
-			r.HTTPResponse.StatusCode,
-			resp.RequestID,
-		)
-	}
-}
@@ -1,45 +0,0 @@
-package rest
-
-import "reflect"
-
-// PayloadMember returns the payload field member of i if there is one, or nil.
-func PayloadMember(i interface{}) interface{} {
-	if i == nil {
-		return nil
-	}
-
-	v := reflect.ValueOf(i).Elem()
-	if !v.IsValid() {
-		return nil
-	}
-	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
-		if payloadName := field.Tag.Get("payload"); payloadName != "" {
-			field, _ := v.Type().FieldByName(payloadName)
-			if field.Tag.Get("type") != "structure" {
-				return nil
-			}
-
-			payload := v.FieldByName(payloadName)
-			if payload.IsValid() || (payload.Kind() == reflect.Ptr && !payload.IsNil()) {
-				return payload.Interface()
-			}
-		}
-	}
-	return nil
-}
-
-// PayloadType returns the type of a payload field member of i if there is one, or "".
-func PayloadType(i interface{}) string {
-	v := reflect.Indirect(reflect.ValueOf(i))
-	if !v.IsValid() {
-		return ""
-	}
-	if field, ok := v.Type().FieldByName("SDKShapeTraits"); ok {
-		if payloadName := field.Tag.Get("payload"); payloadName != "" {
-			if member, ok := v.Type().FieldByName(payloadName); ok {
-				return member.Tag.Get("type")
-			}
-		}
-	}
-	return ""
-}
@@ -1,287 +0,0 @@
-// Package xmlutil provides XML serialisation of AWS requests and responses.
-package xmlutil
-
-import (
-	"encoding/base64"
-	"encoding/xml"
-	"fmt"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// BuildXML will serialize params into an xml.Encoder.
-// Error will be returned if the serialization of any of the params or nested values fails.
-func BuildXML(params interface{}, e *xml.Encoder) error {
-	b := xmlBuilder{encoder: e, namespaces: map[string]string{}}
-	root := NewXMLElement(xml.Name{})
-	if err := b.buildValue(reflect.ValueOf(params), root, ""); err != nil {
-		return err
-	}
-	for _, c := range root.Children {
-		for _, v := range c {
-			return StructToXML(e, v, false)
-		}
-	}
-	return nil
-}
-
-// Returns the reflection element of a value, if it is a pointer.
-func elemOf(value reflect.Value) reflect.Value {
-	for value.Kind() == reflect.Ptr {
-		value = value.Elem()
-	}
-	return value
-}
-
-// A xmlBuilder serializes values from Go code to XML
-type xmlBuilder struct {
-	encoder    *xml.Encoder
-	namespaces map[string]string
-}
-
-// buildValue generic XMLNode builder for any type. Will build value for their specific type
-// struct, list, map, scalar.
-//
-// Also takes a "type" tag value to set what type a value should be converted to XMLNode as. If
-// type is not provided reflect will be used to determine the value's type.
-func (b *xmlBuilder) buildValue(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	value = elemOf(value)
-	if !value.IsValid() { // no need to handle zero values
-		return nil
-	} else if tag.Get("location") != "" { // don't handle non-body location values
-		return nil
-	}
-
-	t := tag.Get("type")
-	if t == "" {
-		switch value.Kind() {
-		case reflect.Struct:
-			t = "structure"
-		case reflect.Slice:
-			t = "list"
-		case reflect.Map:
-			t = "map"
-		}
-	}
-
-	switch t {
-	case "structure":
-		if field, ok := value.Type().FieldByName("SDKShapeTraits"); ok {
-			tag = tag + reflect.StructTag(" ") + field.Tag
-		}
-		return b.buildStruct(value, current, tag)
-	case "list":
-		return b.buildList(value, current, tag)
-	case "map":
-		return b.buildMap(value, current, tag)
-	default:
-		return b.buildScalar(value, current, tag)
-	}
-}
-
-// buildStruct adds a struct and its fields to the current XMLNode. All fields any any nested
-// types are converted to XMLNodes also.
-func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	if !value.IsValid() {
-		return nil
-	}
-
-	fieldAdded := false
-
-	// unwrap payloads
-	if payload := tag.Get("payload"); payload != "" {
-		field, _ := value.Type().FieldByName(payload)
-		tag = field.Tag
-		value = elemOf(value.FieldByName(payload))
-
-		if !value.IsValid() {
-			return nil
-		}
-	}
-
-	child := NewXMLElement(xml.Name{Local: tag.Get("locationName")})
-
-	// there is an xmlNamespace associated with this struct
-	if prefix, uri := tag.Get("xmlPrefix"), tag.Get("xmlURI"); uri != "" {
-		ns := xml.Attr{
-			Name:  xml.Name{Local: "xmlns"},
-			Value: uri,
-		}
-		if prefix != "" {
-			b.namespaces[prefix] = uri // register the namespace
-			ns.Name.Local = "xmlns:" + prefix
-		}
-
-		child.Attr = append(child.Attr, ns)
-	}
-
-	t := value.Type()
-	for i := 0; i < value.NumField(); i++ {
-		if c := t.Field(i).Name[0:1]; strings.ToLower(c) == c {
-			continue // ignore unexported fields
-		}
-
-		member := elemOf(value.Field(i))
-		field := t.Field(i)
-		mTag := field.Tag
-
-		if mTag.Get("location") != "" { // skip non-body members
-			continue
-		}
-
-		memberName := mTag.Get("locationName")
-		if memberName == "" {
-			memberName = field.Name
-			mTag = reflect.StructTag(string(mTag) + ` locationName:"` + memberName + `"`)
-		}
-		if err := b.buildValue(member, child, mTag); err != nil {
-			return err
-		}
-
-		fieldAdded = true
-	}
-
-	if fieldAdded { // only append this child if we have one ore more valid members
-		current.AddChild(child)
-	}
-
-	return nil
-}
-
-// buildList adds the value's list items to the current XMLNode as children nodes. All
-// nested values in the list are converted to XMLNodes also.
-func (b *xmlBuilder) buildList(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	if value.IsNil() { // don't build omitted lists
-		return nil
-	}
-
-	// check for unflattened list member
-	flattened := tag.Get("flattened") != ""
-
-	xname := xml.Name{Local: tag.Get("locationName")}
-	if flattened {
-		for i := 0; i < value.Len(); i++ {
-			child := NewXMLElement(xname)
-			current.AddChild(child)
-			if err := b.buildValue(value.Index(i), child, ""); err != nil {
-				return err
-			}
-		}
-	} else {
-		list := NewXMLElement(xname)
-		current.AddChild(list)
-
-		for i := 0; i < value.Len(); i++ {
-			iname := tag.Get("locationNameList")
-			if iname == "" {
-				iname = "member"
-			}
-
-			child := NewXMLElement(xml.Name{Local: iname})
-			list.AddChild(child)
-			if err := b.buildValue(value.Index(i), child, ""); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-// buildMap adds the value's key/value pairs to the current XMLNode as children nodes. All
-// nested values in the map are converted to XMLNodes also.
-//
-// Error will be returned if it is unable to build the map's values into XMLNodes
-func (b *xmlBuilder) buildMap(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	if value.IsNil() { // don't build omitted maps
-		return nil
-	}
-
-	maproot := NewXMLElement(xml.Name{Local: tag.Get("locationName")})
-	current.AddChild(maproot)
-	current = maproot
-
-	kname, vname := "key", "value"
-	if n := tag.Get("locationNameKey"); n != "" {
-		kname = n
-	}
-	if n := tag.Get("locationNameValue"); n != "" {
-		vname = n
-	}
-
-	// sorting is not required for compliance, but it makes testing easier
-	keys := make([]string, value.Len())
-	for i, k := range value.MapKeys() {
-		keys[i] = k.String()
-	}
-	sort.Strings(keys)
-
-	for _, k := range keys {
-		v := value.MapIndex(reflect.ValueOf(k))
-
-		mapcur := current
-		if tag.Get("flattened") == "" { // add "entry" tag to non-flat maps
-			child := NewXMLElement(xml.Name{Local: "entry"})
-			mapcur.AddChild(child)
-			mapcur = child
-		}
-
-		kchild := NewXMLElement(xml.Name{Local: kname})
-		kchild.Text = k
-		vchild := NewXMLElement(xml.Name{Local: vname})
-		mapcur.AddChild(kchild)
-		mapcur.AddChild(vchild)
-
-		if err := b.buildValue(v, vchild, ""); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// buildScalar will convert the value into a string and append it as a attribute or child
-// of the current XMLNode.
-//
-// The value will be added as an attribute if tag contains a "xmlAttribute" attribute value.
-//
-// Error will be returned if the value type is unsupported.
-func (b *xmlBuilder) buildScalar(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
-	var str string
-	switch converted := value.Interface().(type) {
-	case string:
-		str = converted
-	case []byte:
-		if !value.IsNil() {
-			str = base64.StdEncoding.EncodeToString(converted)
-		}
-	case bool:
-		str = strconv.FormatBool(converted)
-	case int64:
-		str = strconv.FormatInt(converted, 10)
-	case int:
-		str = strconv.Itoa(converted)
-	case float64:
-		str = strconv.FormatFloat(converted, 'f', -1, 64)
-	case float32:
-		str = strconv.FormatFloat(float64(converted), 'f', -1, 32)
-	case time.Time:
-		const ISO8601UTC = "2006-01-02T15:04:05Z"
-		str = converted.UTC().Format(ISO8601UTC)
-	default:
-		return fmt.Errorf("unsupported value for param %s: %v (%s)",
-			tag.Get("locationName"), value.Interface(), value.Type().Name())
-	}
-
-	xname := xml.Name{Local: tag.Get("locationName")}
-	if tag.Get("xmlAttribute") != "" { // put into current node's attribute list
-		attr := xml.Attr{Name: xname, Value: str}
-		current.Attr = append(current.Attr, attr)
-	} else { // regular text node
-		current.AddChild(&XMLNode{Name: xname, Text: str})
-	}
-	return nil
-}
@@ -1,260 +0,0 @@
-package xmlutil
-
-import (
-	"encoding/base64"
-	"encoding/xml"
-	"fmt"
-	"io"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// UnmarshalXML deserializes an xml.Decoder into the container v. V
-// needs to match the shape of the XML expected to be decoded.
-// If the shape doesn't match unmarshaling will fail.
-func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
-	n, _ := XMLToStruct(d, nil)
-	if n.Children != nil {
-		for _, root := range n.Children {
-			for _, c := range root {
-				if wrappedChild, ok := c.Children[wrapper]; ok {
-					c = wrappedChild[0] // pull out wrapped element
-				}
-
-				err := parse(reflect.ValueOf(v), c, "")
-				if err != nil {
-					if err == io.EOF {
-						return nil
-					}
-					return err
-				}
-			}
-		}
-		return nil
-	}
-	return nil
-}
-
-// parse deserializes any value from the XMLNode. The type tag is used to infer the type, or reflect
-// will be used to determine the type from r.
-func parse(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	rtype := r.Type()
-	if rtype.Kind() == reflect.Ptr {
-		rtype = rtype.Elem() // check kind of actual element type
-	}
-
-	t := tag.Get("type")
-	if t == "" {
-		switch rtype.Kind() {
-		case reflect.Struct:
-			t = "structure"
-		case reflect.Slice:
-			t = "list"
-		case reflect.Map:
-			t = "map"
-		}
-	}
-
-	switch t {
-	case "structure":
-		if field, ok := rtype.FieldByName("SDKShapeTraits"); ok {
-			tag = field.Tag
-		}
-		return parseStruct(r, node, tag)
-	case "list":
-		return parseList(r, node, tag)
-	case "map":
-		return parseMap(r, node, tag)
-	default:
-		return parseScalar(r, node, tag)
-	}
-}
-
-// parseStruct deserializes a structure and its fields from an XMLNode. Any nested
-// types in the structure will also be deserialized.
-func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	t := r.Type()
-	if r.Kind() == reflect.Ptr {
-		if r.IsNil() { // create the structure if it's nil
-			s := reflect.New(r.Type().Elem())
-			r.Set(s)
-			r = s
-		}
-
-		r = r.Elem()
-		t = t.Elem()
-	}
-
-	// unwrap any payloads
-	if payload := tag.Get("payload"); payload != "" {
-		field, _ := t.FieldByName(payload)
-		return parseStruct(r.FieldByName(payload), node, field.Tag)
-	}
-
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-		if c := field.Name[0:1]; strings.ToLower(c) == c {
-			continue // ignore unexported fields
-		}
-
-		// figure out what this field is called
-		name := field.Name
-		if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
-			name = field.Tag.Get("locationNameList")
-		} else if locName := field.Tag.Get("locationName"); locName != "" {
-			name = locName
-		}
-
-		// try to find the field by name in elements
-		elems := node.Children[name]
-
-		if elems == nil { // try to find the field in attributes
-			for _, a := range node.Attr {
-				if name == a.Name.Local {
-					// turn this into a text node for de-serializing
-					elems = []*XMLNode{{Text: a.Value}}
-				}
-			}
-		}
-
-		member := r.FieldByName(field.Name)
-		for _, elem := range elems {
-			err := parse(member, elem, field.Tag)
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// parseList deserializes a list of values from an XML node. Each list entry
-// will also be deserialized.
-func parseList(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	t := r.Type()
-
-	if tag.Get("flattened") == "" { // look at all item entries
-		mname := "member"
-		if name := tag.Get("locationNameList"); name != "" {
-			mname = name
-		}
-
-		if Children, ok := node.Children[mname]; ok {
-			if r.IsNil() {
-				r.Set(reflect.MakeSlice(t, len(Children), len(Children)))
-			}
-
-			for i, c := range Children {
-				err := parse(r.Index(i), c, "")
-				if err != nil {
-					return err
-				}
-			}
-		}
-	} else { // flattened list means this is a single element
-		if r.IsNil() {
-			r.Set(reflect.MakeSlice(t, 0, 0))
-		}
-
-		childR := reflect.Zero(t.Elem())
-		r.Set(reflect.Append(r, childR))
-		err := parse(r.Index(r.Len()-1), node, "")
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// parseMap deserializes a map from an XMLNode. The direct children of the XMLNode
-// will also be deserialized as map entries.
-func parseMap(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	if r.IsNil() {
-		r.Set(reflect.MakeMap(r.Type()))
-	}
-
-	if tag.Get("flattened") == "" { // look at all child entries
-		for _, entry := range node.Children["entry"] {
-			parseMapEntry(r, entry, tag)
-		}
-	} else { // this element is itself an entry
-		parseMapEntry(r, node, tag)
-	}
-
-	return nil
-}
-
-// parseMapEntry deserializes a map entry from a XML node.
-func parseMapEntry(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	kname, vname := "key", "value"
-	if n := tag.Get("locationNameKey"); n != "" {
-		kname = n
-	}
-	if n := tag.Get("locationNameValue"); n != "" {
-		vname = n
-	}
-
-	keys, ok := node.Children[kname]
-	values := node.Children[vname]
-	if ok {
-		for i, key := range keys {
-			keyR := reflect.ValueOf(key.Text)
-			value := values[i]
-			valueR := reflect.New(r.Type().Elem()).Elem()
-
-			parse(valueR, value, "")
-			r.SetMapIndex(keyR, valueR)
-		}
-	}
-	return nil
-}
-
-// parseScaller deserializes an XMLNode value into a concrete type based on the
-// interface type of r.
-//
-// Error is returned if the deserialization fails due to invalid type conversion,
-// or unsupported interface type.
-func parseScalar(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
-	switch r.Interface().(type) {
-	case *string:
-		r.Set(reflect.ValueOf(&node.Text))
-		return nil
-	case []byte:
-		b, err := base64.StdEncoding.DecodeString(node.Text)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(b))
-	case *bool:
-		v, err := strconv.ParseBool(node.Text)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(&v))
-	case *int64:
-		v, err := strconv.ParseInt(node.Text, 10, 64)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(&v))
-	case *float64:
-		v, err := strconv.ParseFloat(node.Text, 64)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(&v))
-	case *time.Time:
-		const ISO8601UTC = "2006-01-02T15:04:05Z"
-		t, err := time.Parse(ISO8601UTC, node.Text)
-		if err != nil {
-			return err
-		}
-		r.Set(reflect.ValueOf(&t))
-	default:
-		return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())
-	}
-	return nil
-}
@@ -1,105 +0,0 @@
-package xmlutil
-
-import (
-	"encoding/xml"
-	"io"
-	"sort"
-)
-
-// A XMLNode contains the values to be encoded or decoded.
-type XMLNode struct {
-	Name     xml.Name              `json:",omitempty"`
-	Children map[string][]*XMLNode `json:",omitempty"`
-	Text     string                `json:",omitempty"`
-	Attr     []xml.Attr            `json:",omitempty"`
-}
-
-// NewXMLElement returns a pointer to a new XMLNode initialized to default values.
-func NewXMLElement(name xml.Name) *XMLNode {
-	return &XMLNode{
-		Name:     name,
-		Children: map[string][]*XMLNode{},
-		Attr:     []xml.Attr{},
-	}
-}
-
-// AddChild adds child to the XMLNode.
-func (n *XMLNode) AddChild(child *XMLNode) {
-	if _, ok := n.Children[child.Name.Local]; !ok {
-		n.Children[child.Name.Local] = []*XMLNode{}
-	}
-	n.Children[child.Name.Local] = append(n.Children[child.Name.Local], child)
-}
-
-// XMLToStruct converts a xml.Decoder stream to XMLNode with nested values.
-func XMLToStruct(d *xml.Decoder, s *xml.StartElement) (*XMLNode, error) {
-	out := &XMLNode{}
-	for {
-		tok, err := d.Token()
-		if tok == nil || err == io.EOF {
-			break
-		}
-		if err != nil {
-			return out, err
-		}
-
-		switch typed := tok.(type) {
-		case xml.CharData:
-			out.Text = string(typed.Copy())
-		case xml.StartElement:
-			el := typed.Copy()
-			out.Attr = el.Attr
-			if out.Children == nil {
-				out.Children = map[string][]*XMLNode{}
-			}
-
-			name := typed.Name.Local
-			slice := out.Children[name]
-			if slice == nil {
-				slice = []*XMLNode{}
-			}
-			node, e := XMLToStruct(d, &el)
-			if e != nil {
-				return out, e
-			}
-			node.Name = typed.Name
-			slice = append(slice, node)
-			out.Children[name] = slice
-		case xml.EndElement:
-			if s != nil && s.Name.Local == typed.Name.Local { // matching end token
-				return out, nil
-			}
-		}
-	}
-	return out, nil
-}
-
-// StructToXML writes an XMLNode to a xml.Encoder as tokens.
-func StructToXML(e *xml.Encoder, node *XMLNode, sorted bool) error {
-	e.EncodeToken(xml.StartElement{Name: node.Name, Attr: node.Attr})
-
-	if node.Text != "" {
-		e.EncodeToken(xml.CharData([]byte(node.Text)))
-	} else if sorted {
-		sortedNames := []string{}
-		for k := range node.Children {
-			sortedNames = append(sortedNames, k)
-		}
-		sort.Strings(sortedNames)
-
-		for _, k := range sortedNames {
-			for _, v := range node.Children[k] {
-				StructToXML(e, v, sorted)
-			}
-		}
-	} else {
-		for _, c := range node.Children {
-			for _, v := range c {
-				StructToXML(e, v, sorted)
-			}
-		}
-	}
-
-	e.EncodeToken(xml.EndElement{Name: node.Name})
-	return e.Flush()
-}
@@ -1,42 +0,0 @@
-package v4_test
-
-import (
-	"net/url"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/awstesting/unit"
-	"github.com/aws/aws-sdk-go/service/s3"
-)
-
-func TestPresignHandler(t *testing.T) {
-	svc := s3.New(unit.Session)
-	req, _ := svc.PutObjectRequest(&s3.PutObjectInput{
-		Bucket:             aws.String("bucket"),
-		Key:                aws.String("key"),
-		ContentDisposition: aws.String("a+b c$d"),
-		ACL:                aws.String("public-read"),
-	})
-	req.Time = time.Unix(0, 0)
-	urlstr, err := req.Presign(5 * time.Minute)
-
-	assert.NoError(t, err)
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-acl"
-	expectedSig := "7edcb4e3a1bf12f4989018d75acbe3a7f03df24bd6f3112602d59fc551f0e4e2"
-	expectedCred := "AKID/19700101/mock-region/s3/aws4_request"
-
-	u, _ := url.Parse(urlstr)
-	urlQ := u.Query()
-	assert.Equal(t, expectedSig, urlQ.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, urlQ.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, urlQ.Get("X-Amz-Date"))
-	assert.Equal(t, "300", urlQ.Get("X-Amz-Expires"))
-
-	assert.NotContains(t, urlstr, "+") // + encoded as %20
-}
@@ -1,365 +0,0 @@
-// Package v4 implements signing for AWS V4 signer
-package v4
-
-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/protocol/rest"
-)
-
-const (
-	authHeaderPrefix = "AWS4-HMAC-SHA256"
-	timeFormat       = "20060102T150405Z"
-	shortTimeFormat  = "20060102"
-)
-
-var ignoredHeaders = map[string]bool{
-	"Authorization":  true,
-	"Content-Type":   true,
-	"Content-Length": true,
-	"User-Agent":     true,
-}
-
-type signer struct {
-	Request     *http.Request
-	Time        time.Time
-	ExpireTime  time.Duration
-	ServiceName string
-	Region      string
-	CredValues  credentials.Value
-	Credentials *credentials.Credentials
-	Query       url.Values
-	Body        io.ReadSeeker
-	Debug       aws.LogLevelType
-	Logger      aws.Logger
-
-	isPresign          bool
-	formattedTime      string
-	formattedShortTime string
-
-	signedHeaders    string
-	canonicalHeaders string
-	canonicalString  string
-	credentialString string
-	stringToSign     string
-	signature        string
-	authorization    string
-}
-
-// Sign requests with signature version 4.
-//
-// Will sign the requests with the service config's Credentials object
-// Signing is skipped if the credentials is the credentials.AnonymousCredentials
-// object.
-func Sign(req *request.Request) {
-	// If the request does not need to be signed ignore the signing of the
-	// request if the AnonymousCredentials object is used.
-	if req.Config.Credentials == credentials.AnonymousCredentials {
-		return
-	}
-
-	region := req.ClientInfo.SigningRegion
-	if region == "" {
-		region = aws.StringValue(req.Config.Region)
-	}
-
-	name := req.ClientInfo.SigningName
-	if name == "" {
-		name = req.ClientInfo.ServiceName
-	}
-
-	s := signer{
-		Request:     req.HTTPRequest,
-		Time:        req.Time,
-		ExpireTime:  req.ExpireTime,
-		Query:       req.HTTPRequest.URL.Query(),
-		Body:        req.Body,
-		ServiceName: name,
-		Region:      region,
-		Credentials: req.Config.Credentials,
-		Debug:       req.Config.LogLevel.Value(),
-		Logger:      req.Config.Logger,
-	}
-
-	req.Error = s.sign()
-}
-
-func (v4 *signer) sign() error {
-	if v4.ExpireTime != 0 {
-		v4.isPresign = true
-	}
-
-	if v4.isRequestSigned() {
-		if !v4.Credentials.IsExpired() {
-			// If the request is already signed, and the credentials have not
-			// expired yet ignore the signing request.
-			return nil
-		}
-
-		// The credentials have expired for this request. The current signing
-		// is invalid, and needs to be request because the request will fail.
-		if v4.isPresign {
-			v4.removePresign()
-			// Update the request's query string to ensure the values stays in
-			// sync in the case retrieving the new credentials fails.
-			v4.Request.URL.RawQuery = v4.Query.Encode()
-		}
-	}
-
-	var err error
-	v4.CredValues, err = v4.Credentials.Get()
-	if err != nil {
-		return err
-	}
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-Algorithm", authHeaderPrefix)
-		if v4.CredValues.SessionToken != "" {
-			v4.Query.Set("X-Amz-Security-Token", v4.CredValues.SessionToken)
-		} else {
-			v4.Query.Del("X-Amz-Security-Token")
-		}
-	} else if v4.CredValues.SessionToken != "" {
-		v4.Request.Header.Set("X-Amz-Security-Token", v4.CredValues.SessionToken)
-	}
-
-	v4.build()
-
-	if v4.Debug.Matches(aws.LogDebugWithSigning) {
-		v4.logSigningInfo()
-	}
-
-	return nil
-}
-
-const logSignInfoMsg = `DEBUG: Request Signiture:
---[ CANONICAL STRING  ]-----------------------------
-%s
---[ STRING TO SIGN ]--------------------------------
-%s%s
-----------------------------------------------------`
-const logSignedURLMsg = `
---[ SIGNED URL ]------------------------------------
-%s`
-
-func (v4 *signer) logSigningInfo() {
-	signedURLMsg := ""
-	if v4.isPresign {
-		signedURLMsg = fmt.Sprintf(logSignedURLMsg, v4.Request.URL.String())
-	}
-	msg := fmt.Sprintf(logSignInfoMsg, v4.canonicalString, v4.stringToSign, signedURLMsg)
-	v4.Logger.Log(msg)
-}
-
-func (v4 *signer) build() {
-	v4.buildTime()             // no depends
-	v4.buildCredentialString() // no depends
-	if v4.isPresign {
-		v4.buildQuery() // no depends
-	}
-	v4.buildCanonicalHeaders() // depends on cred string
-	v4.buildCanonicalString()  // depends on canon headers / signed headers
-	v4.buildStringToSign()     // depends on canon string
-	v4.buildSignature()        // depends on string to sign
-
-	if v4.isPresign {
-		v4.Request.URL.RawQuery += "&X-Amz-Signature=" + v4.signature
-	} else {
-		parts := []string{
-			authHeaderPrefix + " Credential=" + v4.CredValues.AccessKeyID + "/" + v4.credentialString,
-			"SignedHeaders=" + v4.signedHeaders,
-			"Signature=" + v4.signature,
-		}
-		v4.Request.Header.Set("Authorization", strings.Join(parts, ", "))
-	}
-}
-
-func (v4 *signer) buildTime() {
-	v4.formattedTime = v4.Time.UTC().Format(timeFormat)
-	v4.formattedShortTime = v4.Time.UTC().Format(shortTimeFormat)
-
-	if v4.isPresign {
-		duration := int64(v4.ExpireTime / time.Second)
-		v4.Query.Set("X-Amz-Date", v4.formattedTime)
-		v4.Query.Set("X-Amz-Expires", strconv.FormatInt(duration, 10))
-	} else {
-		v4.Request.Header.Set("X-Amz-Date", v4.formattedTime)
-	}
-}
-
-func (v4 *signer) buildCredentialString() {
-	v4.credentialString = strings.Join([]string{
-		v4.formattedShortTime,
-		v4.Region,
-		v4.ServiceName,
-		"aws4_request",
-	}, "/")
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-Credential", v4.CredValues.AccessKeyID+"/"+v4.credentialString)
-	}
-}
-
-func (v4 *signer) buildQuery() {
-	for k, h := range v4.Request.Header {
-		if strings.HasPrefix(http.CanonicalHeaderKey(k), "X-Amz-") {
-			continue // never hoist x-amz-* headers, they must be signed
-		}
-		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
-			continue // never hoist ignored headers
-		}
-
-		v4.Request.Header.Del(k)
-		v4.Query.Del(k)
-		for _, v := range h {
-			v4.Query.Add(k, v)
-		}
-	}
-}
-
-func (v4 *signer) buildCanonicalHeaders() {
-	var headers []string
-	headers = append(headers, "host")
-	for k := range v4.Request.Header {
-		if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; ok {
-			continue // ignored header
-		}
-		headers = append(headers, strings.ToLower(k))
-	}
-	sort.Strings(headers)
-
-	v4.signedHeaders = strings.Join(headers, ";")
-
-	if v4.isPresign {
-		v4.Query.Set("X-Amz-SignedHeaders", v4.signedHeaders)
-	}
-
-	headerValues := make([]string, len(headers))
-	for i, k := range headers {
-		if k == "host" {
-			headerValues[i] = "host:" + v4.Request.URL.Host
-		} else {
-			headerValues[i] = k + ":" +
-				strings.Join(v4.Request.Header[http.CanonicalHeaderKey(k)], ",")
-		}
-	}
-
-	v4.canonicalHeaders = strings.Join(headerValues, "\n")
-}
-
-func (v4 *signer) buildCanonicalString() {
-	v4.Request.URL.RawQuery = strings.Replace(v4.Query.Encode(), "+", "%20", -1)
-	uri := v4.Request.URL.Opaque
-	if uri != "" {
-		uri = "/" + strings.Join(strings.Split(uri, "/")[3:], "/")
-	} else {
-		uri = v4.Request.URL.Path
-	}
-	if uri == "" {
-		uri = "/"
-	}
-
-	if v4.ServiceName != "s3" {
-		uri = rest.EscapePath(uri, false)
-	}
-
-	v4.canonicalString = strings.Join([]string{
-		v4.Request.Method,
-		uri,
-		v4.Request.URL.RawQuery,
-		v4.canonicalHeaders + "\n",
-		v4.signedHeaders,
-		v4.bodyDigest(),
-	}, "\n")
-}
-
-func (v4 *signer) buildStringToSign() {
-	v4.stringToSign = strings.Join([]string{
-		authHeaderPrefix,
-		v4.formattedTime,
-		v4.credentialString,
-		hex.EncodeToString(makeSha256([]byte(v4.canonicalString))),
-	}, "\n")
-}
-
-func (v4 *signer) buildSignature() {
-	secret := v4.CredValues.SecretAccessKey
-	date := makeHmac([]byte("AWS4"+secret), []byte(v4.formattedShortTime))
-	region := makeHmac(date, []byte(v4.Region))
-	service := makeHmac(region, []byte(v4.ServiceName))
-	credentials := makeHmac(service, []byte("aws4_request"))
-	signature := makeHmac(credentials, []byte(v4.stringToSign))
-	v4.signature = hex.EncodeToString(signature)
-}
-
-func (v4 *signer) bodyDigest() string {
-	hash := v4.Request.Header.Get("X-Amz-Content-Sha256")
-	if hash == "" {
-		if v4.isPresign && v4.ServiceName == "s3" {
-			hash = "UNSIGNED-PAYLOAD"
-		} else if v4.Body == nil {
-			hash = hex.EncodeToString(makeSha256([]byte{}))
-		} else {
-			hash = hex.EncodeToString(makeSha256Reader(v4.Body))
-		}
-		v4.Request.Header.Add("X-Amz-Content-Sha256", hash)
-	}
-	return hash
-}
-
-// isRequestSigned returns if the request is currently signed or presigned
-func (v4 *signer) isRequestSigned() bool {
-	if v4.isPresign && v4.Query.Get("X-Amz-Signature") != "" {
-		return true
-	}
-	if v4.Request.Header.Get("Authorization") != "" {
-		return true
-	}
-
-	return false
-}
-
-// unsign removes signing flags for both signed and presigned requests.
-func (v4 *signer) removePresign() {
-	v4.Query.Del("X-Amz-Algorithm")
-	v4.Query.Del("X-Amz-Signature")
-	v4.Query.Del("X-Amz-Security-Token")
-	v4.Query.Del("X-Amz-Date")
-	v4.Query.Del("X-Amz-Expires")
-	v4.Query.Del("X-Amz-Credential")
-	v4.Query.Del("X-Amz-SignedHeaders")
-}
-
-func makeHmac(key []byte, data []byte) []byte {
-	hash := hmac.New(sha256.New, key)
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-func makeSha256(data []byte) []byte {
-	hash := sha256.New()
-	hash.Write(data)
-	return hash.Sum(nil)
-}
-
-func makeSha256Reader(reader io.ReadSeeker) []byte {
-	hash := sha256.New()
-	start, _ := reader.Seek(0, 1)
-	defer reader.Seek(start, 0)
-
-	io.Copy(hash, reader)
-	return hash.Sum(nil)
-}
@@ -1,252 +0,0 @@
-package v4
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-)
-
-func buildSigner(serviceName string, region string, signTime time.Time, expireTime time.Duration, body string) signer {
-	endpoint := "https://" + serviceName + "." + region + ".amazonaws.com"
-	reader := strings.NewReader(body)
-	req, _ := http.NewRequest("POST", endpoint, reader)
-	req.URL.Opaque = "//example.org/bucket/key-._~,!@#$%^&*()"
-	req.Header.Add("X-Amz-Target", "prefix.Operation")
-	req.Header.Add("Content-Type", "application/x-amz-json-1.0")
-	req.Header.Add("Content-Length", string(len(body)))
-	req.Header.Add("X-Amz-Meta-Other-Header", "some-value=!@#$%^&* (+)")
-
-	return signer{
-		Request:     req,
-		Time:        signTime,
-		ExpireTime:  expireTime,
-		Query:       req.URL.Query(),
-		Body:        reader,
-		ServiceName: serviceName,
-		Region:      region,
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-	}
-}
-
-func removeWS(text string) string {
-	text = strings.Replace(text, " ", "", -1)
-	text = strings.Replace(text, "\n", "", -1)
-	text = strings.Replace(text, "\t", "", -1)
-	return text
-}
-
-func assertEqual(t *testing.T, expected, given string) {
-	if removeWS(expected) != removeWS(given) {
-		t.Errorf("\nExpected: %s\nGiven:    %s", expected, given)
-	}
-}
-
-func TestPresignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 300*time.Second, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedHeaders := "host;x-amz-meta-other-header;x-amz-target"
-	expectedSig := "5eeedebf6f995145ce56daa02902d10485246d3defb34f97b973c1f40ab82d36"
-	expectedCred := "AKID/19700101/us-east-1/dynamodb/aws4_request"
-
-	q := signer.Request.URL.Query()
-	assert.Equal(t, expectedSig, q.Get("X-Amz-Signature"))
-	assert.Equal(t, expectedCred, q.Get("X-Amz-Credential"))
-	assert.Equal(t, expectedHeaders, q.Get("X-Amz-SignedHeaders"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignRequest(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Unix(0, 0), 0, "{}")
-	signer.sign()
-
-	expectedDate := "19700101T000000Z"
-	expectedSig := "AWS4-HMAC-SHA256 Credential=AKID/19700101/us-east-1/dynamodb/aws4_request, SignedHeaders=host;x-amz-date;x-amz-meta-other-header;x-amz-security-token;x-amz-target, Signature=69ada33fec48180dab153576e4dd80c4e04124f80dda3eccfed8a67c2b91ed5e"
-
-	q := signer.Request.Header
-	assert.Equal(t, expectedSig, q.Get("Authorization"))
-	assert.Equal(t, expectedDate, q.Get("X-Amz-Date"))
-}
-
-func TestSignEmptyBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "")
-	signer.Body = nil
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hash)
-}
-
-func TestSignBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-}
-
-func TestSignSeekedBody(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "   hello")
-	signer.Body.Read(make([]byte, 3)) // consume first 3 bytes so body is now "hello"
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", hash)
-
-	start, _ := signer.Body.Seek(0, 1)
-	assert.Equal(t, int64(3), start)
-}
-
-func TestPresignEmptyBodyS3(t *testing.T) {
-	signer := buildSigner("s3", "us-east-1", time.Now(), 5*time.Minute, "hello")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "UNSIGNED-PAYLOAD", hash)
-}
-
-func TestSignPrecomputedBodyChecksum(t *testing.T) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "hello")
-	signer.Request.Header.Set("X-Amz-Content-Sha256", "PRECOMPUTED")
-	signer.sign()
-	hash := signer.Request.Header.Get("X-Amz-Content-Sha256")
-	assert.Equal(t, "PRECOMPUTED", hash)
-}
-
-func TestAnonymousCredentials(t *testing.T) {
-	svc := awstesting.NewClient(&aws.Config{Credentials: credentials.AnonymousCredentials})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-
-	urlQ := r.HTTPRequest.URL.Query()
-	assert.Empty(t, urlQ.Get("X-Amz-Signature"))
-	assert.Empty(t, urlQ.Get("X-Amz-Credential"))
-	assert.Empty(t, urlQ.Get("X-Amz-SignedHeaders"))
-	assert.Empty(t, urlQ.Get("X-Amz-Date"))
-
-	hQ := r.HTTPRequest.Header
-	assert.Empty(t, hQ.Get("Authorization"))
-	assert.Empty(t, hQ.Get("X-Amz-Date"))
-}
-
-func TestIgnoreResignRequestWithValidCreds(t *testing.T) {
-	svc := awstesting.NewClient(&aws.Config{
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-		Region:      aws.String("us-west-2"),
-	})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("Authorization")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestIgnorePreResignRequestWithValidCreds(t *testing.T) {
-	svc := awstesting.NewClient(&aws.Config{
-		Credentials: credentials.NewStaticCredentials("AKID", "SECRET", "SESSION"),
-		Region:      aws.String("us-west-2"),
-	})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	sig := r.HTTPRequest.Header.Get("X-Amz-Signature")
-
-	Sign(r)
-	assert.Equal(t, sig, r.HTTPRequest.Header.Get("X-Amz-Signature"))
-}
-
-func TestResignRequestExpiredCreds(t *testing.T) {
-	creds := credentials.NewStaticCredentials("AKID", "SECRET", "SESSION")
-	svc := awstesting.NewClient(&aws.Config{Credentials: creds})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	Sign(r)
-	querySig := r.HTTPRequest.Header.Get("Authorization")
-
-	creds.Expire()
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.Header.Get("Authorization"))
-}
-
-func TestPreResignRequestExpiredCreds(t *testing.T) {
-	provider := &credentials.StaticProvider{Value: credentials.Value{
-		AccessKeyID:     "AKID",
-		SecretAccessKey: "SECRET",
-		SessionToken:    "SESSION",
-	}}
-	creds := credentials.NewCredentials(provider)
-	svc := awstesting.NewClient(&aws.Config{Credentials: creds})
-	r := svc.NewRequest(
-		&request.Operation{
-			Name:       "BatchGetItem",
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		},
-		nil,
-		nil,
-	)
-	r.ExpireTime = time.Minute * 10
-
-	Sign(r)
-	querySig := r.HTTPRequest.URL.Query().Get("X-Amz-Signature")
-
-	creds.Expire()
-	r.Time = time.Now().Add(time.Hour * 48)
-
-	Sign(r)
-	assert.NotEqual(t, querySig, r.HTTPRequest.URL.Query().Get("X-Amz-Signature"))
-}
-
-func BenchmarkPresignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 300*time.Second, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
-
-func BenchmarkSignRequest(b *testing.B) {
-	signer := buildSigner("dynamodb", "us-east-1", time.Now(), 0, "{}")
-	for i := 0; i < b.N; i++ {
-		signer.sign()
-	}
-}
@@ -1,125 +0,0 @@
-// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
-
-package cloudwatch
-
-import (
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/aws/client/metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/protocol/query"
-	"github.com/aws/aws-sdk-go/private/signer/v4"
-)
-
-// This is the Amazon CloudWatch API Reference. This guide provides detailed
-// information about Amazon CloudWatch actions, data types, parameters, and
-// errors. For detailed information about Amazon CloudWatch features and their
-// associated API calls, go to the Amazon CloudWatch Developer Guide (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide).
-//
-// Amazon CloudWatch is a web service that enables you to publish, monitor,
-// and manage various metrics, as well as configure alarm actions based on data
-// from metrics. For more information about this product go to http://aws.amazon.com/cloudwatch
-// (http://aws.amazon.com/cloudwatch).
-//
-//  For information about the namespace, metric names, and dimensions that
-// other Amazon Web Services products use to send metrics to Cloudwatch, go
-// to Amazon CloudWatch Metrics, Namespaces, and Dimensions Reference (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CW_Support_For_AWS.html)
-// in the Amazon CloudWatch Developer Guide.
-//
-// Use the following links to get started using the Amazon CloudWatch API Reference:
-//
-//   Actions (http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Operations.html):
-// An alphabetical list of all Amazon CloudWatch actions.  Data Types (http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Types.html):
-// An alphabetical list of all Amazon CloudWatch data types.  Common Parameters
-// (http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/CommonParameters.html):
-// Parameters that all Query actions can use.  Common Errors (http://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/CommonErrors.html):
-// Client and server errors that all actions can return.  Regions and Endpoints
-// (http://docs.aws.amazon.com/general/latest/gr/index.html?rande.html): Itemized
-// regions and endpoints for all AWS products.  WSDL Location (http://monitoring.amazonaws.com/doc/2010-08-01/CloudWatch.wsdl):
-// http://monitoring.amazonaws.com/doc/2010-08-01/CloudWatch.wsdl  In addition
-// to using the Amazon CloudWatch API, you can also use the following SDKs and
-// third-party libraries to access Amazon CloudWatch programmatically.
-//
-//  AWS SDK for Java Documentation (http://aws.amazon.com/documentation/sdkforjava/)
-// AWS SDK for .NET Documentation (http://aws.amazon.com/documentation/sdkfornet/)
-// AWS SDK for PHP Documentation (http://aws.amazon.com/documentation/sdkforphp/)
-// AWS SDK for Ruby Documentation (http://aws.amazon.com/documentation/sdkforruby/)
-//  Developers in the AWS developer community also provide their own libraries,
-// which you can find at the following AWS developer centers:
-//
-//  AWS Java Developer Center (http://aws.amazon.com/java/) AWS PHP Developer
-// Center (http://aws.amazon.com/php/) AWS Python Developer Center (http://aws.amazon.com/python/)
-// AWS Ruby Developer Center (http://aws.amazon.com/ruby/) AWS Windows and .NET
-// Developer Center (http://aws.amazon.com/net/)
-//The service client's operations are safe to be used concurrently.
-// It is not safe to mutate any of the client's properties though.
-type CloudWatch struct {
-	*client.Client
-}
-
-// Used for custom client initialization logic
-var initClient func(*client.Client)
-
-// Used for custom request initialization logic
-var initRequest func(*request.Request)
-
-// A ServiceName is the name of the service the client will make API calls to.
-const ServiceName = "monitoring"
-
-// New creates a new instance of the CloudWatch client with a session.
-// If additional configuration is needed for the client instance use the optional
-// aws.Config parameter to add your extra config.
-//
-// Example:
-//     // Create a CloudWatch client from just a session.
-//     svc := cloudwatch.New(mySession)
-//
-//     // Create a CloudWatch client with additional configuration
-//     svc := cloudwatch.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
-func New(p client.ConfigProvider, cfgs ...*aws.Config) *CloudWatch {
-	c := p.ClientConfig(ServiceName, cfgs...)
-	return newClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion)
-}
-
-// newClient creates, initializes and returns a new service client instance.
-func newClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string) *CloudWatch {
-	svc := &CloudWatch{
-		Client: client.New(
-			cfg,
-			metadata.ClientInfo{
-				ServiceName:   ServiceName,
-				SigningRegion: signingRegion,
-				Endpoint:      endpoint,
-				APIVersion:    "2010-08-01",
-			},
-			handlers,
-		),
-	}
-
-	// Handlers
-	svc.Handlers.Sign.PushBack(v4.Sign)
-	svc.Handlers.Build.PushBack(query.Build)
-	svc.Handlers.Unmarshal.PushBack(query.Unmarshal)
-	svc.Handlers.UnmarshalMeta.PushBack(query.UnmarshalMeta)
-	svc.Handlers.UnmarshalError.PushBack(query.UnmarshalError)
-
-	// Run custom client initialization if present
-	if initClient != nil {
-		initClient(svc.Client)
-	}
-
-	return svc
-}
-
-// newRequest creates a new request for a CloudWatch operation and runs any
-// custom request initialization.
-func (c *CloudWatch) newRequest(op *request.Operation, params, data interface{}) *request.Request {
-	req := c.NewRequest(op, params, data)
-
-	// Run custom request initialization if present
-	if initRequest != nil {
-		initRequest(req)
-	}
-
-	return req
-}
@@ -1,24 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-
-src
@@ -1,8 +0,0 @@
-language: go
-go:
- - 1.5.3
- - tip
-notifications:
-  email:
-      - ionathan@gmail.com
-      - marcosnils@gmail.com
@@ -1,3 +0,0 @@
-test:
-	go get -v -d -t ./...
-	go test -v
@@ -1,444 +0,0 @@
-[![Build Status](https://img.shields.io/travis/franela/goreq/master.svg)](https://travis-ci.org/franela/goreq)
-[![GoDoc](https://godoc.org/github.com/franela/goreq?status.svg)](https://godoc.org/github.com/franela/goreq)
-
-GoReq
-=======
-
-Simple and sane HTTP request library for Go language.
-
-
-
-**Table of Contents**
-
- [Why GoReq?](#user-content-why-goreq)
- [How do I install it?](#user-content-how-do-i-install-it)
- [What can I do with it?](#user-content-what-can-i-do-with-it)
-  - [Making requests with different methods](#user-content-making-requests-with-different-methods)
-  - [GET](#user-content-get)
-    - [Tags](#user-content-tags)
-  - [POST](#user-content-post)
-    - [Sending payloads in the Body](#user-content-sending-payloads-in-the-body)
-  - [Specifiying request headers](#user-content-specifiying-request-headers)
-  - [Sending Cookies](#cookie-support)
-  - [Setting timeouts](#user-content-setting-timeouts)
- - [Using the Response and Error](#user-content-using-the-response-and-error)
- - [Receiving JSON](#user-content-receiving-json)
- - [Sending/Receiving Compressed Payloads](#user-content-sendingreceiving-compressed-payloads)
-    - [Using gzip compression:](#user-content-using-gzip-compression)
-    - [Using deflate compression:](#user-content-using-deflate-compression)
-    - [Using compressed responses:](#user-content-using-compressed-responses)
- - [Proxy](#proxy)
- - [Debugging requests](#debug)
-     - [Getting raw Request & Response](#getting-raw-request--response)
- - [TODO:](#user-content-todo)
-
-
-
-Why GoReq?
-==========
-
-Go has very nice native libraries that allows you to do lots of cool things. But sometimes those libraries are too low level, which means that to do a simple thing, like an HTTP Request, it takes some time. And if you want to do something as simple as adding a timeout to a request, you will end up writing several lines of code.
-
-This is why we think GoReq is useful. Because you can do all your HTTP requests in a very simple and comprehensive way, while enabling you to do more advanced stuff by giving you access to the native API.
-
-How do I install it?
-====================
-
-```bash
-go get github.com/franela/goreq
-```
-
-What can I do with it?
-======================
-
-## Making requests with different methods
-
-#### GET
-```go
-res, err := goreq.Request{ Uri: "http://www.google.com" }.Do()
-```
-
-GoReq default method is GET.
-
-You can also set value to GET method easily
-
-```go
-type Item struct {
-        Limit int
-        Skip int
-        Fields string
-}
-
-item := Item {
-        Limit: 3,
-        Skip: 5,
-        Fields: "Value",
-}
-
-res, err := goreq.Request{
-        Uri: "http://localhost:3000/",
-        QueryString: item,
-}.Do()
-```
-The sample above will send `http://localhost:3000/?limit=3&skip=5&fields=Value`
-
-Alternatively the `url` tag can be used in struct fields to customize encoding properties
-
-```go
-type Item struct {
-        TheLimit int `url:"the_limit"`
-        TheSkip string `url:"the_skip,omitempty"`
-        TheFields string `url:"-"`
-}
-
-item := Item {
-        TheLimit: 3,
-        TheSkip: "",
-        TheFields: "Value",
-}
-
-res, err := goreq.Request{
-        Uri: "http://localhost:3000/",
-        QueryString: item,
-}.Do()
-```
-The sample above will send `http://localhost:3000/?the_limit=3`
-
-
-QueryString also support url.Values
-
-```go
-item := url.Values{}
-item.Set("Limit", 3)
-item.Add("Field", "somefield")
-item.Add("Field", "someotherfield")
-
-res, err := goreq.Request{
-        Uri: "http://localhost:3000/",
-        QueryString: item,
-}.Do()
-```
-
-The sample above will send `http://localhost:3000/?limit=3&field=somefield&field=someotherfield`
-
-### Tags
-
-Struct field `url` tag is mainly used as the request parameter name.
-Tags can be comma separated multiple values, 1st value is for naming and rest has special meanings.
-
- special tag for 1st value
-    - `-`: value is ignored if set this
-
- special tag for rest 2nd value
-    - `omitempty`: zero-value is ignored if set this
-    - `squash`: the fields of embedded struct is used for parameter
-
-#### Tag Examples
-
-```go
-type Place struct {
-    Country string `url:"country"`
-    City    string `url:"city"`
-    ZipCode string `url:"zipcode,omitempty"`
-}
-
-type Person struct {
-    Place `url:",squash"`
-
-    FirstName string `url:"first_name"`
-    LastName  string `url:"last_name"`
-    Age       string `url:"age,omitempty"`
-    Password  string `url:"-"`
-}
-
-johnbull := Person{
-	Place: Place{ // squash the embedded struct value
-		Country: "UK",
-		City:    "London",
-		ZipCode: "SW1",
-	},
-	FirstName: "John",
-	LastName:  "Doe",
-	Age:       "35",
-	Password:  "my-secret", // ignored for parameter
-}
-
-goreq.Request{
-	Uri:         "http://localhost/",
-	QueryString: johnbull,
-}.Do()
-// =>  `http://localhost/?first_name=John&last_name=Doe&age=35&country=UK&city=London&zip_code=SW1`
-
-
-// age and zipcode will be ignored because of `omitempty`
-// but firstname isn't.
-samurai := Person{
-	Place: Place{ // squash the embedded struct value
-		Country: "Japan",
-		City:    "Tokyo",
-	},
-	LastName: "Yagyu",
-}
-
-goreq.Request{
-	Uri:         "http://localhost/",
-	QueryString: samurai,
-}.Do()
-// =>  `http://localhost/?first_name=&last_name=yagyu&country=Japan&city=Tokyo`
-```
-
-
-#### POST
-
-```go
-res, err := goreq.Request{ Method: "POST", Uri: "http://www.google.com" }.Do()
-```
-
-## Sending payloads in the Body
-
-You can send ```string```, ```Reader``` or ```interface{}``` in the body. The first two will be sent as text. The last one will be marshalled to JSON, if possible.
-
-```go
-type Item struct {
-    Id int
-    Name string
-}
-
-item := Item{ Id: 1111, Name: "foobar" }
-
-res, err := goreq.Request{
-    Method: "POST",
-    Uri: "http://www.google.com",
-    Body: item,
-}.Do()
-```
-
-## Specifiying request headers
-
-We think that most of the times the request headers that you use are: ```Host```, ```Content-Type```, ```Accept``` and ```User-Agent```. This is why we decided to make it very easy to set these headers.
-
-```go
-res, err := goreq.Request{
-    Uri: "http://www.google.com",
-    Host: "foobar.com",
-    Accept: "application/json",
-    ContentType: "application/json",
-    UserAgent: "goreq",
-}.Do()
-```
-
-But sometimes you need to set other headers. You can still do it.
-
-```go
-req := goreq.Request{ Uri: "http://www.google.com" }
-
-req.AddHeader("X-Custom", "somevalue")
-
-req.Do()
-```
-
-Alternatively you can use the `WithHeader` function to keep the syntax short
-
-```go
-res, err = goreq.Request{ Uri: "http://www.google.com" }.WithHeader("X-Custom", "somevalue").Do()
-```
-
-## Cookie support
-
-Cookies can be either set at the request level by sending a [CookieJar](http://golang.org/pkg/net/http/cookiejar/) in the `CookieJar` request field
-or you can use goreq's one-liner WithCookie method as shown below
-
-```go
-res, err := goreq.Request{
-    Uri: "http://www.google.com",
-}.
-WithCookie(&http.Cookie{Name: "c1", Value: "v1"}).
-Do()
-```
-
-## Setting timeouts
-
-GoReq supports 2 kind of timeouts. A general connection timeout and a request specific one. By default the connection timeout is of 1 second. There is no default for request timeout, which means it will wait forever.
-
-You can change the connection timeout doing:
-
-```go
-goreq.SetConnectTimeout(100 * time.Millisecond)
-```
-
-And specify the request timeout doing:
-
-```go
-res, err := goreq.Request{
-    Uri: "http://www.google.com",
-    Timeout: 500 * time.Millisecond,
-}.Do()
-```
-
-## Using the Response and Error
-
-GoReq will always return 2 values: a ```Response``` and an ```Error```.
-If ```Error``` is not ```nil``` it means that an error happened while doing the request and you shouldn't use the ```Response``` in any way.
-You can check what happened by getting the error message:
-
-```go
-fmt.Println(err.Error())
-```
-And to make it easy to know if it was a timeout error, you can ask the error or return it:
-
-```go
-if serr, ok := err.(*goreq.Error); ok {
-    if serr.Timeout() {
-        ...
-    }
-}
-return err
-```
-
-If you don't get an error, you can safely use the ```Response```.
-
-```go
-res.Uri // return final URL location of the response (fulfilled after redirect was made)
-res.StatusCode // return the status code of the response
-res.Body // gives you access to the body
-res.Body.ToString() // will return the body as a string
-res.Header.Get("Content-Type") // gives you access to all the response headers
-```
-Remember that you should **always** close `res.Body` if it's not `nil`
-
-## Receiving JSON
-
-GoReq will help you to receive and unmarshal JSON.
-
-```go
-type Item struct {
-    Id int
-    Name string
-}
-
-var item Item
-
-res.Body.FromJsonTo(&item)
-```
-
-## Sending/Receiving Compressed Payloads
-GoReq supports gzip, deflate and zlib compression of requests' body and transparent decompression of responses provided they have a correct `Content-Encoding` header.
-
-#####Using gzip compression:
-```go
-res, err := goreq.Request{
-    Method: "POST",
-    Uri: "http://www.google.com",
-    Body: item,
-    Compression: goreq.Gzip(),
-}.Do()
-```
-#####Using deflate/zlib compression:
-```go
-res, err := goreq.Request{
-    Method: "POST",
-    Uri: "http://www.google.com",
-    Body: item,
-    Compression: goreq.Deflate(),
-}.Do()
-```
-#####Using compressed responses:
-If servers replies a correct and matching `Content-Encoding` header (gzip requires `Content-Encoding: gzip` and deflate `Content-Encoding: deflate`) goreq transparently decompresses the response so the previous example should always work:
-```go
-type Item struct {
-    Id int
-    Name string
-}
-res, err := goreq.Request{
-    Method: "POST",
-    Uri: "http://www.google.com",
-    Body: item,
-    Compression: goreq.Gzip(),
-}.Do()
-var item Item
-res.Body.FromJsonTo(&item)
-```
-If no `Content-Encoding` header is replied by the server GoReq will return the crude response.
-
-## Proxy
-If you need to use a proxy for your requests GoReq supports the standard `http_proxy` env variable as well as manually setting the proxy for each request
-
-```go
-res, err := goreq.Request{
-    Method: "GET",
-    Proxy: "http://myproxy:myproxyport",
-    Uri: "http://www.google.com",
-}.Do()
-```
-
-### Proxy basic auth is also supported
-
-```go
-res, err := goreq.Request{
-    Method: "GET",
-    Proxy: "http://user:pass@myproxy:myproxyport",
-    Uri: "http://www.google.com",
-}.Do()
-```
-
-## Debug
-If you need to debug your http requests, it can print the http request detail.
-
-```go
-res, err := goreq.Request{
-	Method:      "GET",
-	Uri:         "http://www.google.com",
-	Compression: goreq.Gzip(),
-	ShowDebug:   true,
-}.Do()
-fmt.Println(res, err)
-```
-
-and it will print the log:
-```
-GET / HTTP/1.1
-Host: www.google.com
-Accept:
-Accept-Encoding: gzip
-Content-Encoding: gzip
-Content-Type:
-```
-
-
-### Getting raw Request & Response 
-
-To get the Request:
-
-```go
-req := goreq.Request{
-        Host: "foobar.com",
-}
-
-//req.Request will return a new instance of an http.Request so you can safely use it for something else
-request, _ := req.NewRequest()
-
-```
-
-
-To get the Response:
-
-```go
-res, err := goreq.Request{
-	Method:      "GET",
-	Uri:         "http://www.google.com",
-	Compression: goreq.Gzip(),
-	ShowDebug:   true,
-}.Do()
-
-// res.Response will contain the original http.Response structure 
-fmt.Println(res.Response, err)
-```
-
-
-
-
-TODO:
-----
-
-We do have a couple of [issues](https://github.com/franela/goreq/issues) pending we'll be addressing soon. But feel free to
-contribute and send us PRs (with tests please :smile:).
@@ -1,491 +0,0 @@
-package goreq
-
-import (
-	"bufio"
-	"bytes"
-	"compress/gzip"
-	"compress/zlib"
-	"crypto/tls"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"reflect"
-	"strings"
-	"time"
-)
-
-type itimeout interface {
-	Timeout() bool
-}
-type Request struct {
-	headers           []headerTuple
-	cookies           []*http.Cookie
-	Method            string
-	Uri               string
-	Body              interface{}
-	QueryString       interface{}
-	Timeout           time.Duration
-	ContentType       string
-	Accept            string
-	Host              string
-	UserAgent         string
-	Insecure          bool
-	MaxRedirects      int
-	RedirectHeaders   bool
-	Proxy             string
-	Compression       *compression
-	BasicAuthUsername string
-	BasicAuthPassword string
-	CookieJar         http.CookieJar
-	ShowDebug         bool
-	OnBeforeRequest   func(goreq *Request, httpreq *http.Request)
-}
-
-type compression struct {
-	writer          func(buffer io.Writer) (io.WriteCloser, error)
-	reader          func(buffer io.Reader) (io.ReadCloser, error)
-	ContentEncoding string
-}
-
-type Response struct {
-	*http.Response
-	Uri  string
-	Body *Body
-	req  *http.Request
-}
-
-func (r Response) CancelRequest() {
-	cancelRequest(DefaultTransport, r.req)
-
-}
-
-func cancelRequest(transport interface{}, r *http.Request) {
-	if tp, ok := transport.(transportRequestCanceler); ok {
-		tp.CancelRequest(r)
-	}
-}
-
-type headerTuple struct {
-	name  string
-	value string
-}
-
-type Body struct {
-	reader           io.ReadCloser
-	compressedReader io.ReadCloser
-}
-
-type Error struct {
-	timeout bool
-	Err     error
-}
-
-type transportRequestCanceler interface {
-	CancelRequest(*http.Request)
-}
-
-func (e *Error) Timeout() bool {
-	return e.timeout
-}
-
-func (e *Error) Error() string {
-	return e.Err.Error()
-}
-
-func (b *Body) Read(p []byte) (int, error) {
-	if b.compressedReader != nil {
-		return b.compressedReader.Read(p)
-	}
-	return b.reader.Read(p)
-}
-
-func (b *Body) Close() error {
-	err := b.reader.Close()
-	if b.compressedReader != nil {
-		return b.compressedReader.Close()
-	}
-	return err
-}
-
-func (b *Body) FromJsonTo(o interface{}) error {
-	return json.NewDecoder(b).Decode(o)
-}
-
-func (b *Body) ToString() (string, error) {
-	body, err := ioutil.ReadAll(b)
-	if err != nil {
-		return "", err
-	}
-	return string(body), nil
-}
-
-func Gzip() *compression {
-	reader := func(buffer io.Reader) (io.ReadCloser, error) {
-		return gzip.NewReader(buffer)
-	}
-	writer := func(buffer io.Writer) (io.WriteCloser, error) {
-		return gzip.NewWriter(buffer), nil
-	}
-	return &compression{writer: writer, reader: reader, ContentEncoding: "gzip"}
-}
-
-func Deflate() *compression {
-	reader := func(buffer io.Reader) (io.ReadCloser, error) {
-		return zlib.NewReader(buffer)
-	}
-	writer := func(buffer io.Writer) (io.WriteCloser, error) {
-		return zlib.NewWriter(buffer), nil
-	}
-	return &compression{writer: writer, reader: reader, ContentEncoding: "deflate"}
-}
-
-func Zlib() *compression {
-	return Deflate()
-}
-
-func paramParse(query interface{}) (string, error) {
-	switch query.(type) {
-	case url.Values:
-		return query.(url.Values).Encode(), nil
-	case *url.Values:
-		return query.(*url.Values).Encode(), nil
-	default:
-		var v = &url.Values{}
-		err := paramParseStruct(v, query)
-		return v.Encode(), err
-	}
-}
-
-func paramParseStruct(v *url.Values, query interface{}) error {
-	var (
-		s = reflect.ValueOf(query)
-		t = reflect.TypeOf(query)
-	)
-	for t.Kind() == reflect.Ptr || t.Kind() == reflect.Interface {
-		s = s.Elem()
-		t = s.Type()
-	}
-
-	if t.Kind() != reflect.Struct {
-		return errors.New("Can not parse QueryString.")
-	}
-
-	for i := 0; i < t.NumField(); i++ {
-		var name string
-
-		field := s.Field(i)
-		typeField := t.Field(i)
-
-		if !field.CanInterface() {
-			continue
-		}
-
-		urlTag := typeField.Tag.Get("url")
-		if urlTag == "-" {
-			continue
-		}
-
-		name, opts := parseTag(urlTag)
-
-		var omitEmpty, squash bool
-		omitEmpty = opts.Contains("omitempty")
-		squash = opts.Contains("squash")
-
-		if squash {
-			err := paramParseStruct(v, field.Interface())
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		if urlTag == "" {
-			name = strings.ToLower(typeField.Name)
-		}
-
-		if val := fmt.Sprintf("%v", field.Interface()); !(omitEmpty && len(val) == 0) {
-			v.Add(name, val)
-		}
-	}
-	return nil
-}
-
-func prepareRequestBody(b interface{}) (io.Reader, error) {
-	switch b.(type) {
-	case string:
-		// treat is as text
-		return strings.NewReader(b.(string)), nil
-	case io.Reader:
-		// treat is as text
-		return b.(io.Reader), nil
-	case []byte:
-		//treat as byte array
-		return bytes.NewReader(b.([]byte)), nil
-	case nil:
-		return nil, nil
-	default:
-		// try to jsonify it
-		j, err := json.Marshal(b)
-		if err == nil {
-			return bytes.NewReader(j), nil
-		}
-		return nil, err
-	}
-}
-
-var DefaultDialer = &net.Dialer{Timeout: 1000 * time.Millisecond}
-var DefaultTransport http.RoundTripper = &http.Transport{Dial: DefaultDialer.Dial, Proxy: http.ProxyFromEnvironment}
-var DefaultClient = &http.Client{Transport: DefaultTransport}
-
-var proxyTransport http.RoundTripper
-var proxyClient *http.Client
-
-func SetConnectTimeout(duration time.Duration) {
-	DefaultDialer.Timeout = duration
-}
-
-func (r *Request) AddHeader(name string, value string) {
-	if r.headers == nil {
-		r.headers = []headerTuple{}
-	}
-	r.headers = append(r.headers, headerTuple{name: name, value: value})
-}
-
-func (r Request) WithHeader(name string, value string) Request {
-	r.AddHeader(name, value)
-	return r
-}
-
-func (r *Request) AddCookie(c *http.Cookie) {
-	r.cookies = append(r.cookies, c)
-}
-
-func (r Request) WithCookie(c *http.Cookie) Request {
-	r.AddCookie(c)
-	return r
-
-}
-
-func (r Request) Do() (*Response, error) {
-	var client = DefaultClient
-	var transport = DefaultTransport
-	var resUri string
-	var redirectFailed bool
-
-	r.Method = valueOrDefault(r.Method, "GET")
-
-	// use a client with a cookie jar if necessary. We create a new client not
-	// to modify the default one.
-	if r.CookieJar != nil {
-		client = &http.Client{
-			Transport: transport,
-			Jar:       r.CookieJar,
-		}
-	}
-
-	if r.Proxy != "" {
-		proxyUrl, err := url.Parse(r.Proxy)
-		if err != nil {
-			// proxy address is in a wrong format
-			return nil, &Error{Err: err}
-		}
-
-		//If jar is specified new client needs to be built
-		if proxyTransport == nil || client.Jar != nil {
-			proxyTransport = &http.Transport{Dial: DefaultDialer.Dial, Proxy: http.ProxyURL(proxyUrl)}
-			proxyClient = &http.Client{Transport: proxyTransport, Jar: client.Jar}
-		} else if proxyTransport, ok := proxyTransport.(*http.Transport); ok {
-			proxyTransport.Proxy = http.ProxyURL(proxyUrl)
-		}
-		transport = proxyTransport
-		client = proxyClient
-	}
-
-	client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
-
-		if len(via) > r.MaxRedirects {
-			redirectFailed = true
-			return errors.New("Error redirecting. MaxRedirects reached")
-		}
-
-		resUri = req.URL.String()
-
-		//By default Golang will not redirect request headers
-		// https://code.google.com/p/go/issues/detail?id=4800&q=request%20header
-		if r.RedirectHeaders {
-			for key, val := range via[0].Header {
-				req.Header[key] = val
-			}
-		}
-		return nil
-	}
-
-	if transport, ok := transport.(*http.Transport); ok {
-		if r.Insecure {
-			if transport.TLSClientConfig != nil {
-				transport.TLSClientConfig.InsecureSkipVerify = true
-			} else {
-				transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
-			}
-		} else if transport.TLSClientConfig != nil {
-			// the default TLS client (when transport.TLSClientConfig==nil) is
-			// already set to verify, so do nothing in that case
-			transport.TLSClientConfig.InsecureSkipVerify = false
-		}
-	}
-
-	req, err := r.NewRequest()
-
-	if err != nil {
-		// we couldn't parse the URL.
-		return nil, &Error{Err: err}
-	}
-
-	timeout := false
-	if r.Timeout > 0 {
-		client.Timeout = r.Timeout
-	}
-
-	if r.ShowDebug {
-		dump, err := httputil.DumpRequest(req, true)
-		if err != nil {
-			log.Println(err)
-		}
-		log.Println(string(dump))
-	}
-
-	if r.OnBeforeRequest != nil {
-		r.OnBeforeRequest(&r, req)
-	}
-	res, err := client.Do(req)
-
-	if err != nil {
-		if !timeout {
-			if t, ok := err.(itimeout); ok {
-				timeout = t.Timeout()
-			}
-			if ue, ok := err.(*url.Error); ok {
-				if t, ok := ue.Err.(itimeout); ok {
-					timeout = t.Timeout()
-				}
-			}
-		}
-
-		var response *Response
-		//If redirect fails we still want to return response data
-		if redirectFailed {
-			if res != nil {
-				response = &Response{res, resUri, &Body{reader: res.Body}, req}
-			} else {
-				response = &Response{res, resUri, nil, req}
-			}
-		}
-
-		//If redirect fails and we haven't set a redirect count we shouldn't return an error
-		if redirectFailed && r.MaxRedirects == 0 {
-			return response, nil
-		}
-
-		return response, &Error{timeout: timeout, Err: err}
-	}
-
-	if r.Compression != nil && strings.Contains(res.Header.Get("Content-Encoding"), r.Compression.ContentEncoding) {
-		compressedReader, err := r.Compression.reader(res.Body)
-		if err != nil {
-			return nil, &Error{Err: err}
-		}
-		return &Response{res, resUri, &Body{reader: res.Body, compressedReader: compressedReader}, req}, nil
-	}
-
-	return &Response{res, resUri, &Body{reader: res.Body}, req}, nil
-}
-
-func (r Request) addHeaders(headersMap http.Header) {
-	if len(r.UserAgent) > 0 {
-		headersMap.Add("User-Agent", r.UserAgent)
-	}
-	if r.Accept != "" {
-		headersMap.Add("Accept", r.Accept)
-	}
-	if r.ContentType != "" {
-		headersMap.Add("Content-Type", r.ContentType)
-	}
-}
-
-func (r Request) NewRequest() (*http.Request, error) {
-
-	b, e := prepareRequestBody(r.Body)
-	if e != nil {
-		// there was a problem marshaling the body
-		return nil, &Error{Err: e}
-	}
-
-	if r.QueryString != nil {
-		param, e := paramParse(r.QueryString)
-		if e != nil {
-			return nil, &Error{Err: e}
-		}
-		r.Uri = r.Uri + "?" + param
-	}
-
-	var bodyReader io.Reader
-	if b != nil && r.Compression != nil {
-		buffer := bytes.NewBuffer([]byte{})
-		readBuffer := bufio.NewReader(b)
-		writer, err := r.Compression.writer(buffer)
-		if err != nil {
-			return nil, &Error{Err: err}
-		}
-		_, e = readBuffer.WriteTo(writer)
-		writer.Close()
-		if e != nil {
-			return nil, &Error{Err: e}
-		}
-		bodyReader = buffer
-	} else {
-		bodyReader = b
-	}
-
-	req, err := http.NewRequest(r.Method, r.Uri, bodyReader)
-	if err != nil {
-		return nil, err
-	}
-	// add headers to the request
-	req.Host = r.Host
-
-	r.addHeaders(req.Header)
-	if r.Compression != nil {
-		req.Header.Add("Content-Encoding", r.Compression.ContentEncoding)
-		req.Header.Add("Accept-Encoding", r.Compression.ContentEncoding)
-	}
-	if r.headers != nil {
-		for _, header := range r.headers {
-			req.Header.Add(header.name, header.value)
-		}
-	}
-
-	//use basic auth if required
-	if r.BasicAuthUsername != "" {
-		req.SetBasicAuth(r.BasicAuthUsername, r.BasicAuthPassword)
-	}
-
-	for _, c := range r.cookies {
-		req.AddCookie(c)
-	}
-	return req, nil
-}
-
-// Return value if nonempty, def otherwise.
-func valueOrDefault(value, def string) string {
-	if value != "" {
-		return value
-	}
-	return def
-}
@@ -1,64 +0,0 @@
-// Copyright 2011 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 goreq
-
-import (
-	"strings"
-	"unicode"
-)
-
-// 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
-}
-
-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
-}
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   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.
@@ -1,35 +0,0 @@
-package commands
-
-import (
-	"github.com/codegangsta/cli"
-)
-
-type CommandLine interface {
-	ShowHelp()
-	ShowVersion()
-	Application() *cli.App
-	Args() cli.Args
-	Bool(name string) bool
-	Int(name string) int
-	String(name string) string
-	StringSlice(name string) []string
-	GlobalString(name string) string
-	FlagNames() (names []string)
-	Generic(name string) interface{}
-}
-
-type contextCommandLine struct {
-	*cli.Context
-}
-
-func (c *contextCommandLine) ShowHelp() {
-	cli.ShowCommandHelp(c.Context, c.Command.Name)
-}
-
-func (c *contextCommandLine) ShowVersion() {
-	cli.ShowVersion(c.Context)
-}
-
-func (c *contextCommandLine) Application() *cli.App {
-	return c.App
-}
@@ -1,48 +0,0 @@
-package commands
-
-import (
-	"github.com/codegangsta/cli"
-	"github.com/grafana/grafana-cli/pkg/log"
-)
-
-func runCommand(command func(commandLine CommandLine) error) func(context *cli.Context) {
-	return func(context *cli.Context) {
-
-		cmd := &contextCommandLine{context}
-		if err := command(cmd); err != nil {
-			log.Errorf("%v\n\n", err)
-
-			cmd.ShowHelp()
-		} else {
-			log.Info("Restart grafana after installing plugins . <service grafana-server restart>\n")
-		}
-	}
-}
-
-var Commands = []cli.Command{
-	{
-		Name:   "install",
-		Usage:  "installs stuff",
-		Action: runCommand(installCommand),
-	}, {
-		Name:   "list-remote",
-		Usage:  "list remote available plugins",
-		Action: runCommand(listremoteCommand),
-	}, {
-		Name:   "upgrade",
-		Usage:  "upgrades one plugin",
-		Action: runCommand(upgradeCommand),
-	}, {
-		Name:   "upgrade-all",
-		Usage:  "upgrades all your installed plugins",
-		Action: runCommand(upgradeAllCommand),
-	}, {
-		Name:   "ls",
-		Usage:  "list all installed plugins",
-		Action: runCommand(lsCommand),
-	}, {
-		Name:   "remove",
-		Usage:  "removes stuff",
-		Action: runCommand(removeCommand),
-	},
-}
@@ -1,95 +0,0 @@
-package commandstest
-
-import (
-	"github.com/codegangsta/cli"
-)
-
-type FakeFlagger struct {
-	Data map[string]interface{}
-}
-
-type FakeCommandLine struct {
-	LocalFlags, GlobalFlags *FakeFlagger
-	HelpShown, VersionShown bool
-	CliArgs                 []string
-}
-
-func (ff FakeFlagger) String(key string) string {
-	if value, ok := ff.Data[key]; ok {
-		return value.(string)
-	}
-	return ""
-}
-
-func (ff FakeFlagger) StringSlice(key string) []string {
-	if value, ok := ff.Data[key]; ok {
-		return value.([]string)
-	}
-	return []string{}
-}
-
-func (ff FakeFlagger) Int(key string) int {
-	if value, ok := ff.Data[key]; ok {
-		return value.(int)
-	}
-	return 0
-}
-
-func (ff FakeFlagger) Bool(key string) bool {
-	if value, ok := ff.Data[key]; ok {
-		return value.(bool)
-	}
-	return false
-}
-
-func (fcli *FakeCommandLine) String(key string) string {
-	return fcli.LocalFlags.String(key)
-}
-
-func (fcli *FakeCommandLine) StringSlice(key string) []string {
-	return fcli.LocalFlags.StringSlice(key)
-}
-
-func (fcli *FakeCommandLine) Int(key string) int {
-	return fcli.LocalFlags.Int(key)
-}
-
-func (fcli *FakeCommandLine) Bool(key string) bool {
-	if fcli.LocalFlags == nil {
-		return false
-	}
-	return fcli.LocalFlags.Bool(key)
-}
-
-func (fcli *FakeCommandLine) GlobalString(key string) string {
-	return fcli.GlobalFlags.String(key)
-}
-
-func (fcli *FakeCommandLine) Generic(name string) interface{} {
-	return fcli.LocalFlags.Data[name]
-}
-
-func (fcli *FakeCommandLine) FlagNames() []string {
-	flagNames := []string{}
-	for key := range fcli.LocalFlags.Data {
-		flagNames = append(flagNames, key)
-	}
-
-	return flagNames
-}
-
-func (fcli *FakeCommandLine) ShowHelp() {
-	fcli.HelpShown = true
-}
-
-func (fcli *FakeCommandLine) Application() *cli.App {
-	return cli.NewApp()
-}
-
-func (fcli *FakeCommandLine) Args() cli.Args {
-	return fcli.CliArgs
-}
-
-func (fcli *FakeCommandLine) ShowVersion() {
-	fcli.VersionShown = true
-}
@@ -1,55 +0,0 @@
-package commandstest
-
-import (
-	"os"
-	"time"
-)
-
-type FakeIoUtil struct {
-	FakeReadDir     []os.FileInfo
-	FakeIsDirectory bool
-}
-
-func (util *FakeIoUtil) Stat(path string) (os.FileInfo, error) {
-	return FakeFileInfo{IsDirectory: util.FakeIsDirectory}, nil
-}
-
-func (util *FakeIoUtil) RemoveAll(path string) error {
-	return nil
-}
-
-func (util *FakeIoUtil) ReadDir(path string) ([]os.FileInfo, error) {
-	return util.FakeReadDir, nil
-}
-
-func (i *FakeIoUtil) ReadFile(filename string) ([]byte, error) {
-	return make([]byte, 0), nil
-}
-
-type FakeFileInfo struct {
-	IsDirectory bool
-}
-
-func (ffi FakeFileInfo) IsDir() bool {
-	return ffi.IsDirectory
-}
-
-func (ffi FakeFileInfo) Size() int64 {
-	return 1
-}
-
-func (ffi FakeFileInfo) Mode() os.FileMode {
-	return 0777
-}
-
-func (ffi FakeFileInfo) Name() string {
-	return ""
-}
-
-func (ffi FakeFileInfo) ModTime() time.Time {
-	return time.Time{}
-}
-
-func (ffi FakeFileInfo) Sys() interface{} {
-	return nil
-}
@@ -1,146 +0,0 @@
-package commands
-
-import (
-	"archive/zip"
-	"bytes"
-	"errors"
-	"github.com/grafana/grafana-cli/pkg/log"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	services "github.com/grafana/grafana-cli/pkg/services"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path"
-	"regexp"
-)
-
-func validateInput(c CommandLine, pluginFolder string) error {
-	arg := c.Args().First()
-	if arg == "" {
-		return errors.New("please specify plugin to install")
-	}
-
-	pluginDir := c.GlobalString("path")
-	if pluginDir == "" {
-		return errors.New("missing path flag")
-	}
-
-	fileinfo, err := os.Stat(pluginDir)
-	if err != nil && !fileinfo.IsDir() {
-		return errors.New("path is not a directory")
-	}
-
-	return nil
-}
-
-func installCommand(c CommandLine) error {
-	pluginFolder := c.GlobalString("path")
-	if err := validateInput(c, pluginFolder); err != nil {
-		return err
-	}
-
-	pluginToInstall := c.Args().First()
-	version := c.Args().Get(1)
-
-	log.Infof("version: %v\n", version)
-
-	return InstallPlugin(pluginToInstall, pluginFolder, version)
-}
-
-func InstallPlugin(pluginName, pluginFolder, version string) error {
-	plugin, err := services.GetPlugin(pluginName)
-	if err != nil {
-		return err
-	}
-
-	v, err := SelectVersion(plugin, version)
-	if err != nil {
-		return err
-	}
-
-	url := v.Url
-	commit := v.Commit
-
-	downloadURL := url + "/archive/" + commit + ".zip"
-
-	log.Infof("installing %v @ %v\n", plugin.Id, version)
-	log.Infof("from url: %v\n", downloadURL)
-	log.Infof("on commit: %v\n", commit)
-	log.Infof("into: %v\n", pluginFolder)
-
-	err = downloadFile(plugin.Id, pluginFolder, downloadURL)
-	if err == nil {
-		log.Info("Installed %s successfully ✔\n", plugin.Id)
-	}
-
-	res := services.ReadPlugin(pluginFolder, pluginName)
-
-	for _, v := range res.Dependency.Plugins {
-		log.Infof("Depends on %s install!\n", v.Id)
-
-		//Todo: uncomment this code once the repo is more correct.
-		//InstallPlugin(v.Id, pluginFolder, "")
-	}
-
-	return err
-}
-
-func SelectVersion(plugin m.Plugin, version string) (m.Version, error) {
-	if version == "" {
-		return plugin.Versions[0], nil
-	}
-
-	for _, v := range plugin.Versions {
-		if v.Version == version {
-			return v, nil
-		}
-	}
-
-	return m.Version{}, errors.New("Could not find the version your looking for")
-}
-
-func RemoveGitBuildFromname(pluginname, filename string) string {
-	r := regexp.MustCompile("^[a-zA-Z0-9_.-]*/")
-	return r.ReplaceAllString(filename, pluginname+"/")
-}
-
-func downloadFile(pluginName, filepath, url string) (err error) {
-	resp, err := http.Get(url)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return err
-	}
-
-	r, err := zip.NewReader(bytes.NewReader(body), resp.ContentLength)
-	if err != nil {
-		return err
-	}
-	for _, zf := range r.File {
-		newfile := path.Join(filepath, RemoveGitBuildFromname(pluginName, zf.Name))
-
-		if zf.FileInfo().IsDir() {
-			os.Mkdir(newfile, 0777)
-		} else {
-			dst, err := os.Create(newfile)
-			if err != nil {
-				log.Errorf("%v", err)
-			}
-			defer dst.Close()
-			src, err := zf.Open()
-			if err != nil {
-				log.Errorf("%v", err)
-			}
-			defer src.Close()
-
-			io.Copy(dst, src)
-		}
-	}
-
-	return nil
-}
@@ -1,20 +0,0 @@
-package commands
-
-import (
-	"github.com/grafana/grafana-cli/pkg/log"
-	"github.com/grafana/grafana-cli/pkg/services"
-)
-
-func listremoteCommand(c CommandLine) error {
-	plugin, err := services.ListAllPlugins()
-
-	if err != nil {
-		return err
-	}
-
-	for _, i := range plugin.Plugins {
-		log.Infof("id: %v version:\n", i.Id)
-	}
-
-	return nil
-}
@@ -1,49 +0,0 @@
-package commands
-
-import (
-	"errors"
-	"github.com/grafana/grafana-cli/pkg/log"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	s "github.com/grafana/grafana-cli/pkg/services"
-)
-
-var getPlugins func(path string) []m.InstalledPlugin
-
-var GetStat m.IoUtil
-
-func init() {
-	getPlugins = s.GetLocalPlugins
-	GetStat = s.IoUtil
-}
-
-func validateCommand(pluginDir string) error {
-	if pluginDir == "" {
-		return errors.New("missing path flag")
-	}
-    
-	log.Info("plugindir: " + pluginDir + "\n")
-	pluginDirInfo, err := GetStat.Stat(pluginDir)
-
-	if err != nil {
-		return errors.New("missing path flag")
-	}
-
-	if pluginDirInfo.IsDir() == false {
-		return errors.New("plugin path is not a directory")
-	}
-
-	return nil
-}
-
-func lsCommand(c CommandLine) error {
-	pluginDir := c.GlobalString("path")
-	if err := validateCommand(pluginDir); err != nil {
-		return err
-	}
-
-	for _, plugin := range getPlugins(pluginDir) {
-		log.Infof("plugin: %s @ %s \n", plugin.Name, plugin.Info.Version)
-	}
-
-	return nil
-}
@@ -1,35 +0,0 @@
-package commands
-
-import (
-	"errors"
-	"github.com/grafana/grafana-cli/pkg/log"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	services "github.com/grafana/grafana-cli/pkg/services"
-)
-
-var getPluginss func(path string) []m.InstalledPlugin = services.GetLocalPlugins
-var removePlugin func(pluginPath, id string) error = services.RemoveInstalledPlugin
-
-func removeCommand(c CommandLine) error {
-	pluginPath := c.GlobalString("path")
-	localPlugins := getPluginss(pluginPath)
-
-	log.Info("remove!\n")
-
-	plugin := c.Args().First()
-	log.Info("plugin: " + plugin + "\n")
-	if plugin == "" {
-		return errors.New("Missing which plugin parameter")
-	}
-
-	log.Infof("plugins : \n%v\n", localPlugins)
-
-	for _, p := range localPlugins {
-		log.Infof("is %s == %s ? %v", p.Id, c.Args().First(), p.Id == c.Args().First())
-		if p.Id == c.Args().First() {
-			removePlugin(pluginPath, p.Id)
-		}
-	}
-
-	return nil
-}
@@ -1,61 +0,0 @@
-package commands
-
-import (
-	"github.com/grafana/grafana-cli/pkg/log"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	services "github.com/grafana/grafana-cli/pkg/services"
-	"github.com/hashicorp/go-version"
-)
-
-func ShouldUpgrade(installed string, remote m.Plugin) bool {
-	installedVersion, err1 := version.NewVersion(installed)
-
-	if err1 != nil {
-		return false
-	}
-
-	for _, v := range remote.Versions {
-		remoteVersion, err2 := version.NewVersion(v.Version)
-
-		if err2 == nil {
-			if installedVersion.LessThan(remoteVersion) {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-func upgradeAllCommand(c CommandLine) error {
-	pluginDir := c.GlobalString("path")
-
-	localPlugins := services.GetLocalPlugins(pluginDir)
-
-	remotePlugins, err := services.ListAllPlugins()
-
-	if err != nil {
-		return err
-	}
-
-	pluginsToUpgrade := make([]m.InstalledPlugin, 0)
-
-	for _, localPlugin := range localPlugins {
-		for _, remotePlugin := range remotePlugins.Plugins {
-			if localPlugin.Id == remotePlugin.Id {
-				if ShouldUpgrade(localPlugin.Info.Version, remotePlugin) {
-					pluginsToUpgrade = append(pluginsToUpgrade, localPlugin)
-				}
-			}
-		}
-	}
-
-	for _, p := range pluginsToUpgrade {
-		log.Infof("lets upgrade %v \n", p)
-
-		services.RemoveInstalledPlugin(pluginDir, p.Id)
-		InstallPlugin(p.Id, pluginDir, "")
-	}
-
-	return nil
-}
@@ -1,9 +0,0 @@
-package commands
-
-import (
-	"errors"
-)
-
-func upgradeCommand(c CommandLine) error {
-	return errors.New("Not yet Implemented")
-}
@@ -1,48 +0,0 @@
-package models
-
-import (
-	"os"
-)
-
-type InstalledPlugin struct {
-	Id   string `json:"id"`
-	Name string `json:"name"`
-	Type string `json:"type"`
-
-	Info       PluginInfo `json:"info"`
-	Dependency Dependency `json:"dependencies"`
-}
-
-type Dependency struct {
-	GrafanaVersion string   `json:"grafanaVersion"`
-	Plugins        []Plugin `json:"plugins"`
-}
-
-type PluginInfo struct {
-	Version string `json:"version"`
-	Updated string `json:"updated"`
-}
-
-type Plugin struct {
-	Id       string    `json:"id"`
-	Category string    `json:"category"`
-	Versions []Version `json:"versions"`
-}
-
-type Version struct {
-	Commit  string `json:"commit"`
-	Url     string `json:"url"`
-	Version string `json:"version"`
-}
-
-type PluginRepo struct {
-	Plugins []Plugin `json:"plugins"`
-	Version string   `json:"version"`
-}
-
-type IoUtil interface {
-	Stat(path string) (os.FileInfo, error)
-	RemoveAll(path string) error
-	ReadDir(path string) ([]os.FileInfo, error)
-	ReadFile(filename string) ([]byte, error)
-}
@@ -1,28 +0,0 @@
-package services
-
-import (
-	m "github.com/grafana/grafana-cli/pkg/models"
-	"io/ioutil"
-	"os"
-)
-
-var IoUtil m.IoUtil = IoUtilImp{}
-
-type IoUtilImp struct {
-}
-
-func (i IoUtilImp) Stat(path string) (os.FileInfo, error) {
-	return os.Stat(path)
-}
-
-func (i IoUtilImp) RemoveAll(path string) error {
-	return os.RemoveAll(path)
-}
-
-func (i IoUtilImp) ReadDir(path string) ([]os.FileInfo, error) {
-	return ioutil.ReadDir(path)
-}
-
-func (i IoUtilImp) ReadFile(filename string) ([]byte, error) {
-	return ioutil.ReadFile(filename)
-}
@@ -1,70 +0,0 @@
-package services
-
-import (
-	"encoding/json"
-	"errors"
-	"github.com/franela/goreq"
-	m "github.com/grafana/grafana-cli/pkg/models"
-	"path"
-)
-
-var IoHelper m.IoUtil = IoUtilImp{}
-
-func ListAllPlugins() (m.PluginRepo, error) {
-	res, _ := goreq.Request{Uri: "https://raw.githubusercontent.com/grafana/grafana-plugin-repository/master/repo.json"}.Do()
-
-	var resp m.PluginRepo
-	err := res.Body.FromJsonTo(&resp)
-	if err != nil {
-		return m.PluginRepo{}, errors.New("Could not load plugin data")
-	}
-
-	return resp, nil
-}
-
-func ReadPlugin(pluginDir, pluginName string) m.InstalledPlugin {
-	pluginDataPath := path.Join(pluginDir, pluginName, "plugin.json")
-	pluginData, _ := IoHelper.ReadFile(pluginDataPath)
-
-	res := m.InstalledPlugin{}
-	json.Unmarshal(pluginData, &res)
-
-	if res.Info.Version == "" {
-		res.Info.Version = "0.0.0"
-	}
-
-	if res.Id == "" {
-		res.Id = res.Name
-	}
-
-	return res
-}
-
-func GetLocalPlugins(pluginDir string) []m.InstalledPlugin {
-	result := make([]m.InstalledPlugin, 0)
-	files, _ := IoHelper.ReadDir(pluginDir)
-	for _, f := range files {
-		res := ReadPlugin(pluginDir, f.Name())
-		result = append(result, res)
-	}
-
-	return result
-}
-
-func RemoveInstalledPlugin(pluginPath, id string) error {
-	return IoHelper.RemoveAll(path.Join(pluginPath, id))
-}
-
-func GetPlugin(id string) (m.Plugin, error) {
-	resp, err := ListAllPlugins()
-	if err != nil {
-	}
-
-	for _, i := range resp.Plugins {
-		if i.Id == id {
-			return i, nil
-		}
-	}
-
-	return m.Plugin{}, errors.New("could not find plugin named \"" + id + "\"")
-}
@@ -1,5 +0,0 @@
-package version
-
-var (
-	Version = "0.0.2"
-)
@@ -1,3 +0,0 @@
-#ignore
-timeout=1s
-coverpkg=github.com/smartystreets/goconvey/convey/assertions,github.com/smartystreets/goconvey/convey/assertions/oglematchers
@@ -1,103 +0,0 @@
-package assertions
-
-import (
-	"fmt"
-	"testing"
-	"time"
-)
-
-func TestShouldContain(t *testing.T) {
-	fail(t, so([]int{}, ShouldContain), "This assertion requires exactly 1 comparison values (you provided 0).")
-	fail(t, so([]int{}, ShouldContain, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
-
-	fail(t, so(Thing1{}, ShouldContain, 1), "You must provide a valid container (was assertions.Thing1)!")
-	fail(t, so(nil, ShouldContain, 1), "You must provide a valid container (was <nil>)!")
-	fail(t, so([]int{1}, ShouldContain, 2), "Expected the container ([]int) to contain: '2' (but it didn't)!")
-
-	pass(t, so([]int{1}, ShouldContain, 1))
-	pass(t, so([]int{1, 2, 3}, ShouldContain, 2))
-}
-
-func TestShouldNotContain(t *testing.T) {
-	fail(t, so([]int{}, ShouldNotContain), "This assertion requires exactly 1 comparison values (you provided 0).")
-	fail(t, so([]int{}, ShouldNotContain, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
-
-	fail(t, so(Thing1{}, ShouldNotContain, 1), "You must provide a valid container (was assertions.Thing1)!")
-	fail(t, so(nil, ShouldNotContain, 1), "You must provide a valid container (was <nil>)!")
-
-	fail(t, so([]int{1}, ShouldNotContain, 1), "Expected the container ([]int) NOT to contain: '1' (but it did)!")
-	fail(t, so([]int{1, 2, 3}, ShouldNotContain, 2), "Expected the container ([]int) NOT to contain: '2' (but it did)!")
-
-	pass(t, so([]int{1}, ShouldNotContain, 2))
-}
-
-func TestShouldBeIn(t *testing.T) {
-	fail(t, so(4, ShouldBeIn), shouldHaveProvidedCollectionMembers)
-
-	container := []int{1, 2, 3, 4}
-	pass(t, so(4, ShouldBeIn, container))
-	pass(t, so(4, ShouldBeIn, 1, 2, 3, 4))
-
-	fail(t, so(4, ShouldBeIn, 1, 2, 3), "Expected '4' to be in the container ([]interface {}, but it wasn't)!")
-	fail(t, so(4, ShouldBeIn, []int{1, 2, 3}), "Expected '4' to be in the container ([]int, but it wasn't)!")
-}
-
-func TestShouldNotBeIn(t *testing.T) {
-	fail(t, so(4, ShouldNotBeIn), shouldHaveProvidedCollectionMembers)
-
-	container := []int{1, 2, 3, 4}
-	pass(t, so(42, ShouldNotBeIn, container))
-	pass(t, so(42, ShouldNotBeIn, 1, 2, 3, 4))
-
-	fail(t, so(2, ShouldNotBeIn, 1, 2, 3), "Expected '2' NOT to be in the container ([]interface {}, but it was)!")
-	fail(t, so(2, ShouldNotBeIn, []int{1, 2, 3}), "Expected '2' NOT to be in the container ([]int, but it was)!")
-}
-
-func TestShouldBeEmpty(t *testing.T) {
-	fail(t, so(1, ShouldBeEmpty, 2, 3), "This assertion requires exactly 0 comparison values (you provided 2).")
-
-	pass(t, so([]int{}, ShouldBeEmpty))           // empty slice
-	pass(t, so([]interface{}{}, ShouldBeEmpty))   // empty slice
-	pass(t, so(map[string]int{}, ShouldBeEmpty))  // empty map
-	pass(t, so("", ShouldBeEmpty))                // empty string
-	pass(t, so(&[]int{}, ShouldBeEmpty))          // pointer to empty slice
-	pass(t, so(&[0]int{}, ShouldBeEmpty))         // pointer to empty array
-	pass(t, so(nil, ShouldBeEmpty))               // nil
-	pass(t, so(make(chan string), ShouldBeEmpty)) // empty channel
-
-	fail(t, so([]int{1}, ShouldBeEmpty), "Expected [1] to be empty (but it wasn't)!")                      // non-empty slice
-	fail(t, so([]interface{}{1}, ShouldBeEmpty), "Expected [1] to be empty (but it wasn't)!")              // non-empty slice
-	fail(t, so(map[string]int{"hi": 0}, ShouldBeEmpty), "Expected map[hi:0] to be empty (but it wasn't)!") // non-empty map
-	fail(t, so("hi", ShouldBeEmpty), "Expected hi to be empty (but it wasn't)!")                           // non-empty string
-	fail(t, so(&[]int{1}, ShouldBeEmpty), "Expected &[1] to be empty (but it wasn't)!")                    // pointer to non-empty slice
-	fail(t, so(&[1]int{1}, ShouldBeEmpty), "Expected &[1] to be empty (but it wasn't)!")                   // pointer to non-empty array
-	c := make(chan int, 1)                                                                                 // non-empty channel
-	go func() { c <- 1 }()
-	time.Sleep(time.Millisecond)
-	fail(t, so(c, ShouldBeEmpty), fmt.Sprintf("Expected %+v to be empty (but it wasn't)!", c))
-}
-
-func TestShouldNotBeEmpty(t *testing.T) {
-	fail(t, so(1, ShouldNotBeEmpty, 2, 3), "This assertion requires exactly 0 comparison values (you provided 2).")
-
-	fail(t, so([]int{}, ShouldNotBeEmpty), "Expected [] to NOT be empty (but it was)!")             // empty slice
-	fail(t, so([]interface{}{}, ShouldNotBeEmpty), "Expected [] to NOT be empty (but it was)!")     // empty slice
-	fail(t, so(map[string]int{}, ShouldNotBeEmpty), "Expected map[] to NOT be empty (but it was)!") // empty map
-	fail(t, so("", ShouldNotBeEmpty), "Expected  to NOT be empty (but it was)!")                    // empty string
-	fail(t, so(&[]int{}, ShouldNotBeEmpty), "Expected &[] to NOT be empty (but it was)!")           // pointer to empty slice
-	fail(t, so(&[0]int{}, ShouldNotBeEmpty), "Expected &[] to NOT be empty (but it was)!")          // pointer to empty array
-	fail(t, so(nil, ShouldNotBeEmpty), "Expected <nil> to NOT be empty (but it was)!")              // nil
-	c := make(chan int, 0)                                                                          // non-empty channel
-	fail(t, so(c, ShouldNotBeEmpty), fmt.Sprintf("Expected %+v to NOT be empty (but it was)!", c))  // empty channel
-
-	pass(t, so([]int{1}, ShouldNotBeEmpty))                // non-empty slice
-	pass(t, so([]interface{}{1}, ShouldNotBeEmpty))        // non-empty slice
-	pass(t, so(map[string]int{"hi": 0}, ShouldNotBeEmpty)) // non-empty map
-	pass(t, so("hi", ShouldNotBeEmpty))                    // non-empty string
-	pass(t, so(&[]int{1}, ShouldNotBeEmpty))               // pointer to non-empty slice
-	pass(t, so(&[1]int{1}, ShouldNotBeEmpty))              // pointer to non-empty array
-	c = make(chan int, 1)
-	go func() { c <- 1 }()
-	time.Sleep(time.Millisecond)
-	pass(t, so(c, ShouldNotBeEmpty))
-}
@@ -1,43 +0,0 @@
-// Package assertions contains the implementations for all assertions which
-// are referenced in the convey package for use with the So(...) method.
-package assertions
-
-// This function is not used by the goconvey library. It's actually a convenience method
-// for running assertions on arbitrary arguments outside of any testing context, like for
-// application logging. It allows you to perform assertion-like behavior (and get nicely
-// formatted messages detailing discrepancies) but without the probram blowing up or panicking.
-// All that is required is to import this package and call `So` with one of the assertions
-// exported by this package as the second parameter.
-// The first return parameter is a boolean indicating if the assertion was true. The second
-// return parameter is the well-formatted message showing why an assertion was incorrect, or
-// blank if the assertion was correct.
-//
-// Example:
-//
-//   if ok, message := So(x, ShouldBeGreaterThan, y); !ok {
-//        log.Println(message)
-//   }
-//
-func So(actual interface{}, assert assertion, expected ...interface{}) (bool, string) {
-	serializer = noop
-
-	if result := so(actual, assert, expected...); len(result) == 0 {
-		return true, result
-	} else {
-		return false, result
-	}
-}
-
-// so is like So, except that it only returns the string message, which is blank if the
-// assertion passed. Used to facilitate testing.
-func so(actual interface{}, assert func(interface{}, ...interface{}) string, expected ...interface{}) string {
-	return assert(actual, expected...)
-}
-
-// assertion is an alias for a function with a signature that the So()
-// function can handle. Any future or custom assertions should conform to this
-// method signature. The return value should be an empty string if the assertion
-// passes and a well-formed failure message if not.
-type assertion func(actual interface{}, expected ...interface{}) string
-
-////////////////////////////////////////////////////////////////////////////
@@ -1,267 +0,0 @@
-package assertions
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-)
-
-func TestShouldEqual(t *testing.T) {
-	serializer = newFakeSerializer()
-
-	fail(t, so(1, ShouldEqual), "This assertion requires exactly 1 comparison values (you provided 0).")
-	fail(t, so(1, ShouldEqual, 1, 2), "This assertion requires exactly 1 comparison values (you provided 2).")
-	fail(t, so(1, ShouldEqual, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
-
-	pass(t, so(1, ShouldEqual, 1))
-	fail(t, so(1, ShouldEqual, 2), "2|1|Expected: '2' Actual: '1' (Should be equal)")
-
-	pass(t, so(true, ShouldEqual, true))
-	fail(t, so(true, ShouldEqual, false), "false|true|Expected: 'false' Actual: 'true' (Should be equal)")
-
-	pass(t, so("hi", ShouldEqual, "hi"))
-	fail(t, so("hi", ShouldEqual, "bye"), "bye|hi|Expected: 'bye' Actual: 'hi' (Should be equal)")
-
-	pass(t, so(42, ShouldEqual, uint(42)))
-
-	fail(t, so(Thing1{"hi"}, ShouldEqual, Thing1{}), "{}|{hi}|Expected: '{}' Actual: '{hi}' (Should be equal)")
-	fail(t, so(Thing1{"hi"}, ShouldEqual, Thing1{"hi"}), "{hi}|{hi}|Expected: '{hi}' Actual: '{hi}' (Should be equal)")
-	fail(t, so(&Thing1{"hi"}, ShouldEqual, &Thing1{"hi"}), "&{hi}|&{hi}|Expected: '&{hi}' Actual: '&{hi}' (Should be equal)")
-
-	fail(t, so(Thing1{}, ShouldEqual, Thing2{}), "{}|{}|Expected: '{}' Actual: '{}' (Should be equal)")
-}
-
-func TestShouldNotEqual(t *testing.T) {
-	fail(t, so(1, ShouldNotEqual), "This assertion requires exactly 1 comparison values (you provided 0).")
-	fail(t, so(1, ShouldNotEqual, 1, 2), "This assertion requires exactly 1 comparison values (you provided 2).")
-	fail(t, so(1, ShouldNotEqual, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
-
-	pass(t, so(1, ShouldNotEqual, 2))
-	fail(t, so(1, ShouldNotEqual, 1), "Expected '1' to NOT equal '1' (but it did)!")
-
-	pass(t, so(true, ShouldNotEqual, false))
-	fail(t, so(true, ShouldNotEqual, true), "Expected 'true' to NOT equal 'true' (but it did)!")
-
-	pass(t, so("hi", ShouldNotEqual, "bye"))
-	fail(t, so("hi", ShouldNotEqual, "hi"), "Expected 'hi' to NOT equal 'hi' (but it did)!")
-
-	pass(t, so(&Thing1{"hi"}, ShouldNotEqual, &Thing1{"hi"}))
-	pass(t, so(Thing1{"hi"}, ShouldNotEqual, Thing1{"hi"}))
-	pass(t, so(Thing1{}, ShouldNotEqual, Thing1{}))
-	pass(t, so(Thing1{}, ShouldNotEqual, Thing2{}))
-}
-
-func TestShouldAlmostEqual(t *testing.T) {
-	fail(t, so(1, ShouldAlmostEqual), "This assertion requires exactly one comparison value and an optional delta (you provided neither)")
-	fail(t, so(1, ShouldAlmostEqual, 1, 2, 3), "This assertion requires exactly one comparison value and an optional delta (you provided more values)")
-
-	// with the default delta
-	pass(t, so(1, ShouldAlmostEqual, .99999999999999))
-	pass(t, so(1.3612499999999996, ShouldAlmostEqual, 1.36125))
-	pass(t, so(0.7285312499999999, ShouldAlmostEqual, 0.72853125))
-	fail(t, so(1, ShouldAlmostEqual, .99), "Expected '1' to almost equal '0.99' (but it didn't)!")
-
-	// with a different delta
-	pass(t, so(100.0, ShouldAlmostEqual, 110.0, 10.0))
-	fail(t, so(100.0, ShouldAlmostEqual, 111.0, 10.5), "Expected '100' to almost equal '111' (but it didn't)!")
-
-	// ints should work
-	pass(t, so(100, ShouldAlmostEqual, 100.0))
-	fail(t, so(100, ShouldAlmostEqual, 99.0), "Expected '100' to almost equal '99' (but it didn't)!")
-
-	// float32 should work
-	pass(t, so(float64(100.0), ShouldAlmostEqual, float32(100.0)))
-	fail(t, so(float32(100.0), ShouldAlmostEqual, 99.0, float32(0.1)), "Expected '100' to almost equal '99' (but it didn't)!")
-}
-
-func TestShouldNotAlmostEqual(t *testing.T) {
-	fail(t, so(1, ShouldNotAlmostEqual), "This assertion requires exactly one comparison value and an optional delta (you provided neither)")
-	fail(t, so(1, ShouldNotAlmostEqual, 1, 2, 3), "This assertion requires exactly one comparison value and an optional delta (you provided more values)")
-
-	// with the default delta
-	fail(t, so(1, ShouldNotAlmostEqual, .99999999999999), "Expected '1' to NOT almost equal '0.99999999999999' (but it did)!")
-	fail(t, so(1.3612499999999996, ShouldNotAlmostEqual, 1.36125), "Expected '1.3612499999999996' to NOT almost equal '1.36125' (but it did)!")
-	pass(t, so(1, ShouldNotAlmostEqual, .99))
-
-	// with a different delta
-	fail(t, so(100.0, ShouldNotAlmostEqual, 110.0, 10.0), "Expected '100' to NOT almost equal '110' (but it did)!")
-	pass(t, so(100.0, ShouldNotAlmostEqual, 111.0, 10.5))
-
-	// ints should work
-	fail(t, so(100, ShouldNotAlmostEqual, 100.0), "Expected '100' to NOT almost equal '100' (but it did)!")
-	pass(t, so(100, ShouldNotAlmostEqual, 99.0))
-
-	// float32 should work
-	fail(t, so(float64(100.0), ShouldNotAlmostEqual, float32(100.0)), "Expected '100' to NOT almost equal '100' (but it did)!")
-	pass(t, so(float32(100.0), ShouldNotAlmostEqual, 99.0, float32(0.1)))
-}
-
-func TestShouldResemble(t *testing.T) {
-	serializer = newFakeSerializer()
-
-	fail(t, so(Thing1{"hi"}, ShouldResemble), "This assertion requires exactly 1 comparison values (you provided 0).")
-	fail(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"hi"}, Thing1{"hi"}), "This assertion requires exactly 1 comparison values (you provided 2).")
-
-	pass(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"hi"}))
-	fail(t, so(Thing1{"hi"}, ShouldResemble, Thing1{"bye"}), "{bye}|{hi}|Expected: 'assertions.Thing1{a:\"bye\"}' Actual: 'assertions.Thing1{a:\"hi\"}' (Should resemble)!")
-
-	var (
-		a []int
-		b []int = []int{}
-	)
-
-	fail(t, so(a, ShouldResemble, b), "[]|[]|Expected: '[]int{}' Actual: '[]int(nil)' (Should resemble)!")
-	fail(t, so(2, ShouldResemble, 1), "1|2|Expected: '1' Actual: '2' (Should resemble)!")
-
-	fail(t, so(StringStringMapAlias{"hi": "bye"}, ShouldResemble, map[string]string{"hi": "bye"}),
-		"map[hi:bye]|map[hi:bye]|Expected: 'map[string]string{\"hi\":\"bye\"}' Actual: 'assertions.StringStringMapAlias{\"hi\":\"bye\"}' (Should resemble)!")
-	fail(t, so(StringSliceAlias{"hi", "bye"}, ShouldResemble, []string{"hi", "bye"}),
-		"[hi bye]|[hi bye]|Expected: '[]string{\"hi\", \"bye\"}' Actual: 'assertions.StringSliceAlias{\"hi\", \"bye\"}' (Should resemble)!")
-
-	// some types come out looking the same when represented with "%#v" so we show type mismatch info:
-	fail(t, so(StringAlias("hi"), ShouldResemble, "hi"), "hi|hi|Expected: '\"hi\"' Actual: '\"hi\"' (Type mismatch: 'string' vs 'assertions.StringAlias')!")
-	fail(t, so(IntAlias(42), ShouldResemble, 42), "42|42|Expected: '42' Actual: '42' (Type mismatch: 'int' vs 'assertions.IntAlias')!")
-}
-
-func TestShouldNotResemble(t *testing.T) {
-	fail(t, so(Thing1{"hi"}, ShouldNotResemble), "This assertion requires exactly 1 comparison values (you provided 0).")
-	fail(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}, Thing1{"hi"}), "This assertion requires exactly 1 comparison values (you provided 2).")
-
-	pass(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"bye"}))
-	fail(t, so(Thing1{"hi"}, ShouldNotResemble, Thing1{"hi"}),
-		"Expected 'assertions.Thing1{a:\"hi\"}' to NOT resemble 'assertions.Thing1{a:\"hi\"}' (but it did)!")
-
-	pass(t, so(map[string]string{"hi": "bye"}, ShouldResemble, map[string]string{"hi": "bye"}))
-	pass(t, so(IntAlias(42), ShouldNotResemble, 42))
-
-	pass(t, so(StringSliceAlias{"hi", "bye"}, ShouldNotResemble, []string{"hi", "bye"}))
-}
-
-func TestShouldPointTo(t *testing.T) {
-	serializer = newFakeSerializer()
-
-	t1 := &Thing1{}
-	t2 := t1
-	t3 := &Thing1{}
-
-	pointer1 := reflect.ValueOf(t1).Pointer()
-	pointer3 := reflect.ValueOf(t3).Pointer()
-
-	fail(t, so(t1, ShouldPointTo), "This assertion requires exactly 1 comparison values (you provided 0).")
-	fail(t, so(t1, ShouldPointTo, t2, t3), "This assertion requires exactly 1 comparison values (you provided 2).")
-
-	pass(t, so(t1, ShouldPointTo, t2))
-	fail(t, so(t1, ShouldPointTo, t3), fmt.Sprintf(
-		"%v|%v|Expected '&{a:}' (address: '%v') and '&{a:}' (address: '%v') to be the same address (but their weren't)!",
-		pointer3, pointer1, pointer1, pointer3))
-
-	t4 := Thing1{}
-	t5 := t4
-
-	fail(t, so(t4, ShouldPointTo, t5), "Both arguments should be pointers (the first was not)!")
-	fail(t, so(&t4, ShouldPointTo, t5), "Both arguments should be pointers (the second was not)!")
-	fail(t, so(nil, ShouldPointTo, nil), "Both arguments should be pointers (the first was nil)!")
-	fail(t, so(&t4, ShouldPointTo, nil), "Both arguments should be pointers (the second was nil)!")
-}
-
-func TestShouldNotPointTo(t *testing.T) {
-	t1 := &Thing1{}
-	t2 := t1
-	t3 := &Thing1{}
-
-	pointer1 := reflect.ValueOf(t1).Pointer()
-
-	fail(t, so(t1, ShouldNotPointTo), "This assertion requires exactly 1 comparison values (you provided 0).")
-	fail(t, so(t1, ShouldNotPointTo, t2, t3), "This assertion requires exactly 1 comparison values (you provided 2).")
-
-	pass(t, so(t1, ShouldNotPointTo, t3))
-	fail(t, so(t1, ShouldNotPointTo, t2), fmt.Sprintf("Expected '&{a:}' and '&{a:}' to be different references (but they matched: '%v')!", pointer1))
-
-	t4 := Thing1{}
-	t5 := t4
-
-	fail(t, so(t4, ShouldNotPointTo, t5), "Both arguments should be pointers (the first was not)!")
-	fail(t, so(&t4, ShouldNotPointTo, t5), "Both arguments should be pointers (the second was not)!")
-	fail(t, so(nil, ShouldNotPointTo, nil), "Both arguments should be pointers (the first was nil)!")
-	fail(t, so(&t4, ShouldNotPointTo, nil), "Both arguments should be pointers (the second was nil)!")
-}
-
-func TestShouldBeNil(t *testing.T) {
-	fail(t, so(nil, ShouldBeNil, nil, nil, nil), "This assertion requires exactly 0 comparison values (you provided 3).")
-	fail(t, so(nil, ShouldBeNil, nil), "This assertion requires exactly 0 comparison values (you provided 1).")
-
-	pass(t, so(nil, ShouldBeNil))
-	fail(t, so(1, ShouldBeNil), "Expected: nil Actual: '1'")
-
-	var thing Thinger
-	pass(t, so(thing, ShouldBeNil))
-	thing = &Thing{}
-	fail(t, so(thing, ShouldBeNil), "Expected: nil Actual: '&{}'")
-
-	var thingOne *Thing1
-	pass(t, so(thingOne, ShouldBeNil))
-
-	var nilSlice []int = nil
-	pass(t, so(nilSlice, ShouldBeNil))
-
-	var nilMap map[string]string = nil
-	pass(t, so(nilMap, ShouldBeNil))
-
-	var nilChannel chan int = nil
-	pass(t, so(nilChannel, ShouldBeNil))
-
-	var nilFunc func() = nil
-	pass(t, so(nilFunc, ShouldBeNil))
-
-	var nilInterface interface{} = nil
-	pass(t, so(nilInterface, ShouldBeNil))
-}
-
-func TestShouldNotBeNil(t *testing.T) {
-	fail(t, so(nil, ShouldNotBeNil, nil, nil, nil), "This assertion requires exactly 0 comparison values (you provided 3).")
-	fail(t, so(nil, ShouldNotBeNil, nil), "This assertion requires exactly 0 comparison values (you provided 1).")
-
-	fail(t, so(nil, ShouldNotBeNil), "Expected '<nil>' to NOT be nil (but it was)!")
-	pass(t, so(1, ShouldNotBeNil))
-
-	var thing Thinger
-	fail(t, so(thing, ShouldNotBeNil), "Expected '<nil>' to NOT be nil (but it was)!")
-	thing = &Thing{}
-	pass(t, so(thing, ShouldNotBeNil))
-}
-
-func TestShouldBeTrue(t *testing.T) {
-	fail(t, so(true, ShouldBeTrue, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).")
-	fail(t, so(true, ShouldBeTrue, 1), "This assertion requires exactly 0 comparison values (you provided 1).")
-
-	fail(t, so(false, ShouldBeTrue), "Expected: true Actual: false")
-	fail(t, so(1, ShouldBeTrue), "Expected: true Actual: 1")
-	pass(t, so(true, ShouldBeTrue))
-}
-
-func TestShouldBeFalse(t *testing.T) {
-	fail(t, so(false, ShouldBeFalse, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).")
-	fail(t, so(false, ShouldBeFalse, 1), "This assertion requires exactly 0 comparison values (you provided 1).")
-
-	fail(t, so(true, ShouldBeFalse), "Expected: false Actual: true")
-	fail(t, so(1, ShouldBeFalse), "Expected: false Actual: 1")
-	pass(t, so(false, ShouldBeFalse))
-}
-
-func TestShouldBeZeroValue(t *testing.T) {
-	serializer = newFakeSerializer()
-
-	fail(t, so(0, ShouldBeZeroValue, 1, 2, 3), "This assertion requires exactly 0 comparison values (you provided 3).")
-	fail(t, so(false, ShouldBeZeroValue, true), "This assertion requires exactly 0 comparison values (you provided 1).")
-
-	fail(t, so(1, ShouldBeZeroValue), "0|1|'1' should have been the zero value")                                       //"Expected: (zero value) Actual: 1")
-	fail(t, so(true, ShouldBeZeroValue), "false|true|'true' should have been the zero value")                          //"Expected: (zero value) Actual: true")
-	fail(t, so("123", ShouldBeZeroValue), "|123|'123' should have been the zero value")                                //"Expected: (zero value) Actual: 123")
-	fail(t, so(" ", ShouldBeZeroValue), "| |' ' should have been the zero value")                                      //"Expected: (zero value) Actual:  ")
-	fail(t, so([]string{"Nonempty"}, ShouldBeZeroValue), "[]|[Nonempty]|'[Nonempty]' should have been the zero value") //"Expected: (zero value) Actual: [Nonempty]")
-	fail(t, so(struct{ a string }{a: "asdf"}, ShouldBeZeroValue), "{}|{asdf}|'{a:asdf}' should have been the zero value")
-	pass(t, so(0, ShouldBeZeroValue))
-	pass(t, so(false, ShouldBeZeroValue))
-	pass(t, so("", ShouldBeZeroValue))
-	pass(t, so(struct{}{}, ShouldBeZeroValue))
-}
@@ -1,6 +0,0 @@
-package assertions
-
-var (
-	serializer Serializer = newSerializer()
-	noop       Serializer = new(noopSerializer)
-)
@@ -1,5 +0,0 @@
-*.6
-6.out
-_obj/
-_test/
-_testmain.go
@@ -1,110 +0,0 @@
-// Copyright 2011 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	"errors"
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type allOfFakeMatcher struct {
-	desc string
-	err  error
-}
-
-func (m *allOfFakeMatcher) Matches(c interface{}) error {
-	return m.err
-}
-
-func (m *allOfFakeMatcher) Description() string {
-	return m.desc
-}
-
-type AllOfTest struct {
-}
-
-func init() { RegisterTestSuite(&AllOfTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *AllOfTest) DescriptionWithEmptySet() {
-	m := AllOf()
-	ExpectEq("is anything", m.Description())
-}
-
-func (t *AllOfTest) DescriptionWithOneMatcher() {
-	m := AllOf(&allOfFakeMatcher{"taco", errors.New("")})
-	ExpectEq("taco", m.Description())
-}
-
-func (t *AllOfTest) DescriptionWithMultipleMatchers() {
-	m := AllOf(
-		&allOfFakeMatcher{"taco", errors.New("")},
-		&allOfFakeMatcher{"burrito", errors.New("")},
-		&allOfFakeMatcher{"enchilada", errors.New("")})
-
-	ExpectEq("taco, and burrito, and enchilada", m.Description())
-}
-
-func (t *AllOfTest) EmptySet() {
-	m := AllOf()
-	err := m.Matches(17)
-
-	ExpectEq(nil, err)
-}
-
-func (t *AllOfTest) OneMatcherReturnsFatalErrorAndSomeOthersFail() {
-	m := AllOf(
-		&allOfFakeMatcher{"", errors.New("")},
-		&allOfFakeMatcher{"", NewFatalError("taco")},
-		&allOfFakeMatcher{"", errors.New("")},
-		&allOfFakeMatcher{"", nil})
-
-	err := m.Matches(17)
-
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("taco")))
-}
-
-func (t *AllOfTest) OneMatcherReturnsNonFatalAndOthersSayTrue() {
-	m := AllOf(
-		&allOfFakeMatcher{"", nil},
-		&allOfFakeMatcher{"", errors.New("taco")},
-		&allOfFakeMatcher{"", nil})
-
-	err := m.Matches(17)
-
-	ExpectFalse(isFatal(err))
-	ExpectThat(err, Error(Equals("taco")))
-}
-
-func (t *AllOfTest) AllMatchersSayTrue() {
-	m := AllOf(
-		&allOfFakeMatcher{"", nil},
-		&allOfFakeMatcher{"", nil},
-		&allOfFakeMatcher{"", nil})
-
-	err := m.Matches(17)
-
-	ExpectEq(nil, err)
-}
@@ -1,121 +0,0 @@
-// Copyright 2011 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	"errors"
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type fakeAnyOfMatcher struct {
-	desc string
-	err  error
-}
-
-func (m *fakeAnyOfMatcher) Matches(c interface{}) error {
-	return m.err
-}
-
-func (m *fakeAnyOfMatcher) Description() string {
-	return m.desc
-}
-
-type AnyOfTest struct {
-}
-
-func init() { RegisterTestSuite(&AnyOfTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *AnyOfTest) EmptySet() {
-	matcher := AnyOf()
-
-	err := matcher.Matches(0)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *AnyOfTest) OneTrue() {
-	matcher := AnyOf(
-		&fakeAnyOfMatcher{"", NewFatalError("foo")},
-		17,
-		&fakeAnyOfMatcher{"", errors.New("foo")},
-		&fakeAnyOfMatcher{"", nil},
-		&fakeAnyOfMatcher{"", errors.New("foo")},
-	)
-
-	err := matcher.Matches(0)
-	ExpectEq(nil, err)
-}
-
-func (t *AnyOfTest) OneEqual() {
-	matcher := AnyOf(
-		&fakeAnyOfMatcher{"", NewFatalError("foo")},
-		&fakeAnyOfMatcher{"", errors.New("foo")},
-		13,
-		"taco",
-		19,
-		&fakeAnyOfMatcher{"", errors.New("foo")},
-	)
-
-	err := matcher.Matches("taco")
-	ExpectEq(nil, err)
-}
-
-func (t *AnyOfTest) OneFatal() {
-	matcher := AnyOf(
-		&fakeAnyOfMatcher{"", errors.New("foo")},
-		17,
-		&fakeAnyOfMatcher{"", NewFatalError("taco")},
-		&fakeAnyOfMatcher{"", errors.New("foo")},
-	)
-
-	err := matcher.Matches(0)
-	ExpectThat(err, Error(Equals("taco")))
-}
-
-func (t *AnyOfTest) AllFalseAndNotEqual() {
-	matcher := AnyOf(
-		&fakeAnyOfMatcher{"", errors.New("foo")},
-		17,
-		&fakeAnyOfMatcher{"", errors.New("foo")},
-		19,
-	)
-
-	err := matcher.Matches(0)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *AnyOfTest) DescriptionForEmptySet() {
-	matcher := AnyOf()
-	ExpectEq("or()", matcher.Description())
-}
-
-func (t *AnyOfTest) DescriptionForNonEmptySet() {
-	matcher := AnyOf(
-		&fakeAnyOfMatcher{"taco", nil},
-		"burrito",
-		&fakeAnyOfMatcher{"enchilada", nil},
-	)
-
-	ExpectEq("or(taco, burrito, enchilada)", matcher.Description())
-}
@@ -1,53 +0,0 @@
-// Copyright 2011 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type AnyTest struct {
-}
-
-func init() { RegisterTestSuite(&AnyTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *AnyTest) Description() {
-	m := Any()
-	ExpectEq("is anything", m.Description())
-}
-
-func (t *AnyTest) Matches() {
-	var err error
-	m := Any()
-
-	err = m.Matches(nil)
-	ExpectEq(nil, err)
-
-	err = m.Matches(17)
-	ExpectEq(nil, err)
-
-	err = m.Matches("taco")
-	ExpectEq(nil, err)
-}
@@ -1,234 +0,0 @@
-// Copyright 2012 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type ContainsTest struct{}
-
-func init() { RegisterTestSuite(&ContainsTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *ContainsTest) WrongTypeCandidates() {
-	m := Contains("")
-	ExpectEq("contains: ", m.Description())
-
-	var err error
-
-	// Nil candidate
-	err = m.Matches(nil)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("array")))
-	ExpectThat(err, Error(HasSubstr("slice")))
-
-	// String candidate
-	err = m.Matches("")
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("array")))
-	ExpectThat(err, Error(HasSubstr("slice")))
-
-	// Map candidate
-	err = m.Matches(make(map[string]string))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("array")))
-	ExpectThat(err, Error(HasSubstr("slice")))
-}
-
-func (t *ContainsTest) NilArgument() {
-	m := Contains(nil)
-	ExpectEq("contains: is nil", m.Description())
-
-	var c interface{}
-	var err error
-
-	// Empty array of pointers
-	c = [...]*int{}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Empty slice of pointers
-	c = []*int{}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-empty array of integers
-	c = [...]int{17, 0, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-empty slice of integers
-	c = []int{17, 0, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-matching array of pointers
-	c = [...]*int{new(int), new(int)}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-matching slice of pointers
-	c = []*int{new(int), new(int)}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Matching array of pointers
-	c = [...]*int{new(int), nil, new(int)}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Matching slice of pointers
-	c = []*int{new(int), nil, new(int)}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-matching slice of pointers from matching array
-	someArray := [...]*int{new(int), nil, new(int)}
-	c = someArray[0:1]
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *ContainsTest) StringArgument() {
-	m := Contains("taco")
-	ExpectEq("contains: taco", m.Description())
-
-	var c interface{}
-	var err error
-
-	// Non-matching array of strings
-	c = [...]string{"burrito", "enchilada"}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-matching slice of strings
-	c = []string{"burrito", "enchilada"}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Matching array of strings
-	c = [...]string{"burrito", "taco", "enchilada"}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Matching slice of strings
-	c = []string{"burrito", "taco", "enchilada"}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-matching slice of strings from matching array
-	someArray := [...]string{"burrito", "taco", "enchilada"}
-	c = someArray[0:1]
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *ContainsTest) IntegerArgument() {
-	m := Contains(int(17))
-	ExpectEq("contains: 17", m.Description())
-
-	var c interface{}
-	var err error
-
-	// Non-matching array of integers
-	c = [...]int{13, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-matching slice of integers
-	c = []int{13, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Matching array of integers
-	c = [...]int{13, 17, 19}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Matching slice of integers
-	c = []int{13, 17, 19}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-matching slice of integers from matching array
-	someArray := [...]int{13, 17, 19}
-	c = someArray[0:1]
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-matching array of floats
-	c = [...]float32{13, 17.5, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-matching slice of floats
-	c = []float32{13, 17.5, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Matching array of floats
-	c = [...]float32{13, 17, 19}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Matching slice of floats
-	c = []float32{13, 17, 19}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-}
-
-func (t *ContainsTest) MatcherArgument() {
-	m := Contains(HasSubstr("ac"))
-	ExpectEq("contains: has substring \"ac\"", m.Description())
-
-	var c interface{}
-	var err error
-
-	// Non-matching array of strings
-	c = [...]string{"burrito", "enchilada"}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Non-matching slice of strings
-	c = []string{"burrito", "enchilada"}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Matching array of strings
-	c = [...]string{"burrito", "taco", "enchilada"}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Matching slice of strings
-	c = []string{"burrito", "taco", "enchilada"}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-matching slice of strings from matching array
-	someArray := [...]string{"burrito", "taco", "enchilada"}
-	c = someArray[0:1]
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-}
@@ -1,344 +0,0 @@
-// Copyright 2012 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	"bytes"
-	"testing"
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type DeepEqualsTest struct{}
-
-func init() { RegisterTestSuite(&DeepEqualsTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *DeepEqualsTest) WrongTypeCandidateWithScalarValue() {
-	var x int = 17
-	m := DeepEquals(x)
-
-	var err error
-
-	// Nil candidate.
-	err = m.Matches(nil)
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("<nil>")))
-
-	// Int alias candidate.
-	type intAlias int
-	err = m.Matches(intAlias(x))
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("intAlias")))
-
-	// String candidate.
-	err = m.Matches("taco")
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("string")))
-
-	// Byte slice candidate.
-	err = m.Matches([]byte{})
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("[]uint8")))
-
-	// Other slice candidate.
-	err = m.Matches([]uint16{})
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("[]uint16")))
-
-	// Unsigned int candidate.
-	err = m.Matches(uint(17))
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("uint")))
-}
-
-func (t *DeepEqualsTest) WrongTypeCandidateWithByteSliceValue() {
-	x := []byte{}
-	m := DeepEquals(x)
-
-	var err error
-
-	// Nil candidate.
-	err = m.Matches(nil)
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("<nil>")))
-
-	// String candidate.
-	err = m.Matches("taco")
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("string")))
-
-	// Slice candidate with wrong value type.
-	err = m.Matches([]uint16{})
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("[]uint16")))
-}
-
-func (t *DeepEqualsTest) WrongTypeCandidateWithOtherSliceValue() {
-	x := []uint16{}
-	m := DeepEquals(x)
-
-	var err error
-
-	// Nil candidate.
-	err = m.Matches(nil)
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("<nil>")))
-
-	// String candidate.
-	err = m.Matches("taco")
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("string")))
-
-	// Byte slice candidate with wrong value type.
-	err = m.Matches([]byte{})
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("[]uint8")))
-
-	// Other slice candidate with wrong value type.
-	err = m.Matches([]uint32{})
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("[]uint32")))
-}
-
-func (t *DeepEqualsTest) WrongTypeCandidateWithNilLiteralValue() {
-	m := DeepEquals(nil)
-
-	var err error
-
-	// String candidate.
-	err = m.Matches("taco")
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("string")))
-
-	// Nil byte slice candidate.
-	err = m.Matches([]byte(nil))
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("[]uint8")))
-
-	// Nil other slice candidate.
-	err = m.Matches([]uint16(nil))
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("type")))
-	ExpectThat(err, Error(HasSubstr("[]uint16")))
-}
-
-func (t *DeepEqualsTest) NilLiteralValue() {
-	m := DeepEquals(nil)
-	ExpectEq("deep equals: <nil>", m.Description())
-
-	var c interface{}
-	var err error
-
-	// Nil literal candidate.
-	c = nil
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-}
-
-func (t *DeepEqualsTest) IntValue() {
-	m := DeepEquals(int(17))
-	ExpectEq("deep equals: 17", m.Description())
-
-	var c interface{}
-	var err error
-
-	// Matching int.
-	c = int(17)
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-matching int.
-	c = int(18)
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *DeepEqualsTest) ByteSliceValue() {
-	x := []byte{17, 19}
-	m := DeepEquals(x)
-	ExpectEq("deep equals: [17 19]", m.Description())
-
-	var c []byte
-	var err error
-
-	// Matching.
-	c = make([]byte, len(x))
-	AssertEq(len(x), copy(c, x))
-
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Nil slice.
-	c = []byte(nil)
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("which is nil")))
-
-	// Prefix.
-	AssertGt(len(x), 1)
-	c = make([]byte, len(x)-1)
-	AssertEq(len(x)-1, copy(c, x))
-
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Suffix.
-	c = make([]byte, len(x)+1)
-	AssertEq(len(x), copy(c, x))
-
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *DeepEqualsTest) OtherSliceValue() {
-	x := []uint16{17, 19}
-	m := DeepEquals(x)
-	ExpectEq("deep equals: [17 19]", m.Description())
-
-	var c []uint16
-	var err error
-
-	// Matching.
-	c = make([]uint16, len(x))
-	AssertEq(len(x), copy(c, x))
-
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Nil slice.
-	c = []uint16(nil)
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("which is nil")))
-
-	// Prefix.
-	AssertGt(len(x), 1)
-	c = make([]uint16, len(x)-1)
-	AssertEq(len(x)-1, copy(c, x))
-
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-
-	// Suffix.
-	c = make([]uint16, len(x)+1)
-	AssertEq(len(x), copy(c, x))
-
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *DeepEqualsTest) NilByteSliceValue() {
-	x := []byte(nil)
-	m := DeepEquals(x)
-	ExpectEq("deep equals: <nil slice>", m.Description())
-
-	var c []byte
-	var err error
-
-	// Nil slice.
-	c = []byte(nil)
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-nil slice.
-	c = []byte{}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *DeepEqualsTest) NilOtherSliceValue() {
-	x := []uint16(nil)
-	m := DeepEquals(x)
-	ExpectEq("deep equals: <nil slice>", m.Description())
-
-	var c []uint16
-	var err error
-
-	// Nil slice.
-	c = []uint16(nil)
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-nil slice.
-	c = []uint16{}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("")))
-}
-
-////////////////////////////////////////////////////////////////////////
-// Benchmarks
-////////////////////////////////////////////////////////////////////////
-
-func benchmarkWithSize(b *testing.B, size int) {
-	b.StopTimer()
-	buf := bytes.Repeat([]byte{0x01}, size)
-	bufCopy := make([]byte, size)
-	copy(bufCopy, buf)
-
-	matcher := DeepEquals(buf)
-	b.StartTimer()
-
-	for i := 0; i < b.N; i++ {
-		matcher.Matches(bufCopy)
-	}
-
-	b.SetBytes(int64(size))
-}
-
-func BenchmarkShortByteSlice(b *testing.B) {
-	benchmarkWithSize(b, 256)
-}
-
-func BenchmarkLongByteSlice(b *testing.B) {
-	benchmarkWithSize(b, 1<<24)
-}
@@ -1,208 +0,0 @@
-// Copyright 2012 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type ElementsAreTest struct {
-}
-
-func init() { RegisterTestSuite(&ElementsAreTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *ElementsAreTest) EmptySet() {
-	m := ElementsAre()
-	ExpectEq("elements are: []", m.Description())
-
-	var c []interface{}
-	var err error
-
-	// No candidates.
-	c = []interface{}{}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// One candidate.
-	c = []interface{}{17}
-	err = m.Matches(c)
-	ExpectThat(err, Error(HasSubstr("length 1")))
-}
-
-func (t *ElementsAreTest) OneMatcher() {
-	m := ElementsAre(LessThan(17))
-	ExpectEq("elements are: [less than 17]", m.Description())
-
-	var c []interface{}
-	var err error
-
-	// No candidates.
-	c = []interface{}{}
-	err = m.Matches(c)
-	ExpectThat(err, Error(HasSubstr("length 0")))
-
-	// Matching candidate.
-	c = []interface{}{16}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-matching candidate.
-	c = []interface{}{19}
-	err = m.Matches(c)
-	ExpectNe(nil, err)
-
-	// Two candidates.
-	c = []interface{}{17, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(HasSubstr("length 2")))
-}
-
-func (t *ElementsAreTest) OneValue() {
-	m := ElementsAre(17)
-	ExpectEq("elements are: [17]", m.Description())
-
-	var c []interface{}
-	var err error
-
-	// No candidates.
-	c = []interface{}{}
-	err = m.Matches(c)
-	ExpectThat(err, Error(HasSubstr("length 0")))
-
-	// Matching int.
-	c = []interface{}{int(17)}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Matching float.
-	c = []interface{}{float32(17)}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// Non-matching candidate.
-	c = []interface{}{19}
-	err = m.Matches(c)
-	ExpectNe(nil, err)
-
-	// Two candidates.
-	c = []interface{}{17, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(HasSubstr("length 2")))
-}
-
-func (t *ElementsAreTest) MultipleElements() {
-	m := ElementsAre("taco", LessThan(17))
-	ExpectEq("elements are: [taco, less than 17]", m.Description())
-
-	var c []interface{}
-	var err error
-
-	// One candidate.
-	c = []interface{}{17}
-	err = m.Matches(c)
-	ExpectThat(err, Error(HasSubstr("length 1")))
-
-	// Both matching.
-	c = []interface{}{"taco", 16}
-	err = m.Matches(c)
-	ExpectEq(nil, err)
-
-	// First non-matching.
-	c = []interface{}{"burrito", 16}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("whose element 0 doesn't match")))
-
-	// Second non-matching.
-	c = []interface{}{"taco", 17}
-	err = m.Matches(c)
-	ExpectThat(err, Error(Equals("whose element 1 doesn't match")))
-
-	// Three candidates.
-	c = []interface{}{"taco", 17, 19}
-	err = m.Matches(c)
-	ExpectThat(err, Error(HasSubstr("length 3")))
-}
-
-func (t *ElementsAreTest) ArrayCandidates() {
-	m := ElementsAre("taco", LessThan(17))
-
-	var err error
-
-	// One candidate.
-	err = m.Matches([1]interface{}{"taco"})
-	ExpectThat(err, Error(HasSubstr("length 1")))
-
-	// Both matching.
-	err = m.Matches([2]interface{}{"taco", 16})
-	ExpectEq(nil, err)
-
-	// First non-matching.
-	err = m.Matches([2]interface{}{"burrito", 16})
-	ExpectThat(err, Error(Equals("whose element 0 doesn't match")))
-}
-
-func (t *ElementsAreTest) WrongTypeCandidate() {
-	m := ElementsAre("taco")
-
-	var err error
-
-	// String candidate.
-	err = m.Matches("taco")
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("array")))
-	ExpectThat(err, Error(HasSubstr("slice")))
-
-	// Map candidate.
-	err = m.Matches(map[string]string{})
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("array")))
-	ExpectThat(err, Error(HasSubstr("slice")))
-
-	// Nil candidate.
-	err = m.Matches(nil)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("array")))
-	ExpectThat(err, Error(HasSubstr("slice")))
-}
-
-func (t *ElementsAreTest) PropagatesFatality() {
-	m := ElementsAre(LessThan(17))
-	ExpectEq("elements are: [less than 17]", m.Description())
-
-	var c []interface{}
-	var err error
-
-	// Non-fatal error.
-	c = []interface{}{19}
-	err = m.Matches(c)
-	AssertNe(nil, err)
-	ExpectFalse(isFatal(err))
-
-	// Fatal error.
-	c = []interface{}{"taco"}
-	err = m.Matches(c)
-	AssertNe(nil, err)
-	ExpectTrue(isFatal(err))
-}
@@ -1,92 +0,0 @@
-// Copyright 2011 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	"errors"
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type ErrorTest struct {
-	matcherCalled     bool
-	suppliedCandidate interface{}
-	wrappedError      error
-
-	matcher Matcher
-}
-
-func init() { RegisterTestSuite(&ErrorTest{}) }
-
-func (t *ErrorTest) SetUp(i *TestInfo) {
-	wrapped := &fakeMatcher{
-		func(c interface{}) error {
-			t.matcherCalled = true
-			t.suppliedCandidate = c
-			return t.wrappedError
-		},
-		"is foo",
-	}
-
-	t.matcher = Error(wrapped)
-}
-
-func isFatal(err error) bool {
-	_, isFatal := err.(*FatalError)
-	return isFatal
-}
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *ErrorTest) Description() {
-	ExpectThat(t.matcher.Description(), Equals("error is foo"))
-}
-
-func (t *ErrorTest) CandidateIsNil() {
-	err := t.matcher.Matches(nil)
-
-	ExpectThat(t.matcherCalled, Equals(false))
-	ExpectThat(err.Error(), Equals("which is not an error"))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *ErrorTest) CandidateIsString() {
-	err := t.matcher.Matches("taco")
-
-	ExpectThat(t.matcherCalled, Equals(false))
-	ExpectThat(err.Error(), Equals("which is not an error"))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *ErrorTest) CallsWrappedMatcher() {
-	candidate := errors.New("taco")
-	t.matcher.Matches(candidate)
-
-	ExpectThat(t.matcherCalled, Equals(true))
-	ExpectThat(t.suppliedCandidate, Equals("taco"))
-}
-
-func (t *ErrorTest) ReturnsWrappedMatcherResult() {
-	t.wrappedError = errors.New("burrito")
-	err := t.matcher.Matches(errors.New(""))
-	ExpectThat(err, Equals(t.wrappedError))
-}
@@ -1,92 +0,0 @@
-// Copyright 2011 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type HasSubstrTest struct {
-}
-
-func init() { RegisterTestSuite(&HasSubstrTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *HasSubstrTest) Description() {
-	matcher := HasSubstr("taco")
-	ExpectThat(matcher.Description(), Equals("has substring \"taco\""))
-}
-
-func (t *HasSubstrTest) CandidateIsNil() {
-	matcher := HasSubstr("")
-	err := matcher.Matches(nil)
-
-	ExpectThat(err, Error(Equals("which is not a string")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *HasSubstrTest) CandidateIsInteger() {
-	matcher := HasSubstr("")
-	err := matcher.Matches(17)
-
-	ExpectThat(err, Error(Equals("which is not a string")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *HasSubstrTest) CandidateIsByteSlice() {
-	matcher := HasSubstr("")
-	err := matcher.Matches([]byte{17})
-
-	ExpectThat(err, Error(Equals("which is not a string")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *HasSubstrTest) CandidateDoesntHaveSubstring() {
-	matcher := HasSubstr("taco")
-	err := matcher.Matches("tac")
-
-	ExpectThat(err, Error(Equals("")))
-	ExpectFalse(isFatal(err))
-}
-
-func (t *HasSubstrTest) CandidateEqualsArg() {
-	matcher := HasSubstr("taco")
-	err := matcher.Matches("taco")
-
-	ExpectThat(err, Equals(nil))
-}
-
-func (t *HasSubstrTest) CandidateHasProperSubstring() {
-	matcher := HasSubstr("taco")
-	err := matcher.Matches("burritos and tacos")
-
-	ExpectThat(err, Equals(nil))
-}
-
-func (t *HasSubstrTest) EmptyStringIsAlwaysSubString() {
-	matcher := HasSubstr("")
-	err := matcher.Matches("asdf")
-
-	ExpectThat(err, Equals(nil))
-}
@@ -1,849 +0,0 @@
-// Copyright 2012 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	"fmt"
-	"io"
-	"unsafe"
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type IdenticalToTest struct {
-}
-
-func init() { RegisterTestSuite(&IdenticalToTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *IdenticalToTest) TypesNotIdentical() {
-	var m Matcher
-	var err error
-
-	type intAlias int
-
-	// Type alias expected value
-	m = IdenticalTo(intAlias(17))
-	err = m.Matches(int(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int")))
-
-	// Type alias candidate
-	m = IdenticalTo(int(17))
-	err = m.Matches(intAlias(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.intAlias")))
-
-	// int and uint
-	m = IdenticalTo(int(17))
-	err = m.Matches(uint(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type uint")))
-}
-
-func (t *IdenticalToTest) PredeclaredNilIdentifier() {
-	var m Matcher
-	var err error
-
-	// Nil literal
-	m = IdenticalTo(nil)
-	err = m.Matches(nil)
-	ExpectEq(nil, err)
-
-	// Zero interface var (which is the same as above since IdenticalTo takes an
-	// interface{} as an arg)
-	var nilReader io.Reader
-	var nilWriter io.Writer
-
-	m = IdenticalTo(nilReader)
-	err = m.Matches(nilWriter)
-	ExpectEq(nil, err)
-
-	// Typed nil value.
-	m = IdenticalTo(nil)
-	err = m.Matches((chan int)(nil))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type chan int")))
-
-	// Non-nil value.
-	m = IdenticalTo(nil)
-	err = m.Matches("taco")
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type string")))
-}
-
-func (t *IdenticalToTest) Slices() {
-	var m Matcher
-	var err error
-
-	// Nil expected value
-	m = IdenticalTo(([]int)(nil))
-	ExpectEq("identical to <[]int> []", m.Description())
-
-	err = m.Matches(([]int)(nil))
-	ExpectEq(nil, err)
-
-	err = m.Matches([]int{})
-	ExpectThat(err, Error(Equals("which is not an identical reference")))
-
-	// Non-nil expected value
-	o1 := make([]int, 1)
-	o2 := make([]int, 1)
-	m = IdenticalTo(o1)
-	ExpectEq(fmt.Sprintf("identical to <[]int> %v", o1), m.Description())
-
-	err = m.Matches(o1)
-	ExpectEq(nil, err)
-
-	err = m.Matches(o2)
-	ExpectThat(err, Error(Equals("which is not an identical reference")))
-}
-
-func (t *IdenticalToTest) Maps() {
-	var m Matcher
-	var err error
-
-	// Nil expected value
-	m = IdenticalTo((map[int]int)(nil))
-	ExpectEq("identical to <map[int]int> map[]", m.Description())
-
-	err = m.Matches((map[int]int)(nil))
-	ExpectEq(nil, err)
-
-	err = m.Matches(map[int]int{})
-	ExpectThat(err, Error(Equals("which is not an identical reference")))
-
-	// Non-nil expected value
-	o1 := map[int]int{}
-	o2 := map[int]int{}
-	m = IdenticalTo(o1)
-	ExpectEq(fmt.Sprintf("identical to <map[int]int> %v", o1), m.Description())
-
-	err = m.Matches(o1)
-	ExpectEq(nil, err)
-
-	err = m.Matches(o2)
-	ExpectThat(err, Error(Equals("which is not an identical reference")))
-}
-
-func (t *IdenticalToTest) Functions() {
-	var m Matcher
-	var err error
-
-	// Nil expected value
-	m = IdenticalTo((func())(nil))
-	ExpectEq("identical to <func()> <nil>", m.Description())
-
-	err = m.Matches((func())(nil))
-	ExpectEq(nil, err)
-
-	err = m.Matches(func() {})
-	ExpectThat(err, Error(Equals("which is not an identical reference")))
-
-	// Non-nil expected value
-	o1 := func() {}
-	o2 := func() {}
-	m = IdenticalTo(o1)
-	ExpectEq(fmt.Sprintf("identical to <func()> %v", o1), m.Description())
-
-	err = m.Matches(o1)
-	ExpectEq(nil, err)
-
-	err = m.Matches(o2)
-	ExpectThat(err, Error(Equals("which is not an identical reference")))
-}
-
-func (t *IdenticalToTest) Channels() {
-	var m Matcher
-	var err error
-
-	// Nil expected value
-	m = IdenticalTo((chan int)(nil))
-	ExpectEq("identical to <chan int> <nil>", m.Description())
-
-	err = m.Matches((chan int)(nil))
-	ExpectEq(nil, err)
-
-	err = m.Matches(make(chan int))
-	ExpectThat(err, Error(Equals("which is not an identical reference")))
-
-	// Non-nil expected value
-	o1 := make(chan int)
-	o2 := make(chan int)
-	m = IdenticalTo(o1)
-	ExpectEq(fmt.Sprintf("identical to <chan int> %v", o1), m.Description())
-
-	err = m.Matches(o1)
-	ExpectEq(nil, err)
-
-	err = m.Matches(o2)
-	ExpectThat(err, Error(Equals("which is not an identical reference")))
-}
-
-func (t *IdenticalToTest) Bools() {
-	var m Matcher
-	var err error
-
-	// false
-	m = IdenticalTo(false)
-	ExpectEq("identical to <bool> false", m.Description())
-
-	err = m.Matches(false)
-	ExpectEq(nil, err)
-
-	err = m.Matches(true)
-	ExpectThat(err, Error(Equals("")))
-
-	// true
-	m = IdenticalTo(true)
-	ExpectEq("identical to <bool> true", m.Description())
-
-	err = m.Matches(false)
-	ExpectThat(err, Error(Equals("")))
-
-	err = m.Matches(true)
-	ExpectEq(nil, err)
-}
-
-func (t *IdenticalToTest) Ints() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(int(17))
-	ExpectEq("identical to <int> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(int(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType int
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Int8s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(int8(17))
-	ExpectEq("identical to <int8> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(int8(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType int8
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Int16s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(int16(17))
-	ExpectEq("identical to <int16> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(int16(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType int16
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Int32s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(int32(17))
-	ExpectEq("identical to <int32> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(int32(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType int32
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int16(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int16")))
-}
-
-func (t *IdenticalToTest) Int64s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(int64(17))
-	ExpectEq("identical to <int64> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(int64(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType int64
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Uints() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(uint(17))
-	ExpectEq("identical to <uint> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(uint(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType uint
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Uint8s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(uint8(17))
-	ExpectEq("identical to <uint8> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(uint8(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType uint8
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Uint16s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(uint16(17))
-	ExpectEq("identical to <uint16> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(uint16(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType uint16
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Uint32s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(uint32(17))
-	ExpectEq("identical to <uint32> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(uint32(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType uint32
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Uint64s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(uint64(17))
-	ExpectEq("identical to <uint64> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(uint64(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType uint64
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Uintptrs() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(uintptr(17))
-	ExpectEq("identical to <uintptr> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(uintptr(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType uintptr
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Float32s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(float32(17))
-	ExpectEq("identical to <float32> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(float32(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType float32
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Float64s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(float64(17))
-	ExpectEq("identical to <float64> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(float64(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType float64
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Complex64s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(complex64(17))
-	ExpectEq("identical to <complex64> (17+0i)", m.Description())
-
-	// Identical value
-	err = m.Matches(complex64(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType complex64
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) Complex128s() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo(complex128(17))
-	ExpectEq("identical to <complex128> (17+0i)", m.Description())
-
-	// Identical value
-	err = m.Matches(complex128(17))
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType complex128
-	err = m.Matches(myType(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) EmptyComparableArrays() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo([0]int{})
-	ExpectEq("identical to <[0]int> []", m.Description())
-
-	// Identical value
-	err = m.Matches([0]int{})
-	ExpectEq(nil, err)
-
-	// Length too long
-	err = m.Matches([1]int{17})
-	ExpectThat(err, Error(Equals("which is of type [1]int")))
-
-	// Element type alias
-	type myType int
-	err = m.Matches([0]myType{})
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type [0]oglematchers_test.myType")))
-
-	// Completely wrong element type
-	err = m.Matches([0]int32{})
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type [0]int32")))
-}
-
-func (t *IdenticalToTest) NonEmptyComparableArrays() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo([2]int{17, 19})
-	ExpectEq("identical to <[2]int> [17 19]", m.Description())
-
-	// Identical value
-	err = m.Matches([2]int{17, 19})
-	ExpectEq(nil, err)
-
-	// Length too short
-	err = m.Matches([1]int{17})
-	ExpectThat(err, Error(Equals("which is of type [1]int")))
-
-	// Length too long
-	err = m.Matches([3]int{17, 19, 23})
-	ExpectThat(err, Error(Equals("which is of type [3]int")))
-
-	// First element different
-	err = m.Matches([2]int{13, 19})
-	ExpectThat(err, Error(Equals("")))
-
-	// Second element different
-	err = m.Matches([2]int{17, 23})
-	ExpectThat(err, Error(Equals("")))
-
-	// Element type alias
-	type myType int
-	err = m.Matches([2]myType{17, 19})
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type [2]oglematchers_test.myType")))
-
-	// Completely wrong element type
-	err = m.Matches([2]int32{17, 19})
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type [2]int32")))
-}
-
-func (t *IdenticalToTest) NonEmptyArraysOfComparableArrays() {
-	var m Matcher
-	var err error
-
-	x := [2][2]int{
-		[2]int{17, 19},
-		[2]int{23, 29},
-	}
-	m = IdenticalTo(x)
-	ExpectEq("identical to <[2][2]int> [[17 19] [23 29]]", m.Description())
-
-	// Identical value
-	err = m.Matches([2][2]int{[2]int{17, 19}, [2]int{23, 29}})
-	ExpectEq(nil, err)
-
-	// Outer length too short
-	err = m.Matches([1][2]int{[2]int{17, 19}})
-	ExpectThat(err, Error(Equals("which is of type [1][2]int")))
-
-	// Inner length too short
-	err = m.Matches([2][1]int{[1]int{17}, [1]int{23}})
-	ExpectThat(err, Error(Equals("which is of type [2][1]int")))
-
-	// First element different
-	err = m.Matches([2][2]int{[2]int{13, 19}, [2]int{23, 29}})
-	ExpectThat(err, Error(Equals("")))
-
-	// Element type alias
-	type myType int
-	err = m.Matches([2][2]myType{[2]myType{17, 19}, [2]myType{23, 29}})
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type [2][2]oglematchers_test.myType")))
-}
-
-func (t *IdenticalToTest) NonComparableArrays() {
-	x := [0]func(){}
-	f := func() { IdenticalTo(x) }
-	ExpectThat(f, Panics(HasSubstr("is not comparable")))
-}
-
-func (t *IdenticalToTest) ArraysOfNonComparableArrays() {
-	x := [0][0]func(){}
-	f := func() { IdenticalTo(x) }
-	ExpectThat(f, Panics(HasSubstr("is not comparable")))
-}
-
-func (t *IdenticalToTest) Strings() {
-	var m Matcher
-	var err error
-
-	m = IdenticalTo("taco")
-	ExpectEq("identical to <string> taco", m.Description())
-
-	// Identical value
-	err = m.Matches("ta" + "co")
-	ExpectEq(nil, err)
-
-	// Type alias
-	type myType string
-	err = m.Matches(myType("taco"))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) ComparableStructs() {
-	var m Matcher
-	var err error
-
-	type subStruct struct {
-		i int
-	}
-
-	type myStruct struct {
-		u uint
-		s subStruct
-	}
-
-	x := myStruct{17, subStruct{19}}
-	m = IdenticalTo(x)
-	ExpectEq("identical to <oglematchers_test.myStruct> {17 {19}}", m.Description())
-
-	// Identical value
-	err = m.Matches(myStruct{17, subStruct{19}})
-	ExpectEq(nil, err)
-
-	// Wrong outer field
-	err = m.Matches(myStruct{13, subStruct{19}})
-	ExpectThat(err, Error(Equals("")))
-
-	// Wrong inner field
-	err = m.Matches(myStruct{17, subStruct{23}})
-	ExpectThat(err, Error(Equals("")))
-
-	// Type alias
-	type myType myStruct
-	err = m.Matches(myType{17, subStruct{19}})
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) NonComparableStructs() {
-	type subStruct struct {
-		s []int
-	}
-
-	type myStruct struct {
-		u uint
-		s subStruct
-	}
-
-	x := myStruct{17, subStruct{[]int{19}}}
-	f := func() { IdenticalTo(x) }
-	ExpectThat(f, Panics(AllOf(HasSubstr("IdenticalTo"), HasSubstr("comparable"))))
-}
-
-func (t *IdenticalToTest) NilUnsafePointer() {
-	var m Matcher
-	var err error
-
-	x := unsafe.Pointer(nil)
-	m = IdenticalTo(x)
-	ExpectEq(fmt.Sprintf("identical to <unsafe.Pointer> %v", x), m.Description())
-
-	// Identical value
-	err = m.Matches(unsafe.Pointer(nil))
-	ExpectEq(nil, err)
-
-	// Wrong value
-	j := 17
-	err = m.Matches(unsafe.Pointer(&j))
-	ExpectThat(err, Error(Equals("")))
-
-	// Type alias
-	type myType unsafe.Pointer
-	err = m.Matches(myType(unsafe.Pointer(nil)))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) NonNilUnsafePointer() {
-	var m Matcher
-	var err error
-
-	i := 17
-	x := unsafe.Pointer(&i)
-	m = IdenticalTo(x)
-	ExpectEq(fmt.Sprintf("identical to <unsafe.Pointer> %v", x), m.Description())
-
-	// Identical value
-	err = m.Matches(unsafe.Pointer(&i))
-	ExpectEq(nil, err)
-
-	// Nil value
-	err = m.Matches(unsafe.Pointer(nil))
-	ExpectThat(err, Error(Equals("")))
-
-	// Wrong value
-	j := 17
-	err = m.Matches(unsafe.Pointer(&j))
-	ExpectThat(err, Error(Equals("")))
-
-	// Type alias
-	type myType unsafe.Pointer
-	err = m.Matches(myType(unsafe.Pointer(&i)))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type oglematchers_test.myType")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
-
-func (t *IdenticalToTest) IntAlias() {
-	var m Matcher
-	var err error
-
-	type intAlias int
-
-	m = IdenticalTo(intAlias(17))
-	ExpectEq("identical to <oglematchers_test.intAlias> 17", m.Description())
-
-	// Identical value
-	err = m.Matches(intAlias(17))
-	ExpectEq(nil, err)
-
-	// Int
-	err = m.Matches(int(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int")))
-
-	// Completely wrong type
-	err = m.Matches(int32(17))
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("which is of type int32")))
-}
@@ -1,92 +0,0 @@
-// Copyright 2011 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type MatchesRegexpTest struct {
-}
-
-func init() { RegisterTestSuite(&MatchesRegexpTest{}) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *MatchesRegexpTest) Description() {
-	m := MatchesRegexp("foo.*bar")
-	ExpectEq("matches regexp \"foo.*bar\"", m.Description())
-}
-
-func (t *MatchesRegexpTest) InvalidRegexp() {
-	ExpectThat(
-		func() { MatchesRegexp("(foo") },
-		Panics(HasSubstr("missing closing )")))
-}
-
-func (t *MatchesRegexpTest) CandidateIsNil() {
-	m := MatchesRegexp("")
-	err := m.Matches(nil)
-
-	ExpectThat(err, Error(Equals("which is not a string or []byte")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *MatchesRegexpTest) CandidateIsInteger() {
-	m := MatchesRegexp("")
-	err := m.Matches(17)
-
-	ExpectThat(err, Error(Equals("which is not a string or []byte")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *MatchesRegexpTest) NonMatchingCandidates() {
-	m := MatchesRegexp("fo[op]\\s+x")
-	var err error
-
-	err = m.Matches("fon x")
-	ExpectThat(err, Error(Equals("")))
-	ExpectFalse(isFatal(err))
-
-	err = m.Matches("fopx")
-	ExpectThat(err, Error(Equals("")))
-	ExpectFalse(isFatal(err))
-
-	err = m.Matches("fop   ")
-	ExpectThat(err, Error(Equals("")))
-	ExpectFalse(isFatal(err))
-}
-
-func (t *MatchesRegexpTest) MatchingCandidates() {
-	m := MatchesRegexp("fo[op]\\s+x")
-	var err error
-
-	err = m.Matches("foo x")
-	ExpectEq(nil, err)
-
-	err = m.Matches("fop     x")
-	ExpectEq(nil, err)
-
-	err = m.Matches("blah blah foo x blah blah")
-	ExpectEq(nil, err)
-}
@@ -1,107 +0,0 @@
-// Copyright 2011 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	"errors"
-	"testing"
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type fakeMatcher struct {
-	matchFunc   func(interface{}) error
-	description string
-}
-
-func (m *fakeMatcher) Matches(c interface{}) error {
-	return m.matchFunc(c)
-}
-
-func (m *fakeMatcher) Description() string {
-	return m.description
-}
-
-type NotTest struct {
-}
-
-func init()                     { RegisterTestSuite(&NotTest{}) }
-func TestOgletest(t *testing.T) { RunTests(t) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *NotTest) CallsWrapped() {
-	var suppliedCandidate interface{}
-	matchFunc := func(c interface{}) error {
-		suppliedCandidate = c
-		return nil
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Not(wrapped)
-
-	matcher.Matches(17)
-	ExpectThat(suppliedCandidate, Equals(17))
-}
-
-func (t *NotTest) WrappedReturnsTrue() {
-	matchFunc := func(c interface{}) error {
-		return nil
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Not(wrapped)
-
-	err := matcher.Matches(0)
-	ExpectThat(err, Error(Equals("")))
-}
-
-func (t *NotTest) WrappedReturnsNonFatalError() {
-	matchFunc := func(c interface{}) error {
-		return errors.New("taco")
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Not(wrapped)
-
-	err := matcher.Matches(0)
-	ExpectEq(nil, err)
-}
-
-func (t *NotTest) WrappedReturnsFatalError() {
-	matchFunc := func(c interface{}) error {
-		return NewFatalError("taco")
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Not(wrapped)
-
-	err := matcher.Matches(0)
-	ExpectThat(err, Error(Equals("taco")))
-}
-
-func (t *NotTest) Description() {
-	wrapped := &fakeMatcher{nil, "taco"}
-	matcher := Not(wrapped)
-
-	ExpectEq("not(taco)", matcher.Description())
-}
@@ -1,2 +0,0 @@
-#ignore
-timeout=1s
@@ -1,141 +0,0 @@
-// Copyright 2011 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	"errors"
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type PanicsTest struct {
-	matcherCalled     bool
-	suppliedCandidate interface{}
-	wrappedError      error
-
-	matcher Matcher
-}
-
-func init() { RegisterTestSuite(&PanicsTest{}) }
-
-func (t *PanicsTest) SetUp(i *TestInfo) {
-	wrapped := &fakeMatcher{
-		func(c interface{}) error {
-			t.matcherCalled = true
-			t.suppliedCandidate = c
-			return t.wrappedError
-		},
-		"foo",
-	}
-
-	t.matcher = Panics(wrapped)
-}
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *PanicsTest) Description() {
-	ExpectThat(t.matcher.Description(), Equals("panics with: foo"))
-}
-
-func (t *PanicsTest) CandidateIsNil() {
-	err := t.matcher.Matches(nil)
-
-	ExpectThat(err, Error(Equals("which is not a zero-arg function")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *PanicsTest) CandidateIsString() {
-	err := t.matcher.Matches("taco")
-
-	ExpectThat(err, Error(Equals("which is not a zero-arg function")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *PanicsTest) CandidateTakesArgs() {
-	err := t.matcher.Matches(func(i int) string { return "" })
-
-	ExpectThat(err, Error(Equals("which is not a zero-arg function")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *PanicsTest) CallsFunction() {
-	callCount := 0
-	t.matcher.Matches(func() string {
-		callCount++
-		return ""
-	})
-
-	ExpectThat(callCount, Equals(1))
-}
-
-func (t *PanicsTest) FunctionDoesntPanic() {
-	err := t.matcher.Matches(func() {})
-
-	ExpectThat(err, Error(Equals("which didn't panic")))
-	ExpectFalse(isFatal(err))
-}
-
-func (t *PanicsTest) CallsWrappedMatcher() {
-	expectedErr := 17
-	t.wrappedError = errors.New("")
-	t.matcher.Matches(func() { panic(expectedErr) })
-
-	ExpectThat(t.suppliedCandidate, Equals(expectedErr))
-}
-
-func (t *PanicsTest) WrappedReturnsTrue() {
-	err := t.matcher.Matches(func() { panic("") })
-
-	ExpectEq(nil, err)
-}
-
-func (t *PanicsTest) WrappedReturnsFatalErrorWithoutText() {
-	t.wrappedError = NewFatalError("")
-	err := t.matcher.Matches(func() { panic(17) })
-
-	ExpectThat(err, Error(Equals("which panicked with: 17")))
-	ExpectFalse(isFatal(err))
-}
-
-func (t *PanicsTest) WrappedReturnsFatalErrorWithText() {
-	t.wrappedError = NewFatalError("which blah")
-	err := t.matcher.Matches(func() { panic(17) })
-
-	ExpectThat(err, Error(Equals("which panicked with: 17, which blah")))
-	ExpectFalse(isFatal(err))
-}
-
-func (t *PanicsTest) WrappedReturnsNonFatalErrorWithoutText() {
-	t.wrappedError = errors.New("")
-	err := t.matcher.Matches(func() { panic(17) })
-
-	ExpectThat(err, Error(Equals("which panicked with: 17")))
-	ExpectFalse(isFatal(err))
-}
-
-func (t *PanicsTest) WrappedReturnsNonFatalErrorWithText() {
-	t.wrappedError = errors.New("which blah")
-	err := t.matcher.Matches(func() { panic(17) })
-
-	ExpectThat(err, Error(Equals("which panicked with: 17, which blah")))
-	ExpectFalse(isFatal(err))
-}
@@ -1,153 +0,0 @@
-// Copyright 2012 Aaron Jacobs. All Rights Reserved.
-// Author: aaronjjacobs@gmail.com (Aaron Jacobs)
-//
-// 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 oglematchers_test
-
-import (
-	"errors"
-	"testing"
-	. "github.com/smartystreets/goconvey/convey/assertions/oglematchers"
-	. "github.com/smartystreets/goconvey/convey/assertions/ogletest"
-)
-
-////////////////////////////////////////////////////////////////////////
-// Helpers
-////////////////////////////////////////////////////////////////////////
-
-type PointeeTest struct{}
-
-func init() { RegisterTestSuite(&PointeeTest{}) }
-
-func TestPointee(t *testing.T) { RunTests(t) }
-
-////////////////////////////////////////////////////////////////////////
-// Tests
-////////////////////////////////////////////////////////////////////////
-
-func (t *PointeeTest) Description() {
-	wrapped := &fakeMatcher{nil, "taco"}
-	matcher := Pointee(wrapped)
-
-	ExpectEq("pointee(taco)", matcher.Description())
-}
-
-func (t *PointeeTest) CandidateIsNotAPointer() {
-	matcher := Pointee(HasSubstr(""))
-	err := matcher.Matches([]byte{})
-
-	ExpectThat(err, Error(Equals("which is not a pointer")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *PointeeTest) CandidateIsANilLiteral() {
-	matcher := Pointee(HasSubstr(""))
-	err := matcher.Matches(nil)
-
-	ExpectThat(err, Error(Equals("which is not a pointer")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *PointeeTest) CandidateIsANilPointer() {
-	matcher := Pointee(HasSubstr(""))
-	err := matcher.Matches((*int)(nil))
-
-	ExpectThat(err, Error(Equals("")))
-	ExpectTrue(isFatal(err))
-}
-
-func (t *PointeeTest) CallsWrapped() {
-	var suppliedCandidate interface{}
-	matchFunc := func(c interface{}) error {
-		suppliedCandidate = c
-		return nil
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Pointee(wrapped)
-
-	someSlice := []byte{}
-	matcher.Matches(&someSlice)
-	ExpectThat(suppliedCandidate, IdenticalTo(someSlice))
-}
-
-func (t *PointeeTest) WrappedReturnsOkay() {
-	matchFunc := func(c interface{}) error {
-		return nil
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Pointee(wrapped)
-
-	err := matcher.Matches(new(int))
-	ExpectEq(nil, err)
-}
-
-func (t *PointeeTest) WrappedReturnsNonFatalNonEmptyError() {
-	matchFunc := func(c interface{}) error {
-		return errors.New("taco")
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Pointee(wrapped)
-
-	i := 17
-	err := matcher.Matches(&i)
-	ExpectFalse(isFatal(err))
-	ExpectThat(err, Error(Equals("taco")))
-}
-
-func (t *PointeeTest) WrappedReturnsNonFatalEmptyError() {
-	matchFunc := func(c interface{}) error {
-		return errors.New("")
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Pointee(wrapped)
-
-	i := 17
-	err := matcher.Matches(&i)
-	ExpectFalse(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("whose pointee")))
-	ExpectThat(err, Error(HasSubstr("17")))
-}
-
-func (t *PointeeTest) WrappedReturnsFatalNonEmptyError() {
-	matchFunc := func(c interface{}) error {
-		return NewFatalError("taco")
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Pointee(wrapped)
-
-	i := 17
-	err := matcher.Matches(&i)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(Equals("taco")))
-}
-
-func (t *PointeeTest) WrappedReturnsFatalEmptyError() {
-	matchFunc := func(c interface{}) error {
-		return NewFatalError("")
-	}
-
-	wrapped := &fakeMatcher{matchFunc, ""}
-	matcher := Pointee(wrapped)
-
-	i := 17
-	err := matcher.Matches(&i)
-	ExpectTrue(isFatal(err))
-	ExpectThat(err, Error(HasSubstr("whose pointee")))
-	ExpectThat(err, Error(HasSubstr("17")))
-}
@@ -1,5 +0,0 @@
-*.6
-6.out
-_obj/
-_test/
-_testmain.go
@@ -1,101 +0,0 @@
-`oglemock` is a mocking framework for the Go programming language with the
-following features:
-
- *  An extensive and extensible set of matchers for expressing call
-    expectations (provided by the [oglematchers][] package).
-
- *  Clean, readable output that tells you exactly what you need to know.
-
- *  Style and semantics similar to [Google Mock][googlemock] and
-    [Google JS Test][google-js-test].
-
- *  Seamless integration with the [ogletest][] unit testing framework.
-
-It can be integrated into any testing framework (including Go's `testing`
-package), but out of the box support is built in to [ogletest][] and that is the
-easiest place to use it.
-
-
-Installation
------------
-
-First, make sure you have installed Go 1.0.2 or newer. See
-[here][golang-install] for instructions.
-
-Use the following command to install `oglemock` and its dependencies, and to
-keep them up to date:
-
-    go get -u github.com/smartystreets/goconvey/convey/assertions/oglemock
-    go get -u github.com/smartystreets/goconvey/convey/assertions/oglemock/createmock
-
-Those commands will install the `oglemock` package itself, along with the
-`createmock` tool that is used to auto-generate mock types.
-
-
-Generating and using mock types
-------------------------------
-
-Automatically generating a mock implementation of an interface is easy. If you
-want to mock interfaces `Bar` and `Baz` from package `foo`, simply run the
-following:
-
-    createmock foo Bar Baz
-
-That will print source code that can be saved to a file and used in your tests.
-For example, to create a `mock_io` package containing mock implementations of
-`io.Reader` and `io.Writer`:
-
-    mkdir mock_io
-    createmock io Reader Writer > mock_io/mock_io.go
-
-The new package will be named `mock_io`, and contain types called `MockReader`
-and `MockWriter`, which implement `io.Reader` and `io.Writer` respectively.
-
-For each generated mock type, there is a corresponding function for creating an
-instance of that type given a `Controller` object (see below). For example, to
-create a mock reader:
-
-```go
-someController := [...]  // See next section.
-someReader := mock_io.NewMockReader(someController, "Mock file reader")
-```
-
-The snippet above creates a mock `io.Reader` that reports failures to
-`someController`. The reader can subsequently have expectations set up and be
-passed to your code under test that uses an `io.Reader`.
-
-
-Getting ahold of a controller
-----------------------------
-
-[oglemock.Controller][controller-ref] is used to create mock objects, and to set
-up and verify expectations for them. You can create one by calling
-`NewController` with an `ErrorReporter`, which is the basic type used to
-interface between `oglemock` and the testing framework within which it is being
-used.
-
-If you are using [ogletest][] you don't need to worry about any of this, since
-the `TestInfo` struct provided to your test's `SetUp` function already contains
-a working `Controller` that you can use to create mock object, and you can use
-the built-in `ExpectCall` function for setting expectations. (See the
-[ogletest documentation][ogletest-docs] for more info.) Otherwise, you will need
-to implement the simple [ErrorReporter interface][reporter-ref] for your test
-environment.
-
-
-Documentation
-------------
-
-For thorough documentation, including information on how to set up expectations,
-see [here][oglemock-docs].
-
-
-[controller-ref]: http://gopkgdoc.appspot.com/pkg/github.com/smartystreets/goconvey/convey/assertions/oglemock#Controller
-[reporter-ref]: http://gopkgdoc.appspot.com/pkg/github.com/smartystreets/goconvey/convey/assertions/oglemock#ErrorReporter
-[golang-install]: http://golang.org/doc/install.html
-[google-js-test]: http://code.google.com/p/google-js-test/
-[googlemock]: http://code.google.com/p/googlemock/
-[oglematchers]: https://github.com/smartystreets/goconvey/convey/assertions/oglematchers
-[oglemock-docs]: http://gopkgdoc.appspot.com/pkg/github.com/smartystreets/goconvey/convey/assertions/oglemock
-[ogletest]: https://github.com/smartystreets/goconvey/convey/assertions/oglematchers
-[ogletest-docs]: http://gopkgdoc.appspot.com/pkg/github.com/smartystreets/goconvey/convey/assertions/ogletest
--- a/Show More
+++ b/Show More