diff --git a/auth.go b/auth.go
index 9cda8b0..010646c 100644
--- a/auth.go
+++ b/auth.go
@@ -3,7 +3,7 @@ package ssh2docker
import (
"fmt"
- "golang.org/x/crypto/ssh"
+ "github.com/moul/ssh2docker/vendor/golang.org/x/crypto/ssh"
)
// ImageIsAllowed returns true if the target image is in the allowed list
diff --git a/auth_test.go b/auth_test.go
index 7a574e8..481e1d2 100644
--- a/auth_test.go
+++ b/auth_test.go
@@ -3,7 +3,7 @@ package ssh2docker
import (
"testing"
- . "github.com/smartystreets/goconvey/convey"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/goconvey/convey"
)
func TestServer_ImageIsAllowed(t *testing.T) {
diff --git a/client.go b/client.go
index 0de7dd2..6a9ffa3 100644
--- a/client.go
+++ b/client.go
@@ -9,9 +9,9 @@ import (
"sync"
"syscall"
- "github.com/Sirupsen/logrus"
- "github.com/kr/pty"
- "golang.org/x/crypto/ssh"
+ "github.com/moul/ssh2docker/vendor/github.com/Sirupsen/logrus"
+ "github.com/moul/ssh2docker/vendor/github.com/kr/pty"
+ "github.com/moul/ssh2docker/vendor/golang.org/x/crypto/ssh"
)
var clientCounter = 0
diff --git a/cmd/ssh2docker/main.go b/cmd/ssh2docker/main.go
index 8eedb49..bb4c63c 100644
--- a/cmd/ssh2docker/main.go
+++ b/cmd/ssh2docker/main.go
@@ -6,9 +6,9 @@ import (
"path"
"strings"
- "github.com/Sirupsen/logrus"
- "github.com/codegangsta/cli"
"github.com/moul/ssh2docker"
+ "github.com/moul/ssh2docker/vendor/github.com/Sirupsen/logrus"
+ "github.com/moul/ssh2docker/vendor/github.com/codegangsta/cli"
)
var VERSION string
diff --git a/keys.go b/keys.go
index 2b82db2..2b394aa 100644
--- a/keys.go
+++ b/keys.go
@@ -5,7 +5,7 @@ import (
"os"
"strings"
- "golang.org/x/crypto/ssh"
+ "github.com/moul/ssh2docker/vendor/golang.org/x/crypto/ssh"
)
// AddHostKey parses/loads an ssh key and registers it to the server
diff --git a/server.go b/server.go
index e04489e..46b8be5 100644
--- a/server.go
+++ b/server.go
@@ -3,8 +3,8 @@ package ssh2docker
import (
"net"
- "github.com/Sirupsen/logrus"
- "golang.org/x/crypto/ssh"
+ "github.com/moul/ssh2docker/vendor/github.com/Sirupsen/logrus"
+ "github.com/moul/ssh2docker/vendor/golang.org/x/crypto/ssh"
)
// Server is the ssh2docker main structure
diff --git a/tty.go b/tty.go
index ca42c80..845a619 100644
--- a/tty.go
+++ b/tty.go
@@ -5,7 +5,7 @@ import (
"syscall"
"unsafe"
- "github.com/Sirupsen/logrus"
+ "github.com/moul/ssh2docker/vendor/github.com/Sirupsen/logrus"
)
func parseDims(b []byte) (uint32, uint32) {
diff --git a/vendor/github.com/Sirupsen/logrus/CHANGELOG.md b/vendor/github.com/Sirupsen/logrus/CHANGELOG.md
new file mode 100644
index 0000000..b1fe4b6
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/CHANGELOG.md
@@ -0,0 +1,41 @@
+# 0.8.6
+
+* hooks/raven: allow passing an initialized client
+
+# 0.8.5
+
+* logrus/core: revert #208
+
+# 0.8.4
+
+* formatter/text: fix data race (#218)
+
+# 0.8.3
+
+* logrus/core: fix entry log level (#208)
+* logrus/core: improve performance of text formatter by 40%
+* logrus/core: expose `LevelHooks` type
+* logrus/core: add support for DragonflyBSD and NetBSD
+* formatter/text: print structs more verbosely
+
+# 0.8.2
+
+* logrus: fix more Fatal family functions
+
+# 0.8.1
+
+* logrus: fix not exiting on `Fatalf` and `Fatalln`
+
+# 0.8.0
+
+* logrus: defaults to stderr instead of stdout
+* hooks/sentry: add special field for `*http.Request`
+* formatter/text: ignore Windows for colors
+
+# 0.7.3
+
+* formatter/\*: allow configuration of timestamp layout
+
+# 0.7.2
+
+* formatter/text: Add configuration option for time format (#158)
diff --git a/vendor/github.com/Sirupsen/logrus/LICENSE b/vendor/github.com/Sirupsen/logrus/LICENSE
new file mode 100644
index 0000000..f090cb4
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Simon Eskildsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/Sirupsen/logrus/README.md b/vendor/github.com/Sirupsen/logrus/README.md
new file mode 100644
index 0000000..9f712a7
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/README.md
@@ -0,0 +1,357 @@
+# Logrus [![Build Status](https://travis-ci.org/Sirupsen/logrus.svg?branch=master)](https://travis-ci.org/Sirupsen/logrus) [![godoc reference](https://godoc.org/github.com/Sirupsen/logrus?status.png)][godoc]
+
+Logrus is a structured logger for Go (golang), completely API compatible with
+the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not
+yet stable (pre 1.0). Logrus itself is completely stable and has been used in
+many large deployments. The core API is unlikely to change much but please
+version control your Logrus to make sure you aren't fetching latest `master` on
+every build.**
+
+Nicely color-coded in development (when a TTY is attached, otherwise just
+plain text):
+
+![Colored](http://i.imgur.com/PY7qMwd.png)
+
+With `log.Formatter = new(logrus.JSONFormatter)`, for easy parsing by logstash
+or Splunk:
+
+```json
+{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
+ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
+
+{"level":"warning","msg":"The group's number increased tremendously!",
+"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
+
+{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
+"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
+
+{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
+"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
+
+{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
+"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
+```
+
+With the default `log.Formatter = new(&log.TextFormatter{})` when a TTY is not
+attached, the output is compatible with the
+[logfmt](http://godoc.org/github.com/kr/logfmt) format:
+
+```text
+time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8
+time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10
+time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true
+time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4
+time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009
+time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true
+exit status 1
+```
+
+#### Example
+
+The simplest way to use Logrus is simply the package-level exported logger:
+
+```go
+package main
+
+import (
+ log "github.com/Sirupsen/logrus"
+)
+
+func main() {
+ log.WithFields(log.Fields{
+ "animal": "walrus",
+ }).Info("A walrus appears")
+}
+```
+
+Note that it's completely api-compatible with the stdlib logger, so you can
+replace your `log` imports everywhere with `log "github.com/Sirupsen/logrus"`
+and you'll now have the flexibility of Logrus. You can customize it all you
+want:
+
+```go
+package main
+
+import (
+ "os"
+ log "github.com/Sirupsen/logrus"
+ "github.com/Sirupsen/logrus/hooks/airbrake"
+)
+
+func init() {
+ // Log as JSON instead of the default ASCII formatter.
+ log.SetFormatter(&log.JSONFormatter{})
+
+ // Use the Airbrake hook to report errors that have Error severity or above to
+ // an exception tracker. You can create custom hooks, see the Hooks section.
+ log.AddHook(airbrake.NewHook("https://example.com", "xyz", "development"))
+
+ // Output to stderr instead of stdout, could also be a file.
+ log.SetOutput(os.Stderr)
+
+ // Only log the warning severity or above.
+ log.SetLevel(log.WarnLevel)
+}
+
+func main() {
+ log.WithFields(log.Fields{
+ "animal": "walrus",
+ "size": 10,
+ }).Info("A group of walrus emerges from the ocean")
+
+ log.WithFields(log.Fields{
+ "omg": true,
+ "number": 122,
+ }).Warn("The group's number increased tremendously!")
+
+ log.WithFields(log.Fields{
+ "omg": true,
+ "number": 100,
+ }).Fatal("The ice breaks!")
+
+ // A common pattern is to re-use fields between logging statements by re-using
+ // the logrus.Entry returned from WithFields()
+ contextLogger := log.WithFields(log.Fields{
+ "common": "this is a common field",
+ "other": "I also should be logged always",
+ })
+
+ contextLogger.Info("I'll be logged with common and other field")
+ contextLogger.Info("Me too")
+}
+```
+
+For more advanced usage such as logging to multiple locations from the same
+application, you can also create an instance of the `logrus` Logger:
+
+```go
+package main
+
+import (
+ "github.com/Sirupsen/logrus"
+)
+
+// Create a new instance of the logger. You can have any number of instances.
+var log = logrus.New()
+
+func main() {
+ // The API for setting attributes is a little different than the package level
+ // exported logger. See Godoc.
+ log.Out = os.Stderr
+
+ log.WithFields(logrus.Fields{
+ "animal": "walrus",
+ "size": 10,
+ }).Info("A group of walrus emerges from the ocean")
+}
+```
+
+#### Fields
+
+Logrus encourages careful, structured logging though logging fields instead of
+long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
+to send event %s to topic %s with key %d")`, you should log the much more
+discoverable:
+
+```go
+log.WithFields(log.Fields{
+ "event": event,
+ "topic": topic,
+ "key": key,
+}).Fatal("Failed to send event")
+```
+
+We've found this API forces you to think about logging in a way that produces
+much more useful logging messages. We've been in countless situations where just
+a single added field to a log statement that was already there would've saved us
+hours. The `WithFields` call is optional.
+
+In general, with Logrus using any of the `printf`-family functions should be
+seen as a hint you should add a field, however, you can still use the
+`printf`-family functions with Logrus.
+
+#### Hooks
+
+You can add hooks for logging levels. For example to send errors to an exception
+tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
+multiple places simultaneously, e.g. syslog.
+
+Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
+`init`:
+
+```go
+import (
+ log "github.com/Sirupsen/logrus"
+ "github.com/Sirupsen/logrus/hooks/airbrake"
+ logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
+ "log/syslog"
+)
+
+func init() {
+ log.AddHook(airbrake.NewHook("https://example.com", "xyz", "development"))
+
+ hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
+ if err != nil {
+ log.Error("Unable to connect to local syslog daemon")
+ } else {
+ log.AddHook(hook)
+ }
+}
+```
+
+
+| Hook | Description |
+| ----- | ----------- |
+| [Airbrake](https://github.com/Sirupsen/logrus/blob/master/hooks/airbrake/airbrake.go) | Send errors to an exception tracking service compatible with the Airbrake API. Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes. |
+| [Papertrail](https://github.com/Sirupsen/logrus/blob/master/hooks/papertrail/papertrail.go) | Send errors to the Papertrail hosted logging service via UDP. |
+| [Syslog](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. |
+| [BugSnag](https://github.com/Sirupsen/logrus/blob/master/hooks/bugsnag/bugsnag.go) | Send errors to the Bugsnag exception tracking service. |
+| [Sentry](https://github.com/Sirupsen/logrus/blob/master/hooks/sentry/sentry.go) | Send errors to the Sentry error logging and aggregation service. |
+| [Hiprus](https://github.com/nubo/hiprus) | Send errors to a channel in hipchat. |
+| [Logrusly](https://github.com/sebest/logrusly) | Send logs to [Loggly](https://www.loggly.com/) |
+| [Slackrus](https://github.com/johntdyer/slackrus) | Hook for Slack chat. |
+| [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` |
+| [Graylog](https://github.com/gemnasium/logrus-hooks/tree/master/graylog) | Hook for logging to [Graylog](http://graylog2.org/) |
+| [Raygun](https://github.com/squirkle/logrus-raygun-hook) | Hook for logging to [Raygun.io](http://raygun.io/) |
+| [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem |
+| [Honeybadger](https://github.com/agonzalezro/logrus_honeybadger) | Hook for sending exceptions to Honeybadger |
+| [Mail](https://github.com/zbindenren/logrus_mail) | Hook for sending exceptions via mail |
+| [Rollrus](https://github.com/heroku/rollrus) | Hook for sending errors to rollbar |
+| [Fluentd](https://github.com/evalphobia/logrus_fluent) | Hook for logging to fluentd |
+| [Mongodb](https://github.com/weekface/mgorus) | Hook for logging to mongodb |
+
+#### Level logging
+
+Logrus has six logging levels: Debug, Info, Warning, Error, Fatal and Panic.
+
+```go
+log.Debug("Useful debugging information.")
+log.Info("Something noteworthy happened!")
+log.Warn("You should probably take a look at this.")
+log.Error("Something failed but I'm not quitting.")
+// Calls os.Exit(1) after logging
+log.Fatal("Bye.")
+// Calls panic() after logging
+log.Panic("I'm bailing.")
+```
+
+You can set the logging level on a `Logger`, then it will only log entries with
+that severity or anything above it:
+
+```go
+// Will log anything that is info or above (warn, error, fatal, panic). Default.
+log.SetLevel(log.InfoLevel)
+```
+
+It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
+environment if your application has that.
+
+#### Entries
+
+Besides the fields added with `WithField` or `WithFields` some fields are
+automatically added to all logging events:
+
+1. `time`. The timestamp when the entry was created.
+2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
+ the `AddFields` call. E.g. `Failed to send event.`
+3. `level`. The logging level. E.g. `info`.
+
+#### Environments
+
+Logrus has no notion of environment.
+
+If you wish for hooks and formatters to only be used in specific environments,
+you should handle that yourself. For example, if your application has a global
+variable `Environment`, which is a string representation of the environment you
+could do:
+
+```go
+import (
+ log "github.com/Sirupsen/logrus"
+)
+
+init() {
+ // do something here to set environment depending on an environment variable
+ // or command-line flag
+ if Environment == "production" {
+ log.SetFormatter(&log.JSONFormatter{})
+ } else {
+ // The TextFormatter is default, you don't actually have to do this.
+ log.SetFormatter(&log.TextFormatter{})
+ }
+}
+```
+
+This configuration is how `logrus` was intended to be used, but JSON in
+production is mostly only useful if you do log aggregation with tools like
+Splunk or Logstash.
+
+#### Formatters
+
+The built-in logging formatters are:
+
+* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
+ without colors.
+ * *Note:* to force colored output when there is no TTY, set the `ForceColors`
+ field to `true`. To force no colored output even if there is a TTY set the
+ `DisableColors` field to `true`
+* `logrus.JSONFormatter`. Logs fields as JSON.
+* `logrus_logstash.LogstashFormatter`. Logs fields as Logstash Events (http://logstash.net).
+
+ ```go
+ logrus.SetFormatter(&logrus_logstash.LogstashFormatter{Type: “application_name"})
+ ```
+
+Third party logging formatters:
+
+* [`zalgo`](https://github.com/aybabtme/logzalgo): invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
+
+You can define your formatter by implementing the `Formatter` interface,
+requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
+`Fields` type (`map[string]interface{}`) with all your fields as well as the
+default ones (see Entries section above):
+
+```go
+type MyJSONFormatter struct {
+}
+
+log.SetFormatter(new(MyJSONFormatter))
+
+func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
+ // Note this doesn't include Time, Level and Message which are available on
+ // the Entry. Consult `godoc` on information about those fields or read the
+ // source of the official loggers.
+ serialized, err := json.Marshal(entry.Data)
+ if err != nil {
+ return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+ }
+ return append(serialized, '\n'), nil
+}
+```
+
+#### Logger as an `io.Writer`
+
+Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.
+
+```go
+w := logger.Writer()
+defer w.Close()
+
+srv := http.Server{
+ // create a stdlib log.Logger that writes to
+ // logrus.Logger.
+ ErrorLog: log.New(w, "", 0),
+}
+```
+
+Each line written to that writer will be printed the usual way, using formatters
+and hooks. The level for those entries is `info`.
+
+#### Rotation
+
+Log rotation is not provided with Logrus. Log rotation should be done by an
+external program (like `logrotate(8)`) that can compress and delete old log
+entries. It should not be a feature of the application-level logger.
+
+
+[godoc]: https://godoc.org/github.com/Sirupsen/logrus
diff --git a/vendor/github.com/Sirupsen/logrus/entry.go b/vendor/github.com/Sirupsen/logrus/entry.go
new file mode 100644
index 0000000..04673a0
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/entry.go
@@ -0,0 +1,256 @@
+package logrus
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "time"
+)
+
+// An entry is the final or intermediate Logrus logging entry. It contains all
+// the fields passed with WithField{,s}. It's finally logged when Debug, Info,
+// Warn, Error, Fatal or Panic is called on it. These objects can be reused and
+// passed around as much as you wish to avoid field duplication.
+type Entry struct {
+ Logger *Logger
+
+ // Contains all the fields set by the user.
+ Data Fields
+
+ // Time at which the log entry was created
+ Time time.Time
+
+ // Level the log entry was logged at: Debug, Info, Warn, Error, Fatal or Panic
+ Level Level
+
+ // Message passed to Debug, Info, Warn, Error, Fatal or Panic
+ Message string
+}
+
+func NewEntry(logger *Logger) *Entry {
+ return &Entry{
+ Logger: logger,
+ // Default is three fields, give a little extra room
+ Data: make(Fields, 5),
+ }
+}
+
+// Returns a reader for the entry, which is a proxy to the formatter.
+func (entry *Entry) Reader() (*bytes.Buffer, error) {
+ serialized, err := entry.Logger.Formatter.Format(entry)
+ return bytes.NewBuffer(serialized), err
+}
+
+// Returns the string representation from the reader and ultimately the
+// formatter.
+func (entry *Entry) String() (string, error) {
+ reader, err := entry.Reader()
+ if err != nil {
+ return "", err
+ }
+
+ return reader.String(), err
+}
+
+// Add a single field to the Entry.
+func (entry *Entry) WithField(key string, value interface{}) *Entry {
+ return entry.WithFields(Fields{key: value})
+}
+
+// Add a map of fields to the Entry.
+func (entry *Entry) WithFields(fields Fields) *Entry {
+ data := Fields{}
+ for k, v := range entry.Data {
+ data[k] = v
+ }
+ for k, v := range fields {
+ data[k] = v
+ }
+ return &Entry{Logger: entry.Logger, Data: data}
+}
+
+// This function is not declared with a pointer value because otherwise
+// race conditions will occur when using multiple goroutines
+func (entry Entry) log(level Level, msg string) {
+ entry.Time = time.Now()
+ entry.Level = level
+ entry.Message = msg
+
+ if err := entry.Logger.Hooks.Fire(level, &entry); err != nil {
+ entry.Logger.mu.Lock()
+ fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
+ entry.Logger.mu.Unlock()
+ }
+
+ reader, err := entry.Reader()
+ if err != nil {
+ entry.Logger.mu.Lock()
+ fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
+ entry.Logger.mu.Unlock()
+ }
+
+ entry.Logger.mu.Lock()
+ defer entry.Logger.mu.Unlock()
+
+ _, err = io.Copy(entry.Logger.Out, reader)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
+ }
+
+ // To avoid Entry#log() returning a value that only would make sense for
+ // panic() to use in Entry#Panic(), we avoid the allocation by checking
+ // directly here.
+ if level <= PanicLevel {
+ panic(&entry)
+ }
+}
+
+func (entry *Entry) Debug(args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.log(DebugLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Print(args ...interface{}) {
+ entry.Info(args...)
+}
+
+func (entry *Entry) Info(args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.log(InfoLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Warn(args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.log(WarnLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Warning(args ...interface{}) {
+ entry.Warn(args...)
+}
+
+func (entry *Entry) Error(args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.log(ErrorLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Fatal(args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.log(FatalLevel, fmt.Sprint(args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panic(args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.log(PanicLevel, fmt.Sprint(args...))
+ }
+ panic(fmt.Sprint(args...))
+}
+
+// Entry Printf family functions
+
+func (entry *Entry) Debugf(format string, args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.Debug(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Infof(format string, args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.Info(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Printf(format string, args ...interface{}) {
+ entry.Infof(format, args...)
+}
+
+func (entry *Entry) Warnf(format string, args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.Warn(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Warningf(format string, args ...interface{}) {
+ entry.Warnf(format, args...)
+}
+
+func (entry *Entry) Errorf(format string, args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.Error(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Fatalf(format string, args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.Fatal(fmt.Sprintf(format, args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panicf(format string, args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.Panic(fmt.Sprintf(format, args...))
+ }
+}
+
+// Entry Println family functions
+
+func (entry *Entry) Debugln(args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.Debug(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Infoln(args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.Info(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Println(args ...interface{}) {
+ entry.Infoln(args...)
+}
+
+func (entry *Entry) Warnln(args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.Warn(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Warningln(args ...interface{}) {
+ entry.Warnln(args...)
+}
+
+func (entry *Entry) Errorln(args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.Error(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Fatalln(args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.Fatal(entry.sprintlnn(args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panicln(args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.Panic(entry.sprintlnn(args...))
+ }
+}
+
+// Sprintlnn => Sprint no newline. This is to get the behavior of how
+// fmt.Sprintln where spaces are always added between operands, regardless of
+// their type. Instead of vendoring the Sprintln implementation to spare a
+// string allocation, we do the simplest thing.
+func (entry *Entry) sprintlnn(args ...interface{}) string {
+ msg := fmt.Sprintln(args...)
+ return msg[:len(msg)-1]
+}
diff --git a/vendor/github.com/Sirupsen/logrus/entry_test.go b/vendor/github.com/Sirupsen/logrus/entry_test.go
new file mode 100644
index 0000000..ed4054f
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/entry_test.go
@@ -0,0 +1,53 @@
+package logrus
+
+import (
+ "bytes"
+ "fmt"
+ "testing"
+
+ "github.com/moul/ssh2docker/vendor/github.com/stretchr/testify/assert"
+)
+
+func TestEntryPanicln(t *testing.T) {
+ errBoom := fmt.Errorf("boom time")
+
+ defer func() {
+ p := recover()
+ assert.NotNil(t, p)
+
+ switch pVal := p.(type) {
+ case *Entry:
+ assert.Equal(t, "kaboom", pVal.Message)
+ assert.Equal(t, errBoom, pVal.Data["err"])
+ default:
+ t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)
+ }
+ }()
+
+ logger := New()
+ logger.Out = &bytes.Buffer{}
+ entry := NewEntry(logger)
+ entry.WithField("err", errBoom).Panicln("kaboom")
+}
+
+func TestEntryPanicf(t *testing.T) {
+ errBoom := fmt.Errorf("boom again")
+
+ defer func() {
+ p := recover()
+ assert.NotNil(t, p)
+
+ switch pVal := p.(type) {
+ case *Entry:
+ assert.Equal(t, "kaboom true", pVal.Message)
+ assert.Equal(t, errBoom, pVal.Data["err"])
+ default:
+ t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)
+ }
+ }()
+
+ logger := New()
+ logger.Out = &bytes.Buffer{}
+ entry := NewEntry(logger)
+ entry.WithField("err", errBoom).Panicf("kaboom %v", true)
+}
diff --git a/vendor/github.com/Sirupsen/logrus/exported.go b/vendor/github.com/Sirupsen/logrus/exported.go
new file mode 100644
index 0000000..a67e1b8
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/exported.go
@@ -0,0 +1,188 @@
+package logrus
+
+import (
+ "io"
+)
+
+var (
+ // std is the name of the standard logger in stdlib `log`
+ std = New()
+)
+
+func StandardLogger() *Logger {
+ return std
+}
+
+// SetOutput sets the standard logger output.
+func SetOutput(out io.Writer) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Out = out
+}
+
+// SetFormatter sets the standard logger formatter.
+func SetFormatter(formatter Formatter) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Formatter = formatter
+}
+
+// SetLevel sets the standard logger level.
+func SetLevel(level Level) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Level = level
+}
+
+// GetLevel returns the standard logger level.
+func GetLevel() Level {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ return std.Level
+}
+
+// AddHook adds a hook to the standard logger hooks.
+func AddHook(hook Hook) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Hooks.Add(hook)
+}
+
+// WithField creates an entry from the standard logger and adds a field to
+// it. If you want multiple fields, use `WithFields`.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithField(key string, value interface{}) *Entry {
+ return std.WithField(key, value)
+}
+
+// WithFields creates an entry from the standard logger and adds multiple
+// fields to it. This is simply a helper for `WithField`, invoking it
+// once for each field.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithFields(fields Fields) *Entry {
+ return std.WithFields(fields)
+}
+
+// Debug logs a message at level Debug on the standard logger.
+func Debug(args ...interface{}) {
+ std.Debug(args...)
+}
+
+// Print logs a message at level Info on the standard logger.
+func Print(args ...interface{}) {
+ std.Print(args...)
+}
+
+// Info logs a message at level Info on the standard logger.
+func Info(args ...interface{}) {
+ std.Info(args...)
+}
+
+// Warn logs a message at level Warn on the standard logger.
+func Warn(args ...interface{}) {
+ std.Warn(args...)
+}
+
+// Warning logs a message at level Warn on the standard logger.
+func Warning(args ...interface{}) {
+ std.Warning(args...)
+}
+
+// Error logs a message at level Error on the standard logger.
+func Error(args ...interface{}) {
+ std.Error(args...)
+}
+
+// Panic logs a message at level Panic on the standard logger.
+func Panic(args ...interface{}) {
+ std.Panic(args...)
+}
+
+// Fatal logs a message at level Fatal on the standard logger.
+func Fatal(args ...interface{}) {
+ std.Fatal(args...)
+}
+
+// Debugf logs a message at level Debug on the standard logger.
+func Debugf(format string, args ...interface{}) {
+ std.Debugf(format, args...)
+}
+
+// Printf logs a message at level Info on the standard logger.
+func Printf(format string, args ...interface{}) {
+ std.Printf(format, args...)
+}
+
+// Infof logs a message at level Info on the standard logger.
+func Infof(format string, args ...interface{}) {
+ std.Infof(format, args...)
+}
+
+// Warnf logs a message at level Warn on the standard logger.
+func Warnf(format string, args ...interface{}) {
+ std.Warnf(format, args...)
+}
+
+// Warningf logs a message at level Warn on the standard logger.
+func Warningf(format string, args ...interface{}) {
+ std.Warningf(format, args...)
+}
+
+// Errorf logs a message at level Error on the standard logger.
+func Errorf(format string, args ...interface{}) {
+ std.Errorf(format, args...)
+}
+
+// Panicf logs a message at level Panic on the standard logger.
+func Panicf(format string, args ...interface{}) {
+ std.Panicf(format, args...)
+}
+
+// Fatalf logs a message at level Fatal on the standard logger.
+func Fatalf(format string, args ...interface{}) {
+ std.Fatalf(format, args...)
+}
+
+// Debugln logs a message at level Debug on the standard logger.
+func Debugln(args ...interface{}) {
+ std.Debugln(args...)
+}
+
+// Println logs a message at level Info on the standard logger.
+func Println(args ...interface{}) {
+ std.Println(args...)
+}
+
+// Infoln logs a message at level Info on the standard logger.
+func Infoln(args ...interface{}) {
+ std.Infoln(args...)
+}
+
+// Warnln logs a message at level Warn on the standard logger.
+func Warnln(args ...interface{}) {
+ std.Warnln(args...)
+}
+
+// Warningln logs a message at level Warn on the standard logger.
+func Warningln(args ...interface{}) {
+ std.Warningln(args...)
+}
+
+// Errorln logs a message at level Error on the standard logger.
+func Errorln(args ...interface{}) {
+ std.Errorln(args...)
+}
+
+// Panicln logs a message at level Panic on the standard logger.
+func Panicln(args ...interface{}) {
+ std.Panicln(args...)
+}
+
+// Fatalln logs a message at level Fatal on the standard logger.
+func Fatalln(args ...interface{}) {
+ std.Fatalln(args...)
+}
diff --git a/vendor/github.com/Sirupsen/logrus/formatter.go b/vendor/github.com/Sirupsen/logrus/formatter.go
new file mode 100644
index 0000000..104d689
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/formatter.go
@@ -0,0 +1,48 @@
+package logrus
+
+import "time"
+
+const DefaultTimestampFormat = time.RFC3339
+
+// The Formatter interface is used to implement a custom Formatter. It takes an
+// `Entry`. It exposes all the fields, including the default ones:
+//
+// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
+// * `entry.Data["time"]`. The timestamp.
+// * `entry.Data["level"]. The level the entry was logged at.
+//
+// Any additional fields added with `WithField` or `WithFields` are also in
+// `entry.Data`. Format is expected to return an array of bytes which are then
+// logged to `logger.Out`.
+type Formatter interface {
+ Format(*Entry) ([]byte, error)
+}
+
+// This is to not silently overwrite `time`, `msg` and `level` fields when
+// dumping it. If this code wasn't there doing:
+//
+// logrus.WithField("level", 1).Info("hello")
+//
+// Would just silently drop the user provided level. Instead with this code
+// it'll logged as:
+//
+// {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
+//
+// It's not exported because it's still using Data in an opinionated way. It's to
+// avoid code duplication between the two default formatters.
+func prefixFieldClashes(data Fields) {
+ _, ok := data["time"]
+ if ok {
+ data["fields.time"] = data["time"]
+ }
+
+ _, ok = data["msg"]
+ if ok {
+ data["fields.msg"] = data["msg"]
+ }
+
+ _, ok = data["level"]
+ if ok {
+ data["fields.level"] = data["level"]
+ }
+}
diff --git a/vendor/github.com/Sirupsen/logrus/formatter_bench_test.go b/vendor/github.com/Sirupsen/logrus/formatter_bench_test.go
new file mode 100644
index 0000000..c6d290c
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/formatter_bench_test.go
@@ -0,0 +1,98 @@
+package logrus
+
+import (
+ "fmt"
+ "testing"
+ "time"
+)
+
+// smallFields is a small size data set for benchmarking
+var smallFields = Fields{
+ "foo": "bar",
+ "baz": "qux",
+ "one": "two",
+ "three": "four",
+}
+
+// largeFields is a large size data set for benchmarking
+var largeFields = Fields{
+ "foo": "bar",
+ "baz": "qux",
+ "one": "two",
+ "three": "four",
+ "five": "six",
+ "seven": "eight",
+ "nine": "ten",
+ "eleven": "twelve",
+ "thirteen": "fourteen",
+ "fifteen": "sixteen",
+ "seventeen": "eighteen",
+ "nineteen": "twenty",
+ "a": "b",
+ "c": "d",
+ "e": "f",
+ "g": "h",
+ "i": "j",
+ "k": "l",
+ "m": "n",
+ "o": "p",
+ "q": "r",
+ "s": "t",
+ "u": "v",
+ "w": "x",
+ "y": "z",
+ "this": "will",
+ "make": "thirty",
+ "entries": "yeah",
+}
+
+var errorFields = Fields{
+ "foo": fmt.Errorf("bar"),
+ "baz": fmt.Errorf("qux"),
+}
+
+func BenchmarkErrorTextFormatter(b *testing.B) {
+ doBenchmark(b, &TextFormatter{DisableColors: true}, errorFields)
+}
+
+func BenchmarkSmallTextFormatter(b *testing.B) {
+ doBenchmark(b, &TextFormatter{DisableColors: true}, smallFields)
+}
+
+func BenchmarkLargeTextFormatter(b *testing.B) {
+ doBenchmark(b, &TextFormatter{DisableColors: true}, largeFields)
+}
+
+func BenchmarkSmallColoredTextFormatter(b *testing.B) {
+ doBenchmark(b, &TextFormatter{ForceColors: true}, smallFields)
+}
+
+func BenchmarkLargeColoredTextFormatter(b *testing.B) {
+ doBenchmark(b, &TextFormatter{ForceColors: true}, largeFields)
+}
+
+func BenchmarkSmallJSONFormatter(b *testing.B) {
+ doBenchmark(b, &JSONFormatter{}, smallFields)
+}
+
+func BenchmarkLargeJSONFormatter(b *testing.B) {
+ doBenchmark(b, &JSONFormatter{}, largeFields)
+}
+
+func doBenchmark(b *testing.B, formatter Formatter, fields Fields) {
+ entry := &Entry{
+ Time: time.Time{},
+ Level: InfoLevel,
+ Message: "message",
+ Data: fields,
+ }
+ var d []byte
+ var err error
+ for i := 0; i < b.N; i++ {
+ d, err = formatter.Format(entry)
+ if err != nil {
+ b.Fatal(err)
+ }
+ b.SetBytes(int64(len(d)))
+ }
+}
diff --git a/vendor/github.com/Sirupsen/logrus/hook_test.go b/vendor/github.com/Sirupsen/logrus/hook_test.go
new file mode 100644
index 0000000..37027b6
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/hook_test.go
@@ -0,0 +1,122 @@
+package logrus
+
+import (
+ "testing"
+
+ "github.com/moul/ssh2docker/vendor/github.com/stretchr/testify/assert"
+)
+
+type TestHook struct {
+ Fired bool
+}
+
+func (hook *TestHook) Fire(entry *Entry) error {
+ hook.Fired = true
+ return nil
+}
+
+func (hook *TestHook) Levels() []Level {
+ return []Level{
+ DebugLevel,
+ InfoLevel,
+ WarnLevel,
+ ErrorLevel,
+ FatalLevel,
+ PanicLevel,
+ }
+}
+
+func TestHookFires(t *testing.T) {
+ hook := new(TestHook)
+
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Hooks.Add(hook)
+ assert.Equal(t, hook.Fired, false)
+
+ log.Print("test")
+ }, func(fields Fields) {
+ assert.Equal(t, hook.Fired, true)
+ })
+}
+
+type ModifyHook struct {
+}
+
+func (hook *ModifyHook) Fire(entry *Entry) error {
+ entry.Data["wow"] = "whale"
+ return nil
+}
+
+func (hook *ModifyHook) Levels() []Level {
+ return []Level{
+ DebugLevel,
+ InfoLevel,
+ WarnLevel,
+ ErrorLevel,
+ FatalLevel,
+ PanicLevel,
+ }
+}
+
+func TestHookCanModifyEntry(t *testing.T) {
+ hook := new(ModifyHook)
+
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Hooks.Add(hook)
+ log.WithField("wow", "elephant").Print("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["wow"], "whale")
+ })
+}
+
+func TestCanFireMultipleHooks(t *testing.T) {
+ hook1 := new(ModifyHook)
+ hook2 := new(TestHook)
+
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Hooks.Add(hook1)
+ log.Hooks.Add(hook2)
+
+ log.WithField("wow", "elephant").Print("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["wow"], "whale")
+ assert.Equal(t, hook2.Fired, true)
+ })
+}
+
+type ErrorHook struct {
+ Fired bool
+}
+
+func (hook *ErrorHook) Fire(entry *Entry) error {
+ hook.Fired = true
+ return nil
+}
+
+func (hook *ErrorHook) Levels() []Level {
+ return []Level{
+ ErrorLevel,
+ }
+}
+
+func TestErrorHookShouldntFireOnInfo(t *testing.T) {
+ hook := new(ErrorHook)
+
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Hooks.Add(hook)
+ log.Info("test")
+ }, func(fields Fields) {
+ assert.Equal(t, hook.Fired, false)
+ })
+}
+
+func TestErrorHookShouldFireOnError(t *testing.T) {
+ hook := new(ErrorHook)
+
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Hooks.Add(hook)
+ log.Error("test")
+ }, func(fields Fields) {
+ assert.Equal(t, hook.Fired, true)
+ })
+}
diff --git a/vendor/github.com/Sirupsen/logrus/hooks.go b/vendor/github.com/Sirupsen/logrus/hooks.go
new file mode 100644
index 0000000..3f151cd
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/hooks.go
@@ -0,0 +1,34 @@
+package logrus
+
+// A hook to be fired when logging on the logging levels returned from
+// `Levels()` on your implementation of the interface. Note that this is not
+// fired in a goroutine or a channel with workers, you should handle such
+// functionality yourself if your call is non-blocking and you don't wish for
+// the logging calls for levels returned from `Levels()` to block.
+type Hook interface {
+ Levels() []Level
+ Fire(*Entry) error
+}
+
+// Internal type for storing the hooks on a logger instance.
+type LevelHooks map[Level][]Hook
+
+// Add a hook to an instance of logger. This is called with
+// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
+func (hooks LevelHooks) Add(hook Hook) {
+ for _, level := range hook.Levels() {
+ hooks[level] = append(hooks[level], hook)
+ }
+}
+
+// Fire all the hooks for the passed level. Used by `entry.log` to fire
+// appropriate hooks for a log entry.
+func (hooks LevelHooks) Fire(level Level, entry *Entry) error {
+ for _, hook := range hooks[level] {
+ if err := hook.Fire(entry); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/Sirupsen/logrus/json_formatter.go b/vendor/github.com/Sirupsen/logrus/json_formatter.go
new file mode 100644
index 0000000..2ad6dc5
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/json_formatter.go
@@ -0,0 +1,41 @@
+package logrus
+
+import (
+ "encoding/json"
+ "fmt"
+)
+
+type JSONFormatter struct {
+ // TimestampFormat sets the format used for marshaling timestamps.
+ TimestampFormat string
+}
+
+func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
+ data := make(Fields, len(entry.Data)+3)
+ for k, v := range entry.Data {
+ switch v := v.(type) {
+ case error:
+ // Otherwise errors are ignored by `encoding/json`
+ // https://github.com/Sirupsen/logrus/issues/137
+ data[k] = v.Error()
+ default:
+ data[k] = v
+ }
+ }
+ prefixFieldClashes(data)
+
+ timestampFormat := f.TimestampFormat
+ if timestampFormat == "" {
+ timestampFormat = DefaultTimestampFormat
+ }
+
+ data["time"] = entry.Time.Format(timestampFormat)
+ data["msg"] = entry.Message
+ data["level"] = entry.Level.String()
+
+ serialized, err := json.Marshal(data)
+ if err != nil {
+ return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+ }
+ return append(serialized, '\n'), nil
+}
diff --git a/vendor/github.com/Sirupsen/logrus/json_formatter_test.go b/vendor/github.com/Sirupsen/logrus/json_formatter_test.go
new file mode 100644
index 0000000..1d70873
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/json_formatter_test.go
@@ -0,0 +1,120 @@
+package logrus
+
+import (
+ "encoding/json"
+ "errors"
+
+ "testing"
+)
+
+func TestErrorNotLost(t *testing.T) {
+ formatter := &JSONFormatter{}
+
+ b, err := formatter.Format(WithField("error", errors.New("wild walrus")))
+ if err != nil {
+ t.Fatal("Unable to format entry: ", err)
+ }
+
+ entry := make(map[string]interface{})
+ err = json.Unmarshal(b, &entry)
+ if err != nil {
+ t.Fatal("Unable to unmarshal formatted entry: ", err)
+ }
+
+ if entry["error"] != "wild walrus" {
+ t.Fatal("Error field not set")
+ }
+}
+
+func TestErrorNotLostOnFieldNotNamedError(t *testing.T) {
+ formatter := &JSONFormatter{}
+
+ b, err := formatter.Format(WithField("omg", errors.New("wild walrus")))
+ if err != nil {
+ t.Fatal("Unable to format entry: ", err)
+ }
+
+ entry := make(map[string]interface{})
+ err = json.Unmarshal(b, &entry)
+ if err != nil {
+ t.Fatal("Unable to unmarshal formatted entry: ", err)
+ }
+
+ if entry["omg"] != "wild walrus" {
+ t.Fatal("Error field not set")
+ }
+}
+
+func TestFieldClashWithTime(t *testing.T) {
+ formatter := &JSONFormatter{}
+
+ b, err := formatter.Format(WithField("time", "right now!"))
+ if err != nil {
+ t.Fatal("Unable to format entry: ", err)
+ }
+
+ entry := make(map[string]interface{})
+ err = json.Unmarshal(b, &entry)
+ if err != nil {
+ t.Fatal("Unable to unmarshal formatted entry: ", err)
+ }
+
+ if entry["fields.time"] != "right now!" {
+ t.Fatal("fields.time not set to original time field")
+ }
+
+ if entry["time"] != "0001-01-01T00:00:00Z" {
+ t.Fatal("time field not set to current time, was: ", entry["time"])
+ }
+}
+
+func TestFieldClashWithMsg(t *testing.T) {
+ formatter := &JSONFormatter{}
+
+ b, err := formatter.Format(WithField("msg", "something"))
+ if err != nil {
+ t.Fatal("Unable to format entry: ", err)
+ }
+
+ entry := make(map[string]interface{})
+ err = json.Unmarshal(b, &entry)
+ if err != nil {
+ t.Fatal("Unable to unmarshal formatted entry: ", err)
+ }
+
+ if entry["fields.msg"] != "something" {
+ t.Fatal("fields.msg not set to original msg field")
+ }
+}
+
+func TestFieldClashWithLevel(t *testing.T) {
+ formatter := &JSONFormatter{}
+
+ b, err := formatter.Format(WithField("level", "something"))
+ if err != nil {
+ t.Fatal("Unable to format entry: ", err)
+ }
+
+ entry := make(map[string]interface{})
+ err = json.Unmarshal(b, &entry)
+ if err != nil {
+ t.Fatal("Unable to unmarshal formatted entry: ", err)
+ }
+
+ if entry["fields.level"] != "something" {
+ t.Fatal("fields.level not set to original level field")
+ }
+}
+
+func TestJSONEntryEndsWithNewline(t *testing.T) {
+ formatter := &JSONFormatter{}
+
+ b, err := formatter.Format(WithField("level", "something"))
+ if err != nil {
+ t.Fatal("Unable to format entry: ", err)
+ }
+
+ if b[len(b)-1] != '\n' {
+ t.Fatal("Expected JSON log entry to end with a newline")
+ }
+}
diff --git a/vendor/github.com/Sirupsen/logrus/logger.go b/vendor/github.com/Sirupsen/logrus/logger.go
new file mode 100644
index 0000000..fd9804c
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/logger.go
@@ -0,0 +1,206 @@
+package logrus
+
+import (
+ "io"
+ "os"
+ "sync"
+)
+
+type Logger struct {
+ // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
+ // file, or leave it default which is `os.Stderr`. You can also set this to
+ // something more adventorous, such as logging to Kafka.
+ Out io.Writer
+ // Hooks for the logger instance. These allow firing events based on logging
+ // levels and log entries. For example, to send errors to an error tracking
+ // service, log to StatsD or dump the core on fatal errors.
+ Hooks LevelHooks
+ // All log entries pass through the formatter before logged to Out. The
+ // included formatters are `TextFormatter` and `JSONFormatter` for which
+ // TextFormatter is the default. In development (when a TTY is attached) it
+ // logs with colors, but to a file it wouldn't. You can easily implement your
+ // own that implements the `Formatter` interface, see the `README` or included
+ // formatters for examples.
+ Formatter Formatter
+ // The logging level the logger should log at. This is typically (and defaults
+ // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
+ // logged. `logrus.Debug` is useful in
+ Level Level
+ // Used to sync writing to the log.
+ mu sync.Mutex
+}
+
+// Creates a new logger. Configuration should be set by changing `Formatter`,
+// `Out` and `Hooks` directly on the default logger instance. You can also just
+// instantiate your own:
+//
+// var log = &Logger{
+// Out: os.Stderr,
+// Formatter: new(JSONFormatter),
+// Hooks: make(LevelHooks),
+// Level: logrus.DebugLevel,
+// }
+//
+// It's recommended to make this a global instance called `log`.
+func New() *Logger {
+ return &Logger{
+ Out: os.Stderr,
+ Formatter: new(TextFormatter),
+ Hooks: make(LevelHooks),
+ Level: InfoLevel,
+ }
+}
+
+// Adds a field to the log entry, note that you it doesn't log until you call
+// Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.
+// If you want multiple fields, use `WithFields`.
+func (logger *Logger) WithField(key string, value interface{}) *Entry {
+ return NewEntry(logger).WithField(key, value)
+}
+
+// Adds a struct of fields to the log entry. All it does is call `WithField` for
+// each `Field`.
+func (logger *Logger) WithFields(fields Fields) *Entry {
+ return NewEntry(logger).WithFields(fields)
+}
+
+func (logger *Logger) Debugf(format string, args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debugf(format, args...)
+ }
+}
+
+func (logger *Logger) Infof(format string, args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Infof(format, args...)
+ }
+}
+
+func (logger *Logger) Printf(format string, args ...interface{}) {
+ NewEntry(logger).Printf(format, args...)
+}
+
+func (logger *Logger) Warnf(format string, args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnf(format, args...)
+ }
+}
+
+func (logger *Logger) Warningf(format string, args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnf(format, args...)
+ }
+}
+
+func (logger *Logger) Errorf(format string, args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Errorf(format, args...)
+ }
+}
+
+func (logger *Logger) Fatalf(format string, args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatalf(format, args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panicf(format string, args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panicf(format, args...)
+ }
+}
+
+func (logger *Logger) Debug(args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debug(args...)
+ }
+}
+
+func (logger *Logger) Info(args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Info(args...)
+ }
+}
+
+func (logger *Logger) Print(args ...interface{}) {
+ NewEntry(logger).Info(args...)
+}
+
+func (logger *Logger) Warn(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warn(args...)
+ }
+}
+
+func (logger *Logger) Warning(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warn(args...)
+ }
+}
+
+func (logger *Logger) Error(args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Error(args...)
+ }
+}
+
+func (logger *Logger) Fatal(args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatal(args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panic(args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panic(args...)
+ }
+}
+
+func (logger *Logger) Debugln(args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debugln(args...)
+ }
+}
+
+func (logger *Logger) Infoln(args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Infoln(args...)
+ }
+}
+
+func (logger *Logger) Println(args ...interface{}) {
+ NewEntry(logger).Println(args...)
+}
+
+func (logger *Logger) Warnln(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnln(args...)
+ }
+}
+
+func (logger *Logger) Warningln(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnln(args...)
+ }
+}
+
+func (logger *Logger) Errorln(args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Errorln(args...)
+ }
+}
+
+func (logger *Logger) Fatalln(args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatalln(args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panicln(args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panicln(args...)
+ }
+}
diff --git a/vendor/github.com/Sirupsen/logrus/logrus.go b/vendor/github.com/Sirupsen/logrus/logrus.go
new file mode 100644
index 0000000..43ee12e
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/logrus.go
@@ -0,0 +1,94 @@
+package logrus
+
+import (
+ "fmt"
+ "log"
+)
+
+// Fields type, used to pass to `WithFields`.
+type Fields map[string]interface{}
+
+// Level type
+type Level uint8
+
+// Convert the Level to a string. E.g. PanicLevel becomes "panic".
+func (level Level) String() string {
+ switch level {
+ case DebugLevel:
+ return "debug"
+ case InfoLevel:
+ return "info"
+ case WarnLevel:
+ return "warning"
+ case ErrorLevel:
+ return "error"
+ case FatalLevel:
+ return "fatal"
+ case PanicLevel:
+ return "panic"
+ }
+
+ return "unknown"
+}
+
+// ParseLevel takes a string level and returns the Logrus log level constant.
+func ParseLevel(lvl string) (Level, error) {
+ switch lvl {
+ case "panic":
+ return PanicLevel, nil
+ case "fatal":
+ return FatalLevel, nil
+ case "error":
+ return ErrorLevel, nil
+ case "warn", "warning":
+ return WarnLevel, nil
+ case "info":
+ return InfoLevel, nil
+ case "debug":
+ return DebugLevel, nil
+ }
+
+ var l Level
+ return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
+}
+
+// These are the different logging levels. You can set the logging level to log
+// on your instance of logger, obtained with `logrus.New()`.
+const (
+ // PanicLevel level, highest level of severity. Logs and then calls panic with the
+ // message passed to Debug, Info, ...
+ PanicLevel Level = iota
+ // FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the
+ // logging level is set to Panic.
+ FatalLevel
+ // ErrorLevel level. Logs. Used for errors that should definitely be noted.
+ // Commonly used for hooks to send errors to an error tracking service.
+ ErrorLevel
+ // WarnLevel level. Non-critical entries that deserve eyes.
+ WarnLevel
+ // InfoLevel level. General operational entries about what's going on inside the
+ // application.
+ InfoLevel
+ // DebugLevel level. Usually only enabled when debugging. Very verbose logging.
+ DebugLevel
+)
+
+// Won't compile if StdLogger can't be realized by a log.Logger
+var _ StdLogger = &log.Logger{}
+
+// StdLogger is what your logrus-enabled library should take, that way
+// it'll accept a stdlib logger and a logrus logger. There's no standard
+// interface, this is the closest we get, unfortunately.
+type StdLogger interface {
+ Print(...interface{})
+ Printf(string, ...interface{})
+ Println(...interface{})
+
+ Fatal(...interface{})
+ Fatalf(string, ...interface{})
+ Fatalln(...interface{})
+
+ Panic(...interface{})
+ Panicf(string, ...interface{})
+ Panicln(...interface{})
+}
diff --git a/vendor/github.com/Sirupsen/logrus/logrus_test.go b/vendor/github.com/Sirupsen/logrus/logrus_test.go
new file mode 100644
index 0000000..5719a3c
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/logrus_test.go
@@ -0,0 +1,301 @@
+package logrus
+
+import (
+ "bytes"
+ "encoding/json"
+ "strconv"
+ "strings"
+ "sync"
+ "testing"
+
+ "github.com/moul/ssh2docker/vendor/github.com/stretchr/testify/assert"
+)
+
+func LogAndAssertJSON(t *testing.T, log func(*Logger), assertions func(fields Fields)) {
+ var buffer bytes.Buffer
+ var fields Fields
+
+ logger := New()
+ logger.Out = &buffer
+ logger.Formatter = new(JSONFormatter)
+
+ log(logger)
+
+ err := json.Unmarshal(buffer.Bytes(), &fields)
+ assert.Nil(t, err)
+
+ assertions(fields)
+}
+
+func LogAndAssertText(t *testing.T, log func(*Logger), assertions func(fields map[string]string)) {
+ var buffer bytes.Buffer
+
+ logger := New()
+ logger.Out = &buffer
+ logger.Formatter = &TextFormatter{
+ DisableColors: true,
+ }
+
+ log(logger)
+
+ fields := make(map[string]string)
+ for _, kv := range strings.Split(buffer.String(), " ") {
+ if !strings.Contains(kv, "=") {
+ continue
+ }
+ kvArr := strings.Split(kv, "=")
+ key := strings.TrimSpace(kvArr[0])
+ val := kvArr[1]
+ if kvArr[1][0] == '"' {
+ var err error
+ val, err = strconv.Unquote(val)
+ assert.NoError(t, err)
+ }
+ fields[key] = val
+ }
+ assertions(fields)
+}
+
+func TestPrint(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Print("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "test")
+ assert.Equal(t, fields["level"], "info")
+ })
+}
+
+func TestInfo(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Info("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "test")
+ assert.Equal(t, fields["level"], "info")
+ })
+}
+
+func TestWarn(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Warn("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "test")
+ assert.Equal(t, fields["level"], "warning")
+ })
+}
+
+func TestInfolnShouldAddSpacesBetweenStrings(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Infoln("test", "test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "test test")
+ })
+}
+
+func TestInfolnShouldAddSpacesBetweenStringAndNonstring(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Infoln("test", 10)
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "test 10")
+ })
+}
+
+func TestInfolnShouldAddSpacesBetweenTwoNonStrings(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Infoln(10, 10)
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "10 10")
+ })
+}
+
+func TestInfoShouldAddSpacesBetweenTwoNonStrings(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Infoln(10, 10)
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "10 10")
+ })
+}
+
+func TestInfoShouldNotAddSpacesBetweenStringAndNonstring(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Info("test", 10)
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "test10")
+ })
+}
+
+func TestInfoShouldNotAddSpacesBetweenStrings(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.Info("test", "test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "testtest")
+ })
+}
+
+func TestWithFieldsShouldAllowAssignments(t *testing.T) {
+ var buffer bytes.Buffer
+ var fields Fields
+
+ logger := New()
+ logger.Out = &buffer
+ logger.Formatter = new(JSONFormatter)
+
+ localLog := logger.WithFields(Fields{
+ "key1": "value1",
+ })
+
+ localLog.WithField("key2", "value2").Info("test")
+ err := json.Unmarshal(buffer.Bytes(), &fields)
+ assert.Nil(t, err)
+
+ assert.Equal(t, "value2", fields["key2"])
+ assert.Equal(t, "value1", fields["key1"])
+
+ buffer = bytes.Buffer{}
+ fields = Fields{}
+ localLog.Info("test")
+ err = json.Unmarshal(buffer.Bytes(), &fields)
+ assert.Nil(t, err)
+
+ _, ok := fields["key2"]
+ assert.Equal(t, false, ok)
+ assert.Equal(t, "value1", fields["key1"])
+}
+
+func TestUserSuppliedFieldDoesNotOverwriteDefaults(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.WithField("msg", "hello").Info("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "test")
+ })
+}
+
+func TestUserSuppliedMsgFieldHasPrefix(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.WithField("msg", "hello").Info("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["msg"], "test")
+ assert.Equal(t, fields["fields.msg"], "hello")
+ })
+}
+
+func TestUserSuppliedTimeFieldHasPrefix(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.WithField("time", "hello").Info("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["fields.time"], "hello")
+ })
+}
+
+func TestUserSuppliedLevelFieldHasPrefix(t *testing.T) {
+ LogAndAssertJSON(t, func(log *Logger) {
+ log.WithField("level", 1).Info("test")
+ }, func(fields Fields) {
+ assert.Equal(t, fields["level"], "info")
+ assert.Equal(t, fields["fields.level"], 1.0) // JSON has floats only
+ })
+}
+
+func TestDefaultFieldsAreNotPrefixed(t *testing.T) {
+ LogAndAssertText(t, func(log *Logger) {
+ ll := log.WithField("herp", "derp")
+ ll.Info("hello")
+ ll.Info("bye")
+ }, func(fields map[string]string) {
+ for _, fieldName := range []string{"fields.level", "fields.time", "fields.msg"} {
+ if _, ok := fields[fieldName]; ok {
+ t.Fatalf("should not have prefixed %q: %v", fieldName, fields)
+ }
+ }
+ })
+}
+
+func TestDoubleLoggingDoesntPrefixPreviousFields(t *testing.T) {
+
+ var buffer bytes.Buffer
+ var fields Fields
+
+ logger := New()
+ logger.Out = &buffer
+ logger.Formatter = new(JSONFormatter)
+
+ llog := logger.WithField("context", "eating raw fish")
+
+ llog.Info("looks delicious")
+
+ err := json.Unmarshal(buffer.Bytes(), &fields)
+ assert.NoError(t, err, "should have decoded first message")
+ assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields")
+ assert.Equal(t, fields["msg"], "looks delicious")
+ assert.Equal(t, fields["context"], "eating raw fish")
+
+ buffer.Reset()
+
+ llog.Warn("omg it is!")
+
+ err = json.Unmarshal(buffer.Bytes(), &fields)
+ assert.NoError(t, err, "should have decoded second message")
+ assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields")
+ assert.Equal(t, fields["msg"], "omg it is!")
+ assert.Equal(t, fields["context"], "eating raw fish")
+ assert.Nil(t, fields["fields.msg"], "should not have prefixed previous `msg` entry")
+
+}
+
+func TestConvertLevelToString(t *testing.T) {
+ assert.Equal(t, "debug", DebugLevel.String())
+ assert.Equal(t, "info", InfoLevel.String())
+ assert.Equal(t, "warning", WarnLevel.String())
+ assert.Equal(t, "error", ErrorLevel.String())
+ assert.Equal(t, "fatal", FatalLevel.String())
+ assert.Equal(t, "panic", PanicLevel.String())
+}
+
+func TestParseLevel(t *testing.T) {
+ l, err := ParseLevel("panic")
+ assert.Nil(t, err)
+ assert.Equal(t, PanicLevel, l)
+
+ l, err = ParseLevel("fatal")
+ assert.Nil(t, err)
+ assert.Equal(t, FatalLevel, l)
+
+ l, err = ParseLevel("error")
+ assert.Nil(t, err)
+ assert.Equal(t, ErrorLevel, l)
+
+ l, err = ParseLevel("warn")
+ assert.Nil(t, err)
+ assert.Equal(t, WarnLevel, l)
+
+ l, err = ParseLevel("warning")
+ assert.Nil(t, err)
+ assert.Equal(t, WarnLevel, l)
+
+ l, err = ParseLevel("info")
+ assert.Nil(t, err)
+ assert.Equal(t, InfoLevel, l)
+
+ l, err = ParseLevel("debug")
+ assert.Nil(t, err)
+ assert.Equal(t, DebugLevel, l)
+
+ l, err = ParseLevel("invalid")
+ assert.Equal(t, "not a valid logrus Level: \"invalid\"", err.Error())
+}
+
+func TestGetSetLevelRace(t *testing.T) {
+ wg := sync.WaitGroup{}
+ for i := 0; i < 100; i++ {
+ wg.Add(1)
+ go func(i int) {
+ defer wg.Done()
+ if i%2 == 0 {
+ SetLevel(InfoLevel)
+ } else {
+ GetLevel()
+ }
+ }(i)
+
+ }
+ wg.Wait()
+}
diff --git a/vendor/github.com/Sirupsen/logrus/terminal_bsd.go b/vendor/github.com/Sirupsen/logrus/terminal_bsd.go
new file mode 100644
index 0000000..71f8d67
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/terminal_bsd.go
@@ -0,0 +1,9 @@
+// +build darwin freebsd openbsd netbsd dragonfly
+
+package logrus
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA
+
+type Termios syscall.Termios
diff --git a/vendor/github.com/Sirupsen/logrus/terminal_linux.go b/vendor/github.com/Sirupsen/logrus/terminal_linux.go
new file mode 100644
index 0000000..a2c0b40
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/terminal_linux.go
@@ -0,0 +1,12 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logrus
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TCGETS
+
+type Termios syscall.Termios
diff --git a/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go b/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go
new file mode 100644
index 0000000..4bb5376
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go
@@ -0,0 +1,21 @@
+// Based on ssh/terminal:
+// 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.
+
+// +build linux darwin freebsd openbsd netbsd dragonfly
+
+package logrus
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+// IsTerminal returns true if the given file descriptor is a terminal.
+func IsTerminal() bool {
+ fd := syscall.Stdout
+ var termios Termios
+ _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
+ return err == 0
+}
diff --git a/vendor/github.com/Sirupsen/logrus/terminal_windows.go b/vendor/github.com/Sirupsen/logrus/terminal_windows.go
new file mode 100644
index 0000000..2e09f6f
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/terminal_windows.go
@@ -0,0 +1,27 @@
+// Based on ssh/terminal:
+// 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.
+
+// +build windows
+
+package logrus
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+var kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+var (
+ procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
+)
+
+// IsTerminal returns true if the given file descriptor is a terminal.
+func IsTerminal() bool {
+ fd := syscall.Stdout
+ var st uint32
+ r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0)
+ return r != 0 && e == 0
+}
diff --git a/vendor/github.com/Sirupsen/logrus/text_formatter.go b/vendor/github.com/Sirupsen/logrus/text_formatter.go
new file mode 100644
index 0000000..17cc298
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/text_formatter.go
@@ -0,0 +1,159 @@
+package logrus
+
+import (
+ "bytes"
+ "fmt"
+ "runtime"
+ "sort"
+ "strings"
+ "time"
+)
+
+const (
+ nocolor = 0
+ red = 31
+ green = 32
+ yellow = 33
+ blue = 34
+ gray = 37
+)
+
+var (
+ baseTimestamp time.Time
+ isTerminal bool
+)
+
+func init() {
+ baseTimestamp = time.Now()
+ isTerminal = IsTerminal()
+}
+
+func miniTS() int {
+ return int(time.Since(baseTimestamp) / time.Second)
+}
+
+type TextFormatter struct {
+ // Set to true to bypass checking for a TTY before outputting colors.
+ ForceColors bool
+
+ // Force disabling colors.
+ DisableColors bool
+
+ // Disable timestamp logging. useful when output is redirected to logging
+ // system that already adds timestamps.
+ DisableTimestamp bool
+
+ // Enable logging the full timestamp when a TTY is attached instead of just
+ // the time passed since beginning of execution.
+ FullTimestamp bool
+
+ // TimestampFormat to use for display when a full timestamp is printed
+ TimestampFormat string
+
+ // The fields are sorted by default for a consistent output. For applications
+ // that log extremely frequently and don't use the JSON formatter this may not
+ // be desired.
+ DisableSorting bool
+}
+
+func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
+ var keys []string = make([]string, 0, len(entry.Data))
+ for k := range entry.Data {
+ keys = append(keys, k)
+ }
+
+ if !f.DisableSorting {
+ sort.Strings(keys)
+ }
+
+ b := &bytes.Buffer{}
+
+ prefixFieldClashes(entry.Data)
+
+ isColorTerminal := isTerminal && (runtime.GOOS != "windows")
+ isColored := (f.ForceColors || isColorTerminal) && !f.DisableColors
+
+ timestampFormat := f.TimestampFormat
+ if timestampFormat == "" {
+ timestampFormat = DefaultTimestampFormat
+ }
+ if isColored {
+ f.printColored(b, entry, keys, timestampFormat)
+ } else {
+ if !f.DisableTimestamp {
+ f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat))
+ }
+ f.appendKeyValue(b, "level", entry.Level.String())
+ f.appendKeyValue(b, "msg", entry.Message)
+ for _, key := range keys {
+ f.appendKeyValue(b, key, entry.Data[key])
+ }
+ }
+
+ b.WriteByte('\n')
+ return b.Bytes(), nil
+}
+
+func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) {
+ var levelColor int
+ switch entry.Level {
+ case DebugLevel:
+ levelColor = gray
+ case WarnLevel:
+ levelColor = yellow
+ case ErrorLevel, FatalLevel, PanicLevel:
+ levelColor = red
+ default:
+ levelColor = blue
+ }
+
+ levelText := strings.ToUpper(entry.Level.String())[0:4]
+
+ if !f.FullTimestamp {
+ fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, miniTS(), entry.Message)
+ } else {
+ fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), entry.Message)
+ }
+ for _, k := range keys {
+ v := entry.Data[k]
+ fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=%+v", levelColor, k, v)
+ }
+}
+
+func needsQuoting(text string) bool {
+ for _, ch := range text {
+ if !((ch >= 'a' && ch <= 'z') ||
+ (ch >= 'A' && ch <= 'Z') ||
+ (ch >= '0' && ch <= '9') ||
+ ch == '-' || ch == '.') {
+ return false
+ }
+ }
+ return true
+}
+
+func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
+
+ b.WriteString(key)
+ b.WriteByte('=')
+
+ switch value := value.(type) {
+ case string:
+ if needsQuoting(value) {
+ b.WriteString(value)
+ } else {
+ fmt.Fprintf(b, "%q", value)
+ }
+ case error:
+ errmsg := value.Error()
+ if needsQuoting(errmsg) {
+ b.WriteString(errmsg)
+ } else {
+ fmt.Fprintf(b, "%q", value)
+ }
+ default:
+ fmt.Fprint(b, value)
+ }
+
+ b.WriteByte(' ')
+}
diff --git a/vendor/github.com/Sirupsen/logrus/text_formatter_test.go b/vendor/github.com/Sirupsen/logrus/text_formatter_test.go
new file mode 100644
index 0000000..e25a44f
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/text_formatter_test.go
@@ -0,0 +1,61 @@
+package logrus
+
+import (
+ "bytes"
+ "errors"
+ "testing"
+ "time"
+)
+
+func TestQuoting(t *testing.T) {
+ tf := &TextFormatter{DisableColors: true}
+
+ checkQuoting := func(q bool, value interface{}) {
+ b, _ := tf.Format(WithField("test", value))
+ idx := bytes.Index(b, ([]byte)("test="))
+ cont := bytes.Contains(b[idx+5:], []byte{'"'})
+ if cont != q {
+ if q {
+ t.Errorf("quoting expected for: %#v", value)
+ } else {
+ t.Errorf("quoting not expected for: %#v", value)
+ }
+ }
+ }
+
+ checkQuoting(false, "abcd")
+ checkQuoting(false, "v1.0")
+ checkQuoting(false, "1234567890")
+ checkQuoting(true, "/foobar")
+ checkQuoting(true, "x y")
+ checkQuoting(true, "x,y")
+ checkQuoting(false, errors.New("invalid"))
+ checkQuoting(true, errors.New("invalid argument"))
+}
+
+func TestTimestampFormat(t *testing.T) {
+ checkTimeStr := func(format string) {
+ customFormatter := &TextFormatter{DisableColors: true, TimestampFormat: format}
+ customStr, _ := customFormatter.Format(WithField("test", "test"))
+ timeStart := bytes.Index(customStr, ([]byte)("time="))
+ timeEnd := bytes.Index(customStr, ([]byte)("level="))
+ timeStr := customStr[timeStart+5 : timeEnd-1]
+ if timeStr[0] == '"' && timeStr[len(timeStr)-1] == '"' {
+ timeStr = timeStr[1 : len(timeStr)-1]
+ }
+ if format == "" {
+ format = time.RFC3339
+ }
+ _, e := time.Parse(format, (string)(timeStr))
+ if e != nil {
+ t.Errorf("time string \"%s\" did not match provided time format \"%s\": %s", timeStr, format, e)
+ }
+ }
+
+ checkTimeStr("2006-01-02T15:04:05.000000000Z07:00")
+ checkTimeStr("Mon Jan _2 15:04:05 2006")
+ checkTimeStr("")
+}
+
+// TODO add tests for sorting etc., this requires a parser for the text
+// formatter output.
diff --git a/vendor/github.com/Sirupsen/logrus/writer.go b/vendor/github.com/Sirupsen/logrus/writer.go
new file mode 100644
index 0000000..1e30b1c
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/writer.go
@@ -0,0 +1,31 @@
+package logrus
+
+import (
+ "bufio"
+ "io"
+ "runtime"
+)
+
+func (logger *Logger) Writer() *io.PipeWriter {
+ reader, writer := io.Pipe()
+
+ go logger.writerScanner(reader)
+ runtime.SetFinalizer(writer, writerFinalizer)
+
+ return writer
+}
+
+func (logger *Logger) writerScanner(reader *io.PipeReader) {
+ scanner := bufio.NewScanner(reader)
+ for scanner.Scan() {
+ logger.Print(scanner.Text())
+ }
+ if err := scanner.Err(); err != nil {
+ logger.Errorf("Error while reading from Writer: %s", err)
+ }
+ reader.Close()
+}
+
+func writerFinalizer(writer *io.PipeWriter) {
+ writer.Close()
+}
diff --git a/vendor/github.com/codegangsta/cli/LICENSE b/vendor/github.com/codegangsta/cli/LICENSE
new file mode 100644
index 0000000..5515ccf
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/LICENSE
@@ -0,0 +1,21 @@
+Copyright (C) 2013 Jeremy Saenz
+All Rights Reserved.
+
+MIT LICENSE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/codegangsta/cli/README.md b/vendor/github.com/codegangsta/cli/README.md
new file mode 100644
index 0000000..85b9cda
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/README.md
@@ -0,0 +1,308 @@
+[![Build Status](https://travis-ci.org/codegangsta/cli.png?branch=master)](https://travis-ci.org/codegangsta/cli)
+
+# cli.go
+cli.go is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
+
+You can view the API docs here:
+http://godoc.org/github.com/codegangsta/cli
+
+## Overview
+Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
+
+**This is where cli.go comes into play.** cli.go makes command line programming fun, organized, and expressive!
+
+## Installation
+Make sure you have a working Go environment (go 1.1+ is *required*). [See the install instructions](http://golang.org/doc/install.html).
+
+To install `cli.go`, simply run:
+```
+$ go get github.com/codegangsta/cli
+```
+
+Make sure your `PATH` includes to the `$GOPATH/bin` directory so your commands can be easily used:
+```
+export PATH=$PATH:$GOPATH/bin
+```
+
+## Getting Started
+One of the philosophies behind cli.go is that an API should be playful and full of discovery. So a cli.go app can be as little as one line of code in `main()`.
+
+``` go
+package main
+
+import (
+ "os"
+ "github.com/codegangsta/cli"
+)
+
+func main() {
+ cli.NewApp().Run(os.Args)
+}
+```
+
+This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
+
+``` go
+package main
+
+import (
+ "os"
+ "github.com/codegangsta/cli"
+)
+
+func main() {
+ app := cli.NewApp()
+ app.Name = "boom"
+ app.Usage = "make an explosive entrance"
+ app.Action = func(c *cli.Context) {
+ println("boom! I say!")
+ }
+
+ app.Run(os.Args)
+}
+```
+
+Running this already gives you a ton of functionality, plus support for things like subcommands and flags, which are covered below.
+
+## Example
+
+Being a programmer can be a lonely job. Thankfully by the power of automation that is not the case! Let's create a greeter app to fend off our demons of loneliness!
+
+Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
+
+``` go
+package main
+
+import (
+ "os"
+ "github.com/codegangsta/cli"
+)
+
+func main() {
+ app := cli.NewApp()
+ app.Name = "greet"
+ app.Usage = "fight the loneliness!"
+ app.Action = func(c *cli.Context) {
+ println("Hello friend!")
+ }
+
+ app.Run(os.Args)
+}
+```
+
+Install our command to the `$GOPATH/bin` directory:
+
+```
+$ go install
+```
+
+Finally run our new command:
+
+```
+$ greet
+Hello friend!
+```
+
+cli.go also generates some bitchass help text:
+```
+$ greet help
+NAME:
+ greet - fight the loneliness!
+
+USAGE:
+ greet [global options] command [command options] [arguments...]
+
+VERSION:
+ 0.0.0
+
+COMMANDS:
+ help, h Shows a list of commands or help for one command
+
+GLOBAL OPTIONS
+ --version Shows version information
+```
+
+### Arguments
+You can lookup arguments by calling the `Args` function on `cli.Context`.
+
+``` go
+...
+app.Action = func(c *cli.Context) {
+ println("Hello", c.Args()[0])
+}
+...
+```
+
+### Flags
+Setting and querying flags is simple.
+``` go
+...
+app.Flags = []cli.Flag {
+ cli.StringFlag{
+ Name: "lang",
+ Value: "english",
+ Usage: "language for the greeting",
+ },
+}
+app.Action = func(c *cli.Context) {
+ name := "someone"
+ if len(c.Args()) > 0 {
+ name = c.Args()[0]
+ }
+ if c.String("lang") == "spanish" {
+ println("Hola", name)
+ } else {
+ println("Hello", name)
+ }
+}
+...
+```
+
+See full list of flags at http://godoc.org/github.com/codegangsta/cli
+
+#### Alternate Names
+
+You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
+
+``` go
+app.Flags = []cli.Flag {
+ cli.StringFlag{
+ Name: "lang, l",
+ Value: "english",
+ Usage: "language for the greeting",
+ },
+}
+```
+
+That flag can then be set with `--lang spanish` or `-l spanish`. Note that giving two different forms of the same flag in the same command invocation is an error.
+
+#### Values from the Environment
+
+You can also have the default value set from the environment via `EnvVar`. e.g.
+
+``` go
+app.Flags = []cli.Flag {
+ cli.StringFlag{
+ Name: "lang, l",
+ Value: "english",
+ Usage: "language for the greeting",
+ EnvVar: "APP_LANG",
+ },
+}
+```
+
+The `EnvVar` may also be given as a comma-delimited "cascade", where the first environment variable that resolves is used as the default.
+
+``` go
+app.Flags = []cli.Flag {
+ cli.StringFlag{
+ Name: "lang, l",
+ Value: "english",
+ Usage: "language for the greeting",
+ EnvVar: "LEGACY_COMPAT_LANG,APP_LANG,LANG",
+ },
+}
+```
+
+### Subcommands
+
+Subcommands can be defined for a more git-like command line app.
+```go
+...
+app.Commands = []cli.Command{
+ {
+ Name: "add",
+ Aliases: []string{"a"},
+ Usage: "add a task to the list",
+ Action: func(c *cli.Context) {
+ println("added task: ", c.Args().First())
+ },
+ },
+ {
+ Name: "complete",
+ Aliases: []string{"c"},
+ Usage: "complete a task on the list",
+ Action: func(c *cli.Context) {
+ println("completed task: ", c.Args().First())
+ },
+ },
+ {
+ Name: "template",
+ Aliases: []string{"r"},
+ Usage: "options for task templates",
+ Subcommands: []cli.Command{
+ {
+ Name: "add",
+ Usage: "add a new template",
+ Action: func(c *cli.Context) {
+ println("new task template: ", c.Args().First())
+ },
+ },
+ {
+ Name: "remove",
+ Usage: "remove an existing template",
+ Action: func(c *cli.Context) {
+ println("removed task template: ", c.Args().First())
+ },
+ },
+ },
+ },
+}
+...
+```
+
+### Bash Completion
+
+You can enable completion commands by setting the `EnableBashCompletion`
+flag on the `App` object. By default, this setting will only auto-complete to
+show an app's subcommands, but you can write your own completion methods for
+the App or its subcommands.
+```go
+...
+var tasks = []string{"cook", "clean", "laundry", "eat", "sleep", "code"}
+app := cli.NewApp()
+app.EnableBashCompletion = true
+app.Commands = []cli.Command{
+ {
+ Name: "complete",
+ Aliases: []string{"c"},
+ Usage: "complete a task on the list",
+ Action: func(c *cli.Context) {
+ println("completed task: ", c.Args().First())
+ },
+ BashComplete: func(c *cli.Context) {
+ // This will complete if no args are passed
+ if len(c.Args()) > 0 {
+ return
+ }
+ for _, t := range tasks {
+ fmt.Println(t)
+ }
+ },
+ }
+}
+...
+```
+
+#### To Enable
+
+Source the `autocomplete/bash_autocomplete` file in your `.bashrc` file while
+setting the `PROG` variable to the name of your program:
+
+`PROG=myprogram source /.../cli/autocomplete/bash_autocomplete`
+
+#### To Distribute
+
+Copy and modify `autocomplete/bash_autocomplete` to use your program name
+rather than `$PROG` and have the user copy the file into
+`/etc/bash_completion.d/` (or automatically install it there if you are
+distributing a package). Alternatively you can just document that users should
+source the generic `autocomplete/bash_autocomplete` with `$PROG` set to your
+program name in their bash configuration.
+
+## Contribution Guidelines
+Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.
+
+If you have contributed something significant to the project, I will most likely add you as a collaborator. As a collaborator you are given the ability to merge others pull requests. It is very important that new code does not break existing code, so be careful about what code you do choose to merge. If you have any questions feel free to link @codegangsta to the issue in question and we can review it together.
+
+If you feel like you have contributed to the project but have not yet been added as a collaborator, I probably forgot to add you. Hit @codegangsta up over email and we will get it figured out.
diff --git a/vendor/github.com/codegangsta/cli/app.go b/vendor/github.com/codegangsta/cli/app.go
new file mode 100644
index 0000000..e7caec9
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/app.go
@@ -0,0 +1,308 @@
+package cli
+
+import (
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os"
+ "time"
+)
+
+// App is the main structure of a cli application. It is recomended that
+// an app be created with the cli.NewApp() function
+type App struct {
+ // The name of the program. Defaults to os.Args[0]
+ Name string
+ // Description of the program.
+ Usage string
+ // Version of the program
+ Version string
+ // List of commands to execute
+ Commands []Command
+ // List of flags to parse
+ Flags []Flag
+ // Boolean to enable bash completion commands
+ EnableBashCompletion bool
+ // Boolean to hide built-in help command
+ HideHelp bool
+ // Boolean to hide built-in version flag
+ HideVersion bool
+ // An action to execute when the bash-completion flag is set
+ BashComplete func(context *Context)
+ // An action to execute before any subcommands are run, but after the context is ready
+ // If a non-nil error is returned, no subcommands are run
+ Before func(context *Context) error
+ // An action to execute after any subcommands are run, but after the subcommand has finished
+ // It is run even if Action() panics
+ After func(context *Context) error
+ // The action to execute when no subcommands are specified
+ Action func(context *Context)
+ // Execute this function if the proper command cannot be found
+ CommandNotFound func(context *Context, command string)
+ // Compilation date
+ Compiled time.Time
+ // List of all authors who contributed
+ Authors []Author
+ // Copyright of the binary if any
+ Copyright string
+ // Name of Author (Note: Use App.Authors, this is deprecated)
+ Author string
+ // Email of Author (Note: Use App.Authors, this is deprecated)
+ Email string
+ // Writer writer to write output to
+ Writer io.Writer
+}
+
+// Tries to find out when this binary was compiled.
+// Returns the current time if it fails to find it.
+func compileTime() time.Time {
+ info, err := os.Stat(os.Args[0])
+ if err != nil {
+ return time.Now()
+ }
+ return info.ModTime()
+}
+
+// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
+func NewApp() *App {
+ return &App{
+ Name: os.Args[0],
+ Usage: "A new cli application",
+ Version: "0.0.0",
+ BashComplete: DefaultAppComplete,
+ Action: helpCommand.Action,
+ Compiled: compileTime(),
+ Writer: os.Stdout,
+ }
+}
+
+// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
+func (a *App) Run(arguments []string) (err error) {
+ if a.Author != "" || a.Email != "" {
+ a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
+ }
+
+ // append help to commands
+ if a.Command(helpCommand.Name) == nil && !a.HideHelp {
+ a.Commands = append(a.Commands, helpCommand)
+ if (HelpFlag != BoolFlag{}) {
+ a.appendFlag(HelpFlag)
+ }
+ }
+
+ //append version/help flags
+ if a.EnableBashCompletion {
+ a.appendFlag(BashCompletionFlag)
+ }
+
+ if !a.HideVersion {
+ a.appendFlag(VersionFlag)
+ }
+
+ // parse flags
+ set := flagSet(a.Name, a.Flags)
+ set.SetOutput(ioutil.Discard)
+ err = set.Parse(arguments[1:])
+ nerr := normalizeFlags(a.Flags, set)
+ if nerr != nil {
+ fmt.Fprintln(a.Writer, nerr)
+ context := NewContext(a, set, nil)
+ ShowAppHelp(context)
+ return nerr
+ }
+ context := NewContext(a, set, nil)
+
+ if err != nil {
+ fmt.Fprintln(a.Writer, "Incorrect Usage.")
+ fmt.Fprintln(a.Writer)
+ ShowAppHelp(context)
+ return err
+ }
+
+ if checkCompletions(context) {
+ return nil
+ }
+
+ if checkHelp(context) {
+ return nil
+ }
+
+ if checkVersion(context) {
+ return nil
+ }
+
+ if a.After != nil {
+ defer func() {
+ afterErr := a.After(context)
+ if afterErr != nil {
+ if err != nil {
+ err = NewMultiError(err, afterErr)
+ } else {
+ err = afterErr
+ }
+ }
+ }()
+ }
+
+ if a.Before != nil {
+ err := a.Before(context)
+ if err != nil {
+ return err
+ }
+ }
+
+ args := context.Args()
+ if args.Present() {
+ name := args.First()
+ c := a.Command(name)
+ if c != nil {
+ return c.Run(context)
+ }
+ }
+
+ // Run default Action
+ a.Action(context)
+ return nil
+}
+
+// Another entry point to the cli app, takes care of passing arguments and error handling
+func (a *App) RunAndExitOnError() {
+ if err := a.Run(os.Args); err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ os.Exit(1)
+ }
+}
+
+// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
+func (a *App) RunAsSubcommand(ctx *Context) (err error) {
+ // append help to commands
+ if len(a.Commands) > 0 {
+ if a.Command(helpCommand.Name) == nil && !a.HideHelp {
+ a.Commands = append(a.Commands, helpCommand)
+ if (HelpFlag != BoolFlag{}) {
+ a.appendFlag(HelpFlag)
+ }
+ }
+ }
+
+ // append flags
+ if a.EnableBashCompletion {
+ a.appendFlag(BashCompletionFlag)
+ }
+
+ // parse flags
+ set := flagSet(a.Name, a.Flags)
+ set.SetOutput(ioutil.Discard)
+ err = set.Parse(ctx.Args().Tail())
+ nerr := normalizeFlags(a.Flags, set)
+ context := NewContext(a, set, ctx)
+
+ if nerr != nil {
+ fmt.Fprintln(a.Writer, nerr)
+ fmt.Fprintln(a.Writer)
+ if len(a.Commands) > 0 {
+ ShowSubcommandHelp(context)
+ } else {
+ ShowCommandHelp(ctx, context.Args().First())
+ }
+ return nerr
+ }
+
+ if err != nil {
+ fmt.Fprintln(a.Writer, "Incorrect Usage.")
+ fmt.Fprintln(a.Writer)
+ ShowSubcommandHelp(context)
+ return err
+ }
+
+ if checkCompletions(context) {
+ return nil
+ }
+
+ if len(a.Commands) > 0 {
+ if checkSubcommandHelp(context) {
+ return nil
+ }
+ } else {
+ if checkCommandHelp(ctx, context.Args().First()) {
+ return nil
+ }
+ }
+
+ if a.After != nil {
+ defer func() {
+ afterErr := a.After(context)
+ if afterErr != nil {
+ if err != nil {
+ err = NewMultiError(err, afterErr)
+ } else {
+ err = afterErr
+ }
+ }
+ }()
+ }
+
+ if a.Before != nil {
+ err := a.Before(context)
+ if err != nil {
+ return err
+ }
+ }
+
+ args := context.Args()
+ if args.Present() {
+ name := args.First()
+ c := a.Command(name)
+ if c != nil {
+ return c.Run(context)
+ }
+ }
+
+ // Run default Action
+ a.Action(context)
+
+ return nil
+}
+
+// Returns the named command on App. Returns nil if the command does not exist
+func (a *App) Command(name string) *Command {
+ for _, c := range a.Commands {
+ if c.HasName(name) {
+ return &c
+ }
+ }
+
+ return nil
+}
+
+func (a *App) hasFlag(flag Flag) bool {
+ for _, f := range a.Flags {
+ if flag == f {
+ return true
+ }
+ }
+
+ return false
+}
+
+func (a *App) appendFlag(flag Flag) {
+ if !a.hasFlag(flag) {
+ a.Flags = append(a.Flags, flag)
+ }
+}
+
+// Author represents someone who has contributed to a cli project.
+type Author struct {
+ Name string // The Authors name
+ Email string // The Authors email
+}
+
+// String makes Author comply to the Stringer interface, to allow an easy print in the templating process
+func (a Author) String() string {
+ e := ""
+ if a.Email != "" {
+ e = "<" + a.Email + "> "
+ }
+
+ return fmt.Sprintf("%v %v", a.Name, e)
+}
diff --git a/vendor/github.com/codegangsta/cli/app_test.go b/vendor/github.com/codegangsta/cli/app_test.go
new file mode 100644
index 0000000..4c6787a
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/app_test.go
@@ -0,0 +1,867 @@
+package cli
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+ "testing"
+)
+
+func ExampleApp() {
+ // set args for examples sake
+ os.Args = []string{"greet", "--name", "Jeremy"}
+
+ app := NewApp()
+ app.Name = "greet"
+ app.Flags = []Flag{
+ StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
+ }
+ app.Action = func(c *Context) {
+ fmt.Printf("Hello %v\n", c.String("name"))
+ }
+ app.Author = "Harrison"
+ app.Email = "harrison@lolwut.com"
+ app.Authors = []Author{Author{Name: "Oliver Allen", Email: "oliver@toyshop.com"}}
+ app.Run(os.Args)
+ // Output:
+ // Hello Jeremy
+}
+
+func ExampleAppSubcommand() {
+ // set args for examples sake
+ os.Args = []string{"say", "hi", "english", "--name", "Jeremy"}
+ app := NewApp()
+ app.Name = "say"
+ app.Commands = []Command{
+ {
+ Name: "hello",
+ Aliases: []string{"hi"},
+ Usage: "use it to see a description",
+ Description: "This is how we describe hello the function",
+ Subcommands: []Command{
+ {
+ Name: "english",
+ Aliases: []string{"en"},
+ Usage: "sends a greeting in english",
+ Description: "greets someone in english",
+ Flags: []Flag{
+ StringFlag{
+ Name: "name",
+ Value: "Bob",
+ Usage: "Name of the person to greet",
+ },
+ },
+ Action: func(c *Context) {
+ fmt.Println("Hello,", c.String("name"))
+ },
+ },
+ },
+ },
+ }
+
+ app.Run(os.Args)
+ // Output:
+ // Hello, Jeremy
+}
+
+func ExampleAppHelp() {
+ // set args for examples sake
+ os.Args = []string{"greet", "h", "describeit"}
+
+ app := NewApp()
+ app.Name = "greet"
+ app.Flags = []Flag{
+ StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},
+ }
+ app.Commands = []Command{
+ {
+ Name: "describeit",
+ Aliases: []string{"d"},
+ Usage: "use it to see a description",
+ Description: "This is how we describe describeit the function",
+ Action: func(c *Context) {
+ fmt.Printf("i like to describe things")
+ },
+ },
+ }
+ app.Run(os.Args)
+ // Output:
+ // NAME:
+ // describeit - use it to see a description
+ //
+ // USAGE:
+ // command describeit [arguments...]
+ //
+ // DESCRIPTION:
+ // This is how we describe describeit the function
+}
+
+func ExampleAppBashComplete() {
+ // set args for examples sake
+ os.Args = []string{"greet", "--generate-bash-completion"}
+
+ app := NewApp()
+ app.Name = "greet"
+ app.EnableBashCompletion = true
+ app.Commands = []Command{
+ {
+ Name: "describeit",
+ Aliases: []string{"d"},
+ Usage: "use it to see a description",
+ Description: "This is how we describe describeit the function",
+ Action: func(c *Context) {
+ fmt.Printf("i like to describe things")
+ },
+ }, {
+ Name: "next",
+ Usage: "next example",
+ Description: "more stuff to see when generating bash completion",
+ Action: func(c *Context) {
+ fmt.Printf("the next example")
+ },
+ },
+ }
+
+ app.Run(os.Args)
+ // Output:
+ // describeit
+ // d
+ // next
+ // help
+ // h
+}
+
+func TestApp_Run(t *testing.T) {
+ s := ""
+
+ app := NewApp()
+ app.Action = func(c *Context) {
+ s = s + c.Args().First()
+ }
+
+ err := app.Run([]string{"command", "foo"})
+ expect(t, err, nil)
+ err = app.Run([]string{"command", "bar"})
+ expect(t, err, nil)
+ expect(t, s, "foobar")
+}
+
+var commandAppTests = []struct {
+ name string
+ expected bool
+}{
+ {"foobar", true},
+ {"batbaz", true},
+ {"b", true},
+ {"f", true},
+ {"bat", false},
+ {"nothing", false},
+}
+
+func TestApp_Command(t *testing.T) {
+ app := NewApp()
+ fooCommand := Command{Name: "foobar", Aliases: []string{"f"}}
+ batCommand := Command{Name: "batbaz", Aliases: []string{"b"}}
+ app.Commands = []Command{
+ fooCommand,
+ batCommand,
+ }
+
+ for _, test := range commandAppTests {
+ expect(t, app.Command(test.name) != nil, test.expected)
+ }
+}
+
+func TestApp_CommandWithArgBeforeFlags(t *testing.T) {
+ var parsedOption, firstArg string
+
+ app := NewApp()
+ command := Command{
+ Name: "cmd",
+ Flags: []Flag{
+ StringFlag{Name: "option", Value: "", Usage: "some option"},
+ },
+ Action: func(c *Context) {
+ parsedOption = c.String("option")
+ firstArg = c.Args().First()
+ },
+ }
+ app.Commands = []Command{command}
+
+ app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"})
+
+ expect(t, parsedOption, "my-option")
+ expect(t, firstArg, "my-arg")
+}
+
+func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
+ var context *Context
+
+ a := NewApp()
+ a.Commands = []Command{
+ {
+ Name: "foo",
+ Action: func(c *Context) {
+ context = c
+ },
+ Flags: []Flag{
+ StringFlag{
+ Name: "lang",
+ Value: "english",
+ Usage: "language for the greeting",
+ },
+ },
+ Before: func(_ *Context) error { return nil },
+ },
+ }
+ a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
+
+ expect(t, context.Args().Get(0), "abcd")
+ expect(t, context.String("lang"), "spanish")
+}
+
+func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) {
+ var parsedOption string
+ var args []string
+
+ app := NewApp()
+ command := Command{
+ Name: "cmd",
+ Flags: []Flag{
+ StringFlag{Name: "option", Value: "", Usage: "some option"},
+ },
+ Action: func(c *Context) {
+ parsedOption = c.String("option")
+ args = c.Args()
+ },
+ }
+ app.Commands = []Command{command}
+
+ app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"})
+
+ expect(t, parsedOption, "my-option")
+ expect(t, args[0], "my-arg")
+ expect(t, args[1], "--")
+ expect(t, args[2], "--notARealFlag")
+}
+
+func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) {
+ var args []string
+
+ app := NewApp()
+ command := Command{
+ Name: "cmd",
+ Action: func(c *Context) {
+ args = c.Args()
+ },
+ }
+ app.Commands = []Command{command}
+
+ app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"})
+
+ expect(t, args[0], "my-arg")
+ expect(t, args[1], "--")
+ expect(t, args[2], "notAFlagAtAll")
+}
+
+func TestApp_Float64Flag(t *testing.T) {
+ var meters float64
+
+ app := NewApp()
+ app.Flags = []Flag{
+ Float64Flag{Name: "height", Value: 1.5, Usage: "Set the height, in meters"},
+ }
+ app.Action = func(c *Context) {
+ meters = c.Float64("height")
+ }
+
+ app.Run([]string{"", "--height", "1.93"})
+ expect(t, meters, 1.93)
+}
+
+func TestApp_ParseSliceFlags(t *testing.T) {
+ var parsedOption, firstArg string
+ var parsedIntSlice []int
+ var parsedStringSlice []string
+
+ app := NewApp()
+ command := Command{
+ Name: "cmd",
+ Flags: []Flag{
+ IntSliceFlag{Name: "p", Value: &IntSlice{}, Usage: "set one or more ip addr"},
+ StringSliceFlag{Name: "ip", Value: &StringSlice{}, Usage: "set one or more ports to open"},
+ },
+ Action: func(c *Context) {
+ parsedIntSlice = c.IntSlice("p")
+ parsedStringSlice = c.StringSlice("ip")
+ parsedOption = c.String("option")
+ firstArg = c.Args().First()
+ },
+ }
+ app.Commands = []Command{command}
+
+ app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"})
+
+ IntsEquals := func(a, b []int) bool {
+ if len(a) != len(b) {
+ return false
+ }
+ for i, v := range a {
+ if v != b[i] {
+ return false
+ }
+ }
+ return true
+ }
+
+ StrsEquals := func(a, b []string) bool {
+ if len(a) != len(b) {
+ return false
+ }
+ for i, v := range a {
+ if v != b[i] {
+ return false
+ }
+ }
+ return true
+ }
+ var expectedIntSlice = []int{22, 80}
+ var expectedStringSlice = []string{"8.8.8.8", "8.8.4.4"}
+
+ if !IntsEquals(parsedIntSlice, expectedIntSlice) {
+ t.Errorf("%v does not match %v", parsedIntSlice, expectedIntSlice)
+ }
+
+ if !StrsEquals(parsedStringSlice, expectedStringSlice) {
+ t.Errorf("%v does not match %v", parsedStringSlice, expectedStringSlice)
+ }
+}
+
+func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) {
+ var parsedIntSlice []int
+ var parsedStringSlice []string
+
+ app := NewApp()
+ command := Command{
+ Name: "cmd",
+ Flags: []Flag{
+ IntSliceFlag{Name: "a", Usage: "set numbers"},
+ StringSliceFlag{Name: "str", Usage: "set strings"},
+ },
+ Action: func(c *Context) {
+ parsedIntSlice = c.IntSlice("a")
+ parsedStringSlice = c.StringSlice("str")
+ },
+ }
+ app.Commands = []Command{command}
+
+ app.Run([]string{"", "cmd", "my-arg", "-a", "2", "-str", "A"})
+
+ var expectedIntSlice = []int{2}
+ var expectedStringSlice = []string{"A"}
+
+ if parsedIntSlice[0] != expectedIntSlice[0] {
+ t.Errorf("%v does not match %v", parsedIntSlice[0], expectedIntSlice[0])
+ }
+
+ if parsedStringSlice[0] != expectedStringSlice[0] {
+ t.Errorf("%v does not match %v", parsedIntSlice[0], expectedIntSlice[0])
+ }
+}
+
+func TestApp_DefaultStdout(t *testing.T) {
+ app := NewApp()
+
+ if app.Writer != os.Stdout {
+ t.Error("Default output writer not set.")
+ }
+}
+
+type mockWriter struct {
+ written []byte
+}
+
+func (fw *mockWriter) Write(p []byte) (n int, err error) {
+ if fw.written == nil {
+ fw.written = p
+ } else {
+ fw.written = append(fw.written, p...)
+ }
+
+ return len(p), nil
+}
+
+func (fw *mockWriter) GetWritten() (b []byte) {
+ return fw.written
+}
+
+func TestApp_SetStdout(t *testing.T) {
+ w := &mockWriter{}
+
+ app := NewApp()
+ app.Name = "test"
+ app.Writer = w
+
+ err := app.Run([]string{"help"})
+
+ if err != nil {
+ t.Fatalf("Run error: %s", err)
+ }
+
+ if len(w.written) == 0 {
+ t.Error("App did not write output to desired writer.")
+ }
+}
+
+func TestApp_BeforeFunc(t *testing.T) {
+ beforeRun, subcommandRun := false, false
+ beforeError := fmt.Errorf("fail")
+ var err error
+
+ app := NewApp()
+
+ app.Before = func(c *Context) error {
+ beforeRun = true
+ s := c.String("opt")
+ if s == "fail" {
+ return beforeError
+ }
+
+ return nil
+ }
+
+ app.Commands = []Command{
+ Command{
+ Name: "sub",
+ Action: func(c *Context) {
+ subcommandRun = true
+ },
+ },
+ }
+
+ app.Flags = []Flag{
+ StringFlag{Name: "opt"},
+ }
+
+ // run with the Before() func succeeding
+ err = app.Run([]string{"command", "--opt", "succeed", "sub"})
+
+ if err != nil {
+ t.Fatalf("Run error: %s", err)
+ }
+
+ if beforeRun == false {
+ t.Errorf("Before() not executed when expected")
+ }
+
+ if subcommandRun == false {
+ t.Errorf("Subcommand not executed when expected")
+ }
+
+ // reset
+ beforeRun, subcommandRun = false, false
+
+ // run with the Before() func failing
+ err = app.Run([]string{"command", "--opt", "fail", "sub"})
+
+ // should be the same error produced by the Before func
+ if err != beforeError {
+ t.Errorf("Run error expected, but not received")
+ }
+
+ if beforeRun == false {
+ t.Errorf("Before() not executed when expected")
+ }
+
+ if subcommandRun == true {
+ t.Errorf("Subcommand executed when NOT expected")
+ }
+
+}
+
+func TestApp_AfterFunc(t *testing.T) {
+ afterRun, subcommandRun := false, false
+ afterError := fmt.Errorf("fail")
+ var err error
+
+ app := NewApp()
+
+ app.After = func(c *Context) error {
+ afterRun = true
+ s := c.String("opt")
+ if s == "fail" {
+ return afterError
+ }
+
+ return nil
+ }
+
+ app.Commands = []Command{
+ Command{
+ Name: "sub",
+ Action: func(c *Context) {
+ subcommandRun = true
+ },
+ },
+ }
+
+ app.Flags = []Flag{
+ StringFlag{Name: "opt"},
+ }
+
+ // run with the After() func succeeding
+ err = app.Run([]string{"command", "--opt", "succeed", "sub"})
+
+ if err != nil {
+ t.Fatalf("Run error: %s", err)
+ }
+
+ if afterRun == false {
+ t.Errorf("After() not executed when expected")
+ }
+
+ if subcommandRun == false {
+ t.Errorf("Subcommand not executed when expected")
+ }
+
+ // reset
+ afterRun, subcommandRun = false, false
+
+ // run with the Before() func failing
+ err = app.Run([]string{"command", "--opt", "fail", "sub"})
+
+ // should be the same error produced by the Before func
+ if err != afterError {
+ t.Errorf("Run error expected, but not received")
+ }
+
+ if afterRun == false {
+ t.Errorf("After() not executed when expected")
+ }
+
+ if subcommandRun == false {
+ t.Errorf("Subcommand not executed when expected")
+ }
+}
+
+func TestAppNoHelpFlag(t *testing.T) {
+ oldFlag := HelpFlag
+ defer func() {
+ HelpFlag = oldFlag
+ }()
+
+ HelpFlag = BoolFlag{}
+
+ app := NewApp()
+ err := app.Run([]string{"test", "-h"})
+
+ if err != flag.ErrHelp {
+ t.Errorf("expected error about missing help flag, but got: %s (%T)", err, err)
+ }
+}
+
+func TestAppHelpPrinter(t *testing.T) {
+ oldPrinter := HelpPrinter
+ defer func() {
+ HelpPrinter = oldPrinter
+ }()
+
+ var wasCalled = false
+ HelpPrinter = func(w io.Writer, template string, data interface{}) {
+ wasCalled = true
+ }
+
+ app := NewApp()
+ app.Run([]string{"-h"})
+
+ if wasCalled == false {
+ t.Errorf("Help printer expected to be called, but was not")
+ }
+}
+
+func TestAppVersionPrinter(t *testing.T) {
+ oldPrinter := VersionPrinter
+ defer func() {
+ VersionPrinter = oldPrinter
+ }()
+
+ var wasCalled = false
+ VersionPrinter = func(c *Context) {
+ wasCalled = true
+ }
+
+ app := NewApp()
+ ctx := NewContext(app, nil, nil)
+ ShowVersion(ctx)
+
+ if wasCalled == false {
+ t.Errorf("Version printer expected to be called, but was not")
+ }
+}
+
+func TestAppCommandNotFound(t *testing.T) {
+ beforeRun, subcommandRun := false, false
+ app := NewApp()
+
+ app.CommandNotFound = func(c *Context, command string) {
+ beforeRun = true
+ }
+
+ app.Commands = []Command{
+ Command{
+ Name: "bar",
+ Action: func(c *Context) {
+ subcommandRun = true
+ },
+ },
+ }
+
+ app.Run([]string{"command", "foo"})
+
+ expect(t, beforeRun, true)
+ expect(t, subcommandRun, false)
+}
+
+func TestGlobalFlag(t *testing.T) {
+ var globalFlag string
+ var globalFlagSet bool
+ app := NewApp()
+ app.Flags = []Flag{
+ StringFlag{Name: "global, g", Usage: "global"},
+ }
+ app.Action = func(c *Context) {
+ globalFlag = c.GlobalString("global")
+ globalFlagSet = c.GlobalIsSet("global")
+ }
+ app.Run([]string{"command", "-g", "foo"})
+ expect(t, globalFlag, "foo")
+ expect(t, globalFlagSet, true)
+
+}
+
+func TestGlobalFlagsInSubcommands(t *testing.T) {
+ subcommandRun := false
+ parentFlag := false
+ app := NewApp()
+
+ app.Flags = []Flag{
+ BoolFlag{Name: "debug, d", Usage: "Enable debugging"},
+ }
+
+ app.Commands = []Command{
+ Command{
+ Name: "foo",
+ Flags: []Flag{
+ BoolFlag{Name: "parent, p", Usage: "Parent flag"},
+ },
+ Subcommands: []Command{
+ {
+ Name: "bar",
+ Action: func(c *Context) {
+ if c.GlobalBool("debug") {
+ subcommandRun = true
+ }
+ if c.GlobalBool("parent") {
+ parentFlag = true
+ }
+ },
+ },
+ },
+ },
+ }
+
+ app.Run([]string{"command", "-d", "foo", "-p", "bar"})
+
+ expect(t, subcommandRun, true)
+ expect(t, parentFlag, true)
+}
+
+func TestApp_Run_CommandWithSubcommandHasHelpTopic(t *testing.T) {
+ var subcommandHelpTopics = [][]string{
+ {"command", "foo", "--help"},
+ {"command", "foo", "-h"},
+ {"command", "foo", "help"},
+ }
+
+ for _, flagSet := range subcommandHelpTopics {
+ t.Logf("==> checking with flags %v", flagSet)
+
+ app := NewApp()
+ buf := new(bytes.Buffer)
+ app.Writer = buf
+
+ subCmdBar := Command{
+ Name: "bar",
+ Usage: "does bar things",
+ }
+ subCmdBaz := Command{
+ Name: "baz",
+ Usage: "does baz things",
+ }
+ cmd := Command{
+ Name: "foo",
+ Description: "descriptive wall of text about how it does foo things",
+ Subcommands: []Command{subCmdBar, subCmdBaz},
+ }
+
+ app.Commands = []Command{cmd}
+ err := app.Run(flagSet)
+
+ if err != nil {
+ t.Error(err)
+ }
+
+ output := buf.String()
+ t.Logf("output: %q\n", buf.Bytes())
+
+ if strings.Contains(output, "No help topic for") {
+ t.Errorf("expect a help topic, got none: \n%q", output)
+ }
+
+ for _, shouldContain := range []string{
+ cmd.Name, cmd.Description,
+ subCmdBar.Name, subCmdBar.Usage,
+ subCmdBaz.Name, subCmdBaz.Usage,
+ } {
+ if !strings.Contains(output, shouldContain) {
+ t.Errorf("want help to contain %q, did not: \n%q", shouldContain, output)
+ }
+ }
+ }
+}
+
+func TestApp_Run_SubcommandFullPath(t *testing.T) {
+ app := NewApp()
+ buf := new(bytes.Buffer)
+ app.Writer = buf
+
+ subCmd := Command{
+ Name: "bar",
+ Usage: "does bar things",
+ }
+ cmd := Command{
+ Name: "foo",
+ Description: "foo commands",
+ Subcommands: []Command{subCmd},
+ }
+ app.Commands = []Command{cmd}
+
+ err := app.Run([]string{"command", "foo", "bar", "--help"})
+ if err != nil {
+ t.Error(err)
+ }
+
+ output := buf.String()
+ if !strings.Contains(output, "foo bar - does bar things") {
+ t.Errorf("expected full path to subcommand: %s", output)
+ }
+ if !strings.Contains(output, "command foo bar [arguments...]") {
+ t.Errorf("expected full path to subcommand: %s", output)
+ }
+}
+
+func TestApp_Run_Help(t *testing.T) {
+ var helpArguments = [][]string{{"boom", "--help"}, {"boom", "-h"}, {"boom", "help"}}
+
+ for _, args := range helpArguments {
+ buf := new(bytes.Buffer)
+
+ t.Logf("==> checking with arguments %v", args)
+
+ app := NewApp()
+ app.Name = "boom"
+ app.Usage = "make an explosive entrance"
+ app.Writer = buf
+ app.Action = func(c *Context) {
+ buf.WriteString("boom I say!")
+ }
+
+ err := app.Run(args)
+ if err != nil {
+ t.Error(err)
+ }
+
+ output := buf.String()
+ t.Logf("output: %q\n", buf.Bytes())
+
+ if !strings.Contains(output, "boom - make an explosive entrance") {
+ t.Errorf("want help to contain %q, did not: \n%q", "boom - make an explosive entrance", output)
+ }
+ }
+}
+
+func TestApp_Run_Version(t *testing.T) {
+ var versionArguments = [][]string{{"boom", "--version"}, {"boom", "-v"}}
+
+ for _, args := range versionArguments {
+ buf := new(bytes.Buffer)
+
+ t.Logf("==> checking with arguments %v", args)
+
+ app := NewApp()
+ app.Name = "boom"
+ app.Usage = "make an explosive entrance"
+ app.Version = "0.1.0"
+ app.Writer = buf
+ app.Action = func(c *Context) {
+ buf.WriteString("boom I say!")
+ }
+
+ err := app.Run(args)
+ if err != nil {
+ t.Error(err)
+ }
+
+ output := buf.String()
+ t.Logf("output: %q\n", buf.Bytes())
+
+ if !strings.Contains(output, "0.1.0") {
+ t.Errorf("want version to contain %q, did not: \n%q", "0.1.0", output)
+ }
+ }
+}
+
+func TestApp_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) {
+ app := NewApp()
+ app.Action = func(c *Context) {}
+ app.Before = func(c *Context) error { return fmt.Errorf("before error") }
+ app.After = func(c *Context) error { return fmt.Errorf("after error") }
+
+ err := app.Run([]string{"foo"})
+ if err == nil {
+ t.Fatalf("expected to recieve error from Run, got none")
+ }
+
+ if !strings.Contains(err.Error(), "before error") {
+ t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
+ }
+ if !strings.Contains(err.Error(), "after error") {
+ t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
+ }
+}
+
+func TestApp_Run_SubcommandDoesNotOverwriteErrorFromBefore(t *testing.T) {
+ app := NewApp()
+ app.Commands = []Command{
+ Command{
+ Name: "bar",
+ Before: func(c *Context) error { return fmt.Errorf("before error") },
+ After: func(c *Context) error { return fmt.Errorf("after error") },
+ },
+ }
+
+ err := app.Run([]string{"foo", "bar"})
+ if err == nil {
+ t.Fatalf("expected to recieve error from Run, got none")
+ }
+
+ if !strings.Contains(err.Error(), "before error") {
+ t.Errorf("expected text of error from Before method, but got none in \"%v\"", err)
+ }
+ if !strings.Contains(err.Error(), "after error") {
+ t.Errorf("expected text of error from After method, but got none in \"%v\"", err)
+ }
+}
diff --git a/vendor/github.com/codegangsta/cli/cli.go b/vendor/github.com/codegangsta/cli/cli.go
new file mode 100644
index 0000000..31dc912
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/cli.go
@@ -0,0 +1,40 @@
+// Package cli provides a minimal framework for creating and organizing command line
+// Go applications. cli is designed to be easy to understand and write, the most simple
+// cli application can be written as follows:
+// func main() {
+// cli.NewApp().Run(os.Args)
+// }
+//
+// Of course this application does not do much, so let's make this an actual application:
+// func main() {
+// app := cli.NewApp()
+// app.Name = "greet"
+// app.Usage = "say a greeting"
+// app.Action = func(c *cli.Context) {
+// println("Greetings")
+// }
+//
+// app.Run(os.Args)
+// }
+package cli
+
+import (
+ "strings"
+)
+
+type MultiError struct {
+ Errors []error
+}
+
+func NewMultiError(err ...error) MultiError {
+ return MultiError{Errors: err}
+}
+
+func (m MultiError) Error() string {
+ errs := make([]string, len(m.Errors))
+ for i, err := range m.Errors {
+ errs[i] = err.Error()
+ }
+
+ return strings.Join(errs, "\n")
+}
diff --git a/vendor/github.com/codegangsta/cli/cli_test.go b/vendor/github.com/codegangsta/cli/cli_test.go
new file mode 100644
index 0000000..e54f8e2
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/cli_test.go
@@ -0,0 +1,98 @@
+package cli
+
+import (
+ "os"
+)
+
+func Example() {
+ app := NewApp()
+ app.Name = "todo"
+ app.Usage = "task list on the command line"
+ app.Commands = []Command{
+ {
+ Name: "add",
+ Aliases: []string{"a"},
+ Usage: "add a task to the list",
+ Action: func(c *Context) {
+ println("added task: ", c.Args().First())
+ },
+ },
+ {
+ Name: "complete",
+ Aliases: []string{"c"},
+ Usage: "complete a task on the list",
+ Action: func(c *Context) {
+ println("completed task: ", c.Args().First())
+ },
+ },
+ }
+
+ app.Run(os.Args)
+}
+
+func ExampleSubcommand() {
+ app := NewApp()
+ app.Name = "say"
+ app.Commands = []Command{
+ {
+ Name: "hello",
+ Aliases: []string{"hi"},
+ Usage: "use it to see a description",
+ Description: "This is how we describe hello the function",
+ Subcommands: []Command{
+ {
+ Name: "english",
+ Aliases: []string{"en"},
+ Usage: "sends a greeting in english",
+ Description: "greets someone in english",
+ Flags: []Flag{
+ StringFlag{
+ Name: "name",
+ Value: "Bob",
+ Usage: "Name of the person to greet",
+ },
+ },
+ Action: func(c *Context) {
+ println("Hello, ", c.String("name"))
+ },
+ }, {
+ Name: "spanish",
+ Aliases: []string{"sp"},
+ Usage: "sends a greeting in spanish",
+ Flags: []Flag{
+ StringFlag{
+ Name: "surname",
+ Value: "Jones",
+ Usage: "Surname of the person to greet",
+ },
+ },
+ Action: func(c *Context) {
+ println("Hola, ", c.String("surname"))
+ },
+ }, {
+ Name: "french",
+ Aliases: []string{"fr"},
+ Usage: "sends a greeting in french",
+ Flags: []Flag{
+ StringFlag{
+ Name: "nickname",
+ Value: "Stevie",
+ Usage: "Nickname of the person to greet",
+ },
+ },
+ Action: func(c *Context) {
+ println("Bonjour, ", c.String("nickname"))
+ },
+ },
+ },
+ }, {
+ Name: "bye",
+ Usage: "says goodbye",
+ Action: func(c *Context) {
+ println("bye")
+ },
+ },
+ }
+
+ app.Run(os.Args)
+}
diff --git a/vendor/github.com/codegangsta/cli/command.go b/vendor/github.com/codegangsta/cli/command.go
new file mode 100644
index 0000000..54617af
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/command.go
@@ -0,0 +1,200 @@
+package cli
+
+import (
+ "fmt"
+ "io/ioutil"
+ "strings"
+)
+
+// Command is a subcommand for a cli.App.
+type Command struct {
+ // The name of the command
+ Name string
+ // short name of the command. Typically one character (deprecated, use `Aliases`)
+ ShortName string
+ // A list of aliases for the command
+ Aliases []string
+ // A short description of the usage of this command
+ Usage string
+ // A longer explanation of how the command works
+ Description string
+ // The function to call when checking for bash command completions
+ BashComplete func(context *Context)
+ // An action to execute before any sub-subcommands are run, but after the context is ready
+ // If a non-nil error is returned, no sub-subcommands are run
+ Before func(context *Context) error
+ // An action to execute after any subcommands are run, but after the subcommand has finished
+ // It is run even if Action() panics
+ After func(context *Context) error
+ // The function to call when this command is invoked
+ Action func(context *Context)
+ // List of child commands
+ Subcommands []Command
+ // List of flags to parse
+ Flags []Flag
+ // Treat all flags as normal arguments if true
+ SkipFlagParsing bool
+ // Boolean to hide built-in help command
+ HideHelp bool
+
+ commandNamePath []string
+}
+
+// Returns the full name of the command.
+// For subcommands this ensures that parent commands are part of the command path
+func (c Command) FullName() string {
+ if c.commandNamePath == nil {
+ return c.Name
+ }
+ return strings.Join(c.commandNamePath, " ")
+}
+
+// Invokes the command given the context, parses ctx.Args() to generate command-specific flags
+func (c Command) Run(ctx *Context) error {
+ if len(c.Subcommands) > 0 || c.Before != nil || c.After != nil {
+ return c.startApp(ctx)
+ }
+
+ if !c.HideHelp && (HelpFlag != BoolFlag{}) {
+ // append help to flags
+ c.Flags = append(
+ c.Flags,
+ HelpFlag,
+ )
+ }
+
+ if ctx.App.EnableBashCompletion {
+ c.Flags = append(c.Flags, BashCompletionFlag)
+ }
+
+ set := flagSet(c.Name, c.Flags)
+ set.SetOutput(ioutil.Discard)
+
+ firstFlagIndex := -1
+ terminatorIndex := -1
+ for index, arg := range ctx.Args() {
+ if arg == "--" {
+ terminatorIndex = index
+ break
+ } else if strings.HasPrefix(arg, "-") && firstFlagIndex == -1 {
+ firstFlagIndex = index
+ }
+ }
+
+ var err error
+ if firstFlagIndex > -1 && !c.SkipFlagParsing {
+ args := ctx.Args()
+ regularArgs := make([]string, len(args[1:firstFlagIndex]))
+ copy(regularArgs, args[1:firstFlagIndex])
+
+ var flagArgs []string
+ if terminatorIndex > -1 {
+ flagArgs = args[firstFlagIndex:terminatorIndex]
+ regularArgs = append(regularArgs, args[terminatorIndex:]...)
+ } else {
+ flagArgs = args[firstFlagIndex:]
+ }
+
+ err = set.Parse(append(flagArgs, regularArgs...))
+ } else {
+ err = set.Parse(ctx.Args().Tail())
+ }
+
+ if err != nil {
+ fmt.Fprintln(ctx.App.Writer, "Incorrect Usage.")
+ fmt.Fprintln(ctx.App.Writer)
+ ShowCommandHelp(ctx, c.Name)
+ return err
+ }
+
+ nerr := normalizeFlags(c.Flags, set)
+ if nerr != nil {
+ fmt.Fprintln(ctx.App.Writer, nerr)
+ fmt.Fprintln(ctx.App.Writer)
+ ShowCommandHelp(ctx, c.Name)
+ return nerr
+ }
+ context := NewContext(ctx.App, set, ctx)
+
+ if checkCommandCompletions(context, c.Name) {
+ return nil
+ }
+
+ if checkCommandHelp(context, c.Name) {
+ return nil
+ }
+ context.Command = c
+ c.Action(context)
+ return nil
+}
+
+func (c Command) Names() []string {
+ names := []string{c.Name}
+
+ if c.ShortName != "" {
+ names = append(names, c.ShortName)
+ }
+
+ return append(names, c.Aliases...)
+}
+
+// Returns true if Command.Name or Command.ShortName matches given name
+func (c Command) HasName(name string) bool {
+ for _, n := range c.Names() {
+ if n == name {
+ return true
+ }
+ }
+ return false
+}
+
+func (c Command) startApp(ctx *Context) error {
+ app := NewApp()
+
+ // set the name and usage
+ app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
+ if c.Description != "" {
+ app.Usage = c.Description
+ } else {
+ app.Usage = c.Usage
+ }
+
+ // set CommandNotFound
+ app.CommandNotFound = ctx.App.CommandNotFound
+
+ // set the flags and commands
+ app.Commands = c.Subcommands
+ app.Flags = c.Flags
+ app.HideHelp = c.HideHelp
+
+ app.Version = ctx.App.Version
+ app.HideVersion = ctx.App.HideVersion
+ app.Compiled = ctx.App.Compiled
+ app.Author = ctx.App.Author
+ app.Email = ctx.App.Email
+ app.Writer = ctx.App.Writer
+
+ // bash completion
+ app.EnableBashCompletion = ctx.App.EnableBashCompletion
+ if c.BashComplete != nil {
+ app.BashComplete = c.BashComplete
+ }
+
+ // set the actions
+ app.Before = c.Before
+ app.After = c.After
+ if c.Action != nil {
+ app.Action = c.Action
+ } else {
+ app.Action = helpSubcommand.Action
+ }
+
+ var newCmds []Command
+ for _, cc := range app.Commands {
+ cc.commandNamePath = []string{c.Name, cc.Name}
+ newCmds = append(newCmds, cc)
+ }
+ app.Commands = newCmds
+
+ return app.RunAsSubcommand(ctx)
+}
diff --git a/vendor/github.com/codegangsta/cli/command_test.go b/vendor/github.com/codegangsta/cli/command_test.go
new file mode 100644
index 0000000..688d12c
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/command_test.go
@@ -0,0 +1,47 @@
+package cli
+
+import (
+ "flag"
+ "testing"
+)
+
+func TestCommandDoNotIgnoreFlags(t *testing.T) {
+ app := NewApp()
+ set := flag.NewFlagSet("test", 0)
+ test := []string{"blah", "blah", "-break"}
+ set.Parse(test)
+
+ c := NewContext(app, set, nil)
+
+ command := Command{
+ Name: "test-cmd",
+ Aliases: []string{"tc"},
+ Usage: "this is for testing",
+ Description: "testing",
+ Action: func(_ *Context) {},
+ }
+ err := command.Run(c)
+
+ expect(t, err.Error(), "flag provided but not defined: -break")
+}
+
+func TestCommandIgnoreFlags(t *testing.T) {
+ app := NewApp()
+ set := flag.NewFlagSet("test", 0)
+ test := []string{"blah", "blah"}
+ set.Parse(test)
+
+ c := NewContext(app, set, nil)
+
+ command := Command{
+ Name: "test-cmd",
+ Aliases: []string{"tc"},
+ Usage: "this is for testing",
+ Description: "testing",
+ Action: func(_ *Context) {},
+ SkipFlagParsing: true,
+ }
+ err := command.Run(c)
+
+ expect(t, err, nil)
+}
diff --git a/vendor/github.com/codegangsta/cli/context.go b/vendor/github.com/codegangsta/cli/context.go
new file mode 100644
index 0000000..f541f41
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/context.go
@@ -0,0 +1,388 @@
+package cli
+
+import (
+ "errors"
+ "flag"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// Context is a type that is passed through to
+// each Handler action in a cli application. Context
+// can be used to retrieve context-specific Args and
+// parsed command-line options.
+type Context struct {
+ App *App
+ Command Command
+ flagSet *flag.FlagSet
+ setFlags map[string]bool
+ globalSetFlags map[string]bool
+ parentContext *Context
+}
+
+// Creates a new context. For use in when invoking an App or Command action.
+func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
+ return &Context{App: app, flagSet: set, parentContext: parentCtx}
+}
+
+// Looks up the value of a local int flag, returns 0 if no int flag exists
+func (c *Context) Int(name string) int {
+ return lookupInt(name, c.flagSet)
+}
+
+// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
+func (c *Context) Duration(name string) time.Duration {
+ return lookupDuration(name, c.flagSet)
+}
+
+// Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
+func (c *Context) Float64(name string) float64 {
+ return lookupFloat64(name, c.flagSet)
+}
+
+// Looks up the value of a local bool flag, returns false if no bool flag exists
+func (c *Context) Bool(name string) bool {
+ return lookupBool(name, c.flagSet)
+}
+
+// Looks up the value of a local boolT flag, returns false if no bool flag exists
+func (c *Context) BoolT(name string) bool {
+ return lookupBoolT(name, c.flagSet)
+}
+
+// Looks up the value of a local string flag, returns "" if no string flag exists
+func (c *Context) String(name string) string {
+ return lookupString(name, c.flagSet)
+}
+
+// Looks up the value of a local string slice flag, returns nil if no string slice flag exists
+func (c *Context) StringSlice(name string) []string {
+ return lookupStringSlice(name, c.flagSet)
+}
+
+// Looks up the value of a local int slice flag, returns nil if no int slice flag exists
+func (c *Context) IntSlice(name string) []int {
+ return lookupIntSlice(name, c.flagSet)
+}
+
+// Looks up the value of a local generic flag, returns nil if no generic flag exists
+func (c *Context) Generic(name string) interface{} {
+ return lookupGeneric(name, c.flagSet)
+}
+
+// Looks up the value of a global int flag, returns 0 if no int flag exists
+func (c *Context) GlobalInt(name string) int {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupInt(name, fs)
+ }
+ return 0
+}
+
+// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
+func (c *Context) GlobalDuration(name string) time.Duration {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupDuration(name, fs)
+ }
+ return 0
+}
+
+// Looks up the value of a global bool flag, returns false if no bool flag exists
+func (c *Context) GlobalBool(name string) bool {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupBool(name, fs)
+ }
+ return false
+}
+
+// Looks up the value of a global string flag, returns "" if no string flag exists
+func (c *Context) GlobalString(name string) string {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupString(name, fs)
+ }
+ return ""
+}
+
+// Looks up the value of a global string slice flag, returns nil if no string slice flag exists
+func (c *Context) GlobalStringSlice(name string) []string {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupStringSlice(name, fs)
+ }
+ return nil
+}
+
+// Looks up the value of a global int slice flag, returns nil if no int slice flag exists
+func (c *Context) GlobalIntSlice(name string) []int {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupIntSlice(name, fs)
+ }
+ return nil
+}
+
+// Looks up the value of a global generic flag, returns nil if no generic flag exists
+func (c *Context) GlobalGeneric(name string) interface{} {
+ if fs := lookupGlobalFlagSet(name, c); fs != nil {
+ return lookupGeneric(name, fs)
+ }
+ return nil
+}
+
+// Returns the number of flags set
+func (c *Context) NumFlags() int {
+ return c.flagSet.NFlag()
+}
+
+// Determines if the flag was actually set
+func (c *Context) IsSet(name string) bool {
+ if c.setFlags == nil {
+ c.setFlags = make(map[string]bool)
+ c.flagSet.Visit(func(f *flag.Flag) {
+ c.setFlags[f.Name] = true
+ })
+ }
+ return c.setFlags[name] == true
+}
+
+// Determines if the global flag was actually set
+func (c *Context) GlobalIsSet(name string) bool {
+ if c.globalSetFlags == nil {
+ c.globalSetFlags = make(map[string]bool)
+ ctx := c
+ if ctx.parentContext != nil {
+ ctx = ctx.parentContext
+ }
+ for ; ctx != nil && c.globalSetFlags[name] == false; ctx = ctx.parentContext {
+ ctx.flagSet.Visit(func(f *flag.Flag) {
+ c.globalSetFlags[f.Name] = true
+ })
+ }
+ }
+ return c.globalSetFlags[name]
+}
+
+// Returns a slice of flag names used in this context.
+func (c *Context) FlagNames() (names []string) {
+ for _, flag := range c.Command.Flags {
+ name := strings.Split(flag.getName(), ",")[0]
+ if name == "help" {
+ continue
+ }
+ names = append(names, name)
+ }
+ return
+}
+
+// Returns a slice of global flag names used by the app.
+func (c *Context) GlobalFlagNames() (names []string) {
+ for _, flag := range c.App.Flags {
+ name := strings.Split(flag.getName(), ",")[0]
+ if name == "help" || name == "version" {
+ continue
+ }
+ names = append(names, name)
+ }
+ return
+}
+
+// Returns the parent context, if any
+func (c *Context) Parent() *Context {
+ return c.parentContext
+}
+
+type Args []string
+
+// Returns the command line arguments associated with the context.
+func (c *Context) Args() Args {
+ args := Args(c.flagSet.Args())
+ return args
+}
+
+// Returns the nth argument, or else a blank string
+func (a Args) Get(n int) string {
+ if len(a) > n {
+ return a[n]
+ }
+ return ""
+}
+
+// Returns the first argument, or else a blank string
+func (a Args) First() string {
+ return a.Get(0)
+}
+
+// Return the rest of the arguments (not the first one)
+// or else an empty string slice
+func (a Args) Tail() []string {
+ if len(a) >= 2 {
+ return []string(a)[1:]
+ }
+ return []string{}
+}
+
+// Checks if there are any arguments present
+func (a Args) Present() bool {
+ return len(a) != 0
+}
+
+// Swaps arguments at the given indexes
+func (a Args) Swap(from, to int) error {
+ if from >= len(a) || to >= len(a) {
+ return errors.New("index out of range")
+ }
+ a[from], a[to] = a[to], a[from]
+ return nil
+}
+
+func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet {
+ if ctx.parentContext != nil {
+ ctx = ctx.parentContext
+ }
+ for ; ctx != nil; ctx = ctx.parentContext {
+ if f := ctx.flagSet.Lookup(name); f != nil {
+ return ctx.flagSet
+ }
+ }
+ return nil
+}
+
+func lookupInt(name string, set *flag.FlagSet) int {
+ f := set.Lookup(name)
+ if f != nil {
+ val, err := strconv.Atoi(f.Value.String())
+ if err != nil {
+ return 0
+ }
+ return val
+ }
+
+ return 0
+}
+
+func lookupDuration(name string, set *flag.FlagSet) time.Duration {
+ f := set.Lookup(name)
+ if f != nil {
+ val, err := time.ParseDuration(f.Value.String())
+ if err == nil {
+ return val
+ }
+ }
+
+ return 0
+}
+
+func lookupFloat64(name string, set *flag.FlagSet) float64 {
+ f := set.Lookup(name)
+ if f != nil {
+ val, err := strconv.ParseFloat(f.Value.String(), 64)
+ if err != nil {
+ return 0
+ }
+ return val
+ }
+
+ return 0
+}
+
+func lookupString(name string, set *flag.FlagSet) string {
+ f := set.Lookup(name)
+ if f != nil {
+ return f.Value.String()
+ }
+
+ return ""
+}
+
+func lookupStringSlice(name string, set *flag.FlagSet) []string {
+ f := set.Lookup(name)
+ if f != nil {
+ return (f.Value.(*StringSlice)).Value()
+
+ }
+
+ return nil
+}
+
+func lookupIntSlice(name string, set *flag.FlagSet) []int {
+ f := set.Lookup(name)
+ if f != nil {
+ return (f.Value.(*IntSlice)).Value()
+
+ }
+
+ return nil
+}
+
+func lookupGeneric(name string, set *flag.FlagSet) interface{} {
+ f := set.Lookup(name)
+ if f != nil {
+ return f.Value
+ }
+ return nil
+}
+
+func lookupBool(name string, set *flag.FlagSet) bool {
+ f := set.Lookup(name)
+ if f != nil {
+ val, err := strconv.ParseBool(f.Value.String())
+ if err != nil {
+ return false
+ }
+ return val
+ }
+
+ return false
+}
+
+func lookupBoolT(name string, set *flag.FlagSet) bool {
+ f := set.Lookup(name)
+ if f != nil {
+ val, err := strconv.ParseBool(f.Value.String())
+ if err != nil {
+ return true
+ }
+ return val
+ }
+
+ return false
+}
+
+func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
+ switch ff.Value.(type) {
+ case *StringSlice:
+ default:
+ set.Set(name, ff.Value.String())
+ }
+}
+
+func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
+ visited := make(map[string]bool)
+ set.Visit(func(f *flag.Flag) {
+ visited[f.Name] = true
+ })
+ for _, f := range flags {
+ parts := strings.Split(f.getName(), ",")
+ if len(parts) == 1 {
+ continue
+ }
+ var ff *flag.Flag
+ for _, name := range parts {
+ name = strings.Trim(name, " ")
+ if visited[name] {
+ if ff != nil {
+ return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
+ }
+ ff = set.Lookup(name)
+ }
+ }
+ if ff == nil {
+ continue
+ }
+ for _, name := range parts {
+ name = strings.Trim(name, " ")
+ if !visited[name] {
+ copyFlag(name, ff, set)
+ }
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/codegangsta/cli/context_test.go b/vendor/github.com/codegangsta/cli/context_test.go
new file mode 100644
index 0000000..7f8e928
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/context_test.go
@@ -0,0 +1,113 @@
+package cli
+
+import (
+ "flag"
+ "testing"
+ "time"
+)
+
+func TestNewContext(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Int("myflag", 12, "doc")
+ globalSet := flag.NewFlagSet("test", 0)
+ globalSet.Int("myflag", 42, "doc")
+ globalCtx := NewContext(nil, globalSet, nil)
+ command := Command{Name: "mycommand"}
+ c := NewContext(nil, set, globalCtx)
+ c.Command = command
+ expect(t, c.Int("myflag"), 12)
+ expect(t, c.GlobalInt("myflag"), 42)
+ expect(t, c.Command.Name, "mycommand")
+}
+
+func TestContext_Int(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Int("myflag", 12, "doc")
+ c := NewContext(nil, set, nil)
+ expect(t, c.Int("myflag"), 12)
+}
+
+func TestContext_Duration(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Duration("myflag", time.Duration(12*time.Second), "doc")
+ c := NewContext(nil, set, nil)
+ expect(t, c.Duration("myflag"), time.Duration(12*time.Second))
+}
+
+func TestContext_String(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.String("myflag", "hello world", "doc")
+ c := NewContext(nil, set, nil)
+ expect(t, c.String("myflag"), "hello world")
+}
+
+func TestContext_Bool(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Bool("myflag", false, "doc")
+ c := NewContext(nil, set, nil)
+ expect(t, c.Bool("myflag"), false)
+}
+
+func TestContext_BoolT(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Bool("myflag", true, "doc")
+ c := NewContext(nil, set, nil)
+ expect(t, c.BoolT("myflag"), true)
+}
+
+func TestContext_Args(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Bool("myflag", false, "doc")
+ c := NewContext(nil, set, nil)
+ set.Parse([]string{"--myflag", "bat", "baz"})
+ expect(t, len(c.Args()), 2)
+ expect(t, c.Bool("myflag"), true)
+}
+
+func TestContext_IsSet(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Bool("myflag", false, "doc")
+ set.String("otherflag", "hello world", "doc")
+ globalSet := flag.NewFlagSet("test", 0)
+ globalSet.Bool("myflagGlobal", true, "doc")
+ globalCtx := NewContext(nil, globalSet, nil)
+ c := NewContext(nil, set, globalCtx)
+ set.Parse([]string{"--myflag", "bat", "baz"})
+ globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
+ expect(t, c.IsSet("myflag"), true)
+ expect(t, c.IsSet("otherflag"), false)
+ expect(t, c.IsSet("bogusflag"), false)
+ expect(t, c.IsSet("myflagGlobal"), false)
+}
+
+func TestContext_GlobalIsSet(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Bool("myflag", false, "doc")
+ set.String("otherflag", "hello world", "doc")
+ globalSet := flag.NewFlagSet("test", 0)
+ globalSet.Bool("myflagGlobal", true, "doc")
+ globalSet.Bool("myflagGlobalUnset", true, "doc")
+ globalCtx := NewContext(nil, globalSet, nil)
+ c := NewContext(nil, set, globalCtx)
+ set.Parse([]string{"--myflag", "bat", "baz"})
+ globalSet.Parse([]string{"--myflagGlobal", "bat", "baz"})
+ expect(t, c.GlobalIsSet("myflag"), false)
+ expect(t, c.GlobalIsSet("otherflag"), false)
+ expect(t, c.GlobalIsSet("bogusflag"), false)
+ expect(t, c.GlobalIsSet("myflagGlobal"), true)
+ expect(t, c.GlobalIsSet("myflagGlobalUnset"), false)
+ expect(t, c.GlobalIsSet("bogusGlobal"), false)
+}
+
+func TestContext_NumFlags(t *testing.T) {
+ set := flag.NewFlagSet("test", 0)
+ set.Bool("myflag", false, "doc")
+ set.String("otherflag", "hello world", "doc")
+ globalSet := flag.NewFlagSet("test", 0)
+ globalSet.Bool("myflagGlobal", true, "doc")
+ globalCtx := NewContext(nil, globalSet, nil)
+ c := NewContext(nil, set, globalCtx)
+ set.Parse([]string{"--myflag", "--otherflag=foo"})
+ globalSet.Parse([]string{"--myflagGlobal"})
+ expect(t, c.NumFlags(), 2)
+}
diff --git a/vendor/github.com/codegangsta/cli/flag.go b/vendor/github.com/codegangsta/cli/flag.go
new file mode 100644
index 0000000..531b091
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/flag.go
@@ -0,0 +1,497 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// This flag enables bash-completion for all commands and subcommands
+var BashCompletionFlag = BoolFlag{
+ Name: "generate-bash-completion",
+}
+
+// This flag prints the version for the application
+var VersionFlag = BoolFlag{
+ Name: "version, v",
+ Usage: "print the version",
+}
+
+// This flag prints the help for all commands and subcommands
+// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
+// unless HideHelp is set to true)
+var HelpFlag = BoolFlag{
+ Name: "help, h",
+ Usage: "show help",
+}
+
+// Flag is a common interface related to parsing flags in cli.
+// For more advanced flag parsing techniques, it is recomended that
+// this interface be implemented.
+type Flag interface {
+ fmt.Stringer
+ // Apply Flag settings to the given flag set
+ Apply(*flag.FlagSet)
+ getName() string
+}
+
+func flagSet(name string, flags []Flag) *flag.FlagSet {
+ set := flag.NewFlagSet(name, flag.ContinueOnError)
+
+ for _, f := range flags {
+ f.Apply(set)
+ }
+ return set
+}
+
+func eachName(longName string, fn func(string)) {
+ parts := strings.Split(longName, ",")
+ for _, name := range parts {
+ name = strings.Trim(name, " ")
+ fn(name)
+ }
+}
+
+// Generic is a generic parseable type identified by a specific flag
+type Generic interface {
+ Set(value string) error
+ String() string
+}
+
+// GenericFlag is the flag type for types implementing Generic
+type GenericFlag struct {
+ Name string
+ Value Generic
+ Usage string
+ EnvVar string
+}
+
+// String returns the string representation of the generic flag to display the
+// help text to the user (uses the String() method of the generic flag to show
+// the value)
+func (f GenericFlag) String() string {
+ return withEnvHint(f.EnvVar, fmt.Sprintf("%s%s \"%v\"\t%v", prefixFor(f.Name), f.Name, f.Value, f.Usage))
+}
+
+// Apply takes the flagset and calls Set on the generic flag with the value
+// provided by the user for parsing by the flag
+func (f GenericFlag) Apply(set *flag.FlagSet) {
+ val := f.Value
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ val.Set(envVal)
+ break
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ set.Var(f.Value, name, f.Usage)
+ })
+}
+
+func (f GenericFlag) getName() string {
+ return f.Name
+}
+
+// StringSlice is an opaque type for []string to satisfy flag.Value
+type StringSlice []string
+
+// Set appends the string value to the list of values
+func (f *StringSlice) Set(value string) error {
+ *f = append(*f, value)
+ return nil
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *StringSlice) String() string {
+ return fmt.Sprintf("%s", *f)
+}
+
+// Value returns the slice of strings set by this flag
+func (f *StringSlice) Value() []string {
+ return *f
+}
+
+// StringSlice is a string flag that can be specified multiple times on the
+// command-line
+type StringSliceFlag struct {
+ Name string
+ Value *StringSlice
+ Usage string
+ EnvVar string
+}
+
+// String returns the usage
+func (f StringSliceFlag) String() string {
+ firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
+ pref := prefixFor(firstName)
+ return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
+}
+
+// Apply populates the flag given the flag set and environment
+func (f StringSliceFlag) Apply(set *flag.FlagSet) {
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ newVal := &StringSlice{}
+ for _, s := range strings.Split(envVal, ",") {
+ s = strings.TrimSpace(s)
+ newVal.Set(s)
+ }
+ f.Value = newVal
+ break
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ if f.Value == nil {
+ f.Value = &StringSlice{}
+ }
+ set.Var(f.Value, name, f.Usage)
+ })
+}
+
+func (f StringSliceFlag) getName() string {
+ return f.Name
+}
+
+// StringSlice is an opaque type for []int to satisfy flag.Value
+type IntSlice []int
+
+// Set parses the value into an integer and appends it to the list of values
+func (f *IntSlice) Set(value string) error {
+ tmp, err := strconv.Atoi(value)
+ if err != nil {
+ return err
+ } else {
+ *f = append(*f, tmp)
+ }
+ return nil
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *IntSlice) String() string {
+ return fmt.Sprintf("%d", *f)
+}
+
+// Value returns the slice of ints set by this flag
+func (f *IntSlice) Value() []int {
+ return *f
+}
+
+// IntSliceFlag is an int flag that can be specified multiple times on the
+// command-line
+type IntSliceFlag struct {
+ Name string
+ Value *IntSlice
+ Usage string
+ EnvVar string
+}
+
+// String returns the usage
+func (f IntSliceFlag) String() string {
+ firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
+ pref := prefixFor(firstName)
+ return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
+}
+
+// Apply populates the flag given the flag set and environment
+func (f IntSliceFlag) Apply(set *flag.FlagSet) {
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ newVal := &IntSlice{}
+ for _, s := range strings.Split(envVal, ",") {
+ s = strings.TrimSpace(s)
+ err := newVal.Set(s)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, err.Error())
+ }
+ }
+ f.Value = newVal
+ break
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ if f.Value == nil {
+ f.Value = &IntSlice{}
+ }
+ set.Var(f.Value, name, f.Usage)
+ })
+}
+
+func (f IntSliceFlag) getName() string {
+ return f.Name
+}
+
+// BoolFlag is a switch that defaults to false
+type BoolFlag struct {
+ Name string
+ Usage string
+ EnvVar string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f BoolFlag) String() string {
+ return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+}
+
+// Apply populates the flag given the flag set and environment
+func (f BoolFlag) Apply(set *flag.FlagSet) {
+ val := false
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ envValBool, err := strconv.ParseBool(envVal)
+ if err == nil {
+ val = envValBool
+ }
+ break
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ set.Bool(name, val, f.Usage)
+ })
+}
+
+func (f BoolFlag) getName() string {
+ return f.Name
+}
+
+// BoolTFlag this represents a boolean flag that is true by default, but can
+// still be set to false by --some-flag=false
+type BoolTFlag struct {
+ Name string
+ Usage string
+ EnvVar string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f BoolTFlag) String() string {
+ return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
+}
+
+// Apply populates the flag given the flag set and environment
+func (f BoolTFlag) Apply(set *flag.FlagSet) {
+ val := true
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ envValBool, err := strconv.ParseBool(envVal)
+ if err == nil {
+ val = envValBool
+ break
+ }
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ set.Bool(name, val, f.Usage)
+ })
+}
+
+func (f BoolTFlag) getName() string {
+ return f.Name
+}
+
+// StringFlag represents a flag that takes as string value
+type StringFlag struct {
+ Name string
+ Value string
+ Usage string
+ EnvVar string
+}
+
+// String returns the usage
+func (f StringFlag) String() string {
+ var fmtString string
+ fmtString = "%s %v\t%v"
+
+ if len(f.Value) > 0 {
+ fmtString = "%s \"%v\"\t%v"
+ } else {
+ fmtString = "%s %v\t%v"
+ }
+
+ return withEnvHint(f.EnvVar, fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage))
+}
+
+// Apply populates the flag given the flag set and environment
+func (f StringFlag) Apply(set *flag.FlagSet) {
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ f.Value = envVal
+ break
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ set.String(name, f.Value, f.Usage)
+ })
+}
+
+func (f StringFlag) getName() string {
+ return f.Name
+}
+
+// IntFlag is a flag that takes an integer
+// Errors if the value provided cannot be parsed
+type IntFlag struct {
+ Name string
+ Value int
+ Usage string
+ EnvVar string
+}
+
+// String returns the usage
+func (f IntFlag) String() string {
+ return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+}
+
+// Apply populates the flag given the flag set and environment
+func (f IntFlag) Apply(set *flag.FlagSet) {
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ envValInt, err := strconv.ParseInt(envVal, 0, 64)
+ if err == nil {
+ f.Value = int(envValInt)
+ break
+ }
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ set.Int(name, f.Value, f.Usage)
+ })
+}
+
+func (f IntFlag) getName() string {
+ return f.Name
+}
+
+// DurationFlag is a flag that takes a duration specified in Go's duration
+// format: https://golang.org/pkg/time/#ParseDuration
+type DurationFlag struct {
+ Name string
+ Value time.Duration
+ Usage string
+ EnvVar string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f DurationFlag) String() string {
+ return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+}
+
+// Apply populates the flag given the flag set and environment
+func (f DurationFlag) Apply(set *flag.FlagSet) {
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ envValDuration, err := time.ParseDuration(envVal)
+ if err == nil {
+ f.Value = envValDuration
+ break
+ }
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ set.Duration(name, f.Value, f.Usage)
+ })
+}
+
+func (f DurationFlag) getName() string {
+ return f.Name
+}
+
+// Float64Flag is a flag that takes an float value
+// Errors if the value provided cannot be parsed
+type Float64Flag struct {
+ Name string
+ Value float64
+ Usage string
+ EnvVar string
+}
+
+// String returns the usage
+func (f Float64Flag) String() string {
+ return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
+}
+
+// Apply populates the flag given the flag set and environment
+func (f Float64Flag) Apply(set *flag.FlagSet) {
+ if f.EnvVar != "" {
+ for _, envVar := range strings.Split(f.EnvVar, ",") {
+ envVar = strings.TrimSpace(envVar)
+ if envVal := os.Getenv(envVar); envVal != "" {
+ envValFloat, err := strconv.ParseFloat(envVal, 10)
+ if err == nil {
+ f.Value = float64(envValFloat)
+ }
+ }
+ }
+ }
+
+ eachName(f.Name, func(name string) {
+ set.Float64(name, f.Value, f.Usage)
+ })
+}
+
+func (f Float64Flag) getName() string {
+ return f.Name
+}
+
+func prefixFor(name string) (prefix string) {
+ if len(name) == 1 {
+ prefix = "-"
+ } else {
+ prefix = "--"
+ }
+
+ return
+}
+
+func prefixedNames(fullName string) (prefixed string) {
+ parts := strings.Split(fullName, ",")
+ for i, name := range parts {
+ name = strings.Trim(name, " ")
+ prefixed += prefixFor(name) + name
+ if i < len(parts)-1 {
+ prefixed += ", "
+ }
+ }
+ return
+}
+
+func withEnvHint(envVar, str string) string {
+ envText := ""
+ if envVar != "" {
+ envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
+ }
+ return str + envText
+}
diff --git a/vendor/github.com/codegangsta/cli/flag_test.go b/vendor/github.com/codegangsta/cli/flag_test.go
new file mode 100644
index 0000000..3606102
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/flag_test.go
@@ -0,0 +1,740 @@
+package cli
+
+import (
+ "fmt"
+ "os"
+ "reflect"
+ "strings"
+ "testing"
+)
+
+var boolFlagTests = []struct {
+ name string
+ expected string
+}{
+ {"help", "--help\t"},
+ {"h", "-h\t"},
+}
+
+func TestBoolFlagHelpOutput(t *testing.T) {
+
+ for _, test := range boolFlagTests {
+ flag := BoolFlag{Name: test.name}
+ output := flag.String()
+
+ if output != test.expected {
+ t.Errorf("%s does not match %s", output, test.expected)
+ }
+ }
+}
+
+var stringFlagTests = []struct {
+ name string
+ value string
+ expected string
+}{
+ {"help", "", "--help \t"},
+ {"h", "", "-h \t"},
+ {"h", "", "-h \t"},
+ {"test", "Something", "--test \"Something\"\t"},
+}
+
+func TestStringFlagHelpOutput(t *testing.T) {
+
+ for _, test := range stringFlagTests {
+ flag := StringFlag{Name: test.name, Value: test.value}
+ output := flag.String()
+
+ if output != test.expected {
+ t.Errorf("%s does not match %s", output, test.expected)
+ }
+ }
+}
+
+func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_FOO", "derp")
+ for _, test := range stringFlagTests {
+ flag := StringFlag{Name: test.name, Value: test.value, EnvVar: "APP_FOO"}
+ output := flag.String()
+
+ if !strings.HasSuffix(output, " [$APP_FOO]") {
+ t.Errorf("%s does not end with [$APP_FOO]", output)
+ }
+ }
+}
+
+var stringSliceFlagTests = []struct {
+ name string
+ value *StringSlice
+ expected string
+}{
+ {"help", func() *StringSlice {
+ s := &StringSlice{}
+ s.Set("")
+ return s
+ }(), "--help [--help option --help option]\t"},
+ {"h", func() *StringSlice {
+ s := &StringSlice{}
+ s.Set("")
+ return s
+ }(), "-h [-h option -h option]\t"},
+ {"h", func() *StringSlice {
+ s := &StringSlice{}
+ s.Set("")
+ return s
+ }(), "-h [-h option -h option]\t"},
+ {"test", func() *StringSlice {
+ s := &StringSlice{}
+ s.Set("Something")
+ return s
+ }(), "--test [--test option --test option]\t"},
+}
+
+func TestStringSliceFlagHelpOutput(t *testing.T) {
+
+ for _, test := range stringSliceFlagTests {
+ flag := StringSliceFlag{Name: test.name, Value: test.value}
+ output := flag.String()
+
+ if output != test.expected {
+ t.Errorf("%q does not match %q", output, test.expected)
+ }
+ }
+}
+
+func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_QWWX", "11,4")
+ for _, test := range stringSliceFlagTests {
+ flag := StringSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_QWWX"}
+ output := flag.String()
+
+ if !strings.HasSuffix(output, " [$APP_QWWX]") {
+ t.Errorf("%q does not end with [$APP_QWWX]", output)
+ }
+ }
+}
+
+var intFlagTests = []struct {
+ name string
+ expected string
+}{
+ {"help", "--help \"0\"\t"},
+ {"h", "-h \"0\"\t"},
+}
+
+func TestIntFlagHelpOutput(t *testing.T) {
+
+ for _, test := range intFlagTests {
+ flag := IntFlag{Name: test.name}
+ output := flag.String()
+
+ if output != test.expected {
+ t.Errorf("%s does not match %s", output, test.expected)
+ }
+ }
+}
+
+func TestIntFlagWithEnvVarHelpOutput(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_BAR", "2")
+ for _, test := range intFlagTests {
+ flag := IntFlag{Name: test.name, EnvVar: "APP_BAR"}
+ output := flag.String()
+
+ if !strings.HasSuffix(output, " [$APP_BAR]") {
+ t.Errorf("%s does not end with [$APP_BAR]", output)
+ }
+ }
+}
+
+var durationFlagTests = []struct {
+ name string
+ expected string
+}{
+ {"help", "--help \"0\"\t"},
+ {"h", "-h \"0\"\t"},
+}
+
+func TestDurationFlagHelpOutput(t *testing.T) {
+
+ for _, test := range durationFlagTests {
+ flag := DurationFlag{Name: test.name}
+ output := flag.String()
+
+ if output != test.expected {
+ t.Errorf("%s does not match %s", output, test.expected)
+ }
+ }
+}
+
+func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_BAR", "2h3m6s")
+ for _, test := range durationFlagTests {
+ flag := DurationFlag{Name: test.name, EnvVar: "APP_BAR"}
+ output := flag.String()
+
+ if !strings.HasSuffix(output, " [$APP_BAR]") {
+ t.Errorf("%s does not end with [$APP_BAR]", output)
+ }
+ }
+}
+
+var intSliceFlagTests = []struct {
+ name string
+ value *IntSlice
+ expected string
+}{
+ {"help", &IntSlice{}, "--help [--help option --help option]\t"},
+ {"h", &IntSlice{}, "-h [-h option -h option]\t"},
+ {"h", &IntSlice{}, "-h [-h option -h option]\t"},
+ {"test", func() *IntSlice {
+ i := &IntSlice{}
+ i.Set("9")
+ return i
+ }(), "--test [--test option --test option]\t"},
+}
+
+func TestIntSliceFlagHelpOutput(t *testing.T) {
+
+ for _, test := range intSliceFlagTests {
+ flag := IntSliceFlag{Name: test.name, Value: test.value}
+ output := flag.String()
+
+ if output != test.expected {
+ t.Errorf("%q does not match %q", output, test.expected)
+ }
+ }
+}
+
+func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_SMURF", "42,3")
+ for _, test := range intSliceFlagTests {
+ flag := IntSliceFlag{Name: test.name, Value: test.value, EnvVar: "APP_SMURF"}
+ output := flag.String()
+
+ if !strings.HasSuffix(output, " [$APP_SMURF]") {
+ t.Errorf("%q does not end with [$APP_SMURF]", output)
+ }
+ }
+}
+
+var float64FlagTests = []struct {
+ name string
+ expected string
+}{
+ {"help", "--help \"0\"\t"},
+ {"h", "-h \"0\"\t"},
+}
+
+func TestFloat64FlagHelpOutput(t *testing.T) {
+
+ for _, test := range float64FlagTests {
+ flag := Float64Flag{Name: test.name}
+ output := flag.String()
+
+ if output != test.expected {
+ t.Errorf("%s does not match %s", output, test.expected)
+ }
+ }
+}
+
+func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_BAZ", "99.4")
+ for _, test := range float64FlagTests {
+ flag := Float64Flag{Name: test.name, EnvVar: "APP_BAZ"}
+ output := flag.String()
+
+ if !strings.HasSuffix(output, " [$APP_BAZ]") {
+ t.Errorf("%s does not end with [$APP_BAZ]", output)
+ }
+ }
+}
+
+var genericFlagTests = []struct {
+ name string
+ value Generic
+ expected string
+}{
+ {"test", &Parser{"abc", "def"}, "--test \"abc,def\"\ttest flag"},
+ {"t", &Parser{"abc", "def"}, "-t \"abc,def\"\ttest flag"},
+}
+
+func TestGenericFlagHelpOutput(t *testing.T) {
+
+ for _, test := range genericFlagTests {
+ flag := GenericFlag{Name: test.name, Value: test.value, Usage: "test flag"}
+ output := flag.String()
+
+ if output != test.expected {
+ t.Errorf("%q does not match %q", output, test.expected)
+ }
+ }
+}
+
+func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_ZAP", "3")
+ for _, test := range genericFlagTests {
+ flag := GenericFlag{Name: test.name, EnvVar: "APP_ZAP"}
+ output := flag.String()
+
+ if !strings.HasSuffix(output, " [$APP_ZAP]") {
+ t.Errorf("%s does not end with [$APP_ZAP]", output)
+ }
+ }
+}
+
+func TestParseMultiString(t *testing.T) {
+ (&App{
+ Flags: []Flag{
+ StringFlag{Name: "serve, s"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.String("serve") != "10" {
+ t.Errorf("main name not set")
+ }
+ if ctx.String("s") != "10" {
+ t.Errorf("short name not set")
+ }
+ },
+ }).Run([]string{"run", "-s", "10"})
+}
+
+func TestParseMultiStringFromEnv(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_COUNT", "20")
+ (&App{
+ Flags: []Flag{
+ StringFlag{Name: "count, c", EnvVar: "APP_COUNT"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.String("count") != "20" {
+ t.Errorf("main name not set")
+ }
+ if ctx.String("c") != "20" {
+ t.Errorf("short name not set")
+ }
+ },
+ }).Run([]string{"run"})
+}
+
+func TestParseMultiStringFromEnvCascade(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_COUNT", "20")
+ (&App{
+ Flags: []Flag{
+ StringFlag{Name: "count, c", EnvVar: "COMPAT_COUNT,APP_COUNT"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.String("count") != "20" {
+ t.Errorf("main name not set")
+ }
+ if ctx.String("c") != "20" {
+ t.Errorf("short name not set")
+ }
+ },
+ }).Run([]string{"run"})
+}
+
+func TestParseMultiStringSlice(t *testing.T) {
+ (&App{
+ Flags: []Flag{
+ StringSliceFlag{Name: "serve, s", Value: &StringSlice{}},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.StringSlice("serve"), []string{"10", "20"}) {
+ t.Errorf("main name not set")
+ }
+ if !reflect.DeepEqual(ctx.StringSlice("s"), []string{"10", "20"}) {
+ t.Errorf("short name not set")
+ }
+ },
+ }).Run([]string{"run", "-s", "10", "-s", "20"})
+}
+
+func TestParseMultiStringSliceFromEnv(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_INTERVALS", "20,30,40")
+
+ (&App{
+ Flags: []Flag{
+ StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "APP_INTERVALS"},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
+ t.Errorf("main name not set from env")
+ }
+ if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }).Run([]string{"run"})
+}
+
+func TestParseMultiStringSliceFromEnvCascade(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_INTERVALS", "20,30,40")
+
+ (&App{
+ Flags: []Flag{
+ StringSliceFlag{Name: "intervals, i", Value: &StringSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.StringSlice("intervals"), []string{"20", "30", "40"}) {
+ t.Errorf("main name not set from env")
+ }
+ if !reflect.DeepEqual(ctx.StringSlice("i"), []string{"20", "30", "40"}) {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }).Run([]string{"run"})
+}
+
+func TestParseMultiInt(t *testing.T) {
+ a := App{
+ Flags: []Flag{
+ IntFlag{Name: "serve, s"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Int("serve") != 10 {
+ t.Errorf("main name not set")
+ }
+ if ctx.Int("s") != 10 {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run", "-s", "10"})
+}
+
+func TestParseMultiIntFromEnv(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_TIMEOUT_SECONDS", "10")
+ a := App{
+ Flags: []Flag{
+ IntFlag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Int("timeout") != 10 {
+ t.Errorf("main name not set")
+ }
+ if ctx.Int("t") != 10 {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+func TestParseMultiIntFromEnvCascade(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_TIMEOUT_SECONDS", "10")
+ a := App{
+ Flags: []Flag{
+ IntFlag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Int("timeout") != 10 {
+ t.Errorf("main name not set")
+ }
+ if ctx.Int("t") != 10 {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+func TestParseMultiIntSlice(t *testing.T) {
+ (&App{
+ Flags: []Flag{
+ IntSliceFlag{Name: "serve, s", Value: &IntSlice{}},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.IntSlice("serve"), []int{10, 20}) {
+ t.Errorf("main name not set")
+ }
+ if !reflect.DeepEqual(ctx.IntSlice("s"), []int{10, 20}) {
+ t.Errorf("short name not set")
+ }
+ },
+ }).Run([]string{"run", "-s", "10", "-s", "20"})
+}
+
+func TestParseMultiIntSliceFromEnv(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_INTERVALS", "20,30,40")
+
+ (&App{
+ Flags: []Flag{
+ IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "APP_INTERVALS"},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
+ t.Errorf("main name not set from env")
+ }
+ if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }).Run([]string{"run"})
+}
+
+func TestParseMultiIntSliceFromEnvCascade(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_INTERVALS", "20,30,40")
+
+ (&App{
+ Flags: []Flag{
+ IntSliceFlag{Name: "intervals, i", Value: &IntSlice{}, EnvVar: "COMPAT_INTERVALS,APP_INTERVALS"},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.IntSlice("intervals"), []int{20, 30, 40}) {
+ t.Errorf("main name not set from env")
+ }
+ if !reflect.DeepEqual(ctx.IntSlice("i"), []int{20, 30, 40}) {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }).Run([]string{"run"})
+}
+
+func TestParseMultiFloat64(t *testing.T) {
+ a := App{
+ Flags: []Flag{
+ Float64Flag{Name: "serve, s"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Float64("serve") != 10.2 {
+ t.Errorf("main name not set")
+ }
+ if ctx.Float64("s") != 10.2 {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run", "-s", "10.2"})
+}
+
+func TestParseMultiFloat64FromEnv(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
+ a := App{
+ Flags: []Flag{
+ Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Float64("timeout") != 15.5 {
+ t.Errorf("main name not set")
+ }
+ if ctx.Float64("t") != 15.5 {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+func TestParseMultiFloat64FromEnvCascade(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_TIMEOUT_SECONDS", "15.5")
+ a := App{
+ Flags: []Flag{
+ Float64Flag{Name: "timeout, t", EnvVar: "COMPAT_TIMEOUT_SECONDS,APP_TIMEOUT_SECONDS"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Float64("timeout") != 15.5 {
+ t.Errorf("main name not set")
+ }
+ if ctx.Float64("t") != 15.5 {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+func TestParseMultiBool(t *testing.T) {
+ a := App{
+ Flags: []Flag{
+ BoolFlag{Name: "serve, s"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Bool("serve") != true {
+ t.Errorf("main name not set")
+ }
+ if ctx.Bool("s") != true {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run", "--serve"})
+}
+
+func TestParseMultiBoolFromEnv(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_DEBUG", "1")
+ a := App{
+ Flags: []Flag{
+ BoolFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Bool("debug") != true {
+ t.Errorf("main name not set from env")
+ }
+ if ctx.Bool("d") != true {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+func TestParseMultiBoolFromEnvCascade(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_DEBUG", "1")
+ a := App{
+ Flags: []Flag{
+ BoolFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.Bool("debug") != true {
+ t.Errorf("main name not set from env")
+ }
+ if ctx.Bool("d") != true {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+func TestParseMultiBoolT(t *testing.T) {
+ a := App{
+ Flags: []Flag{
+ BoolTFlag{Name: "serve, s"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.BoolT("serve") != true {
+ t.Errorf("main name not set")
+ }
+ if ctx.BoolT("s") != true {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run", "--serve"})
+}
+
+func TestParseMultiBoolTFromEnv(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_DEBUG", "0")
+ a := App{
+ Flags: []Flag{
+ BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.BoolT("debug") != false {
+ t.Errorf("main name not set from env")
+ }
+ if ctx.BoolT("d") != false {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+func TestParseMultiBoolTFromEnvCascade(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_DEBUG", "0")
+ a := App{
+ Flags: []Flag{
+ BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"},
+ },
+ Action: func(ctx *Context) {
+ if ctx.BoolT("debug") != false {
+ t.Errorf("main name not set from env")
+ }
+ if ctx.BoolT("d") != false {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+type Parser [2]string
+
+func (p *Parser) Set(value string) error {
+ parts := strings.Split(value, ",")
+ if len(parts) != 2 {
+ return fmt.Errorf("invalid format")
+ }
+
+ (*p)[0] = parts[0]
+ (*p)[1] = parts[1]
+
+ return nil
+}
+
+func (p *Parser) String() string {
+ return fmt.Sprintf("%s,%s", p[0], p[1])
+}
+
+func TestParseGeneric(t *testing.T) {
+ a := App{
+ Flags: []Flag{
+ GenericFlag{Name: "serve, s", Value: &Parser{}},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"10", "20"}) {
+ t.Errorf("main name not set")
+ }
+ if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"10", "20"}) {
+ t.Errorf("short name not set")
+ }
+ },
+ }
+ a.Run([]string{"run", "-s", "10,20"})
+}
+
+func TestParseGenericFromEnv(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_SERVE", "20,30")
+ a := App{
+ Flags: []Flag{
+ GenericFlag{Name: "serve, s", Value: &Parser{}, EnvVar: "APP_SERVE"},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.Generic("serve"), &Parser{"20", "30"}) {
+ t.Errorf("main name not set from env")
+ }
+ if !reflect.DeepEqual(ctx.Generic("s"), &Parser{"20", "30"}) {
+ t.Errorf("short name not set from env")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
+
+func TestParseGenericFromEnvCascade(t *testing.T) {
+ os.Clearenv()
+ os.Setenv("APP_FOO", "99,2000")
+ a := App{
+ Flags: []Flag{
+ GenericFlag{Name: "foos", Value: &Parser{}, EnvVar: "COMPAT_FOO,APP_FOO"},
+ },
+ Action: func(ctx *Context) {
+ if !reflect.DeepEqual(ctx.Generic("foos"), &Parser{"99", "2000"}) {
+ t.Errorf("value not set from env")
+ }
+ },
+ }
+ a.Run([]string{"run"})
+}
diff --git a/vendor/github.com/codegangsta/cli/help.go b/vendor/github.com/codegangsta/cli/help.go
new file mode 100644
index 0000000..66ef2fb
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/help.go
@@ -0,0 +1,238 @@
+package cli
+
+import (
+ "fmt"
+ "io"
+ "strings"
+ "text/tabwriter"
+ "text/template"
+)
+
+// The text template for the Default help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var AppHelpTemplate = `NAME:
+ {{.Name}} - {{.Usage}}
+
+USAGE:
+ {{.Name}} {{if .Flags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} [arguments...]
+ {{if .Version}}
+VERSION:
+ {{.Version}}
+ {{end}}{{if len .Authors}}
+AUTHOR(S):
+ {{range .Authors}}{{ . }}{{end}}
+ {{end}}{{if .Commands}}
+COMMANDS:
+ {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
+ {{end}}{{end}}{{if .Flags}}
+GLOBAL OPTIONS:
+ {{range .Flags}}{{.}}
+ {{end}}{{end}}{{if .Copyright }}
+COPYRIGHT:
+ {{.Copyright}}
+ {{end}}
+`
+
+// The text template for the command help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var CommandHelpTemplate = `NAME:
+ {{.FullName}} - {{.Usage}}
+
+USAGE:
+ command {{.FullName}}{{if .Flags}} [command options]{{end}} [arguments...]{{if .Description}}
+
+DESCRIPTION:
+ {{.Description}}{{end}}{{if .Flags}}
+
+OPTIONS:
+ {{range .Flags}}{{.}}
+ {{end}}{{ end }}
+`
+
+// The text template for the subcommand help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var SubcommandHelpTemplate = `NAME:
+ {{.Name}} - {{.Usage}}
+
+USAGE:
+ {{.Name}} command{{if .Flags}} [command options]{{end}} [arguments...]
+
+COMMANDS:
+ {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
+ {{end}}{{if .Flags}}
+OPTIONS:
+ {{range .Flags}}{{.}}
+ {{end}}{{end}}
+`
+
+var helpCommand = Command{
+ Name: "help",
+ Aliases: []string{"h"},
+ Usage: "Shows a list of commands or help for one command",
+ Action: func(c *Context) {
+ args := c.Args()
+ if args.Present() {
+ ShowCommandHelp(c, args.First())
+ } else {
+ ShowAppHelp(c)
+ }
+ },
+}
+
+var helpSubcommand = Command{
+ Name: "help",
+ Aliases: []string{"h"},
+ Usage: "Shows a list of commands or help for one command",
+ Action: func(c *Context) {
+ args := c.Args()
+ if args.Present() {
+ ShowCommandHelp(c, args.First())
+ } else {
+ ShowSubcommandHelp(c)
+ }
+ },
+}
+
+// Prints help for the App or Command
+type helpPrinter func(w io.Writer, templ string, data interface{})
+
+var HelpPrinter helpPrinter = printHelp
+
+// Prints version for the App
+var VersionPrinter = printVersion
+
+func ShowAppHelp(c *Context) {
+ HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
+}
+
+// Prints the list of subcommands as the default app completion method
+func DefaultAppComplete(c *Context) {
+ for _, command := range c.App.Commands {
+ for _, name := range command.Names() {
+ fmt.Fprintln(c.App.Writer, name)
+ }
+ }
+}
+
+// Prints help for the given command
+func ShowCommandHelp(ctx *Context, command string) {
+ // show the subcommand help for a command with subcommands
+ if command == "" {
+ HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
+ return
+ }
+
+ for _, c := range ctx.App.Commands {
+ if c.HasName(command) {
+ HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c)
+ return
+ }
+ }
+
+ if ctx.App.CommandNotFound != nil {
+ ctx.App.CommandNotFound(ctx, command)
+ } else {
+ fmt.Fprintf(ctx.App.Writer, "No help topic for '%v'\n", command)
+ }
+}
+
+// Prints help for the given subcommand
+func ShowSubcommandHelp(c *Context) {
+ ShowCommandHelp(c, c.Command.Name)
+}
+
+// Prints the version number of the App
+func ShowVersion(c *Context) {
+ VersionPrinter(c)
+}
+
+func printVersion(c *Context) {
+ fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
+}
+
+// Prints the lists of commands within a given context
+func ShowCompletions(c *Context) {
+ a := c.App
+ if a != nil && a.BashComplete != nil {
+ a.BashComplete(c)
+ }
+}
+
+// Prints the custom completions for a given command
+func ShowCommandCompletions(ctx *Context, command string) {
+ c := ctx.App.Command(command)
+ if c != nil && c.BashComplete != nil {
+ c.BashComplete(ctx)
+ }
+}
+
+func printHelp(out io.Writer, templ string, data interface{}) {
+ funcMap := template.FuncMap{
+ "join": strings.Join,
+ }
+
+ w := tabwriter.NewWriter(out, 0, 8, 1, '\t', 0)
+ t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
+ err := t.Execute(w, data)
+ if err != nil {
+ panic(err)
+ }
+ w.Flush()
+}
+
+func checkVersion(c *Context) bool {
+ if c.GlobalBool("version") || c.GlobalBool("v") || c.Bool("version") || c.Bool("v") {
+ ShowVersion(c)
+ return true
+ }
+
+ return false
+}
+
+func checkHelp(c *Context) bool {
+ if c.GlobalBool("h") || c.GlobalBool("help") || c.Bool("h") || c.Bool("help") {
+ ShowAppHelp(c)
+ return true
+ }
+
+ return false
+}
+
+func checkCommandHelp(c *Context, name string) bool {
+ if c.Bool("h") || c.Bool("help") {
+ ShowCommandHelp(c, name)
+ return true
+ }
+
+ return false
+}
+
+func checkSubcommandHelp(c *Context) bool {
+ if c.GlobalBool("h") || c.GlobalBool("help") {
+ ShowSubcommandHelp(c)
+ return true
+ }
+
+ return false
+}
+
+func checkCompletions(c *Context) bool {
+ if (c.GlobalBool(BashCompletionFlag.Name) || c.Bool(BashCompletionFlag.Name)) && c.App.EnableBashCompletion {
+ ShowCompletions(c)
+ return true
+ }
+
+ return false
+}
+
+func checkCommandCompletions(c *Context, name string) bool {
+ if c.Bool(BashCompletionFlag.Name) && c.App.EnableBashCompletion {
+ ShowCommandCompletions(c, name)
+ return true
+ }
+
+ return false
+}
diff --git a/vendor/github.com/codegangsta/cli/help_test.go b/vendor/github.com/codegangsta/cli/help_test.go
new file mode 100644
index 0000000..42d0284
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/help_test.go
@@ -0,0 +1,36 @@
+package cli
+
+import (
+ "bytes"
+ "testing"
+)
+
+func Test_ShowAppHelp_NoAuthor(t *testing.T) {
+ output := new(bytes.Buffer)
+ app := NewApp()
+ app.Writer = output
+
+ c := NewContext(app, nil, nil)
+
+ ShowAppHelp(c)
+
+ if bytes.Index(output.Bytes(), []byte("AUTHOR(S):")) != -1 {
+ t.Errorf("expected\n%snot to include %s", output.String(), "AUTHOR(S):")
+ }
+}
+
+func Test_ShowAppHelp_NoVersion(t *testing.T) {
+ output := new(bytes.Buffer)
+ app := NewApp()
+ app.Writer = output
+
+ app.Version = ""
+
+ c := NewContext(app, nil, nil)
+
+ ShowAppHelp(c)
+
+ if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 {
+ t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:")
+ }
+}
diff --git a/vendor/github.com/codegangsta/cli/helpers_test.go b/vendor/github.com/codegangsta/cli/helpers_test.go
new file mode 100644
index 0000000..3ce8e93
--- /dev/null
+++ b/vendor/github.com/codegangsta/cli/helpers_test.go
@@ -0,0 +1,19 @@
+package cli
+
+import (
+ "reflect"
+ "testing"
+)
+
+/* Test Helpers */
+func expect(t *testing.T, a interface{}, b interface{}) {
+ if a != b {
+ t.Errorf("Expected %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
+ }
+}
+
+func refute(t *testing.T, a interface{}, b interface{}) {
+ if a == b {
+ t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
+ }
+}
diff --git a/vendor/github.com/jtolds/gls/LICENSE b/vendor/github.com/jtolds/gls/LICENSE
new file mode 100644
index 0000000..9b4a822
--- /dev/null
+++ b/vendor/github.com/jtolds/gls/LICENSE
@@ -0,0 +1,18 @@
+Copyright (c) 2013, Space Monkey, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/jtolds/gls/README.md b/vendor/github.com/jtolds/gls/README.md
new file mode 100644
index 0000000..4ebb692
--- /dev/null
+++ b/vendor/github.com/jtolds/gls/README.md
@@ -0,0 +1,89 @@
+gls
+===
+
+Goroutine local storage
+
+### IMPORTANT NOTE ###
+
+It is my duty to point you to https://blog.golang.org/context, which is how
+Google solves all of the problems you'd perhaps consider using this package
+for at scale.
+
+One downside to Google's approach is that *all* of your functions must have
+a new first argument, but after clearing that hurdle everything else is much
+better.
+
+If you aren't interested in this warning, read on.
+
+### Huhwaht? Why? ###
+
+Every so often, a thread shows up on the
+[golang-nuts](https://groups.google.com/d/forum/golang-nuts) asking for some
+form of goroutine-local-storage, or some kind of goroutine id, or some kind of
+context. There are a few valid use cases for goroutine-local-storage, one of
+the most prominent being log line context. One poster was interested in being
+able to log an HTTP request context id in every log line in the same goroutine
+as the incoming HTTP request, without having to change every library and
+function call he was interested in logging.
+
+This would be pretty useful. Provided that you could get some kind of
+goroutine-local-storage, you could call
+[log.SetOutput](http://golang.org/pkg/log/#SetOutput) with your own logging
+writer that checks goroutine-local-storage for some context information and
+adds that context to your log lines.
+
+But alas, Andrew Gerrand's typically diplomatic answer to the question of
+goroutine-local variables was:
+
+> We wouldn't even be having this discussion if thread local storage wasn't
+> useful. But every feature comes at a cost, and in my opinion the cost of
+> threadlocals far outweighs their benefits. They're just not a good fit for
+> Go.
+
+So, yeah, that makes sense. That's a pretty good reason for why the language
+won't support a specific and (relatively) unuseful feature that requires some
+runtime changes, just for the sake of a little bit of log improvement.
+
+But does Go require runtime changes?
+
+### How it works ###
+
+Go has pretty fantastic introspective and reflective features, but one thing Go
+doesn't give you is any kind of access to the stack pointer, or frame pointer,
+or goroutine id, or anything contextual about your current stack. It gives you
+access to your list of callers, but only along with program counters, which are
+fixed at compile time.
+
+But it does give you the stack.
+
+So, we define 16 special functions and embed base-16 tags into the stack using
+the call order of those 16 functions. Then, we can read our tags back out of
+the stack looking at the callers list.
+
+We then use these tags as an index into a traditional map for implementing
+this library.
+
+### What are people saying? ###
+
+"Wow, that's horrifying."
+
+"This is the most terrible thing I have seen in a very long time."
+
+"Where is it getting a context from? Is this serializing all the requests?
+What the heck is the client being bound to? What are these tags? Why does he
+need callers? Oh god no. No no no."
+
+### Docs ###
+
+Please see the docs at http://godoc.org/github.com/jtolds/gls
+
+### Related ###
+
+If you're okay relying on the string format of the current runtime stacktrace
+including a unique goroutine id (not guaranteed by the spec or anything, but
+very unlikely to change within a Go release), you might be able to squeeze
+out a bit more performance by using this similar library, inspired by some
+code Brad Fitzpatrick wrote for debugging his HTTP/2 library:
+https://github.com/tylerb/gls (in contrast, jtolds/gls doesn't require
+any knowledge of the string format of the runtime stacktrace, which
+probably adds unnecessary overhead).
diff --git a/vendor/github.com/jtolds/gls/context.go b/vendor/github.com/jtolds/gls/context.go
new file mode 100644
index 0000000..94d7fbb
--- /dev/null
+++ b/vendor/github.com/jtolds/gls/context.go
@@ -0,0 +1,150 @@
+// Package gls implements goroutine-local storage.
+package gls
+
+import (
+ "runtime"
+ "sync"
+)
+
+const (
+ maxCallers = 64
+)
+
+var (
+ stackTagPool = &idPool{}
+ mgrRegistry = make(map[*ContextManager]bool)
+ mgrRegistryMtx sync.RWMutex
+)
+
+// Values is simply a map of key types to value types. Used by SetValues to
+// set multiple values at once.
+type Values map[interface{}]interface{}
+
+func currentStack(skip int) []uintptr {
+ stack := make([]uintptr, maxCallers)
+ return stack[:runtime.Callers(2+skip, stack)]
+}
+
+// ContextManager is the main entrypoint for interacting with
+// Goroutine-local-storage. You can have multiple independent ContextManagers
+// at any given time. ContextManagers are usually declared globally for a given
+// class of context variables. You should use NewContextManager for
+// construction.
+type ContextManager struct {
+ mtx sync.RWMutex
+ values map[uint]Values
+}
+
+// NewContextManager returns a brand new ContextManager. It also registers the
+// new ContextManager in the ContextManager registry which is used by the Go
+// method. ContextManagers are typically defined globally at package scope.
+func NewContextManager() *ContextManager {
+ mgr := &ContextManager{values: make(map[uint]Values)}
+ mgrRegistryMtx.Lock()
+ defer mgrRegistryMtx.Unlock()
+ mgrRegistry[mgr] = true
+ return mgr
+}
+
+// Unregister removes a ContextManager from the global registry, used by the
+// Go method. Only intended for use when you're completely done with a
+// ContextManager. Use of Unregister at all is rare.
+func (m *ContextManager) Unregister() {
+ mgrRegistryMtx.Lock()
+ defer mgrRegistryMtx.Unlock()
+ delete(mgrRegistry, m)
+}
+
+// SetValues takes a collection of values and a function to call for those
+// values to be set in. Anything further down the stack will have the set
+// values available through GetValue. SetValues will add new values or replace
+// existing values of the same key and will not mutate or change values for
+// previous stack frames.
+// SetValues is slow (makes a copy of all current and new values for the new
+// gls-context) in order to reduce the amount of lookups GetValue requires.
+func (m *ContextManager) SetValues(new_values Values, context_call func()) {
+ if len(new_values) == 0 {
+ context_call()
+ return
+ }
+
+ tags := readStackTags(currentStack(1))
+
+ m.mtx.Lock()
+ values := new_values
+ for _, tag := range tags {
+ if existing_values, ok := m.values[tag]; ok {
+ // oh, we found existing values, let's make a copy
+ values = make(Values, len(existing_values)+len(new_values))
+ for key, val := range existing_values {
+ values[key] = val
+ }
+ for key, val := range new_values {
+ values[key] = val
+ }
+ break
+ }
+ }
+ new_tag := stackTagPool.Acquire()
+ m.values[new_tag] = values
+ m.mtx.Unlock()
+ defer func() {
+ m.mtx.Lock()
+ delete(m.values, new_tag)
+ m.mtx.Unlock()
+ stackTagPool.Release(new_tag)
+ }()
+
+ addStackTag(new_tag, context_call)
+}
+
+// GetValue will return a previously set value, provided that the value was set
+// by SetValues somewhere higher up the stack. If the value is not found, ok
+// will be false.
+func (m *ContextManager) GetValue(key interface{}) (value interface{}, ok bool) {
+
+ tags := readStackTags(currentStack(1))
+ m.mtx.RLock()
+ defer m.mtx.RUnlock()
+ for _, tag := range tags {
+ if values, ok := m.values[tag]; ok {
+ value, ok := values[key]
+ return value, ok
+ }
+ }
+ return "", false
+}
+
+func (m *ContextManager) getValues() Values {
+ tags := readStackTags(currentStack(2))
+ m.mtx.RLock()
+ defer m.mtx.RUnlock()
+ for _, tag := range tags {
+ if values, ok := m.values[tag]; ok {
+ return values
+ }
+ }
+ return nil
+}
+
+// Go preserves ContextManager values and Goroutine-local-storage across new
+// goroutine invocations. The Go method makes a copy of all existing values on
+// all registered context managers and makes sure they are still set after
+// kicking off the provided function in a new goroutine. If you don't use this
+// Go method instead of the standard 'go' keyword, you will lose values in
+// ContextManagers, as goroutines have brand new stacks.
+func Go(cb func()) {
+ mgrRegistryMtx.RLock()
+ defer mgrRegistryMtx.RUnlock()
+
+ for mgr, _ := range mgrRegistry {
+ values := mgr.getValues()
+ if len(values) > 0 {
+ mgr_copy := mgr
+ cb_copy := cb
+ cb = func() { mgr_copy.SetValues(values, cb_copy) }
+ }
+ }
+
+ go cb()
+}
diff --git a/vendor/github.com/jtolds/gls/context_test.go b/vendor/github.com/jtolds/gls/context_test.go
new file mode 100644
index 0000000..ae5bde4
--- /dev/null
+++ b/vendor/github.com/jtolds/gls/context_test.go
@@ -0,0 +1,139 @@
+package gls
+
+import (
+ "fmt"
+ "sync"
+ "testing"
+)
+
+func TestContexts(t *testing.T) {
+ mgr1 := NewContextManager()
+ mgr2 := NewContextManager()
+
+ CheckVal := func(mgr *ContextManager, key, exp_val string) {
+ val, ok := mgr.GetValue(key)
+ if len(exp_val) == 0 {
+ if ok {
+ t.Fatalf("expected no value for key %s, got %s", key, val)
+ }
+ return
+ }
+ if !ok {
+ t.Fatalf("expected value %s for key %s, got no value",
+ exp_val, key)
+ }
+ if exp_val != val {
+ t.Fatalf("expected value %s for key %s, got %s", exp_val, key,
+ val)
+ }
+
+ }
+
+ Check := func(exp_m1v1, exp_m1v2, exp_m2v1, exp_m2v2 string) {
+ CheckVal(mgr1, "key1", exp_m1v1)
+ CheckVal(mgr1, "key2", exp_m1v2)
+ CheckVal(mgr2, "key1", exp_m2v1)
+ CheckVal(mgr2, "key2", exp_m2v2)
+ }
+
+ Check("", "", "", "")
+ mgr2.SetValues(Values{"key1": "val1c"}, func() {
+ Check("", "", "val1c", "")
+ mgr1.SetValues(Values{"key1": "val1a"}, func() {
+ Check("val1a", "", "val1c", "")
+ mgr1.SetValues(Values{"key2": "val1b"}, func() {
+ Check("val1a", "val1b", "val1c", "")
+ var wg sync.WaitGroup
+ wg.Add(2)
+ go func() {
+ defer wg.Done()
+ Check("", "", "", "")
+ }()
+ Go(func() {
+ defer wg.Done()
+ Check("val1a", "val1b", "val1c", "")
+ })
+ wg.Wait()
+ })
+ })
+ })
+}
+
+func ExampleContextManager_SetValues() {
+ var (
+ mgr = NewContextManager()
+ request_id_key = GenSym()
+ )
+
+ MyLog := func() {
+ if request_id, ok := mgr.GetValue(request_id_key); ok {
+ fmt.Println("My request id is:", request_id)
+ } else {
+ fmt.Println("No request id found")
+ }
+ }
+
+ mgr.SetValues(Values{request_id_key: "12345"}, func() {
+ MyLog()
+ })
+ MyLog()
+
+ // Output: My request id is: 12345
+ // No request id found
+}
+
+func ExampleGo() {
+ var (
+ mgr = NewContextManager()
+ request_id_key = GenSym()
+ )
+
+ MyLog := func() {
+ if request_id, ok := mgr.GetValue(request_id_key); ok {
+ fmt.Println("My request id is:", request_id)
+ } else {
+ fmt.Println("No request id found")
+ }
+ }
+
+ mgr.SetValues(Values{request_id_key: "12345"}, func() {
+ var wg sync.WaitGroup
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+ MyLog()
+ }()
+ wg.Wait()
+ wg.Add(1)
+ Go(func() {
+ defer wg.Done()
+ MyLog()
+ })
+ wg.Wait()
+ })
+
+ // Output: No request id found
+ // My request id is: 12345
+}
+
+func BenchmarkGetValue(b *testing.B) {
+ mgr := NewContextManager()
+ mgr.SetValues(Values{"test_key": "test_val"}, func() {
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ val, ok := mgr.GetValue("test_key")
+ if !ok || val != "test_val" {
+ b.FailNow()
+ }
+ }
+ })
+}
+
+func BenchmarkSetValues(b *testing.B) {
+ mgr := NewContextManager()
+ for i := 0; i < b.N/2; i++ {
+ mgr.SetValues(Values{"test_key": "test_val"}, func() {
+ mgr.SetValues(Values{"test_key2": "test_val2"}, func() {})
+ })
+ }
+}
diff --git a/vendor/github.com/jtolds/gls/gen_sym.go b/vendor/github.com/jtolds/gls/gen_sym.go
new file mode 100644
index 0000000..8d5fc24
--- /dev/null
+++ b/vendor/github.com/jtolds/gls/gen_sym.go
@@ -0,0 +1,13 @@
+package gls
+
+var (
+ symPool = &idPool{}
+)
+
+// ContextKey is a throwaway value you can use as a key to a ContextManager
+type ContextKey struct{ id uint }
+
+// GenSym will return a brand new, never-before-used ContextKey
+func GenSym() ContextKey {
+ return ContextKey{id: symPool.Acquire()}
+}
diff --git a/vendor/github.com/jtolds/gls/id_pool.go b/vendor/github.com/jtolds/gls/id_pool.go
new file mode 100644
index 0000000..b7974ae
--- /dev/null
+++ b/vendor/github.com/jtolds/gls/id_pool.go
@@ -0,0 +1,34 @@
+package gls
+
+// though this could probably be better at keeping ids smaller, the goal of
+// this class is to keep a registry of the smallest unique integer ids
+// per-process possible
+
+import (
+ "sync"
+)
+
+type idPool struct {
+ mtx sync.Mutex
+ released []uint
+ max_id uint
+}
+
+func (p *idPool) Acquire() (id uint) {
+ p.mtx.Lock()
+ defer p.mtx.Unlock()
+ if len(p.released) > 0 {
+ id = p.released[len(p.released)-1]
+ p.released = p.released[:len(p.released)-1]
+ return id
+ }
+ id = p.max_id
+ p.max_id++
+ return id
+}
+
+func (p *idPool) Release(id uint) {
+ p.mtx.Lock()
+ defer p.mtx.Unlock()
+ p.released = append(p.released, id)
+}
diff --git a/vendor/github.com/jtolds/gls/stack_tags.go b/vendor/github.com/jtolds/gls/stack_tags.go
new file mode 100644
index 0000000..562a2fa
--- /dev/null
+++ b/vendor/github.com/jtolds/gls/stack_tags.go
@@ -0,0 +1,93 @@
+package gls
+
+// so, basically, we're going to encode integer tags in base-16 on the stack
+
+import (
+ "reflect"
+ "runtime"
+)
+
+const (
+ bitWidth = 4
+)
+
+func addStackTag(tag uint, context_call func()) {
+ if context_call == nil {
+ return
+ }
+ markS(tag, context_call)
+}
+
+func markS(tag uint, cb func()) { _m(tag, cb) }
+func mark0(tag uint, cb func()) { _m(tag, cb) }
+func mark1(tag uint, cb func()) { _m(tag, cb) }
+func mark2(tag uint, cb func()) { _m(tag, cb) }
+func mark3(tag uint, cb func()) { _m(tag, cb) }
+func mark4(tag uint, cb func()) { _m(tag, cb) }
+func mark5(tag uint, cb func()) { _m(tag, cb) }
+func mark6(tag uint, cb func()) { _m(tag, cb) }
+func mark7(tag uint, cb func()) { _m(tag, cb) }
+func mark8(tag uint, cb func()) { _m(tag, cb) }
+func mark9(tag uint, cb func()) { _m(tag, cb) }
+func markA(tag uint, cb func()) { _m(tag, cb) }
+func markB(tag uint, cb func()) { _m(tag, cb) }
+func markC(tag uint, cb func()) { _m(tag, cb) }
+func markD(tag uint, cb func()) { _m(tag, cb) }
+func markE(tag uint, cb func()) { _m(tag, cb) }
+func markF(tag uint, cb func()) { _m(tag, cb) }
+
+var pc_lookup = make(map[uintptr]int8, 17)
+var mark_lookup [16]func(uint, func())
+
+func init() {
+ setEntries := func(f func(uint, func()), v int8) {
+ pc_lookup[reflect.ValueOf(f).Pointer()] = v
+ if v >= 0 {
+ mark_lookup[v] = f
+ }
+ }
+ setEntries(markS, -0x1)
+ setEntries(mark0, 0x0)
+ setEntries(mark1, 0x1)
+ setEntries(mark2, 0x2)
+ setEntries(mark3, 0x3)
+ setEntries(mark4, 0x4)
+ setEntries(mark5, 0x5)
+ setEntries(mark6, 0x6)
+ setEntries(mark7, 0x7)
+ setEntries(mark8, 0x8)
+ setEntries(mark9, 0x9)
+ setEntries(markA, 0xa)
+ setEntries(markB, 0xb)
+ setEntries(markC, 0xc)
+ setEntries(markD, 0xd)
+ setEntries(markE, 0xe)
+ setEntries(markF, 0xf)
+}
+
+func _m(tag_remainder uint, cb func()) {
+ if tag_remainder == 0 {
+ cb()
+ } else {
+ mark_lookup[tag_remainder&0xf](tag_remainder>>bitWidth, cb)
+ }
+}
+
+func readStackTags(stack []uintptr) (tags []uint) {
+ var current_tag uint
+ for _, pc := range stack {
+ pc = runtime.FuncForPC(pc).Entry()
+ val, ok := pc_lookup[pc]
+ if !ok {
+ continue
+ }
+ if val < 0 {
+ tags = append(tags, current_tag)
+ current_tag = 0
+ continue
+ }
+ current_tag <<= bitWidth
+ current_tag += uint(val)
+ }
+ return
+}
diff --git a/vendor/github.com/kr/pty/License b/vendor/github.com/kr/pty/License
new file mode 100644
index 0000000..6b7558b
--- /dev/null
+++ b/vendor/github.com/kr/pty/License
@@ -0,0 +1,23 @@
+Copyright (c) 2011 Keith Rarick
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall
+be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/kr/pty/README.md b/vendor/github.com/kr/pty/README.md
new file mode 100644
index 0000000..7b7900c
--- /dev/null
+++ b/vendor/github.com/kr/pty/README.md
@@ -0,0 +1,36 @@
+# pty
+
+Pty is a Go package for using unix pseudo-terminals.
+
+## Install
+
+ go get github.com/kr/pty
+
+## Example
+
+```go
+package main
+
+import (
+ "github.com/kr/pty"
+ "io"
+ "os"
+ "os/exec"
+)
+
+func main() {
+ c := exec.Command("grep", "--color=auto", "bar")
+ f, err := pty.Start(c)
+ if err != nil {
+ panic(err)
+ }
+
+ go func() {
+ f.Write([]byte("foo\n"))
+ f.Write([]byte("bar\n"))
+ f.Write([]byte("baz\n"))
+ f.Write([]byte{4}) // EOT
+ }()
+ io.Copy(os.Stdout, f)
+}
+```
diff --git a/vendor/github.com/kr/pty/doc.go b/vendor/github.com/kr/pty/doc.go
new file mode 100644
index 0000000..190cfbe
--- /dev/null
+++ b/vendor/github.com/kr/pty/doc.go
@@ -0,0 +1,16 @@
+// Package pty provides functions for working with Unix terminals.
+package pty
+
+import (
+ "errors"
+ "os"
+)
+
+// ErrUnsupported is returned if a function is not
+// available on the current platform.
+var ErrUnsupported = errors.New("unsupported")
+
+// Opens a pty and its corresponding tty.
+func Open() (pty, tty *os.File, err error) {
+ return open()
+}
diff --git a/vendor/github.com/kr/pty/ioctl.go b/vendor/github.com/kr/pty/ioctl.go
new file mode 100644
index 0000000..5b856e8
--- /dev/null
+++ b/vendor/github.com/kr/pty/ioctl.go
@@ -0,0 +1,11 @@
+package pty
+
+import "syscall"
+
+func ioctl(fd, cmd, ptr uintptr) error {
+ _, _, e := syscall.Syscall(syscall.SYS_IOCTL, fd, cmd, ptr)
+ if e != 0 {
+ return e
+ }
+ return nil
+}
diff --git a/vendor/github.com/kr/pty/ioctl_bsd.go b/vendor/github.com/kr/pty/ioctl_bsd.go
new file mode 100644
index 0000000..73b12c5
--- /dev/null
+++ b/vendor/github.com/kr/pty/ioctl_bsd.go
@@ -0,0 +1,39 @@
+// +build darwin dragonfly freebsd netbsd openbsd
+
+package pty
+
+// from
+const (
+ _IOC_VOID uintptr = 0x20000000
+ _IOC_OUT uintptr = 0x40000000
+ _IOC_IN uintptr = 0x80000000
+ _IOC_IN_OUT uintptr = _IOC_OUT | _IOC_IN
+ _IOC_DIRMASK = _IOC_VOID | _IOC_OUT | _IOC_IN
+
+ _IOC_PARAM_SHIFT = 13
+ _IOC_PARAM_MASK = (1 << _IOC_PARAM_SHIFT) - 1
+)
+
+func _IOC_PARM_LEN(ioctl uintptr) uintptr {
+ return (ioctl >> 16) & _IOC_PARAM_MASK
+}
+
+func _IOC(inout uintptr, group byte, ioctl_num uintptr, param_len uintptr) uintptr {
+ return inout | (param_len&_IOC_PARAM_MASK)<<16 | uintptr(group)<<8 | ioctl_num
+}
+
+func _IO(group byte, ioctl_num uintptr) uintptr {
+ return _IOC(_IOC_VOID, group, ioctl_num, 0)
+}
+
+func _IOR(group byte, ioctl_num uintptr, param_len uintptr) uintptr {
+ return _IOC(_IOC_OUT, group, ioctl_num, param_len)
+}
+
+func _IOW(group byte, ioctl_num uintptr, param_len uintptr) uintptr {
+ return _IOC(_IOC_IN, group, ioctl_num, param_len)
+}
+
+func _IOWR(group byte, ioctl_num uintptr, param_len uintptr) uintptr {
+ return _IOC(_IOC_IN_OUT, group, ioctl_num, param_len)
+}
diff --git a/vendor/github.com/kr/pty/mktypes.bash b/vendor/github.com/kr/pty/mktypes.bash
new file mode 100755
index 0000000..9952c88
--- /dev/null
+++ b/vendor/github.com/kr/pty/mktypes.bash
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+GOOSARCH="${GOOS}_${GOARCH}"
+case "$GOOSARCH" in
+_* | *_ | _)
+ echo 'undefined $GOOS_$GOARCH:' "$GOOSARCH" 1>&2
+ exit 1
+ ;;
+esac
+
+GODEFS="go tool cgo -godefs"
+
+$GODEFS types.go |gofmt > ztypes_$GOARCH.go
+
+case $GOOS in
+freebsd)
+ $GODEFS types_$GOOS.go |gofmt > ztypes_$GOOSARCH.go
+ ;;
+esac
diff --git a/vendor/github.com/kr/pty/pty_darwin.go b/vendor/github.com/kr/pty/pty_darwin.go
new file mode 100644
index 0000000..4f4d5ca
--- /dev/null
+++ b/vendor/github.com/kr/pty/pty_darwin.go
@@ -0,0 +1,60 @@
+package pty
+
+import (
+ "errors"
+ "os"
+ "syscall"
+ "unsafe"
+)
+
+func open() (pty, tty *os.File, err error) {
+ p, err := os.OpenFile("/dev/ptmx", os.O_RDWR, 0)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ sname, err := ptsname(p)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ err = grantpt(p)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ err = unlockpt(p)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ t, err := os.OpenFile(sname, os.O_RDWR, 0)
+ if err != nil {
+ return nil, nil, err
+ }
+ return p, t, nil
+}
+
+func ptsname(f *os.File) (string, error) {
+ n := make([]byte, _IOC_PARM_LEN(syscall.TIOCPTYGNAME))
+
+ err := ioctl(f.Fd(), syscall.TIOCPTYGNAME, uintptr(unsafe.Pointer(&n[0])))
+ if err != nil {
+ return "", err
+ }
+
+ for i, c := range n {
+ if c == 0 {
+ return string(n[:i]), nil
+ }
+ }
+ return "", errors.New("TIOCPTYGNAME string not NUL-terminated")
+}
+
+func grantpt(f *os.File) error {
+ return ioctl(f.Fd(), syscall.TIOCPTYGRANT, 0)
+}
+
+func unlockpt(f *os.File) error {
+ return ioctl(f.Fd(), syscall.TIOCPTYUNLK, 0)
+}
diff --git a/vendor/github.com/kr/pty/pty_freebsd.go b/vendor/github.com/kr/pty/pty_freebsd.go
new file mode 100644
index 0000000..b341bab
--- /dev/null
+++ b/vendor/github.com/kr/pty/pty_freebsd.go
@@ -0,0 +1,73 @@
+package pty
+
+import (
+ "errors"
+ "os"
+ "syscall"
+ "unsafe"
+)
+
+func posix_openpt(oflag int) (fd int, err error) {
+ r0, _, e1 := syscall.Syscall(syscall.SYS_POSIX_OPENPT, uintptr(oflag), 0, 0)
+ fd = int(r0)
+ if e1 != 0 {
+ err = e1
+ }
+ return
+}
+
+func open() (pty, tty *os.File, err error) {
+ fd, err := posix_openpt(syscall.O_RDWR | syscall.O_CLOEXEC)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ p := os.NewFile(uintptr(fd), "/dev/pts")
+ sname, err := ptsname(p)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ t, err := os.OpenFile("/dev/"+sname, os.O_RDWR, 0)
+ if err != nil {
+ return nil, nil, err
+ }
+ return p, t, nil
+}
+
+func isptmaster(fd uintptr) (bool, error) {
+ err := ioctl(fd, syscall.TIOCPTMASTER, 0)
+ return err == nil, err
+}
+
+var (
+ emptyFiodgnameArg fiodgnameArg
+ ioctl_FIODGNAME = _IOW('f', 120, unsafe.Sizeof(emptyFiodgnameArg))
+)
+
+func ptsname(f *os.File) (string, error) {
+ master, err := isptmaster(f.Fd())
+ if err != nil {
+ return "", err
+ }
+ if !master {
+ return "", syscall.EINVAL
+ }
+
+ const n = _C_SPECNAMELEN + 1
+ var (
+ buf = make([]byte, n)
+ arg = fiodgnameArg{Len: n, Buf: (*byte)(unsafe.Pointer(&buf[0]))}
+ )
+ err = ioctl(f.Fd(), ioctl_FIODGNAME, uintptr(unsafe.Pointer(&arg)))
+ if err != nil {
+ return "", err
+ }
+
+ for i, c := range buf {
+ if c == 0 {
+ return string(buf[:i]), nil
+ }
+ }
+ return "", errors.New("FIODGNAME string not NUL-terminated")
+}
diff --git a/vendor/github.com/kr/pty/pty_linux.go b/vendor/github.com/kr/pty/pty_linux.go
new file mode 100644
index 0000000..cb901a2
--- /dev/null
+++ b/vendor/github.com/kr/pty/pty_linux.go
@@ -0,0 +1,46 @@
+package pty
+
+import (
+ "os"
+ "strconv"
+ "syscall"
+ "unsafe"
+)
+
+func open() (pty, tty *os.File, err error) {
+ p, err := os.OpenFile("/dev/ptmx", os.O_RDWR, 0)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ sname, err := ptsname(p)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ err = unlockpt(p)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ t, err := os.OpenFile(sname, os.O_RDWR|syscall.O_NOCTTY, 0)
+ if err != nil {
+ return nil, nil, err
+ }
+ return p, t, nil
+}
+
+func ptsname(f *os.File) (string, error) {
+ var n _C_uint
+ err := ioctl(f.Fd(), syscall.TIOCGPTN, uintptr(unsafe.Pointer(&n)))
+ if err != nil {
+ return "", err
+ }
+ return "/dev/pts/" + strconv.Itoa(int(n)), nil
+}
+
+func unlockpt(f *os.File) error {
+ var u _C_int
+ // use TIOCSPTLCK with a zero valued arg to clear the slave pty lock
+ return ioctl(f.Fd(), syscall.TIOCSPTLCK, uintptr(unsafe.Pointer(&u)))
+}
diff --git a/vendor/github.com/kr/pty/pty_unsupported.go b/vendor/github.com/kr/pty/pty_unsupported.go
new file mode 100644
index 0000000..898c730
--- /dev/null
+++ b/vendor/github.com/kr/pty/pty_unsupported.go
@@ -0,0 +1,11 @@
+// +build !linux,!darwin,!freebsd
+
+package pty
+
+import (
+ "os"
+)
+
+func open() (pty, tty *os.File, err error) {
+ return nil, nil, ErrUnsupported
+}
diff --git a/vendor/github.com/kr/pty/run.go b/vendor/github.com/kr/pty/run.go
new file mode 100644
index 0000000..f0678d2
--- /dev/null
+++ b/vendor/github.com/kr/pty/run.go
@@ -0,0 +1,28 @@
+package pty
+
+import (
+ "os"
+ "os/exec"
+ "syscall"
+)
+
+// Start assigns a pseudo-terminal tty os.File to c.Stdin, c.Stdout,
+// and c.Stderr, calls c.Start, and returns the File of the tty's
+// corresponding pty.
+func Start(c *exec.Cmd) (pty *os.File, err error) {
+ pty, tty, err := Open()
+ if err != nil {
+ return nil, err
+ }
+ defer tty.Close()
+ c.Stdout = tty
+ c.Stdin = tty
+ c.Stderr = tty
+ c.SysProcAttr = &syscall.SysProcAttr{Setctty: true, Setsid: true}
+ err = c.Start()
+ if err != nil {
+ pty.Close()
+ return nil, err
+ }
+ return pty, err
+}
diff --git a/vendor/github.com/kr/pty/types.go b/vendor/github.com/kr/pty/types.go
new file mode 100644
index 0000000..5aecb6b
--- /dev/null
+++ b/vendor/github.com/kr/pty/types.go
@@ -0,0 +1,10 @@
+// +build ignore
+
+package pty
+
+import "C"
+
+type (
+ _C_int C.int
+ _C_uint C.uint
+)
diff --git a/vendor/github.com/kr/pty/types_freebsd.go b/vendor/github.com/kr/pty/types_freebsd.go
new file mode 100644
index 0000000..ce3eb95
--- /dev/null
+++ b/vendor/github.com/kr/pty/types_freebsd.go
@@ -0,0 +1,15 @@
+// +build ignore
+
+package pty
+
+/*
+#include
+#include
+*/
+import "C"
+
+const (
+ _C_SPECNAMELEN = C.SPECNAMELEN /* max length of devicename */
+)
+
+type fiodgnameArg C.struct_fiodgname_arg
diff --git a/vendor/github.com/kr/pty/util.go b/vendor/github.com/kr/pty/util.go
new file mode 100644
index 0000000..67c52d0
--- /dev/null
+++ b/vendor/github.com/kr/pty/util.go
@@ -0,0 +1,35 @@
+package pty
+
+import (
+ "os"
+ "syscall"
+ "unsafe"
+)
+
+// Getsize returns the number of rows (lines) and cols (positions
+// in each line) in terminal t.
+func Getsize(t *os.File) (rows, cols int, err error) {
+ var ws winsize
+ err = windowrect(&ws, t.Fd())
+ return int(ws.ws_row), int(ws.ws_col), err
+}
+
+type winsize struct {
+ ws_row uint16
+ ws_col uint16
+ ws_xpixel uint16
+ ws_ypixel uint16
+}
+
+func windowrect(ws *winsize, fd uintptr) error {
+ _, _, errno := syscall.Syscall(
+ syscall.SYS_IOCTL,
+ fd,
+ syscall.TIOCGWINSZ,
+ uintptr(unsafe.Pointer(ws)),
+ )
+ if errno != 0 {
+ return syscall.Errno(errno)
+ }
+ return nil
+}
diff --git a/vendor/github.com/kr/pty/ztypes_386.go b/vendor/github.com/kr/pty/ztypes_386.go
new file mode 100644
index 0000000..ff0b8fd
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_386.go
@@ -0,0 +1,9 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types.go
+
+package pty
+
+type (
+ _C_int int32
+ _C_uint uint32
+)
diff --git a/vendor/github.com/kr/pty/ztypes_amd64.go b/vendor/github.com/kr/pty/ztypes_amd64.go
new file mode 100644
index 0000000..ff0b8fd
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_amd64.go
@@ -0,0 +1,9 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types.go
+
+package pty
+
+type (
+ _C_int int32
+ _C_uint uint32
+)
diff --git a/vendor/github.com/kr/pty/ztypes_arm.go b/vendor/github.com/kr/pty/ztypes_arm.go
new file mode 100644
index 0000000..ff0b8fd
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_arm.go
@@ -0,0 +1,9 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types.go
+
+package pty
+
+type (
+ _C_int int32
+ _C_uint uint32
+)
diff --git a/vendor/github.com/kr/pty/ztypes_arm64.go b/vendor/github.com/kr/pty/ztypes_arm64.go
new file mode 100644
index 0000000..6c29a4b
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_arm64.go
@@ -0,0 +1,11 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types.go
+
+// +build arm64
+
+package pty
+
+type (
+ _C_int int32
+ _C_uint uint32
+)
diff --git a/vendor/github.com/kr/pty/ztypes_freebsd_386.go b/vendor/github.com/kr/pty/ztypes_freebsd_386.go
new file mode 100644
index 0000000..d997537
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_freebsd_386.go
@@ -0,0 +1,13 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package pty
+
+const (
+ _C_SPECNAMELEN = 0x3f
+)
+
+type fiodgnameArg struct {
+ Len int32
+ Buf *byte
+}
diff --git a/vendor/github.com/kr/pty/ztypes_freebsd_amd64.go b/vendor/github.com/kr/pty/ztypes_freebsd_amd64.go
new file mode 100644
index 0000000..5fa102f
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_freebsd_amd64.go
@@ -0,0 +1,14 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package pty
+
+const (
+ _C_SPECNAMELEN = 0x3f
+)
+
+type fiodgnameArg struct {
+ Len int32
+ Pad_cgo_0 [4]byte
+ Buf *byte
+}
diff --git a/vendor/github.com/kr/pty/ztypes_freebsd_arm.go b/vendor/github.com/kr/pty/ztypes_freebsd_arm.go
new file mode 100644
index 0000000..d997537
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_freebsd_arm.go
@@ -0,0 +1,13 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package pty
+
+const (
+ _C_SPECNAMELEN = 0x3f
+)
+
+type fiodgnameArg struct {
+ Len int32
+ Buf *byte
+}
diff --git a/vendor/github.com/kr/pty/ztypes_ppc64.go b/vendor/github.com/kr/pty/ztypes_ppc64.go
new file mode 100644
index 0000000..4e1af84
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_ppc64.go
@@ -0,0 +1,11 @@
+// +build ppc64
+
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types.go
+
+package pty
+
+type (
+ _C_int int32
+ _C_uint uint32
+)
diff --git a/vendor/github.com/kr/pty/ztypes_ppc64le.go b/vendor/github.com/kr/pty/ztypes_ppc64le.go
new file mode 100644
index 0000000..e6780f4
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_ppc64le.go
@@ -0,0 +1,11 @@
+// +build ppc64le
+
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types.go
+
+package pty
+
+type (
+ _C_int int32
+ _C_uint uint32
+)
diff --git a/vendor/github.com/kr/pty/ztypes_s390x.go b/vendor/github.com/kr/pty/ztypes_s390x.go
new file mode 100644
index 0000000..a7452b6
--- /dev/null
+++ b/vendor/github.com/kr/pty/ztypes_s390x.go
@@ -0,0 +1,11 @@
+// +build s390x
+
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types.go
+
+package pty
+
+type (
+ _C_int int32
+ _C_uint uint32
+)
diff --git a/vendor/github.com/smartystreets/assertions/LICENSE.md b/vendor/github.com/smartystreets/assertions/LICENSE.md
new file mode 100644
index 0000000..48a3731
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/LICENSE.md
@@ -0,0 +1,23 @@
+Copyright (c) 2015 SmartyStreets, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+NOTE: Various optional and subordinate components carry their own licensing
+requirements and restrictions. Use of those components is subject to the terms
+and conditions outlined the respective license of each component.
diff --git a/vendor/github.com/smartystreets/assertions/README.md b/vendor/github.com/smartystreets/assertions/README.md
new file mode 100644
index 0000000..fdbd632
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/README.md
@@ -0,0 +1,528 @@
+# assertions
+--
+ import "github.com/smartystreets/assertions"
+
+Package assertions contains the implementations for all assertions which are
+referenced in goconvey's `convey` package
+(github.com/smartystreets/goconvey/convey) for use with the So(...) method. They
+can also be used in traditional Go test functions and even in applicaitons.
+
+## Usage
+
+#### func GoConveyMode
+
+```go
+func GoConveyMode(yes bool)
+```
+GoConveyMode provides control over JSON serialization of failures. When using
+the assertions in this package from the convey package JSON results are very
+helpful and can be rendered in a DIFF view. In that case, this function will be
+called with a true value to enable the JSON serialization. By default, the
+assertions in this package will not serializer a JSON result, making standalone
+ussage more convenient.
+
+#### func ShouldAlmostEqual
+
+```go
+func ShouldAlmostEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldAlmostEqual makes sure that two parameters are close enough to being
+equal. The acceptable delta may be specified with a third argument, or a very
+small default delta will be used.
+
+#### func ShouldBeBetween
+
+```go
+func ShouldBeBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldBeBetween receives exactly three parameters: an actual value, a lower
+bound, and an upper bound. It ensures that the actual value is between both
+bounds (but not equal to either of them).
+
+#### func ShouldBeBetweenOrEqual
+
+```go
+func ShouldBeBetweenOrEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldBeBetweenOrEqual receives exactly three parameters: an actual value, a
+lower bound, and an upper bound. It ensures that the actual value is between
+both bounds or equal to one of them.
+
+#### func ShouldBeBlank
+
+```go
+func ShouldBeBlank(actual interface{}, expected ...interface{}) string
+```
+ShouldBeBlank receives exactly 1 string parameter and ensures that it is equal
+to "".
+
+#### func ShouldBeChronological
+
+```go
+func ShouldBeChronological(actual interface{}, expected ...interface{}) string
+```
+ShouldBeChronological receives a []time.Time slice and asserts that the are in
+chronological order starting with the first time.Time as the earliest.
+
+#### func ShouldBeEmpty
+
+```go
+func ShouldBeEmpty(actual interface{}, expected ...interface{}) string
+```
+ShouldBeEmpty receives a single parameter (actual) and determines whether or not
+calling len(actual) would return `0`. It obeys the rules specified by the len
+function for determining length: http://golang.org/pkg/builtin/#len
+
+#### func ShouldBeFalse
+
+```go
+func ShouldBeFalse(actual interface{}, expected ...interface{}) string
+```
+ShouldBeFalse receives a single parameter and ensures that it is false.
+
+#### func ShouldBeGreaterThan
+
+```go
+func ShouldBeGreaterThan(actual interface{}, expected ...interface{}) string
+```
+ShouldBeGreaterThan receives exactly two parameters and ensures that the first
+is greater than the second.
+
+#### func ShouldBeGreaterThanOrEqualTo
+
+```go
+func ShouldBeGreaterThanOrEqualTo(actual interface{}, expected ...interface{}) string
+```
+ShouldBeGreaterThanOrEqualTo receives exactly two parameters and ensures that
+the first is greater than or equal to the second.
+
+#### func ShouldBeIn
+
+```go
+func ShouldBeIn(actual interface{}, expected ...interface{}) string
+```
+ShouldBeIn receives at least 2 parameters. The first is a proposed member of the
+collection that is passed in either as the second parameter, or of the
+collection that is comprised of all the remaining parameters. This assertion
+ensures that the proposed member is in the collection (using ShouldEqual).
+
+#### func ShouldBeLessThan
+
+```go
+func ShouldBeLessThan(actual interface{}, expected ...interface{}) string
+```
+ShouldBeLessThan receives exactly two parameters and ensures that the first is
+less than the second.
+
+#### func ShouldBeLessThanOrEqualTo
+
+```go
+func ShouldBeLessThanOrEqualTo(actual interface{}, expected ...interface{}) string
+```
+ShouldBeLessThan receives exactly two parameters and ensures that the first is
+less than or equal to the second.
+
+#### func ShouldBeNil
+
+```go
+func ShouldBeNil(actual interface{}, expected ...interface{}) string
+```
+ShouldBeNil receives a single parameter and ensures that it is nil.
+
+#### func ShouldBeTrue
+
+```go
+func ShouldBeTrue(actual interface{}, expected ...interface{}) string
+```
+ShouldBeTrue receives a single parameter and ensures that it is true.
+
+#### func ShouldBeZeroValue
+
+```go
+func ShouldBeZeroValue(actual interface{}, expected ...interface{}) string
+```
+ShouldBeZeroValue receives a single parameter and ensures that it is the Go
+equivalent of the default value, or "zero" value.
+
+#### func ShouldContain
+
+```go
+func ShouldContain(actual interface{}, expected ...interface{}) string
+```
+ShouldContain receives exactly two parameters. The first is a slice and the
+second is a proposed member. Membership is determined using ShouldEqual.
+
+#### func ShouldContainKey
+
+```go
+func ShouldContainKey(actual interface{}, expected ...interface{}) string
+```
+ShouldContainKey receives exactly two parameters. The first is a map and the
+second is a proposed key. Keys are compared with a simple '=='.
+
+#### func ShouldContainSubstring
+
+```go
+func ShouldContainSubstring(actual interface{}, expected ...interface{}) string
+```
+ShouldContainSubstring receives exactly 2 string parameters and ensures that the
+first contains the second as a substring.
+
+#### func ShouldEndWith
+
+```go
+func ShouldEndWith(actual interface{}, expected ...interface{}) string
+```
+ShouldEndWith receives exactly 2 string parameters and ensures that the first
+ends with the second.
+
+#### func ShouldEqual
+
+```go
+func ShouldEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldEqual receives exactly two parameters and does an equality check.
+
+#### func ShouldHappenAfter
+
+```go
+func ShouldHappenAfter(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenAfter receives exactly 2 time.Time arguments and asserts that the
+first happens after the second.
+
+#### func ShouldHappenBefore
+
+```go
+func ShouldHappenBefore(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenBefore receives exactly 2 time.Time arguments and asserts that the
+first happens before the second.
+
+#### func ShouldHappenBetween
+
+```go
+func ShouldHappenBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenBetween receives exactly 3 time.Time arguments and asserts that the
+first happens between (not on) the second and third.
+
+#### func ShouldHappenOnOrAfter
+
+```go
+func ShouldHappenOnOrAfter(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenOnOrAfter receives exactly 2 time.Time arguments and asserts that
+the first happens on or after the second.
+
+#### func ShouldHappenOnOrBefore
+
+```go
+func ShouldHappenOnOrBefore(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenOnOrBefore receives exactly 2 time.Time arguments and asserts that
+the first happens on or before the second.
+
+#### func ShouldHappenOnOrBetween
+
+```go
+func ShouldHappenOnOrBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that
+the first happens between or on the second and third.
+
+#### func ShouldHappenWithin
+
+```go
+func ShouldHappenWithin(actual interface{}, expected ...interface{}) string
+```
+ShouldHappenWithin receives a time.Time, a time.Duration, and a time.Time (3
+arguments) and asserts that the first time.Time happens within or on the
+duration specified relative to the other time.Time.
+
+#### func ShouldHaveSameTypeAs
+
+```go
+func ShouldHaveSameTypeAs(actual interface{}, expected ...interface{}) string
+```
+ShouldHaveSameTypeAs receives exactly two parameters and compares their
+underlying types for equality.
+
+#### func ShouldImplement
+
+```go
+func ShouldImplement(actual interface{}, expectedList ...interface{}) string
+```
+ShouldImplement receives exactly two parameters and ensures that the first
+implements the interface type of the second.
+
+#### func ShouldNotAlmostEqual
+
+```go
+func ShouldNotAlmostEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldNotAlmostEqual is the inverse of ShouldAlmostEqual
+
+#### func ShouldNotBeBetween
+
+```go
+func ShouldNotBeBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeBetween receives exactly three parameters: an actual value, a lower
+bound, and an upper bound. It ensures that the actual value is NOT between both
+bounds.
+
+#### func ShouldNotBeBetweenOrEqual
+
+```go
+func ShouldNotBeBetweenOrEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeBetweenOrEqual receives exactly three parameters: an actual value, a
+lower bound, and an upper bound. It ensures that the actual value is nopt
+between the bounds nor equal to either of them.
+
+#### func ShouldNotBeBlank
+
+```go
+func ShouldNotBeBlank(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeBlank receives exactly 1 string parameter and ensures that it is
+equal to "".
+
+#### func ShouldNotBeEmpty
+
+```go
+func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeEmpty receives a single parameter (actual) and determines whether or
+not calling len(actual) would return a value greater than zero. It obeys the
+rules specified by the `len` function for determining length:
+http://golang.org/pkg/builtin/#len
+
+#### func ShouldNotBeIn
+
+```go
+func ShouldNotBeIn(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeIn receives at least 2 parameters. The first is a proposed member of
+the collection that is passed in either as the second parameter, or of the
+collection that is comprised of all the remaining parameters. This assertion
+ensures that the proposed member is NOT in the collection (using ShouldEqual).
+
+#### func ShouldNotBeNil
+
+```go
+func ShouldNotBeNil(actual interface{}, expected ...interface{}) string
+```
+ShouldNotBeNil receives a single parameter and ensures that it is not nil.
+
+#### func ShouldNotContain
+
+```go
+func ShouldNotContain(actual interface{}, expected ...interface{}) string
+```
+ShouldNotContain receives exactly two parameters. The first is a slice and the
+second is a proposed member. Membership is determinied using ShouldEqual.
+
+#### func ShouldNotContainKey
+
+```go
+func ShouldNotContainKey(actual interface{}, expected ...interface{}) string
+```
+ShouldNotContainKey receives exactly two parameters. The first is a map and the
+second is a proposed absent key. Keys are compared with a simple '=='.
+
+#### func ShouldNotContainSubstring
+
+```go
+func ShouldNotContainSubstring(actual interface{}, expected ...interface{}) string
+```
+ShouldNotContainSubstring receives exactly 2 string parameters and ensures that
+the first does NOT contain the second as a substring.
+
+#### func ShouldNotEndWith
+
+```go
+func ShouldNotEndWith(actual interface{}, expected ...interface{}) string
+```
+ShouldEndWith receives exactly 2 string parameters and ensures that the first
+does not end with the second.
+
+#### func ShouldNotEqual
+
+```go
+func ShouldNotEqual(actual interface{}, expected ...interface{}) string
+```
+ShouldNotEqual receives exactly two parameters and does an inequality check.
+
+#### func ShouldNotHappenOnOrBetween
+
+```go
+func ShouldNotHappenOnOrBetween(actual interface{}, expected ...interface{}) string
+```
+ShouldNotHappenOnOrBetween receives exactly 3 time.Time arguments and asserts
+that the first does NOT happen between or on the second or third.
+
+#### func ShouldNotHappenWithin
+
+```go
+func ShouldNotHappenWithin(actual interface{}, expected ...interface{}) string
+```
+ShouldNotHappenWithin receives a time.Time, a time.Duration, and a time.Time (3
+arguments) and asserts that the first time.Time does NOT happen within or on the
+duration specified relative to the other time.Time.
+
+#### func ShouldNotHaveSameTypeAs
+
+```go
+func ShouldNotHaveSameTypeAs(actual interface{}, expected ...interface{}) string
+```
+ShouldNotHaveSameTypeAs receives exactly two parameters and compares their
+underlying types for inequality.
+
+#### func ShouldNotImplement
+
+```go
+func ShouldNotImplement(actual interface{}, expectedList ...interface{}) string
+```
+ShouldNotImplement receives exactly two parameters and ensures that the first
+does NOT implement the interface type of the second.
+
+#### func ShouldNotPanic
+
+```go
+func ShouldNotPanic(actual interface{}, expected ...interface{}) (message string)
+```
+ShouldNotPanic receives a void, niladic function and expects to execute the
+function without any panic.
+
+#### func ShouldNotPanicWith
+
+```go
+func ShouldNotPanicWith(actual interface{}, expected ...interface{}) (message string)
+```
+ShouldNotPanicWith receives a void, niladic function and expects to recover a
+panic whose content differs from the second argument.
+
+#### func ShouldNotPointTo
+
+```go
+func ShouldNotPointTo(actual interface{}, expected ...interface{}) string
+```
+ShouldNotPointTo receives exactly two parameters and checks to see that they
+point to different addresess.
+
+#### func ShouldNotResemble
+
+```go
+func ShouldNotResemble(actual interface{}, expected ...interface{}) string
+```
+ShouldNotResemble receives exactly two parameters and does an inverse deep equal
+check (see reflect.DeepEqual)
+
+#### func ShouldNotStartWith
+
+```go
+func ShouldNotStartWith(actual interface{}, expected ...interface{}) string
+```
+ShouldNotStartWith receives exactly 2 string parameters and ensures that the
+first does not start with the second.
+
+#### func ShouldPanic
+
+```go
+func ShouldPanic(actual interface{}, expected ...interface{}) (message string)
+```
+ShouldPanic receives a void, niladic function and expects to recover a panic.
+
+#### func ShouldPanicWith
+
+```go
+func ShouldPanicWith(actual interface{}, expected ...interface{}) (message string)
+```
+ShouldPanicWith receives a void, niladic function and expects to recover a panic
+with the second argument as the content.
+
+#### func ShouldPointTo
+
+```go
+func ShouldPointTo(actual interface{}, expected ...interface{}) string
+```
+ShouldPointTo receives exactly two parameters and checks to see that they point
+to the same address.
+
+#### func ShouldResemble
+
+```go
+func ShouldResemble(actual interface{}, expected ...interface{}) string
+```
+ShouldResemble receives exactly two parameters and does a deep equal check (see
+reflect.DeepEqual)
+
+#### func ShouldStartWith
+
+```go
+func ShouldStartWith(actual interface{}, expected ...interface{}) string
+```
+ShouldStartWith receives exactly 2 string parameters and ensures that the first
+starts with the second.
+
+#### func So
+
+```go
+func So(actual interface{}, assert assertion, expected ...interface{}) (bool, string)
+```
+So is a convenience function (as opposed to an inconvenience function?) for
+running assertions on arbitrary arguments in any context, be it for testing or
+even application logging. It allows you to perform assertion-like behavior (and
+get nicely formatted messages detailing discrepancies) but without the program
+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)
+ }
+
+#### type Assertion
+
+```go
+type Assertion struct {
+}
+```
+
+
+#### func New
+
+```go
+func New(t testingT) *Assertion
+```
+New swallows the *testing.T struct and prints failed assertions using t.Error.
+Example: assertions.New(t).So(1, should.Equal, 1)
+
+#### func (*Assertion) Failed
+
+```go
+func (this *Assertion) Failed() bool
+```
+Failed reports whether any calls to So (on this Assertion instance) have failed.
+
+#### func (*Assertion) So
+
+```go
+func (this *Assertion) So(actual interface{}, assert assertion, expected ...interface{}) bool
+```
+So calls the standalone So function and additionally, calls t.Error in failure
+scenarios.
+
+#### type Serializer
+
+```go
+type Serializer interface {
+ // contains filtered or unexported methods
+}
+```
diff --git a/vendor/github.com/smartystreets/assertions/assertions.goconvey b/vendor/github.com/smartystreets/assertions/assertions.goconvey
new file mode 100644
index 0000000..e76cf27
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/assertions.goconvey
@@ -0,0 +1,3 @@
+#ignore
+-timeout=1s
+-coverpkg=github.com/smartystreets/assertions,github.com/smartystreets/assertions/internal/oglematchers
\ No newline at end of file
diff --git a/vendor/github.com/smartystreets/assertions/collections.go b/vendor/github.com/smartystreets/assertions/collections.go
new file mode 100644
index 0000000..d279acc
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/collections.go
@@ -0,0 +1,195 @@
+package assertions
+
+import (
+ "fmt"
+ "reflect"
+
+ "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+)
+
+// ShouldContain receives exactly two parameters. The first is a slice and the
+// second is a proposed member. Membership is determined using ShouldEqual.
+func ShouldContain(actual interface{}, expected ...interface{}) string {
+ if fail := need(1, expected); fail != success {
+ return fail
+ }
+
+ if matchError := oglematchers.Contains(expected[0]).Matches(actual); matchError != nil {
+ typeName := reflect.TypeOf(actual)
+
+ if fmt.Sprintf("%v", matchError) == "which is not a slice or array" {
+ return fmt.Sprintf(shouldHaveBeenAValidCollection, typeName)
+ }
+ return fmt.Sprintf(shouldHaveContained, typeName, expected[0])
+ }
+ return success
+}
+
+// ShouldNotContain receives exactly two parameters. The first is a slice and the
+// second is a proposed member. Membership is determinied using ShouldEqual.
+func ShouldNotContain(actual interface{}, expected ...interface{}) string {
+ if fail := need(1, expected); fail != success {
+ return fail
+ }
+ typeName := reflect.TypeOf(actual)
+
+ if matchError := oglematchers.Contains(expected[0]).Matches(actual); matchError != nil {
+ if fmt.Sprintf("%v", matchError) == "which is not a slice or array" {
+ return fmt.Sprintf(shouldHaveBeenAValidCollection, typeName)
+ }
+ return success
+ }
+ return fmt.Sprintf(shouldNotHaveContained, typeName, expected[0])
+}
+
+// ShouldContainKey receives exactly two parameters. The first is a map and the
+// second is a proposed key. Keys are compared with a simple '=='.
+func ShouldContainKey(actual interface{}, expected ...interface{}) string {
+ if fail := need(1, expected); fail != success {
+ return fail
+ }
+
+ keys, isMap := mapKeys(actual)
+ if !isMap {
+ return fmt.Sprintf(shouldHaveBeenAValidMap, reflect.TypeOf(actual))
+ }
+
+ if !keyFound(keys, expected[0]) {
+ return fmt.Sprintf(shouldHaveContainedKey, reflect.TypeOf(actual), expected)
+ }
+
+ return ""
+}
+
+// ShouldNotContainKey receives exactly two parameters. The first is a map and the
+// second is a proposed absent key. Keys are compared with a simple '=='.
+func ShouldNotContainKey(actual interface{}, expected ...interface{}) string {
+ if fail := need(1, expected); fail != success {
+ return fail
+ }
+
+ keys, isMap := mapKeys(actual)
+ if !isMap {
+ return fmt.Sprintf(shouldHaveBeenAValidMap, reflect.TypeOf(actual))
+ }
+
+ if keyFound(keys, expected[0]) {
+ return fmt.Sprintf(shouldNotHaveContainedKey, reflect.TypeOf(actual), expected)
+ }
+
+ return ""
+}
+
+func mapKeys(m interface{}) ([]reflect.Value, bool) {
+ value := reflect.ValueOf(m)
+ if value.Kind() != reflect.Map {
+ return nil, false
+ }
+ return value.MapKeys(), true
+}
+func keyFound(keys []reflect.Value, expectedKey interface{}) bool {
+ found := false
+ for _, key := range keys {
+ if key.Interface() == expectedKey {
+ found = true
+ }
+ }
+ return found
+}
+
+// ShouldBeIn receives at least 2 parameters. The first is a proposed member of the collection
+// that is passed in either as the second parameter, or of the collection that is comprised
+// of all the remaining parameters. This assertion ensures that the proposed member is in
+// the collection (using ShouldEqual).
+func ShouldBeIn(actual interface{}, expected ...interface{}) string {
+ if fail := atLeast(1, expected); fail != success {
+ return fail
+ }
+
+ if len(expected) == 1 {
+ return shouldBeIn(actual, expected[0])
+ }
+ return shouldBeIn(actual, expected)
+}
+func shouldBeIn(actual interface{}, expected interface{}) string {
+ if matchError := oglematchers.Contains(actual).Matches(expected); matchError != nil {
+ return fmt.Sprintf(shouldHaveBeenIn, actual, reflect.TypeOf(expected))
+ }
+ return success
+}
+
+// ShouldNotBeIn receives at least 2 parameters. The first is a proposed member of the collection
+// that is passed in either as the second parameter, or of the collection that is comprised
+// of all the remaining parameters. This assertion ensures that the proposed member is NOT in
+// the collection (using ShouldEqual).
+func ShouldNotBeIn(actual interface{}, expected ...interface{}) string {
+ if fail := atLeast(1, expected); fail != success {
+ return fail
+ }
+
+ if len(expected) == 1 {
+ return shouldNotBeIn(actual, expected[0])
+ }
+ return shouldNotBeIn(actual, expected)
+}
+func shouldNotBeIn(actual interface{}, expected interface{}) string {
+ if matchError := oglematchers.Contains(actual).Matches(expected); matchError == nil {
+ return fmt.Sprintf(shouldNotHaveBeenIn, actual, reflect.TypeOf(expected))
+ }
+ return success
+}
+
+// ShouldBeEmpty receives a single parameter (actual) and determines whether or not
+// calling len(actual) would return `0`. It obeys the rules specified by the len
+// function for determining length: http://golang.org/pkg/builtin/#len
+func ShouldBeEmpty(actual interface{}, expected ...interface{}) string {
+ if fail := need(0, expected); fail != success {
+ return fail
+ }
+
+ if actual == nil {
+ return success
+ }
+
+ value := reflect.ValueOf(actual)
+ switch value.Kind() {
+ case reflect.Slice:
+ if value.Len() == 0 {
+ return success
+ }
+ case reflect.Chan:
+ if value.Len() == 0 {
+ return success
+ }
+ case reflect.Map:
+ if value.Len() == 0 {
+ return success
+ }
+ case reflect.String:
+ if value.Len() == 0 {
+ return success
+ }
+ case reflect.Ptr:
+ elem := value.Elem()
+ kind := elem.Kind()
+ if (kind == reflect.Slice || kind == reflect.Array) && elem.Len() == 0 {
+ return success
+ }
+ }
+
+ return fmt.Sprintf(shouldHaveBeenEmpty, actual)
+}
+
+// ShouldNotBeEmpty receives a single parameter (actual) and determines whether or not
+// calling len(actual) would return a value greater than zero. It obeys the rules
+// specified by the `len` function for determining length: http://golang.org/pkg/builtin/#len
+func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string {
+ if fail := need(0, expected); fail != success {
+ return fail
+ }
+
+ if empty := ShouldBeEmpty(actual, expected...); empty != success {
+ return success
+ }
+ return fmt.Sprintf(shouldNotHaveBeenEmpty, actual)
+}
diff --git a/vendor/github.com/smartystreets/assertions/collections_test.go b/vendor/github.com/smartystreets/assertions/collections_test.go
new file mode 100644
index 0000000..ba4afb4
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/collections_test.go
@@ -0,0 +1,125 @@
+package assertions
+
+import (
+ "fmt"
+ "testing"
+ "time"
+)
+
+func TestShouldContainKey(t *testing.T) {
+ fail(t, so(map[int]int{}, ShouldContainKey), "This assertion requires exactly 1 comparison values (you provided 0).")
+ fail(t, so(map[int]int{}, ShouldContainKey, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
+
+ fail(t, so(Thing1{}, ShouldContainKey, 1), "You must provide a valid map type (was assertions.Thing1)!")
+ fail(t, so(nil, ShouldContainKey, 1), "You must provide a valid map type (was )!")
+ fail(t, so(map[int]int{1: 41}, ShouldContainKey, 2), "Expected the map[int]int to contain the key: [2] (but it didn't)!")
+
+ pass(t, so(map[int]int{1: 41}, ShouldContainKey, 1))
+ pass(t, so(map[int]int{1: 41, 2: 42, 3: 43}, ShouldContainKey, 2))
+}
+
+func TestShouldNotContainKey(t *testing.T) {
+ fail(t, so(map[int]int{}, ShouldNotContainKey), "This assertion requires exactly 1 comparison values (you provided 0).")
+ fail(t, so(map[int]int{}, ShouldNotContainKey, 1, 2, 3), "This assertion requires exactly 1 comparison values (you provided 3).")
+
+ fail(t, so(Thing1{}, ShouldNotContainKey, 1), "You must provide a valid map type (was assertions.Thing1)!")
+ fail(t, so(nil, ShouldNotContainKey, 1), "You must provide a valid map type (was )!")
+ fail(t, so(map[int]int{1: 41}, ShouldNotContainKey, 1), "Expected the map[int]int NOT to contain the key: [1] (but it did)!")
+ pass(t, so(map[int]int{1: 41}, ShouldNotContainKey, 2))
+}
+
+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 )!")
+ 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 )!")
+
+ 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), needNonEmptyCollection)
+
+ 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), needNonEmptyCollection)
+
+ 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 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))
+}
diff --git a/vendor/github.com/smartystreets/assertions/doc.go b/vendor/github.com/smartystreets/assertions/doc.go
new file mode 100644
index 0000000..d3d116c
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/doc.go
@@ -0,0 +1,99 @@
+// Package assertions contains the implementations for all assertions which
+// are referenced in goconvey's `convey` package
+// (github.com/smartystreets/goconvey/convey) for use with the So(...) method.
+// They can also be used in traditional Go test functions and even in
+// applicaitons.
+package assertions
+
+import (
+ "fmt"
+ "runtime"
+)
+
+// By default we use a no-op serializer. The actual Serializer provides a JSON
+// representation of failure results on selected assertions so the goconvey
+// web UI can display a convenient diff.
+var serializer Serializer = new(noopSerializer)
+
+// GoConveyMode provides control over JSON serialization of failures. When
+// using the assertions in this package from the convey package JSON results
+// are very helpful and can be rendered in a DIFF view. In that case, this function
+// will be called with a true value to enable the JSON serialization. By default,
+// the assertions in this package will not serializer a JSON result, making
+// standalone ussage more convenient.
+func GoConveyMode(yes bool) {
+ if yes {
+ serializer = newSerializer()
+ } else {
+ serializer = new(noopSerializer)
+ }
+}
+
+type testingT interface {
+ Error(args ...interface{})
+}
+
+type Assertion struct {
+ t testingT
+ failed bool
+}
+
+// New swallows the *testing.T struct and prints failed assertions using t.Error.
+// Example: assertions.New(t).So(1, should.Equal, 1)
+func New(t testingT) *Assertion {
+ return &Assertion{t: t}
+}
+
+// Failed reports whether any calls to So (on this Assertion instance) have failed.
+func (this *Assertion) Failed() bool {
+ return this.failed
+}
+
+// So calls the standalone So function and additionally, calls t.Error in failure scenarios.
+func (this *Assertion) So(actual interface{}, assert assertion, expected ...interface{}) bool {
+ ok, result := So(actual, assert, expected...)
+ if !ok {
+ this.failed = true
+ _, file, line, _ := runtime.Caller(1)
+ this.t.Error(fmt.Sprintf("\n%s:%d\n%s", file, line, result))
+ }
+ return ok
+}
+
+// So is a convenience function (as opposed to an inconvenience function?)
+// for running assertions on arbitrary arguments in any context, be it for testing or even
+// application logging. It allows you to perform assertion-like behavior (and get nicely
+// formatted messages detailing discrepancies) but without the program 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) {
+ 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
+
+////////////////////////////////////////////////////////////////////////////
diff --git a/vendor/github.com/smartystreets/assertions/doc_test.go b/vendor/github.com/smartystreets/assertions/doc_test.go
new file mode 100644
index 0000000..041faaf
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/doc_test.go
@@ -0,0 +1,57 @@
+package assertions
+
+import (
+ "bytes"
+ "fmt"
+ "testing"
+)
+
+func TestPassingAssertion(t *testing.T) {
+ fake := &FakeT{buffer: new(bytes.Buffer)}
+ assertion := New(fake)
+ passed := assertion.So(1, ShouldEqual, 1)
+
+ if !passed {
+ t.Error("Assertion failed when it should have passed.")
+ }
+ if fake.buffer.Len() > 0 {
+ t.Error("Unexpected error message was printed.")
+ }
+}
+
+func TestFailingAssertion(t *testing.T) {
+ fake := &FakeT{buffer: new(bytes.Buffer)}
+ assertion := New(fake)
+ passed := assertion.So(1, ShouldEqual, 2)
+
+ if passed {
+ t.Error("Assertion passed when it should have failed.")
+ }
+ if fake.buffer.Len() == 0 {
+ t.Error("Expected error message not printed.")
+ }
+}
+
+func TestFailingGroupsOfAssertions(t *testing.T) {
+ fake := &FakeT{buffer: new(bytes.Buffer)}
+ assertion1 := New(fake)
+ assertion2 := New(fake)
+
+ assertion1.So(1, ShouldEqual, 2) // fail
+ assertion2.So(1, ShouldEqual, 1) // pass
+
+ if !assertion1.Failed() {
+ t.Error("Expected the first assertion to have been marked as failed.")
+ }
+ if assertion2.Failed() {
+ t.Error("Expected the second assertion to NOT have been marked as failed.")
+ }
+}
+
+type FakeT struct {
+ buffer *bytes.Buffer
+}
+
+func (this *FakeT) Error(args ...interface{}) {
+ fmt.Fprint(this.buffer, args...)
+}
diff --git a/vendor/github.com/smartystreets/assertions/equality.go b/vendor/github.com/smartystreets/assertions/equality.go
new file mode 100644
index 0000000..3bfe766
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/equality.go
@@ -0,0 +1,279 @@
+package assertions
+
+import (
+ "errors"
+ "fmt"
+ "math"
+ "reflect"
+ "strings"
+
+ "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+)
+
+// default acceptable delta for ShouldAlmostEqual
+const defaultDelta = 0.0000000001
+
+// ShouldEqual receives exactly two parameters and does an equality check.
+func ShouldEqual(actual interface{}, expected ...interface{}) string {
+ if message := need(1, expected); message != success {
+ return message
+ }
+ return shouldEqual(actual, expected[0])
+}
+func shouldEqual(actual, expected interface{}) (message string) {
+ defer func() {
+ if r := recover(); r != nil {
+ message = serializer.serialize(expected, actual, fmt.Sprintf(shouldHaveBeenEqual, expected, actual))
+ return
+ }
+ }()
+
+ if matchError := oglematchers.Equals(expected).Matches(actual); matchError != nil {
+ message = serializer.serialize(expected, actual, fmt.Sprintf(shouldHaveBeenEqual, expected, actual))
+ return
+ }
+
+ return success
+}
+
+// ShouldNotEqual receives exactly two parameters and does an inequality check.
+func ShouldNotEqual(actual interface{}, expected ...interface{}) string {
+ if fail := need(1, expected); fail != success {
+ return fail
+ } else if ShouldEqual(actual, expected[0]) == success {
+ return fmt.Sprintf(shouldNotHaveBeenEqual, actual, expected[0])
+ }
+ return success
+}
+
+// ShouldAlmostEqual makes sure that two parameters are close enough to being equal.
+// The acceptable delta may be specified with a third argument,
+// or a very small default delta will be used.
+func ShouldAlmostEqual(actual interface{}, expected ...interface{}) string {
+ actualFloat, expectedFloat, deltaFloat, err := cleanAlmostEqualInput(actual, expected...)
+
+ if err != "" {
+ return err
+ }
+
+ if math.Abs(actualFloat-expectedFloat) <= deltaFloat {
+ return success
+ } else {
+ return fmt.Sprintf(shouldHaveBeenAlmostEqual, actualFloat, expectedFloat)
+ }
+}
+
+// ShouldNotAlmostEqual is the inverse of ShouldAlmostEqual
+func ShouldNotAlmostEqual(actual interface{}, expected ...interface{}) string {
+ actualFloat, expectedFloat, deltaFloat, err := cleanAlmostEqualInput(actual, expected...)
+
+ if err != "" {
+ return err
+ }
+
+ if math.Abs(actualFloat-expectedFloat) > deltaFloat {
+ return success
+ } else {
+ return fmt.Sprintf(shouldHaveNotBeenAlmostEqual, actualFloat, expectedFloat)
+ }
+}
+
+func cleanAlmostEqualInput(actual interface{}, expected ...interface{}) (float64, float64, float64, string) {
+ deltaFloat := 0.0000000001
+
+ if len(expected) == 0 {
+ return 0.0, 0.0, 0.0, "This assertion requires exactly one comparison value and an optional delta (you provided neither)"
+ } else if len(expected) == 2 {
+ delta, err := getFloat(expected[1])
+
+ if err != nil {
+ return 0.0, 0.0, 0.0, "delta must be a numerical type"
+ }
+
+ deltaFloat = delta
+ } else if len(expected) > 2 {
+ return 0.0, 0.0, 0.0, "This assertion requires exactly one comparison value and an optional delta (you provided more values)"
+ }
+
+ actualFloat, err := getFloat(actual)
+
+ if err != nil {
+ return 0.0, 0.0, 0.0, err.Error()
+ }
+
+ expectedFloat, err := getFloat(expected[0])
+
+ if err != nil {
+ return 0.0, 0.0, 0.0, err.Error()
+ }
+
+ return actualFloat, expectedFloat, deltaFloat, ""
+}
+
+// returns the float value of any real number, or error if it is not a numerical type
+func getFloat(num interface{}) (float64, error) {
+ numValue := reflect.ValueOf(num)
+ numKind := numValue.Kind()
+
+ if numKind == reflect.Int ||
+ numKind == reflect.Int8 ||
+ numKind == reflect.Int16 ||
+ numKind == reflect.Int32 ||
+ numKind == reflect.Int64 {
+ return float64(numValue.Int()), nil
+ } else if numKind == reflect.Uint ||
+ numKind == reflect.Uint8 ||
+ numKind == reflect.Uint16 ||
+ numKind == reflect.Uint32 ||
+ numKind == reflect.Uint64 {
+ return float64(numValue.Uint()), nil
+ } else if numKind == reflect.Float32 ||
+ numKind == reflect.Float64 {
+ return numValue.Float(), nil
+ } else {
+ return 0.0, errors.New("must be a numerical type, but was " + numKind.String())
+ }
+}
+
+// ShouldResemble receives exactly two parameters and does a deep equal check (see reflect.DeepEqual)
+func ShouldResemble(actual interface{}, expected ...interface{}) string {
+ if message := need(1, expected); message != success {
+ return message
+ }
+
+ if matchError := oglematchers.DeepEquals(expected[0]).Matches(actual); matchError != nil {
+ expectedSyntax := fmt.Sprintf("%#v", expected[0])
+ actualSyntax := fmt.Sprintf("%#v", actual)
+ var message string
+ if expectedSyntax == actualSyntax {
+ message = fmt.Sprintf(shouldHaveResembledTypeMismatch, expected[0], actual, expected[0], actual)
+ } else {
+ message = fmt.Sprintf(shouldHaveResembled, expected[0], actual)
+ }
+ return serializer.serializeDetailed(expected[0], actual, message)
+ }
+
+ return success
+}
+
+// ShouldNotResemble receives exactly two parameters and does an inverse deep equal check (see reflect.DeepEqual)
+func ShouldNotResemble(actual interface{}, expected ...interface{}) string {
+ if message := need(1, expected); message != success {
+ return message
+ } else if ShouldResemble(actual, expected[0]) == success {
+ return fmt.Sprintf(shouldNotHaveResembled, actual, expected[0])
+ }
+ return success
+}
+
+// ShouldPointTo receives exactly two parameters and checks to see that they point to the same address.
+func ShouldPointTo(actual interface{}, expected ...interface{}) string {
+ if message := need(1, expected); message != success {
+ return message
+ }
+ return shouldPointTo(actual, expected[0])
+
+}
+func shouldPointTo(actual, expected interface{}) string {
+ actualValue := reflect.ValueOf(actual)
+ expectedValue := reflect.ValueOf(expected)
+
+ if ShouldNotBeNil(actual) != success {
+ return fmt.Sprintf(shouldHaveBeenNonNilPointer, "first", "nil")
+ } else if ShouldNotBeNil(expected) != success {
+ return fmt.Sprintf(shouldHaveBeenNonNilPointer, "second", "nil")
+ } else if actualValue.Kind() != reflect.Ptr {
+ return fmt.Sprintf(shouldHaveBeenNonNilPointer, "first", "not")
+ } else if expectedValue.Kind() != reflect.Ptr {
+ return fmt.Sprintf(shouldHaveBeenNonNilPointer, "second", "not")
+ } else if ShouldEqual(actualValue.Pointer(), expectedValue.Pointer()) != success {
+ actualAddress := reflect.ValueOf(actual).Pointer()
+ expectedAddress := reflect.ValueOf(expected).Pointer()
+ return serializer.serialize(expectedAddress, actualAddress, fmt.Sprintf(shouldHavePointedTo,
+ actual, actualAddress,
+ expected, expectedAddress))
+ }
+ return success
+}
+
+// ShouldNotPointTo receives exactly two parameters and checks to see that they point to different addresess.
+func ShouldNotPointTo(actual interface{}, expected ...interface{}) string {
+ if message := need(1, expected); message != success {
+ return message
+ }
+ compare := ShouldPointTo(actual, expected[0])
+ if strings.HasPrefix(compare, shouldBePointers) {
+ return compare
+ } else if compare == success {
+ return fmt.Sprintf(shouldNotHavePointedTo, actual, expected[0], reflect.ValueOf(actual).Pointer())
+ }
+ return success
+}
+
+// ShouldBeNil receives a single parameter and ensures that it is nil.
+func ShouldBeNil(actual interface{}, expected ...interface{}) string {
+ if fail := need(0, expected); fail != success {
+ return fail
+ } else if actual == nil {
+ return success
+ } else if interfaceHasNilValue(actual) {
+ return success
+ }
+ return fmt.Sprintf(shouldHaveBeenNil, actual)
+}
+func interfaceHasNilValue(actual interface{}) bool {
+ value := reflect.ValueOf(actual)
+ kind := value.Kind()
+ nilable := kind == reflect.Slice ||
+ kind == reflect.Chan ||
+ kind == reflect.Func ||
+ kind == reflect.Ptr ||
+ kind == reflect.Map
+
+ // Careful: reflect.Value.IsNil() will panic unless it's an interface, chan, map, func, slice, or ptr
+ // Reference: http://golang.org/pkg/reflect/#Value.IsNil
+ return nilable && value.IsNil()
+}
+
+// ShouldNotBeNil receives a single parameter and ensures that it is not nil.
+func ShouldNotBeNil(actual interface{}, expected ...interface{}) string {
+ if fail := need(0, expected); fail != success {
+ return fail
+ } else if ShouldBeNil(actual) == success {
+ return fmt.Sprintf(shouldNotHaveBeenNil, actual)
+ }
+ return success
+}
+
+// ShouldBeTrue receives a single parameter and ensures that it is true.
+func ShouldBeTrue(actual interface{}, expected ...interface{}) string {
+ if fail := need(0, expected); fail != success {
+ return fail
+ } else if actual != true {
+ return fmt.Sprintf(shouldHaveBeenTrue, actual)
+ }
+ return success
+}
+
+// ShouldBeFalse receives a single parameter and ensures that it is false.
+func ShouldBeFalse(actual interface{}, expected ...interface{}) string {
+ if fail := need(0, expected); fail != success {
+ return fail
+ } else if actual != false {
+ return fmt.Sprintf(shouldHaveBeenFalse, actual)
+ }
+ return success
+}
+
+// ShouldBeZeroValue receives a single parameter and ensures that it is
+// the Go equivalent of the default value, or "zero" value.
+func ShouldBeZeroValue(actual interface{}, expected ...interface{}) string {
+ if fail := need(0, expected); fail != success {
+ return fail
+ }
+ zeroVal := reflect.Zero(reflect.TypeOf(actual)).Interface()
+ if !reflect.DeepEqual(zeroVal, actual) {
+ return serializer.serialize(zeroVal, actual, fmt.Sprintf(shouldHaveBeenZeroValue, actual))
+ }
+ return success
+}
diff --git a/vendor/github.com/smartystreets/assertions/equality_test.go b/vendor/github.com/smartystreets/assertions/equality_test.go
new file mode 100644
index 0000000..ee39397
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/equality_test.go
@@ -0,0 +1,267 @@
+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 '' to NOT be nil (but it was)!")
+ pass(t, so(1, ShouldNotBeNil))
+
+ var thing Thinger
+ fail(t, so(thing, ShouldNotBeNil), "Expected '' 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))
+}
diff --git a/vendor/github.com/smartystreets/assertions/filter.go b/vendor/github.com/smartystreets/assertions/filter.go
new file mode 100644
index 0000000..ee368a9
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/filter.go
@@ -0,0 +1,23 @@
+package assertions
+
+import "fmt"
+
+const (
+ success = ""
+ needExactValues = "This assertion requires exactly %d comparison values (you provided %d)."
+ needNonEmptyCollection = "This assertion requires at least 1 comparison value (you provided 0)."
+)
+
+func need(needed int, expected []interface{}) string {
+ if len(expected) != needed {
+ return fmt.Sprintf(needExactValues, needed, len(expected))
+ }
+ return success
+}
+
+func atLeast(minimum int, expected []interface{}) string {
+ if len(expected) < 1 {
+ return needNonEmptyCollection
+ }
+ return success
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/LICENSE b/vendor/github.com/smartystreets/assertions/internal/oglematchers/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/LICENSE
@@ -0,0 +1,202 @@
+
+ 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.
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/README.md b/vendor/github.com/smartystreets/assertions/internal/oglematchers/README.md
new file mode 100644
index 0000000..215a2bb
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/README.md
@@ -0,0 +1,58 @@
+[![GoDoc](https://godoc.org/github.com/smartystreets/assertions/internal/oglematchers?status.svg)](https://godoc.org/github.com/smartystreets/assertions/internal/oglematchers)
+
+`oglematchers` is a package for the Go programming language containing a set of
+matchers, useful in a testing or mocking framework, inspired by and mostly
+compatible with [Google Test][googletest] for C++ and
+[Google JS Test][google-js-test]. The package is used by the
+[ogletest][ogletest] testing framework and [oglemock][oglemock] mocking
+framework, which may be more directly useful to you, but can be generically used
+elsewhere as well.
+
+A "matcher" is simply an object with a `Matches` method defining a set of golang
+values matched by the matcher, and a `Description` method describing that set.
+For example, here are some matchers:
+
+```go
+// Numbers
+Equals(17.13)
+LessThan(19)
+
+// Strings
+Equals("taco")
+HasSubstr("burrito")
+MatchesRegex("t.*o")
+
+// Combining matchers
+AnyOf(LessThan(17), GreaterThan(19))
+```
+
+There are lots more; see [here][reference] for a reference. You can also add
+your own simply by implementing the `oglematchers.Matcher` interface.
+
+
+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 `oglematchers` and keep it up to date:
+
+ go get -u github.com/smartystreets/assertions/internal/oglematchers
+
+
+Documentation
+-------------
+
+See [here][reference] for documentation. Alternatively, you can install the
+package and then use `godoc`:
+
+ godoc github.com/smartystreets/assertions/internal/oglematchers
+
+
+[reference]: http://godoc.org/github.com/smartystreets/assertions/internal/oglematchers
+[golang-install]: http://golang.org/doc/install.html
+[googletest]: http://code.google.com/p/googletest/
+[google-js-test]: http://code.google.com/p/google-js-test/
+[ogletest]: http://github.com/smartystreets/assertions/internal/ogletest
+[oglemock]: http://github.com/smartystreets/assertions/internal/oglemock
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/all_of.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/all_of.go
new file mode 100644
index 0000000..d93a974
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/all_of.go
@@ -0,0 +1,70 @@
+// 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
+
+import (
+ "strings"
+)
+
+// AllOf accepts a set of matchers S and returns a matcher that follows the
+// algorithm below when considering a candidate c:
+//
+// 1. Return true if for every Matcher m in S, m matches c.
+//
+// 2. Otherwise, if there is a matcher m in S such that m returns a fatal
+// error for c, return that matcher's error message.
+//
+// 3. Otherwise, return false with the error from some wrapped matcher.
+//
+// This is akin to a logical AND operation for matchers.
+func AllOf(matchers ...Matcher) Matcher {
+ return &allOfMatcher{matchers}
+}
+
+type allOfMatcher struct {
+ wrappedMatchers []Matcher
+}
+
+func (m *allOfMatcher) Description() string {
+ // Special case: the empty set.
+ if len(m.wrappedMatchers) == 0 {
+ return "is anything"
+ }
+
+ // Join the descriptions for the wrapped matchers.
+ wrappedDescs := make([]string, len(m.wrappedMatchers))
+ for i, wrappedMatcher := range m.wrappedMatchers {
+ wrappedDescs[i] = wrappedMatcher.Description()
+ }
+
+ return strings.Join(wrappedDescs, ", and ")
+}
+
+func (m *allOfMatcher) Matches(c interface{}) (err error) {
+ for _, wrappedMatcher := range m.wrappedMatchers {
+ if wrappedErr := wrappedMatcher.Matches(c); wrappedErr != nil {
+ err = wrappedErr
+
+ // If the error is fatal, return immediately with this error.
+ _, ok := wrappedErr.(*FatalError)
+ if ok {
+ return
+ }
+ }
+ }
+
+ return
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/all_of_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/all_of_test.go
new file mode 100644
index 0000000..89ceb69
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/all_of_test.go
@@ -0,0 +1,110 @@
+// 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/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/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)
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/any.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/any.go
new file mode 100644
index 0000000..f6991ec
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/any.go
@@ -0,0 +1,32 @@
+// 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
+
+// Any returns a matcher that matches any value.
+func Any() Matcher {
+ return &anyMatcher{}
+}
+
+type anyMatcher struct {
+}
+
+func (m *anyMatcher) Description() string {
+ return "is anything"
+}
+
+func (m *anyMatcher) Matches(c interface{}) error {
+ return nil
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_of.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_of.go
new file mode 100644
index 0000000..2918b51
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_of.go
@@ -0,0 +1,94 @@
+// 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
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "strings"
+)
+
+// AnyOf accepts a set of values S and returns a matcher that follows the
+// algorithm below when considering a candidate c:
+//
+// 1. If there exists a value m in S such that m implements the Matcher
+// interface and m matches c, return true.
+//
+// 2. Otherwise, if there exists a value v in S such that v does not implement
+// the Matcher interface and the matcher Equals(v) matches c, return true.
+//
+// 3. Otherwise, if there is a value m in S such that m implements the Matcher
+// interface and m returns a fatal error for c, return that fatal error.
+//
+// 4. Otherwise, return false.
+//
+// This is akin to a logical OR operation for matchers, with non-matchers x
+// being treated as Equals(x).
+func AnyOf(vals ...interface{}) Matcher {
+ // Get ahold of a type variable for the Matcher interface.
+ var dummy *Matcher
+ matcherType := reflect.TypeOf(dummy).Elem()
+
+ // Create a matcher for each value, or use the value itself if it's already a
+ // matcher.
+ wrapped := make([]Matcher, len(vals))
+ for i, v := range vals {
+ t := reflect.TypeOf(v)
+ if t != nil && t.Implements(matcherType) {
+ wrapped[i] = v.(Matcher)
+ } else {
+ wrapped[i] = Equals(v)
+ }
+ }
+
+ return &anyOfMatcher{wrapped}
+}
+
+type anyOfMatcher struct {
+ wrapped []Matcher
+}
+
+func (m *anyOfMatcher) Description() string {
+ wrappedDescs := make([]string, len(m.wrapped))
+ for i, matcher := range m.wrapped {
+ wrappedDescs[i] = matcher.Description()
+ }
+
+ return fmt.Sprintf("or(%s)", strings.Join(wrappedDescs, ", "))
+}
+
+func (m *anyOfMatcher) Matches(c interface{}) (err error) {
+ err = errors.New("")
+
+ // Try each matcher in turn.
+ for _, matcher := range m.wrapped {
+ wrappedErr := matcher.Matches(c)
+
+ // Return immediately if there's a match.
+ if wrappedErr == nil {
+ err = nil
+ return
+ }
+
+ // Note the fatal error, if any.
+ if _, isFatal := wrappedErr.(*FatalError); isFatal {
+ err = wrappedErr
+ }
+ }
+
+ return
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_of_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_of_test.go
new file mode 100644
index 0000000..5700070
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_of_test.go
@@ -0,0 +1,139 @@
+// 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/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/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) OneNil() {
+ var err error
+ matcher := AnyOf(
+ 13,
+ nil,
+ 19,
+ )
+
+ // No match
+ err = matcher.Matches(14)
+ ExpectNe(nil, err)
+
+ // Match
+ err = matcher.Matches(nil)
+ ExpectEq(nil, err)
+}
+
+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())
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_test.go
new file mode 100644
index 0000000..70d7e64
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/any_test.go
@@ -0,0 +1,53 @@
+// 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/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/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)
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/contains.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/contains.go
new file mode 100644
index 0000000..2f326db
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/contains.go
@@ -0,0 +1,61 @@
+// 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
+
+import (
+ "fmt"
+ "reflect"
+)
+
+// Return a matcher that matches arrays slices with at least one element that
+// matches the supplied argument. If the argument x is not itself a Matcher,
+// this is equivalent to Contains(Equals(x)).
+func Contains(x interface{}) Matcher {
+ var result containsMatcher
+ var ok bool
+
+ if result.elementMatcher, ok = x.(Matcher); !ok {
+ result.elementMatcher = Equals(x)
+ }
+
+ return &result
+}
+
+type containsMatcher struct {
+ elementMatcher Matcher
+}
+
+func (m *containsMatcher) Description() string {
+ return fmt.Sprintf("contains: %s", m.elementMatcher.Description())
+}
+
+func (m *containsMatcher) Matches(candidate interface{}) error {
+ // The candidate must be a slice or an array.
+ v := reflect.ValueOf(candidate)
+ if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+ return NewFatalError("which is not a slice or array")
+ }
+
+ // Check each element.
+ for i := 0; i < v.Len(); i++ {
+ elem := v.Index(i)
+ if matchErr := m.elementMatcher.Matches(elem.Interface()); matchErr == nil {
+ return nil
+ }
+ }
+
+ return fmt.Errorf("")
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/contains_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/contains_test.go
new file mode 100644
index 0000000..772eb1d
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/contains_test.go
@@ -0,0 +1,234 @@
+// 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/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/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("")))
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/deep_equals.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/deep_equals.go
new file mode 100644
index 0000000..1d91bae
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/deep_equals.go
@@ -0,0 +1,88 @@
+// 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
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "reflect"
+)
+
+var byteSliceType reflect.Type = reflect.TypeOf([]byte{})
+
+// DeepEquals returns a matcher that matches based on 'deep equality', as
+// defined by the reflect package. This matcher requires that values have
+// identical types to x.
+func DeepEquals(x interface{}) Matcher {
+ return &deepEqualsMatcher{x}
+}
+
+type deepEqualsMatcher struct {
+ x interface{}
+}
+
+func (m *deepEqualsMatcher) Description() string {
+ xDesc := fmt.Sprintf("%v", m.x)
+ xValue := reflect.ValueOf(m.x)
+
+ // Special case: fmt.Sprintf presents nil slices as "[]", but
+ // reflect.DeepEqual makes a distinction between nil and empty slices. Make
+ // this less confusing.
+ if xValue.Kind() == reflect.Slice && xValue.IsNil() {
+ xDesc = ""
+ }
+
+ return fmt.Sprintf("deep equals: %s", xDesc)
+}
+
+func (m *deepEqualsMatcher) Matches(c interface{}) error {
+ // Make sure the types match.
+ ct := reflect.TypeOf(c)
+ xt := reflect.TypeOf(m.x)
+
+ if ct != xt {
+ return NewFatalError(fmt.Sprintf("which is of type %v", ct))
+ }
+
+ // Special case: handle byte slices more efficiently.
+ cValue := reflect.ValueOf(c)
+ xValue := reflect.ValueOf(m.x)
+
+ if ct == byteSliceType && !cValue.IsNil() && !xValue.IsNil() {
+ xBytes := m.x.([]byte)
+ cBytes := c.([]byte)
+
+ if bytes.Equal(cBytes, xBytes) {
+ return nil
+ }
+
+ return errors.New("")
+ }
+
+ // Defer to the reflect package.
+ if reflect.DeepEqual(m.x, c) {
+ return nil
+ }
+
+ // Special case: if the comparison failed because c is the nil slice, given
+ // an indication of this (since its value is printed as "[]").
+ if cValue.Kind() == reflect.Slice && cValue.IsNil() {
+ return errors.New("which is nil")
+ }
+
+ return errors.New("")
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/deep_equals_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/deep_equals_test.go
new file mode 100644
index 0000000..40aa83f
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/deep_equals_test.go
@@ -0,0 +1,344 @@
+// 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"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/ogletest"
+ "testing"
+)
+
+////////////////////////////////////////////////////////////////////////
+// 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("")))
+
+ // 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("")))
+
+ // 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("")))
+
+ // 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: ", 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: ", 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: ", 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)
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/elements_are.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/elements_are.go
new file mode 100644
index 0000000..2941847
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/elements_are.go
@@ -0,0 +1,91 @@
+// 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
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "strings"
+)
+
+// Given a list of arguments M, ElementsAre returns a matcher that matches
+// arrays and slices A where all of the following hold:
+//
+// * A is the same length as M.
+//
+// * For each i < len(A) where M[i] is a matcher, A[i] matches M[i].
+//
+// * For each i < len(A) where M[i] is not a matcher, A[i] matches
+// Equals(M[i]).
+//
+func ElementsAre(M ...interface{}) Matcher {
+ // Copy over matchers, or convert to Equals(x) for non-matcher x.
+ subMatchers := make([]Matcher, len(M))
+ for i, x := range M {
+ if matcher, ok := x.(Matcher); ok {
+ subMatchers[i] = matcher
+ continue
+ }
+
+ subMatchers[i] = Equals(x)
+ }
+
+ return &elementsAreMatcher{subMatchers}
+}
+
+type elementsAreMatcher struct {
+ subMatchers []Matcher
+}
+
+func (m *elementsAreMatcher) Description() string {
+ subDescs := make([]string, len(m.subMatchers))
+ for i, sm := range m.subMatchers {
+ subDescs[i] = sm.Description()
+ }
+
+ return fmt.Sprintf("elements are: [%s]", strings.Join(subDescs, ", "))
+}
+
+func (m *elementsAreMatcher) Matches(candidates interface{}) error {
+ // The candidate must be a slice or an array.
+ v := reflect.ValueOf(candidates)
+ if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+ return NewFatalError("which is not a slice or array")
+ }
+
+ // The length must be correct.
+ if v.Len() != len(m.subMatchers) {
+ return errors.New(fmt.Sprintf("which is of length %d", v.Len()))
+ }
+
+ // Check each element.
+ for i, subMatcher := range m.subMatchers {
+ c := v.Index(i)
+ if matchErr := subMatcher.Matches(c.Interface()); matchErr != nil {
+ // Return an errors indicating which element doesn't match. If the
+ // matcher error was fatal, make this one fatal too.
+ err := errors.New(fmt.Sprintf("whose element %d doesn't match", i))
+ if _, isFatal := matchErr.(*FatalError); isFatal {
+ err = NewFatalError(err.Error())
+ }
+
+ return err
+ }
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/elements_are_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/elements_are_test.go
new file mode 100644
index 0000000..a39601b
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/elements_are_test.go
@@ -0,0 +1,208 @@
+// 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/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/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))
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/equals.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/equals.go
new file mode 100644
index 0000000..a510707
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/equals.go
@@ -0,0 +1,541 @@
+// 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
+
+import (
+ "errors"
+ "fmt"
+ "math"
+ "reflect"
+)
+
+// Equals(x) returns a matcher that matches values v such that v and x are
+// equivalent. This includes the case when the comparison v == x using Go's
+// built-in comparison operator is legal (except for structs, which this
+// matcher does not support), but for convenience the following rules also
+// apply:
+//
+// * Type checking is done based on underlying types rather than actual
+// types, so that e.g. two aliases for string can be compared:
+//
+// type stringAlias1 string
+// type stringAlias2 string
+//
+// a := "taco"
+// b := stringAlias1("taco")
+// c := stringAlias2("taco")
+//
+// ExpectTrue(a == b) // Legal, passes
+// ExpectTrue(b == c) // Illegal, doesn't compile
+//
+// ExpectThat(a, Equals(b)) // Passes
+// ExpectThat(b, Equals(c)) // Passes
+//
+// * Values of numeric type are treated as if they were abstract numbers, and
+// compared accordingly. Therefore Equals(17) will match int(17),
+// int16(17), uint(17), float32(17), complex64(17), and so on.
+//
+// If you want a stricter matcher that contains no such cleverness, see
+// IdenticalTo instead.
+//
+// Arrays are supported by this matcher, but do not participate in the
+// exceptions above. Two arrays compared with this matcher must have identical
+// types, and their element type must itself be comparable according to Go's ==
+// operator.
+func Equals(x interface{}) Matcher {
+ v := reflect.ValueOf(x)
+
+ // This matcher doesn't support structs.
+ if v.Kind() == reflect.Struct {
+ panic(fmt.Sprintf("oglematchers.Equals: unsupported kind %v", v.Kind()))
+ }
+
+ // The == operator is not defined for non-nil slices.
+ if v.Kind() == reflect.Slice && v.Pointer() != uintptr(0) {
+ panic(fmt.Sprintf("oglematchers.Equals: non-nil slice"))
+ }
+
+ return &equalsMatcher{v}
+}
+
+type equalsMatcher struct {
+ expectedValue reflect.Value
+}
+
+////////////////////////////////////////////////////////////////////////
+// Numeric types
+////////////////////////////////////////////////////////////////////////
+
+func isSignedInteger(v reflect.Value) bool {
+ k := v.Kind()
+ return k >= reflect.Int && k <= reflect.Int64
+}
+
+func isUnsignedInteger(v reflect.Value) bool {
+ k := v.Kind()
+ return k >= reflect.Uint && k <= reflect.Uintptr
+}
+
+func isInteger(v reflect.Value) bool {
+ return isSignedInteger(v) || isUnsignedInteger(v)
+}
+
+func isFloat(v reflect.Value) bool {
+ k := v.Kind()
+ return k == reflect.Float32 || k == reflect.Float64
+}
+
+func isComplex(v reflect.Value) bool {
+ k := v.Kind()
+ return k == reflect.Complex64 || k == reflect.Complex128
+}
+
+func checkAgainstInt64(e int64, c reflect.Value) (err error) {
+ err = errors.New("")
+
+ switch {
+ case isSignedInteger(c):
+ if c.Int() == e {
+ err = nil
+ }
+
+ case isUnsignedInteger(c):
+ u := c.Uint()
+ if u <= math.MaxInt64 && int64(u) == e {
+ err = nil
+ }
+
+ // Turn around the various floating point types so that the checkAgainst*
+ // functions for them can deal with precision issues.
+ case isFloat(c), isComplex(c):
+ return Equals(c.Interface()).Matches(e)
+
+ default:
+ err = NewFatalError("which is not numeric")
+ }
+
+ return
+}
+
+func checkAgainstUint64(e uint64, c reflect.Value) (err error) {
+ err = errors.New("")
+
+ switch {
+ case isSignedInteger(c):
+ i := c.Int()
+ if i >= 0 && uint64(i) == e {
+ err = nil
+ }
+
+ case isUnsignedInteger(c):
+ if c.Uint() == e {
+ err = nil
+ }
+
+ // Turn around the various floating point types so that the checkAgainst*
+ // functions for them can deal with precision issues.
+ case isFloat(c), isComplex(c):
+ return Equals(c.Interface()).Matches(e)
+
+ default:
+ err = NewFatalError("which is not numeric")
+ }
+
+ return
+}
+
+func checkAgainstFloat32(e float32, c reflect.Value) (err error) {
+ err = errors.New("")
+
+ switch {
+ case isSignedInteger(c):
+ if float32(c.Int()) == e {
+ err = nil
+ }
+
+ case isUnsignedInteger(c):
+ if float32(c.Uint()) == e {
+ err = nil
+ }
+
+ case isFloat(c):
+ // Compare using float32 to avoid a false sense of precision; otherwise
+ // e.g. Equals(float32(0.1)) won't match float32(0.1).
+ if float32(c.Float()) == e {
+ err = nil
+ }
+
+ case isComplex(c):
+ comp := c.Complex()
+ rl := real(comp)
+ im := imag(comp)
+
+ // Compare using float32 to avoid a false sense of precision; otherwise
+ // e.g. Equals(float32(0.1)) won't match (0.1 + 0i).
+ if im == 0 && float32(rl) == e {
+ err = nil
+ }
+
+ default:
+ err = NewFatalError("which is not numeric")
+ }
+
+ return
+}
+
+func checkAgainstFloat64(e float64, c reflect.Value) (err error) {
+ err = errors.New("")
+
+ ck := c.Kind()
+
+ switch {
+ case isSignedInteger(c):
+ if float64(c.Int()) == e {
+ err = nil
+ }
+
+ case isUnsignedInteger(c):
+ if float64(c.Uint()) == e {
+ err = nil
+ }
+
+ // If the actual value is lower precision, turn the comparison around so we
+ // apply the low-precision rules. Otherwise, e.g. Equals(0.1) may not match
+ // float32(0.1).
+ case ck == reflect.Float32 || ck == reflect.Complex64:
+ return Equals(c.Interface()).Matches(e)
+
+ // Otherwise, compare with double precision.
+ case isFloat(c):
+ if c.Float() == e {
+ err = nil
+ }
+
+ case isComplex(c):
+ comp := c.Complex()
+ rl := real(comp)
+ im := imag(comp)
+
+ if im == 0 && rl == e {
+ err = nil
+ }
+
+ default:
+ err = NewFatalError("which is not numeric")
+ }
+
+ return
+}
+
+func checkAgainstComplex64(e complex64, c reflect.Value) (err error) {
+ err = errors.New("")
+ realPart := real(e)
+ imaginaryPart := imag(e)
+
+ switch {
+ case isInteger(c) || isFloat(c):
+ // If we have no imaginary part, then we should just compare against the
+ // real part. Otherwise, we can't be equal.
+ if imaginaryPart != 0 {
+ return
+ }
+
+ return checkAgainstFloat32(realPart, c)
+
+ case isComplex(c):
+ // Compare using complex64 to avoid a false sense of precision; otherwise
+ // e.g. Equals(0.1 + 0i) won't match float32(0.1).
+ if complex64(c.Complex()) == e {
+ err = nil
+ }
+
+ default:
+ err = NewFatalError("which is not numeric")
+ }
+
+ return
+}
+
+func checkAgainstComplex128(e complex128, c reflect.Value) (err error) {
+ err = errors.New("")
+ realPart := real(e)
+ imaginaryPart := imag(e)
+
+ switch {
+ case isInteger(c) || isFloat(c):
+ // If we have no imaginary part, then we should just compare against the
+ // real part. Otherwise, we can't be equal.
+ if imaginaryPart != 0 {
+ return
+ }
+
+ return checkAgainstFloat64(realPart, c)
+
+ case isComplex(c):
+ if c.Complex() == e {
+ err = nil
+ }
+
+ default:
+ err = NewFatalError("which is not numeric")
+ }
+
+ return
+}
+
+////////////////////////////////////////////////////////////////////////
+// Other types
+////////////////////////////////////////////////////////////////////////
+
+func checkAgainstBool(e bool, c reflect.Value) (err error) {
+ if c.Kind() != reflect.Bool {
+ err = NewFatalError("which is not a bool")
+ return
+ }
+
+ err = errors.New("")
+ if c.Bool() == e {
+ err = nil
+ }
+ return
+}
+
+func checkAgainstChan(e reflect.Value, c reflect.Value) (err error) {
+ // Create a description of e's type, e.g. "chan int".
+ typeStr := fmt.Sprintf("%s %s", e.Type().ChanDir(), e.Type().Elem())
+
+ // Make sure c is a chan of the correct type.
+ if c.Kind() != reflect.Chan ||
+ c.Type().ChanDir() != e.Type().ChanDir() ||
+ c.Type().Elem() != e.Type().Elem() {
+ err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr))
+ return
+ }
+
+ err = errors.New("")
+ if c.Pointer() == e.Pointer() {
+ err = nil
+ }
+ return
+}
+
+func checkAgainstFunc(e reflect.Value, c reflect.Value) (err error) {
+ // Make sure c is a function.
+ if c.Kind() != reflect.Func {
+ err = NewFatalError("which is not a function")
+ return
+ }
+
+ err = errors.New("")
+ if c.Pointer() == e.Pointer() {
+ err = nil
+ }
+ return
+}
+
+func checkAgainstMap(e reflect.Value, c reflect.Value) (err error) {
+ // Make sure c is a map.
+ if c.Kind() != reflect.Map {
+ err = NewFatalError("which is not a map")
+ return
+ }
+
+ err = errors.New("")
+ if c.Pointer() == e.Pointer() {
+ err = nil
+ }
+ return
+}
+
+func checkAgainstPtr(e reflect.Value, c reflect.Value) (err error) {
+ // Create a description of e's type, e.g. "*int".
+ typeStr := fmt.Sprintf("*%v", e.Type().Elem())
+
+ // Make sure c is a pointer of the correct type.
+ if c.Kind() != reflect.Ptr ||
+ c.Type().Elem() != e.Type().Elem() {
+ err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr))
+ return
+ }
+
+ err = errors.New("")
+ if c.Pointer() == e.Pointer() {
+ err = nil
+ }
+ return
+}
+
+func checkAgainstSlice(e reflect.Value, c reflect.Value) (err error) {
+ // Create a description of e's type, e.g. "[]int".
+ typeStr := fmt.Sprintf("[]%v", e.Type().Elem())
+
+ // Make sure c is a slice of the correct type.
+ if c.Kind() != reflect.Slice ||
+ c.Type().Elem() != e.Type().Elem() {
+ err = NewFatalError(fmt.Sprintf("which is not a %s", typeStr))
+ return
+ }
+
+ err = errors.New("")
+ if c.Pointer() == e.Pointer() {
+ err = nil
+ }
+ return
+}
+
+func checkAgainstString(e reflect.Value, c reflect.Value) (err error) {
+ // Make sure c is a string.
+ if c.Kind() != reflect.String {
+ err = NewFatalError("which is not a string")
+ return
+ }
+
+ err = errors.New("")
+ if c.String() == e.String() {
+ err = nil
+ }
+ return
+}
+
+func checkAgainstArray(e reflect.Value, c reflect.Value) (err error) {
+ // Create a description of e's type, e.g. "[2]int".
+ typeStr := fmt.Sprintf("%v", e.Type())
+
+ // Make sure c is the correct type.
+ if c.Type() != e.Type() {
+ err = NewFatalError(fmt.Sprintf("which is not %s", typeStr))
+ return
+ }
+
+ // Check for equality.
+ if e.Interface() != c.Interface() {
+ err = errors.New("")
+ return
+ }
+
+ return
+}
+
+func checkAgainstUnsafePointer(e reflect.Value, c reflect.Value) (err error) {
+ // Make sure c is a pointer.
+ if c.Kind() != reflect.UnsafePointer {
+ err = NewFatalError("which is not a unsafe.Pointer")
+ return
+ }
+
+ err = errors.New("")
+ if c.Pointer() == e.Pointer() {
+ err = nil
+ }
+ return
+}
+
+func checkForNil(c reflect.Value) (err error) {
+ err = errors.New("")
+
+ // Make sure it is legal to call IsNil.
+ switch c.Kind() {
+ case reflect.Invalid:
+ case reflect.Chan:
+ case reflect.Func:
+ case reflect.Interface:
+ case reflect.Map:
+ case reflect.Ptr:
+ case reflect.Slice:
+
+ default:
+ err = NewFatalError("which cannot be compared to nil")
+ return
+ }
+
+ // Ask whether the value is nil. Handle a nil literal (kind Invalid)
+ // specially, since it's not legal to call IsNil there.
+ if c.Kind() == reflect.Invalid || c.IsNil() {
+ err = nil
+ }
+ return
+}
+
+////////////////////////////////////////////////////////////////////////
+// Public implementation
+////////////////////////////////////////////////////////////////////////
+
+func (m *equalsMatcher) Matches(candidate interface{}) error {
+ e := m.expectedValue
+ c := reflect.ValueOf(candidate)
+ ek := e.Kind()
+
+ switch {
+ case ek == reflect.Bool:
+ return checkAgainstBool(e.Bool(), c)
+
+ case isSignedInteger(e):
+ return checkAgainstInt64(e.Int(), c)
+
+ case isUnsignedInteger(e):
+ return checkAgainstUint64(e.Uint(), c)
+
+ case ek == reflect.Float32:
+ return checkAgainstFloat32(float32(e.Float()), c)
+
+ case ek == reflect.Float64:
+ return checkAgainstFloat64(e.Float(), c)
+
+ case ek == reflect.Complex64:
+ return checkAgainstComplex64(complex64(e.Complex()), c)
+
+ case ek == reflect.Complex128:
+ return checkAgainstComplex128(complex128(e.Complex()), c)
+
+ case ek == reflect.Chan:
+ return checkAgainstChan(e, c)
+
+ case ek == reflect.Func:
+ return checkAgainstFunc(e, c)
+
+ case ek == reflect.Map:
+ return checkAgainstMap(e, c)
+
+ case ek == reflect.Ptr:
+ return checkAgainstPtr(e, c)
+
+ case ek == reflect.Slice:
+ return checkAgainstSlice(e, c)
+
+ case ek == reflect.String:
+ return checkAgainstString(e, c)
+
+ case ek == reflect.Array:
+ return checkAgainstArray(e, c)
+
+ case ek == reflect.UnsafePointer:
+ return checkAgainstUnsafePointer(e, c)
+
+ case ek == reflect.Invalid:
+ return checkForNil(c)
+ }
+
+ panic(fmt.Sprintf("equalsMatcher.Matches: unexpected kind: %v", ek))
+}
+
+func (m *equalsMatcher) Description() string {
+ // Special case: handle nil.
+ if !m.expectedValue.IsValid() {
+ return "is nil"
+ }
+
+ return fmt.Sprintf("%v", m.expectedValue.Interface())
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/equals_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/equals_test.go
new file mode 100644
index 0000000..8135127
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/equals_test.go
@@ -0,0 +1,3864 @@
+// 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 (
+ "fmt"
+ "math"
+ "unsafe"
+
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/ogletest"
+)
+
+var someInt int = -17
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type EqualsTest struct {
+}
+
+func init() { RegisterTestSuite(&EqualsTest{}) }
+
+type equalsTestCase struct {
+ candidate interface{}
+ expectedResult bool
+ shouldBeFatal bool
+ expectedError string
+}
+
+func (t *EqualsTest) checkTestCases(matcher Matcher, cases []equalsTestCase) {
+ for i, c := range cases {
+ err := matcher.Matches(c.candidate)
+ ExpectEq(
+ c.expectedResult,
+ (err == nil),
+ "Result for case %d: %v (Error: %v)", i, c, err)
+
+ if err == nil {
+ continue
+ }
+
+ _, isFatal := err.(*FatalError)
+ ExpectEq(c.shouldBeFatal, isFatal, "Fatality for case %d: %v", i, c)
+
+ ExpectThat(err, Error(Equals(c.expectedError)), "Case %d: %v", i, c)
+ }
+}
+
+////////////////////////////////////////////////////////////////////////
+// nil
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) EqualsNil() {
+ matcher := Equals(nil)
+ ExpectEq("is nil", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Legal types
+ equalsTestCase{nil, true, false, ""},
+ equalsTestCase{chan int(nil), true, false, ""},
+ equalsTestCase{(func())(nil), true, false, ""},
+ equalsTestCase{interface{}(nil), true, false, ""},
+ equalsTestCase{map[int]int(nil), true, false, ""},
+ equalsTestCase{(*int)(nil), true, false, ""},
+ equalsTestCase{[]int(nil), true, false, ""},
+
+ equalsTestCase{make(chan int), false, false, ""},
+ equalsTestCase{func() {}, false, false, ""},
+ equalsTestCase{map[int]int{}, false, false, ""},
+ equalsTestCase{&someInt, false, false, ""},
+ equalsTestCase{[]int{}, false, false, ""},
+
+ // Illegal types
+ equalsTestCase{17, false, true, "which cannot be compared to nil"},
+ equalsTestCase{int8(17), false, true, "which cannot be compared to nil"},
+ equalsTestCase{uintptr(17), false, true, "which cannot be compared to nil"},
+ equalsTestCase{[...]int{}, false, true, "which cannot be compared to nil"},
+ equalsTestCase{"taco", false, true, "which cannot be compared to nil"},
+ equalsTestCase{equalsTestCase{}, false, true, "which cannot be compared to nil"},
+ equalsTestCase{unsafe.Pointer(&someInt), false, true, "which cannot be compared to nil"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegerLiteral() {
+ // -2^30
+ matcher := Equals(-1073741824)
+ ExpectEq("-1073741824", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -1073741824.
+ equalsTestCase{-1073741824, true, false, ""},
+ equalsTestCase{-1073741824.0, true, false, ""},
+ equalsTestCase{-1073741824 + 0i, true, false, ""},
+ equalsTestCase{int(-1073741824), true, false, ""},
+ equalsTestCase{int32(-1073741824), true, false, ""},
+ equalsTestCase{int64(-1073741824), true, false, ""},
+ equalsTestCase{float32(-1073741824), true, false, ""},
+ equalsTestCase{float64(-1073741824), true, false, ""},
+ equalsTestCase{complex64(-1073741824), true, false, ""},
+ equalsTestCase{complex128(-1073741824), true, false, ""},
+ equalsTestCase{interface{}(int(-1073741824)), true, false, ""},
+
+ // Values that would be -1073741824 in two's complement.
+ equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+ // Non-equal values of signed integer type.
+ equalsTestCase{int(-1073741823), false, false, ""},
+ equalsTestCase{int32(-1073741823), false, false, ""},
+ equalsTestCase{int64(-1073741823), false, false, ""},
+
+ // Non-equal values of other numeric types.
+ equalsTestCase{float64(-1073741824.1), false, false, ""},
+ equalsTestCase{float64(-1073741823.9), false, false, ""},
+ equalsTestCase{complex128(-1073741823), false, false, ""},
+ equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegerLiteral() {
+ // 2^30
+ matcher := Equals(1073741824)
+ ExpectEq("1073741824", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 1073741824.
+ equalsTestCase{1073741824, true, false, ""},
+ equalsTestCase{1073741824.0, true, false, ""},
+ equalsTestCase{1073741824 + 0i, true, false, ""},
+ equalsTestCase{int(1073741824), true, false, ""},
+ equalsTestCase{uint(1073741824), true, false, ""},
+ equalsTestCase{int32(1073741824), true, false, ""},
+ equalsTestCase{int64(1073741824), true, false, ""},
+ equalsTestCase{uint32(1073741824), true, false, ""},
+ equalsTestCase{uint64(1073741824), true, false, ""},
+ equalsTestCase{uintptr(1073741824), true, false, ""},
+ equalsTestCase{float32(1073741824), true, false, ""},
+ equalsTestCase{float64(1073741824), true, false, ""},
+ equalsTestCase{complex64(1073741824), true, false, ""},
+ equalsTestCase{complex128(1073741824), true, false, ""},
+ equalsTestCase{interface{}(int(1073741824)), true, false, ""},
+ equalsTestCase{interface{}(uint(1073741824)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(1073741823), false, false, ""},
+ equalsTestCase{int32(1073741823), false, false, ""},
+ equalsTestCase{int64(1073741823), false, false, ""},
+ equalsTestCase{float64(1073741824.1), false, false, ""},
+ equalsTestCase{float64(1073741823.9), false, false, ""},
+ equalsTestCase{complex128(1073741823), false, false, ""},
+ equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Floating point literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralFloatingPointLiteral() {
+ // -2^30
+ matcher := Equals(-1073741824.0)
+ ExpectEq("-1.073741824e+09", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -1073741824.
+ equalsTestCase{-1073741824, true, false, ""},
+ equalsTestCase{-1073741824.0, true, false, ""},
+ equalsTestCase{-1073741824 + 0i, true, false, ""},
+ equalsTestCase{int(-1073741824), true, false, ""},
+ equalsTestCase{int32(-1073741824), true, false, ""},
+ equalsTestCase{int64(-1073741824), true, false, ""},
+ equalsTestCase{float32(-1073741824), true, false, ""},
+ equalsTestCase{float64(-1073741824), true, false, ""},
+ equalsTestCase{complex64(-1073741824), true, false, ""},
+ equalsTestCase{complex128(-1073741824), true, false, ""},
+ equalsTestCase{interface{}(int(-1073741824)), true, false, ""},
+ equalsTestCase{interface{}(float64(-1073741824)), true, false, ""},
+
+ // Values that would be -1073741824 in two's complement.
+ equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+ // Non-equal values of signed integer type.
+ equalsTestCase{int(-1073741823), false, false, ""},
+ equalsTestCase{int32(-1073741823), false, false, ""},
+ equalsTestCase{int64(-1073741823), false, false, ""},
+
+ // Non-equal values of other numeric types.
+ equalsTestCase{float64(-1073741824.1), false, false, ""},
+ equalsTestCase{float64(-1073741823.9), false, false, ""},
+ equalsTestCase{complex128(-1073741823), false, false, ""},
+ equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralFloatingPointLiteral() {
+ // 2^30
+ matcher := Equals(1073741824.0)
+ ExpectEq("1.073741824e+09", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 1073741824.
+ equalsTestCase{1073741824, true, false, ""},
+ equalsTestCase{1073741824.0, true, false, ""},
+ equalsTestCase{1073741824 + 0i, true, false, ""},
+ equalsTestCase{int(1073741824), true, false, ""},
+ equalsTestCase{int32(1073741824), true, false, ""},
+ equalsTestCase{int64(1073741824), true, false, ""},
+ equalsTestCase{uint(1073741824), true, false, ""},
+ equalsTestCase{uint32(1073741824), true, false, ""},
+ equalsTestCase{uint64(1073741824), true, false, ""},
+ equalsTestCase{float32(1073741824), true, false, ""},
+ equalsTestCase{float64(1073741824), true, false, ""},
+ equalsTestCase{complex64(1073741824), true, false, ""},
+ equalsTestCase{complex128(1073741824), true, false, ""},
+ equalsTestCase{interface{}(int(1073741824)), true, false, ""},
+ equalsTestCase{interface{}(float64(1073741824)), true, false, ""},
+
+ // Values that would be 1073741824 in two's complement.
+ equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(1073741823), false, false, ""},
+ equalsTestCase{int32(1073741823), false, false, ""},
+ equalsTestCase{int64(1073741823), false, false, ""},
+ equalsTestCase{uint(1073741823), false, false, ""},
+ equalsTestCase{uint32(1073741823), false, false, ""},
+ equalsTestCase{uint64(1073741823), false, false, ""},
+ equalsTestCase{float64(1073741824.1), false, false, ""},
+ equalsTestCase{float64(1073741823.9), false, false, ""},
+ equalsTestCase{complex128(1073741823), false, false, ""},
+ equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonIntegralFloatingPointLiteral() {
+ matcher := Equals(17.1)
+ ExpectEq("17.1", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 17.1.
+ equalsTestCase{17.1, true, false, ""},
+ equalsTestCase{17.1, true, false, ""},
+ equalsTestCase{17.1 + 0i, true, false, ""},
+ equalsTestCase{float32(17.1), true, false, ""},
+ equalsTestCase{float64(17.1), true, false, ""},
+ equalsTestCase{complex64(17.1), true, false, ""},
+ equalsTestCase{complex128(17.1), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{17, false, false, ""},
+ equalsTestCase{17.2, false, false, ""},
+ equalsTestCase{18, false, false, ""},
+ equalsTestCase{int(17), false, false, ""},
+ equalsTestCase{int(18), false, false, ""},
+ equalsTestCase{int32(17), false, false, ""},
+ equalsTestCase{int64(17), false, false, ""},
+ equalsTestCase{uint(17), false, false, ""},
+ equalsTestCase{uint32(17), false, false, ""},
+ equalsTestCase{uint64(17), false, false, ""},
+ equalsTestCase{uintptr(17), false, false, ""},
+ equalsTestCase{complex128(17.1 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// bool
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) False() {
+ matcher := Equals(false)
+ ExpectEq("false", matcher.Description())
+
+ cases := []equalsTestCase{
+ // bools
+ equalsTestCase{false, true, false, ""},
+ equalsTestCase{bool(false), true, false, ""},
+
+ equalsTestCase{true, false, false, ""},
+ equalsTestCase{bool(true), false, false, ""},
+
+ // Other types.
+ equalsTestCase{int(0), false, true, "which is not a bool"},
+ equalsTestCase{int8(0), false, true, "which is not a bool"},
+ equalsTestCase{int16(0), false, true, "which is not a bool"},
+ equalsTestCase{int32(0), false, true, "which is not a bool"},
+ equalsTestCase{int64(0), false, true, "which is not a bool"},
+ equalsTestCase{uint(0), false, true, "which is not a bool"},
+ equalsTestCase{uint8(0), false, true, "which is not a bool"},
+ equalsTestCase{uint16(0), false, true, "which is not a bool"},
+ equalsTestCase{uint32(0), false, true, "which is not a bool"},
+ equalsTestCase{uint64(0), false, true, "which is not a bool"},
+ equalsTestCase{uintptr(0), false, true, "which is not a bool"},
+ equalsTestCase{[...]int{}, false, true, "which is not a bool"},
+ equalsTestCase{make(chan int), false, true, "which is not a bool"},
+ equalsTestCase{func() {}, false, true, "which is not a bool"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a bool"},
+ equalsTestCase{&someInt, false, true, "which is not a bool"},
+ equalsTestCase{[]int{}, false, true, "which is not a bool"},
+ equalsTestCase{"taco", false, true, "which is not a bool"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a bool"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) True() {
+ matcher := Equals(true)
+ ExpectEq("true", matcher.Description())
+
+ cases := []equalsTestCase{
+ // bools
+ equalsTestCase{true, true, false, ""},
+ equalsTestCase{bool(true), true, false, ""},
+
+ equalsTestCase{false, false, false, ""},
+ equalsTestCase{bool(false), false, false, ""},
+
+ // Other types.
+ equalsTestCase{int(1), false, true, "which is not a bool"},
+ equalsTestCase{int8(1), false, true, "which is not a bool"},
+ equalsTestCase{int16(1), false, true, "which is not a bool"},
+ equalsTestCase{int32(1), false, true, "which is not a bool"},
+ equalsTestCase{int64(1), false, true, "which is not a bool"},
+ equalsTestCase{uint(1), false, true, "which is not a bool"},
+ equalsTestCase{uint8(1), false, true, "which is not a bool"},
+ equalsTestCase{uint16(1), false, true, "which is not a bool"},
+ equalsTestCase{uint32(1), false, true, "which is not a bool"},
+ equalsTestCase{uint64(1), false, true, "which is not a bool"},
+ equalsTestCase{uintptr(1), false, true, "which is not a bool"},
+ equalsTestCase{[...]int{}, false, true, "which is not a bool"},
+ equalsTestCase{make(chan int), false, true, "which is not a bool"},
+ equalsTestCase{func() {}, false, true, "which is not a bool"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a bool"},
+ equalsTestCase{&someInt, false, true, "which is not a bool"},
+ equalsTestCase{[]int{}, false, true, "which is not a bool"},
+ equalsTestCase{"taco", false, true, "which is not a bool"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a bool"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt() {
+ // -2^30
+ matcher := Equals(int(-1073741824))
+ ExpectEq("-1073741824", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -1073741824.
+ equalsTestCase{-1073741824, true, false, ""},
+ equalsTestCase{-1073741824.0, true, false, ""},
+ equalsTestCase{-1073741824 + 0i, true, false, ""},
+ equalsTestCase{int(-1073741824), true, false, ""},
+ equalsTestCase{int32(-1073741824), true, false, ""},
+ equalsTestCase{int64(-1073741824), true, false, ""},
+ equalsTestCase{float32(-1073741824), true, false, ""},
+ equalsTestCase{float64(-1073741824), true, false, ""},
+ equalsTestCase{complex64(-1073741824), true, false, ""},
+ equalsTestCase{complex128(-1073741824), true, false, ""},
+ equalsTestCase{interface{}(int(-1073741824)), true, false, ""},
+
+ // Values that would be -1073741824 in two's complement.
+ equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+ // Non-equal values of signed integer type.
+ equalsTestCase{int(-1073741823), false, false, ""},
+ equalsTestCase{int32(-1073741823), false, false, ""},
+ equalsTestCase{int64(-1073741823), false, false, ""},
+
+ // Non-equal values of other numeric types.
+ equalsTestCase{float64(-1073741824.1), false, false, ""},
+ equalsTestCase{float64(-1073741823.9), false, false, ""},
+ equalsTestCase{complex128(-1073741823), false, false, ""},
+ equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt() {
+ // 2^30
+ matcher := Equals(int(1073741824))
+ ExpectEq("1073741824", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 1073741824.
+ equalsTestCase{1073741824, true, false, ""},
+ equalsTestCase{1073741824.0, true, false, ""},
+ equalsTestCase{1073741824 + 0i, true, false, ""},
+ equalsTestCase{int(1073741824), true, false, ""},
+ equalsTestCase{uint(1073741824), true, false, ""},
+ equalsTestCase{int32(1073741824), true, false, ""},
+ equalsTestCase{int64(1073741824), true, false, ""},
+ equalsTestCase{uint32(1073741824), true, false, ""},
+ equalsTestCase{uint64(1073741824), true, false, ""},
+ equalsTestCase{uintptr(1073741824), true, false, ""},
+ equalsTestCase{float32(1073741824), true, false, ""},
+ equalsTestCase{float64(1073741824), true, false, ""},
+ equalsTestCase{complex64(1073741824), true, false, ""},
+ equalsTestCase{complex128(1073741824), true, false, ""},
+ equalsTestCase{interface{}(int(1073741824)), true, false, ""},
+ equalsTestCase{interface{}(uint(1073741824)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(1073741823), false, false, ""},
+ equalsTestCase{int32(1073741823), false, false, ""},
+ equalsTestCase{int64(1073741823), false, false, ""},
+ equalsTestCase{float64(1073741824.1), false, false, ""},
+ equalsTestCase{float64(1073741823.9), false, false, ""},
+ equalsTestCase{complex128(1073741823), false, false, ""},
+ equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int8
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt8() {
+ matcher := Equals(int8(-17))
+ ExpectEq("-17", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -17.
+ equalsTestCase{-17, true, false, ""},
+ equalsTestCase{-17.0, true, false, ""},
+ equalsTestCase{-17 + 0i, true, false, ""},
+ equalsTestCase{int(-17), true, false, ""},
+ equalsTestCase{int8(-17), true, false, ""},
+ equalsTestCase{int16(-17), true, false, ""},
+ equalsTestCase{int32(-17), true, false, ""},
+ equalsTestCase{int64(-17), true, false, ""},
+ equalsTestCase{float32(-17), true, false, ""},
+ equalsTestCase{float64(-17), true, false, ""},
+ equalsTestCase{complex64(-17), true, false, ""},
+ equalsTestCase{complex128(-17), true, false, ""},
+ equalsTestCase{interface{}(int(-17)), true, false, ""},
+
+ // Values that would be -17 in two's complement.
+ equalsTestCase{uint((1 << 32) - 17), false, false, ""},
+ equalsTestCase{uint8((1 << 8) - 17), false, false, ""},
+ equalsTestCase{uint16((1 << 16) - 17), false, false, ""},
+ equalsTestCase{uint32((1 << 32) - 17), false, false, ""},
+ equalsTestCase{uint64((1 << 64) - 17), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 17), false, false, ""},
+
+ // Non-equal values of signed integer type.
+ equalsTestCase{int(-16), false, false, ""},
+ equalsTestCase{int8(-16), false, false, ""},
+ equalsTestCase{int16(-16), false, false, ""},
+ equalsTestCase{int32(-16), false, false, ""},
+ equalsTestCase{int64(-16), false, false, ""},
+
+ // Non-equal values of other numeric types.
+ equalsTestCase{float32(-17.1), false, false, ""},
+ equalsTestCase{float32(-16.9), false, false, ""},
+ equalsTestCase{complex64(-16), false, false, ""},
+ equalsTestCase{complex64(-17 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{-17}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{-17}, false, true, "which is not numeric"},
+ equalsTestCase{"-17", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroInt8() {
+ matcher := Equals(int8(0))
+ ExpectEq("0", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 0.
+ equalsTestCase{0, true, false, ""},
+ equalsTestCase{0.0, true, false, ""},
+ equalsTestCase{0 + 0i, true, false, ""},
+ equalsTestCase{int(0), true, false, ""},
+ equalsTestCase{int8(0), true, false, ""},
+ equalsTestCase{int16(0), true, false, ""},
+ equalsTestCase{int32(0), true, false, ""},
+ equalsTestCase{int64(0), true, false, ""},
+ equalsTestCase{float32(0), true, false, ""},
+ equalsTestCase{float64(0), true, false, ""},
+ equalsTestCase{complex64(0), true, false, ""},
+ equalsTestCase{complex128(0), true, false, ""},
+ equalsTestCase{interface{}(int(0)), true, false, ""},
+ equalsTestCase{uint(0), true, false, ""},
+ equalsTestCase{uint8(0), true, false, ""},
+ equalsTestCase{uint16(0), true, false, ""},
+ equalsTestCase{uint32(0), true, false, ""},
+ equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(1), false, false, ""},
+ equalsTestCase{int8(1), false, false, ""},
+ equalsTestCase{int16(1), false, false, ""},
+ equalsTestCase{int32(1), false, false, ""},
+ equalsTestCase{int64(1), false, false, ""},
+ equalsTestCase{float32(-0.1), false, false, ""},
+ equalsTestCase{float32(0.1), false, false, ""},
+ equalsTestCase{complex64(1), false, false, ""},
+ equalsTestCase{complex64(0 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{0}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{0}, false, true, "which is not numeric"},
+ equalsTestCase{"0", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt8() {
+ matcher := Equals(int8(17))
+ ExpectEq("17", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 17.
+ equalsTestCase{17, true, false, ""},
+ equalsTestCase{17.0, true, false, ""},
+ equalsTestCase{17 + 0i, true, false, ""},
+ equalsTestCase{int(17), true, false, ""},
+ equalsTestCase{int8(17), true, false, ""},
+ equalsTestCase{int16(17), true, false, ""},
+ equalsTestCase{int32(17), true, false, ""},
+ equalsTestCase{int64(17), true, false, ""},
+ equalsTestCase{float32(17), true, false, ""},
+ equalsTestCase{float64(17), true, false, ""},
+ equalsTestCase{complex64(17), true, false, ""},
+ equalsTestCase{complex128(17), true, false, ""},
+ equalsTestCase{interface{}(int(17)), true, false, ""},
+ equalsTestCase{uint(17), true, false, ""},
+ equalsTestCase{uint8(17), true, false, ""},
+ equalsTestCase{uint16(17), true, false, ""},
+ equalsTestCase{uint32(17), true, false, ""},
+ equalsTestCase{uint64(17), true, false, ""},
+ equalsTestCase{uintptr(17), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(16), false, false, ""},
+ equalsTestCase{int8(16), false, false, ""},
+ equalsTestCase{int16(16), false, false, ""},
+ equalsTestCase{int32(16), false, false, ""},
+ equalsTestCase{int64(16), false, false, ""},
+ equalsTestCase{float32(16.9), false, false, ""},
+ equalsTestCase{float32(17.1), false, false, ""},
+ equalsTestCase{complex64(16), false, false, ""},
+ equalsTestCase{complex64(17 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{17}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{17}, false, true, "which is not numeric"},
+ equalsTestCase{"17", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int16
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt16() {
+ matcher := Equals(int16(-32766))
+ ExpectEq("-32766", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -32766.
+ equalsTestCase{-32766, true, false, ""},
+ equalsTestCase{-32766.0, true, false, ""},
+ equalsTestCase{-32766 + 0i, true, false, ""},
+ equalsTestCase{int(-32766), true, false, ""},
+ equalsTestCase{int16(-32766), true, false, ""},
+ equalsTestCase{int32(-32766), true, false, ""},
+ equalsTestCase{int64(-32766), true, false, ""},
+ equalsTestCase{float32(-32766), true, false, ""},
+ equalsTestCase{float64(-32766), true, false, ""},
+ equalsTestCase{complex64(-32766), true, false, ""},
+ equalsTestCase{complex128(-32766), true, false, ""},
+ equalsTestCase{interface{}(int(-32766)), true, false, ""},
+
+ // Values that would be -32766 in two's complement.
+ equalsTestCase{uint((1 << 32) - 32766), false, false, ""},
+ equalsTestCase{uint16((1 << 16) - 32766), false, false, ""},
+ equalsTestCase{uint32((1 << 32) - 32766), false, false, ""},
+ equalsTestCase{uint64((1 << 64) - 32766), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 32766), false, false, ""},
+
+ // Non-equal values of signed integer type.
+ equalsTestCase{int(-16), false, false, ""},
+ equalsTestCase{int8(-16), false, false, ""},
+ equalsTestCase{int16(-16), false, false, ""},
+ equalsTestCase{int32(-16), false, false, ""},
+ equalsTestCase{int64(-16), false, false, ""},
+
+ // Non-equal values of other numeric types.
+ equalsTestCase{float32(-32766.1), false, false, ""},
+ equalsTestCase{float32(-32765.9), false, false, ""},
+ equalsTestCase{complex64(-32766.1), false, false, ""},
+ equalsTestCase{complex64(-32766 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{-32766}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{-32766}, false, true, "which is not numeric"},
+ equalsTestCase{"-32766", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroInt16() {
+ matcher := Equals(int16(0))
+ ExpectEq("0", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 0.
+ equalsTestCase{0, true, false, ""},
+ equalsTestCase{0.0, true, false, ""},
+ equalsTestCase{0 + 0i, true, false, ""},
+ equalsTestCase{int(0), true, false, ""},
+ equalsTestCase{int8(0), true, false, ""},
+ equalsTestCase{int16(0), true, false, ""},
+ equalsTestCase{int32(0), true, false, ""},
+ equalsTestCase{int64(0), true, false, ""},
+ equalsTestCase{float32(0), true, false, ""},
+ equalsTestCase{float64(0), true, false, ""},
+ equalsTestCase{complex64(0), true, false, ""},
+ equalsTestCase{complex128(0), true, false, ""},
+ equalsTestCase{interface{}(int(0)), true, false, ""},
+ equalsTestCase{uint(0), true, false, ""},
+ equalsTestCase{uint8(0), true, false, ""},
+ equalsTestCase{uint16(0), true, false, ""},
+ equalsTestCase{uint32(0), true, false, ""},
+ equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(1), false, false, ""},
+ equalsTestCase{int8(1), false, false, ""},
+ equalsTestCase{int16(1), false, false, ""},
+ equalsTestCase{int32(1), false, false, ""},
+ equalsTestCase{int64(1), false, false, ""},
+ equalsTestCase{float32(-0.1), false, false, ""},
+ equalsTestCase{float32(0.1), false, false, ""},
+ equalsTestCase{complex64(1), false, false, ""},
+ equalsTestCase{complex64(0 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{0}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{0}, false, true, "which is not numeric"},
+ equalsTestCase{"0", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt16() {
+ matcher := Equals(int16(32765))
+ ExpectEq("32765", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 32765.
+ equalsTestCase{32765, true, false, ""},
+ equalsTestCase{32765.0, true, false, ""},
+ equalsTestCase{32765 + 0i, true, false, ""},
+ equalsTestCase{int(32765), true, false, ""},
+ equalsTestCase{int16(32765), true, false, ""},
+ equalsTestCase{int32(32765), true, false, ""},
+ equalsTestCase{int64(32765), true, false, ""},
+ equalsTestCase{float32(32765), true, false, ""},
+ equalsTestCase{float64(32765), true, false, ""},
+ equalsTestCase{complex64(32765), true, false, ""},
+ equalsTestCase{complex128(32765), true, false, ""},
+ equalsTestCase{interface{}(int(32765)), true, false, ""},
+ equalsTestCase{uint(32765), true, false, ""},
+ equalsTestCase{uint16(32765), true, false, ""},
+ equalsTestCase{uint32(32765), true, false, ""},
+ equalsTestCase{uint64(32765), true, false, ""},
+ equalsTestCase{uintptr(32765), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(32764), false, false, ""},
+ equalsTestCase{int16(32764), false, false, ""},
+ equalsTestCase{int32(32764), false, false, ""},
+ equalsTestCase{int64(32764), false, false, ""},
+ equalsTestCase{float32(32764.9), false, false, ""},
+ equalsTestCase{float32(32765.1), false, false, ""},
+ equalsTestCase{complex64(32765.9), false, false, ""},
+ equalsTestCase{complex64(32765 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{32765}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{32765}, false, true, "which is not numeric"},
+ equalsTestCase{"32765", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int32
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt32() {
+ // -2^30
+ matcher := Equals(int32(-1073741824))
+ ExpectEq("-1073741824", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -1073741824.
+ equalsTestCase{-1073741824, true, false, ""},
+ equalsTestCase{-1073741824.0, true, false, ""},
+ equalsTestCase{-1073741824 + 0i, true, false, ""},
+ equalsTestCase{int(-1073741824), true, false, ""},
+ equalsTestCase{int32(-1073741824), true, false, ""},
+ equalsTestCase{int64(-1073741824), true, false, ""},
+ equalsTestCase{float32(-1073741824), true, false, ""},
+ equalsTestCase{float64(-1073741824), true, false, ""},
+ equalsTestCase{complex64(-1073741824), true, false, ""},
+ equalsTestCase{complex128(-1073741824), true, false, ""},
+ equalsTestCase{interface{}(int(-1073741824)), true, false, ""},
+
+ // Values that would be -1073741824 in two's complement.
+ equalsTestCase{uint((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint32((1 << 32) - 1073741824), false, false, ""},
+ equalsTestCase{uint64((1 << 64) - 1073741824), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 1073741824), false, false, ""},
+
+ // Non-equal values of signed integer type.
+ equalsTestCase{int(-1073741823), false, false, ""},
+ equalsTestCase{int32(-1073741823), false, false, ""},
+ equalsTestCase{int64(-1073741823), false, false, ""},
+
+ // Non-equal values of other numeric types.
+ equalsTestCase{float64(-1073741824.1), false, false, ""},
+ equalsTestCase{float64(-1073741823.9), false, false, ""},
+ equalsTestCase{complex128(-1073741823), false, false, ""},
+ equalsTestCase{complex128(-1073741824 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt32() {
+ // 2^30
+ matcher := Equals(int32(1073741824))
+ ExpectEq("1073741824", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 1073741824.
+ equalsTestCase{1073741824, true, false, ""},
+ equalsTestCase{1073741824.0, true, false, ""},
+ equalsTestCase{1073741824 + 0i, true, false, ""},
+ equalsTestCase{int(1073741824), true, false, ""},
+ equalsTestCase{uint(1073741824), true, false, ""},
+ equalsTestCase{int32(1073741824), true, false, ""},
+ equalsTestCase{int64(1073741824), true, false, ""},
+ equalsTestCase{uint32(1073741824), true, false, ""},
+ equalsTestCase{uint64(1073741824), true, false, ""},
+ equalsTestCase{uintptr(1073741824), true, false, ""},
+ equalsTestCase{float32(1073741824), true, false, ""},
+ equalsTestCase{float64(1073741824), true, false, ""},
+ equalsTestCase{complex64(1073741824), true, false, ""},
+ equalsTestCase{complex128(1073741824), true, false, ""},
+ equalsTestCase{interface{}(int(1073741824)), true, false, ""},
+ equalsTestCase{interface{}(uint(1073741824)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(1073741823), false, false, ""},
+ equalsTestCase{int32(1073741823), false, false, ""},
+ equalsTestCase{int64(1073741823), false, false, ""},
+ equalsTestCase{float64(1073741824.1), false, false, ""},
+ equalsTestCase{float64(1073741823.9), false, false, ""},
+ equalsTestCase{complex128(1073741823), false, false, ""},
+ equalsTestCase{complex128(1073741824 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// int64
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeInt64() {
+ // -2^40
+ matcher := Equals(int64(-1099511627776))
+ ExpectEq("-1099511627776", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -1099511627776.
+ equalsTestCase{-1099511627776.0, true, false, ""},
+ equalsTestCase{-1099511627776 + 0i, true, false, ""},
+ equalsTestCase{int64(-1099511627776), true, false, ""},
+ equalsTestCase{float32(-1099511627776), true, false, ""},
+ equalsTestCase{float64(-1099511627776), true, false, ""},
+ equalsTestCase{complex64(-1099511627776), true, false, ""},
+ equalsTestCase{complex128(-1099511627776), true, false, ""},
+ equalsTestCase{interface{}(int64(-1099511627776)), true, false, ""},
+
+ // Values that would be -1099511627776 in two's complement.
+ equalsTestCase{uint64((1 << 64) - 1099511627776), false, false, ""},
+
+ // Non-equal values of signed integer type.
+ equalsTestCase{int64(-1099511627775), false, false, ""},
+
+ // Non-equal values of other numeric types.
+ equalsTestCase{float64(-1099511627776.1), false, false, ""},
+ equalsTestCase{float64(-1099511627775.9), false, false, ""},
+ equalsTestCase{complex128(-1099511627775), false, false, ""},
+ equalsTestCase{complex128(-1099511627776 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveInt64() {
+ // 2^40
+ matcher := Equals(int64(1099511627776))
+ ExpectEq("1099511627776", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 1099511627776.
+ equalsTestCase{1099511627776.0, true, false, ""},
+ equalsTestCase{1099511627776 + 0i, true, false, ""},
+ equalsTestCase{int64(1099511627776), true, false, ""},
+ equalsTestCase{uint64(1099511627776), true, false, ""},
+ equalsTestCase{uintptr(1099511627776), true, false, ""},
+ equalsTestCase{float32(1099511627776), true, false, ""},
+ equalsTestCase{float64(1099511627776), true, false, ""},
+ equalsTestCase{complex64(1099511627776), true, false, ""},
+ equalsTestCase{complex128(1099511627776), true, false, ""},
+ equalsTestCase{interface{}(int64(1099511627776)), true, false, ""},
+ equalsTestCase{interface{}(uint64(1099511627776)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(1099511627775), false, false, ""},
+ equalsTestCase{uint64(1099511627775), false, false, ""},
+ equalsTestCase{float64(1099511627776.1), false, false, ""},
+ equalsTestCase{float64(1099511627775.9), false, false, ""},
+ equalsTestCase{complex128(1099511627775), false, false, ""},
+ equalsTestCase{complex128(1099511627776 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Int64NotExactlyRepresentableBySinglePrecision() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := Equals(int64(kTwoTo25 + 1))
+ ExpectEq("33554433", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+ // Single-precision floating point.
+ equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 2), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Int64NotExactlyRepresentableByDoublePrecision() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := Equals(int64(kTwoTo54 + 1))
+ ExpectEq("18014398509481985", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo54 + 0), false, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 2), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{float64(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 3), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint() {
+ const kExpected = 17
+ matcher := Equals(uint(kExpected))
+ ExpectEq("17", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{17, true, false, ""},
+ equalsTestCase{17.0, true, false, ""},
+ equalsTestCase{17 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int8(kExpected), true, false, ""},
+ equalsTestCase{int16(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint8(kExpected), true, false, ""},
+ equalsTestCase{uint16(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{kExpected + 1, false, false, ""},
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int8(kExpected + 1), false, false, ""},
+ equalsTestCase{int16(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint8(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUint() {
+ const kExpected = (1 << 16) + 17
+ matcher := Equals(uint(kExpected))
+ ExpectEq("65553", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{65553, true, false, ""},
+ equalsTestCase{65553.0, true, false, ""},
+ equalsTestCase{65553 + 0i, true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{int16(17), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(17), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) UintNotExactlyRepresentableBySinglePrecision() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := Equals(uint(kTwoTo25 + 1))
+ ExpectEq("33554433", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+ // Single-precision floating point.
+ equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 2), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint8
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint8() {
+ const kExpected = 17
+ matcher := Equals(uint8(kExpected))
+ ExpectEq("17", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{17, true, false, ""},
+ equalsTestCase{17.0, true, false, ""},
+ equalsTestCase{17 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int8(kExpected), true, false, ""},
+ equalsTestCase{int16(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint8(kExpected), true, false, ""},
+ equalsTestCase{uint16(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{kExpected + 1, false, false, ""},
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int8(kExpected + 1), false, false, ""},
+ equalsTestCase{int16(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint8(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint16
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint16() {
+ const kExpected = 17
+ matcher := Equals(uint16(kExpected))
+ ExpectEq("17", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{17, true, false, ""},
+ equalsTestCase{17.0, true, false, ""},
+ equalsTestCase{17 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int8(kExpected), true, false, ""},
+ equalsTestCase{int16(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint8(kExpected), true, false, ""},
+ equalsTestCase{uint16(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{kExpected + 1, false, false, ""},
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int8(kExpected + 1), false, false, ""},
+ equalsTestCase{int16(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint8(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUint16() {
+ const kExpected = (1 << 8) + 17
+ matcher := Equals(uint16(kExpected))
+ ExpectEq("273", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{273, true, false, ""},
+ equalsTestCase{273.0, true, false, ""},
+ equalsTestCase{273 + 0i, true, false, ""},
+ equalsTestCase{int16(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint16(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{int8(17), false, false, ""},
+ equalsTestCase{int16(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint8(17), false, false, ""},
+ equalsTestCase{uint16(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint32
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint32() {
+ const kExpected = 17
+ matcher := Equals(uint32(kExpected))
+ ExpectEq("17", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{17, true, false, ""},
+ equalsTestCase{17.0, true, false, ""},
+ equalsTestCase{17 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int8(kExpected), true, false, ""},
+ equalsTestCase{int16(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint8(kExpected), true, false, ""},
+ equalsTestCase{uint16(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{kExpected + 1, false, false, ""},
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int8(kExpected + 1), false, false, ""},
+ equalsTestCase{int16(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint8(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUint32() {
+ const kExpected = (1 << 16) + 17
+ matcher := Equals(uint32(kExpected))
+ ExpectEq("65553", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{65553, true, false, ""},
+ equalsTestCase{65553.0, true, false, ""},
+ equalsTestCase{65553 + 0i, true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{int16(17), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(17), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Uint32NotExactlyRepresentableBySinglePrecision() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := Equals(uint32(kTwoTo25 + 1))
+ ExpectEq("33554433", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+ // Single-precision floating point.
+ equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 2), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uint64
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUint64() {
+ const kExpected = 17
+ matcher := Equals(uint64(kExpected))
+ ExpectEq("17", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{17, true, false, ""},
+ equalsTestCase{17.0, true, false, ""},
+ equalsTestCase{17 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int8(kExpected), true, false, ""},
+ equalsTestCase{int16(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint8(kExpected), true, false, ""},
+ equalsTestCase{uint16(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{kExpected + 1, false, false, ""},
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int8(kExpected + 1), false, false, ""},
+ equalsTestCase{int16(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint8(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUint64() {
+ const kExpected = (1 << 32) + 17
+ matcher := Equals(uint64(kExpected))
+ ExpectEq("4294967313", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{4294967313.0, true, false, ""},
+ equalsTestCase{4294967313 + 0i, true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{int(17), false, false, ""},
+ equalsTestCase{int32(17), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(17), false, false, ""},
+ equalsTestCase{uint32(17), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Uint64NotExactlyRepresentableBySinglePrecision() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := Equals(uint64(kTwoTo25 + 1))
+ ExpectEq("33554433", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 2), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+
+ // Single-precision floating point.
+ equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 2), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo25 + 0), false, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 2), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Uint64NotExactlyRepresentableByDoublePrecision() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := Equals(uint64(kTwoTo54 + 1))
+ ExpectEq("18014398509481985", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo54 + 0), false, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 2), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{float64(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 3), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// uintptr
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) SmallUintptr() {
+ const kExpected = 17
+ matcher := Equals(uintptr(kExpected))
+ ExpectEq("17", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{17, true, false, ""},
+ equalsTestCase{17.0, true, false, ""},
+ equalsTestCase{17 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int8(kExpected), true, false, ""},
+ equalsTestCase{int16(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint8(kExpected), true, false, ""},
+ equalsTestCase{uint16(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{kExpected + 1, false, false, ""},
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int8(kExpected + 1), false, false, ""},
+ equalsTestCase{int16(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint8(kExpected + 1), false, false, ""},
+ equalsTestCase{uint16(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeUintptr() {
+ const kExpected = (1 << 32) + 17
+ matcher := Equals(uintptr(kExpected))
+ ExpectEq("4294967313", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{4294967313.0, true, false, ""},
+ equalsTestCase{4294967313 + 0i, true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric types.
+ equalsTestCase{int(17), false, false, ""},
+ equalsTestCase{int32(17), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(17), false, false, ""},
+ equalsTestCase{uint32(17), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected + 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 1), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// float32
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralFloat32() {
+ matcher := Equals(float32(-32769))
+ ExpectEq("-32769", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -32769.
+ equalsTestCase{-32769.0, true, false, ""},
+ equalsTestCase{-32769 + 0i, true, false, ""},
+ equalsTestCase{int32(-32769), true, false, ""},
+ equalsTestCase{int64(-32769), true, false, ""},
+ equalsTestCase{float32(-32769), true, false, ""},
+ equalsTestCase{float64(-32769), true, false, ""},
+ equalsTestCase{complex64(-32769), true, false, ""},
+ equalsTestCase{complex128(-32769), true, false, ""},
+ equalsTestCase{interface{}(float32(-32769)), true, false, ""},
+ equalsTestCase{interface{}(int64(-32769)), true, false, ""},
+
+ // Values that would be -32769 in two's complement.
+ equalsTestCase{uint64((1 << 64) - 32769), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) - 32769), false, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(-32770), false, false, ""},
+ equalsTestCase{float32(-32769.1), false, false, ""},
+ equalsTestCase{float32(-32768.9), false, false, ""},
+ equalsTestCase{float64(-32769.1), false, false, ""},
+ equalsTestCase{float64(-32768.9), false, false, ""},
+ equalsTestCase{complex128(-32768), false, false, ""},
+ equalsTestCase{complex128(-32769 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NegativeNonIntegralFloat32() {
+ matcher := Equals(float32(-32769.1))
+ ExpectEq("-32769.1", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of -32769.1.
+ equalsTestCase{-32769.1, true, false, ""},
+ equalsTestCase{-32769.1 + 0i, true, false, ""},
+ equalsTestCase{float32(-32769.1), true, false, ""},
+ equalsTestCase{float64(-32769.1), true, false, ""},
+ equalsTestCase{complex64(-32769.1), true, false, ""},
+ equalsTestCase{complex128(-32769.1), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int32(-32769), false, false, ""},
+ equalsTestCase{int32(-32770), false, false, ""},
+ equalsTestCase{int64(-32769), false, false, ""},
+ equalsTestCase{int64(-32770), false, false, ""},
+ equalsTestCase{float32(-32769.2), false, false, ""},
+ equalsTestCase{float32(-32769.0), false, false, ""},
+ equalsTestCase{float64(-32769.2), false, false, ""},
+ equalsTestCase{complex128(-32769.1 + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeNegativeFloat32() {
+ const kExpected = -1 * (1 << 65)
+ matcher := Equals(float32(kExpected))
+ ExpectEq("-3.689349e+19", matcher.Description())
+
+ floatExpected := float32(kExpected)
+ castedInt := int64(floatExpected)
+
+ cases := []equalsTestCase{
+ // Equal values of numeric type.
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{castedInt, false, false, ""},
+ equalsTestCase{int64(0), false, false, ""},
+ equalsTestCase{int64(math.MinInt64), false, false, ""},
+ equalsTestCase{int64(math.MaxInt64), false, false, ""},
+ equalsTestCase{float32(kExpected / 2), false, false, ""},
+ equalsTestCase{float64(kExpected / 2), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroFloat32() {
+ matcher := Equals(float32(0))
+ ExpectEq("0", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of zero.
+ equalsTestCase{0.0, true, false, ""},
+ equalsTestCase{0 + 0i, true, false, ""},
+ equalsTestCase{int(0), true, false, ""},
+ equalsTestCase{int8(0), true, false, ""},
+ equalsTestCase{int16(0), true, false, ""},
+ equalsTestCase{int32(0), true, false, ""},
+ equalsTestCase{int64(0), true, false, ""},
+ equalsTestCase{uint(0), true, false, ""},
+ equalsTestCase{uint8(0), true, false, ""},
+ equalsTestCase{uint16(0), true, false, ""},
+ equalsTestCase{uint32(0), true, false, ""},
+ equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
+ equalsTestCase{float32(0), true, false, ""},
+ equalsTestCase{float64(0), true, false, ""},
+ equalsTestCase{complex64(0), true, false, ""},
+ equalsTestCase{complex128(0), true, false, ""},
+ equalsTestCase{interface{}(float32(0)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(1), false, false, ""},
+ equalsTestCase{int64(-1), false, false, ""},
+ equalsTestCase{float32(1), false, false, ""},
+ equalsTestCase{float32(-1), false, false, ""},
+ equalsTestCase{complex128(0 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralFloat32() {
+ matcher := Equals(float32(32769))
+ ExpectEq("32769", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 32769.
+ equalsTestCase{32769.0, true, false, ""},
+ equalsTestCase{32769 + 0i, true, false, ""},
+ equalsTestCase{int(32769), true, false, ""},
+ equalsTestCase{int32(32769), true, false, ""},
+ equalsTestCase{int64(32769), true, false, ""},
+ equalsTestCase{uint(32769), true, false, ""},
+ equalsTestCase{uint32(32769), true, false, ""},
+ equalsTestCase{uint64(32769), true, false, ""},
+ equalsTestCase{uintptr(32769), true, false, ""},
+ equalsTestCase{float32(32769), true, false, ""},
+ equalsTestCase{float64(32769), true, false, ""},
+ equalsTestCase{complex64(32769), true, false, ""},
+ equalsTestCase{complex128(32769), true, false, ""},
+ equalsTestCase{interface{}(float32(32769)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(32770), false, false, ""},
+ equalsTestCase{uint64(32770), false, false, ""},
+ equalsTestCase{float32(32769.1), false, false, ""},
+ equalsTestCase{float32(32768.9), false, false, ""},
+ equalsTestCase{float64(32769.1), false, false, ""},
+ equalsTestCase{float64(32768.9), false, false, ""},
+ equalsTestCase{complex128(32768), false, false, ""},
+ equalsTestCase{complex128(32769 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveNonIntegralFloat32() {
+ matcher := Equals(float32(32769.1))
+ ExpectEq("32769.1", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 32769.1.
+ equalsTestCase{32769.1, true, false, ""},
+ equalsTestCase{32769.1 + 0i, true, false, ""},
+ equalsTestCase{float32(32769.1), true, false, ""},
+ equalsTestCase{float64(32769.1), true, false, ""},
+ equalsTestCase{complex64(32769.1), true, false, ""},
+ equalsTestCase{complex128(32769.1), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int32(32769), false, false, ""},
+ equalsTestCase{int32(32770), false, false, ""},
+ equalsTestCase{uint64(32769), false, false, ""},
+ equalsTestCase{uint64(32770), false, false, ""},
+ equalsTestCase{float32(32769.2), false, false, ""},
+ equalsTestCase{float32(32769.0), false, false, ""},
+ equalsTestCase{float64(32769.2), false, false, ""},
+ equalsTestCase{complex128(32769.1 + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargePositiveFloat32() {
+ const kExpected = 1 << 65
+ matcher := Equals(float32(kExpected))
+ ExpectEq("3.689349e+19", matcher.Description())
+
+ floatExpected := float32(kExpected)
+ castedInt := uint64(floatExpected)
+
+ cases := []equalsTestCase{
+ // Equal values of numeric type.
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{castedInt, false, false, ""},
+ equalsTestCase{int64(0), false, false, ""},
+ equalsTestCase{int64(math.MinInt64), false, false, ""},
+ equalsTestCase{int64(math.MaxInt64), false, false, ""},
+ equalsTestCase{uint64(0), false, false, ""},
+ equalsTestCase{uint64(math.MaxUint64), false, false, ""},
+ equalsTestCase{float32(kExpected / 2), false, false, ""},
+ equalsTestCase{float64(kExpected / 2), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Float32AboveExactIntegerRange() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := Equals(float32(kTwoTo25 + 1))
+ ExpectEq("3.3554432e+07", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{int64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{uint64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 3), false, false, ""},
+
+ // Single-precision floating point.
+ equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{float64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{complex128(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 3), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// float64
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralFloat64() {
+ const kExpected = -(1 << 50)
+ matcher := Equals(float64(kExpected))
+ ExpectEq("-1.125899906842624e+15", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{-1125899906842624.0, true, false, ""},
+ equalsTestCase{-1125899906842624.0 + 0i, true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+ equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+ // Values that would be kExpected in two's complement.
+ equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NegativeNonIntegralFloat64() {
+ const kTwoTo50 = 1 << 50
+ const kExpected = -kTwoTo50 - 0.25
+
+ matcher := Equals(float64(kExpected))
+ ExpectEq("-1.1258999068426242e+15", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{kExpected, true, false, ""},
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(-kTwoTo50), false, false, ""},
+ equalsTestCase{int64(-kTwoTo50 - 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeNegativeFloat64() {
+ const kExpected = -1 * (1 << 65)
+ matcher := Equals(float64(kExpected))
+ ExpectEq("-3.6893488147419103e+19", matcher.Description())
+
+ floatExpected := float64(kExpected)
+ castedInt := int64(floatExpected)
+
+ cases := []equalsTestCase{
+ // Equal values of numeric type.
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{castedInt, false, false, ""},
+ equalsTestCase{int64(0), false, false, ""},
+ equalsTestCase{int64(math.MinInt64), false, false, ""},
+ equalsTestCase{int64(math.MaxInt64), false, false, ""},
+ equalsTestCase{float32(kExpected / 2), false, false, ""},
+ equalsTestCase{float64(kExpected / 2), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroFloat64() {
+ matcher := Equals(float64(0))
+ ExpectEq("0", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of zero.
+ equalsTestCase{0.0, true, false, ""},
+ equalsTestCase{0 + 0i, true, false, ""},
+ equalsTestCase{int(0), true, false, ""},
+ equalsTestCase{int8(0), true, false, ""},
+ equalsTestCase{int16(0), true, false, ""},
+ equalsTestCase{int32(0), true, false, ""},
+ equalsTestCase{int64(0), true, false, ""},
+ equalsTestCase{uint(0), true, false, ""},
+ equalsTestCase{uint8(0), true, false, ""},
+ equalsTestCase{uint16(0), true, false, ""},
+ equalsTestCase{uint32(0), true, false, ""},
+ equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
+ equalsTestCase{float32(0), true, false, ""},
+ equalsTestCase{float64(0), true, false, ""},
+ equalsTestCase{complex64(0), true, false, ""},
+ equalsTestCase{complex128(0), true, false, ""},
+ equalsTestCase{interface{}(float32(0)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(1), false, false, ""},
+ equalsTestCase{int64(-1), false, false, ""},
+ equalsTestCase{float32(1), false, false, ""},
+ equalsTestCase{float32(-1), false, false, ""},
+ equalsTestCase{complex128(0 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralFloat64() {
+ const kExpected = 1 << 50
+ matcher := Equals(float64(kExpected))
+ ExpectEq("1.125899906842624e+15", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 32769.
+ equalsTestCase{1125899906842624.0, true, false, ""},
+ equalsTestCase{1125899906842624.0 + 0i, true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+ equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveNonIntegralFloat64() {
+ const kTwoTo50 = 1 << 50
+ const kExpected = kTwoTo50 + 0.25
+ matcher := Equals(float64(kExpected))
+ ExpectEq("1.1258999068426242e+15", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{kExpected, true, false, ""},
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(kTwoTo50), false, false, ""},
+ equalsTestCase{int64(kTwoTo50 - 1), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargePositiveFloat64() {
+ const kExpected = 1 << 65
+ matcher := Equals(float64(kExpected))
+ ExpectEq("3.6893488147419103e+19", matcher.Description())
+
+ floatExpected := float64(kExpected)
+ castedInt := uint64(floatExpected)
+
+ cases := []equalsTestCase{
+ // Equal values of numeric type.
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{castedInt, false, false, ""},
+ equalsTestCase{int64(0), false, false, ""},
+ equalsTestCase{int64(math.MinInt64), false, false, ""},
+ equalsTestCase{int64(math.MaxInt64), false, false, ""},
+ equalsTestCase{uint64(0), false, false, ""},
+ equalsTestCase{uint64(math.MaxUint64), false, false, ""},
+ equalsTestCase{float32(kExpected / 2), false, false, ""},
+ equalsTestCase{float64(kExpected / 2), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Float64AboveExactIntegerRange() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := Equals(float64(kTwoTo54 + 1))
+ ExpectEq("1.8014398509481984e+16", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{int64(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 3), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 3), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{float64(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 3), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// complex64
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralComplex64() {
+ const kExpected = -32769
+ matcher := Equals(complex64(kExpected))
+ ExpectEq("(-32769+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{-32769.0, true, false, ""},
+ equalsTestCase{-32769.0 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+ equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+ // Values that would be kExpected in two's complement.
+ equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""},
+ equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) + kExpected), false, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+ equalsTestCase{complex64(kExpected - 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NegativeNonIntegralComplex64() {
+ const kTwoTo20 = 1 << 20
+ const kExpected = -kTwoTo20 - 0.25
+
+ matcher := Equals(complex64(kExpected))
+ ExpectEq("(-1.0485762e+06+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{kExpected, true, false, ""},
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(-kTwoTo20), false, false, ""},
+ equalsTestCase{int(-kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{int32(-kTwoTo20), false, false, ""},
+ equalsTestCase{int32(-kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{int64(-kTwoTo20), false, false, ""},
+ equalsTestCase{int64(-kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+ equalsTestCase{complex64(kExpected - 0.75), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected - 0.75), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeNegativeComplex64() {
+ const kExpected = -1 * (1 << 65)
+ matcher := Equals(complex64(kExpected))
+ ExpectEq("(-3.689349e+19+0i)", matcher.Description())
+
+ floatExpected := float64(kExpected)
+ castedInt := int64(floatExpected)
+
+ cases := []equalsTestCase{
+ // Equal values of numeric type.
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{castedInt, false, false, ""},
+ equalsTestCase{int64(0), false, false, ""},
+ equalsTestCase{int64(math.MinInt64), false, false, ""},
+ equalsTestCase{int64(math.MaxInt64), false, false, ""},
+ equalsTestCase{float32(kExpected / 2), false, false, ""},
+ equalsTestCase{float64(kExpected / 2), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroComplex64() {
+ matcher := Equals(complex64(0))
+ ExpectEq("(0+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of zero.
+ equalsTestCase{0.0, true, false, ""},
+ equalsTestCase{0 + 0i, true, false, ""},
+ equalsTestCase{int(0), true, false, ""},
+ equalsTestCase{int8(0), true, false, ""},
+ equalsTestCase{int16(0), true, false, ""},
+ equalsTestCase{int32(0), true, false, ""},
+ equalsTestCase{int64(0), true, false, ""},
+ equalsTestCase{uint(0), true, false, ""},
+ equalsTestCase{uint8(0), true, false, ""},
+ equalsTestCase{uint16(0), true, false, ""},
+ equalsTestCase{uint32(0), true, false, ""},
+ equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
+ equalsTestCase{float32(0), true, false, ""},
+ equalsTestCase{float64(0), true, false, ""},
+ equalsTestCase{complex64(0), true, false, ""},
+ equalsTestCase{complex128(0), true, false, ""},
+ equalsTestCase{interface{}(float32(0)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(1), false, false, ""},
+ equalsTestCase{int64(-1), false, false, ""},
+ equalsTestCase{float32(1), false, false, ""},
+ equalsTestCase{float32(-1), false, false, ""},
+ equalsTestCase{float64(1), false, false, ""},
+ equalsTestCase{float64(-1), false, false, ""},
+ equalsTestCase{complex64(0 + 2i), false, false, ""},
+ equalsTestCase{complex128(0 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralComplex64() {
+ const kExpected = 1 << 20
+ matcher := Equals(complex64(kExpected))
+ ExpectEq("(1.048576e+06+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 32769.
+ equalsTestCase{1048576.0, true, false, ""},
+ equalsTestCase{1048576.0 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+ equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveNonIntegralComplex64() {
+ const kTwoTo20 = 1 << 20
+ const kExpected = kTwoTo20 + 0.25
+ matcher := Equals(complex64(kExpected))
+ ExpectEq("(1.0485762e+06+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{kExpected, true, false, ""},
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(kTwoTo20), false, false, ""},
+ equalsTestCase{int64(kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{uint64(kTwoTo20), false, false, ""},
+ equalsTestCase{uint64(kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{float32(kExpected - 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+ equalsTestCase{complex64(kExpected - 1), false, false, ""},
+ equalsTestCase{complex64(kExpected - 1i), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargePositiveComplex64() {
+ const kExpected = 1 << 65
+ matcher := Equals(complex64(kExpected))
+ ExpectEq("(3.689349e+19+0i)", matcher.Description())
+
+ floatExpected := float64(kExpected)
+ castedInt := uint64(floatExpected)
+
+ cases := []equalsTestCase{
+ // Equal values of numeric type.
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{castedInt, false, false, ""},
+ equalsTestCase{int64(0), false, false, ""},
+ equalsTestCase{int64(math.MinInt64), false, false, ""},
+ equalsTestCase{int64(math.MaxInt64), false, false, ""},
+ equalsTestCase{uint64(0), false, false, ""},
+ equalsTestCase{uint64(math.MaxUint64), false, false, ""},
+ equalsTestCase{float32(kExpected / 2), false, false, ""},
+ equalsTestCase{float64(kExpected / 2), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Complex64AboveExactIntegerRange() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := Equals(complex64(kTwoTo25 + 1))
+ ExpectEq("(3.3554432e+07+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{int64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{int64(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{uint64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{uint64(kTwoTo25 + 3), false, false, ""},
+
+ // Single-precision floating point.
+ equalsTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{float32(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{complex64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{complex64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{complex64(kTwoTo25 + 3), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{float64(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{float64(kTwoTo25 + 3), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo25 - 2), false, false, ""},
+ equalsTestCase{complex128(kTwoTo25 - 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 0), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 2), true, false, ""},
+ equalsTestCase{complex128(kTwoTo25 + 3), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Complex64WithNonZeroImaginaryPart() {
+ const kRealPart = 17
+ const kImagPart = 0.25i
+ const kExpected = kRealPart + kImagPart
+ matcher := Equals(complex64(kExpected))
+ ExpectEq("(17+0.25i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{kExpected, true, false, ""},
+ equalsTestCase{kRealPart + kImagPart, true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(kRealPart), false, false, ""},
+ equalsTestCase{int8(kRealPart), false, false, ""},
+ equalsTestCase{int16(kRealPart), false, false, ""},
+ equalsTestCase{int32(kRealPart), false, false, ""},
+ equalsTestCase{int64(kRealPart), false, false, ""},
+ equalsTestCase{uint(kRealPart), false, false, ""},
+ equalsTestCase{uint8(kRealPart), false, false, ""},
+ equalsTestCase{uint16(kRealPart), false, false, ""},
+ equalsTestCase{uint32(kRealPart), false, false, ""},
+ equalsTestCase{uint64(kRealPart), false, false, ""},
+ equalsTestCase{float32(kRealPart), false, false, ""},
+ equalsTestCase{float64(kRealPart), false, false, ""},
+ equalsTestCase{complex64(kRealPart), false, false, ""},
+ equalsTestCase{complex64(kRealPart + kImagPart + 0.5), false, false, ""},
+ equalsTestCase{complex64(kRealPart + kImagPart + 0.5i), false, false, ""},
+ equalsTestCase{complex128(kRealPart), false, false, ""},
+ equalsTestCase{complex128(kRealPart + kImagPart + 0.5), false, false, ""},
+ equalsTestCase{complex128(kRealPart + kImagPart + 0.5i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// complex128
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NegativeIntegralComplex128() {
+ const kExpected = -32769
+ matcher := Equals(complex128(kExpected))
+ ExpectEq("(-32769+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{-32769.0, true, false, ""},
+ equalsTestCase{-32769.0 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+ equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+ // Values that would be kExpected in two's complement.
+ equalsTestCase{uint32((1 << 32) + kExpected), false, false, ""},
+ equalsTestCase{uint64((1 << 64) + kExpected), false, false, ""},
+ equalsTestCase{uintptr((1 << 64) + kExpected), false, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+ equalsTestCase{complex64(kExpected - 1), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NegativeNonIntegralComplex128() {
+ const kTwoTo20 = 1 << 20
+ const kExpected = -kTwoTo20 - 0.25
+
+ matcher := Equals(complex128(kExpected))
+ ExpectEq("(-1.04857625e+06+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{kExpected, true, false, ""},
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(-kTwoTo20), false, false, ""},
+ equalsTestCase{int(-kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{int32(-kTwoTo20), false, false, ""},
+ equalsTestCase{int32(-kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{int64(-kTwoTo20), false, false, ""},
+ equalsTestCase{int64(-kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+ equalsTestCase{complex64(kExpected - 0.75), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected - 0.75), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargeNegativeComplex128() {
+ const kExpected = -1 * (1 << 65)
+ matcher := Equals(complex128(kExpected))
+ ExpectEq("(-3.6893488147419103e+19+0i)", matcher.Description())
+
+ floatExpected := float64(kExpected)
+ castedInt := int64(floatExpected)
+
+ cases := []equalsTestCase{
+ // Equal values of numeric type.
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{castedInt, false, false, ""},
+ equalsTestCase{int64(0), false, false, ""},
+ equalsTestCase{int64(math.MinInt64), false, false, ""},
+ equalsTestCase{int64(math.MaxInt64), false, false, ""},
+ equalsTestCase{float32(kExpected / 2), false, false, ""},
+ equalsTestCase{float64(kExpected / 2), false, false, ""},
+ equalsTestCase{complex64(kExpected + 2i), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ZeroComplex128() {
+ matcher := Equals(complex128(0))
+ ExpectEq("(0+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of zero.
+ equalsTestCase{0.0, true, false, ""},
+ equalsTestCase{0 + 0i, true, false, ""},
+ equalsTestCase{int(0), true, false, ""},
+ equalsTestCase{int8(0), true, false, ""},
+ equalsTestCase{int16(0), true, false, ""},
+ equalsTestCase{int32(0), true, false, ""},
+ equalsTestCase{int64(0), true, false, ""},
+ equalsTestCase{uint(0), true, false, ""},
+ equalsTestCase{uint8(0), true, false, ""},
+ equalsTestCase{uint16(0), true, false, ""},
+ equalsTestCase{uint32(0), true, false, ""},
+ equalsTestCase{uint64(0), true, false, ""},
+ equalsTestCase{uintptr(0), true, false, ""},
+ equalsTestCase{float32(0), true, false, ""},
+ equalsTestCase{float64(0), true, false, ""},
+ equalsTestCase{complex64(0), true, false, ""},
+ equalsTestCase{complex128(0), true, false, ""},
+ equalsTestCase{interface{}(float32(0)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(1), false, false, ""},
+ equalsTestCase{int64(-1), false, false, ""},
+ equalsTestCase{float32(1), false, false, ""},
+ equalsTestCase{float32(-1), false, false, ""},
+ equalsTestCase{float64(1), false, false, ""},
+ equalsTestCase{float64(-1), false, false, ""},
+ equalsTestCase{complex64(0 + 2i), false, false, ""},
+ equalsTestCase{complex128(0 + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveIntegralComplex128() {
+ const kExpected = 1 << 20
+ matcher := Equals(complex128(kExpected))
+ ExpectEq("(1.048576e+06+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of 32769.
+ equalsTestCase{1048576.0, true, false, ""},
+ equalsTestCase{1048576.0 + 0i, true, false, ""},
+ equalsTestCase{int(kExpected), true, false, ""},
+ equalsTestCase{int32(kExpected), true, false, ""},
+ equalsTestCase{int64(kExpected), true, false, ""},
+ equalsTestCase{uint(kExpected), true, false, ""},
+ equalsTestCase{uint32(kExpected), true, false, ""},
+ equalsTestCase{uint64(kExpected), true, false, ""},
+ equalsTestCase{uintptr(kExpected), true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+ equalsTestCase{interface{}(float64(kExpected)), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(kExpected + 1), false, false, ""},
+ equalsTestCase{int32(kExpected + 1), false, false, ""},
+ equalsTestCase{int64(kExpected + 1), false, false, ""},
+ equalsTestCase{uint(kExpected + 1), false, false, ""},
+ equalsTestCase{uint32(kExpected + 1), false, false, ""},
+ equalsTestCase{uint64(kExpected + 1), false, false, ""},
+ equalsTestCase{uintptr(kExpected + 1), false, false, ""},
+ equalsTestCase{float32(kExpected - (1 << 30)), false, false, ""},
+ equalsTestCase{float32(kExpected + (1 << 30)), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.5), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.5), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+
+ // Non-numeric types.
+ equalsTestCase{true, false, true, "which is not numeric"},
+ equalsTestCase{[...]int{}, false, true, "which is not numeric"},
+ equalsTestCase{make(chan int), false, true, "which is not numeric"},
+ equalsTestCase{func() {}, false, true, "which is not numeric"},
+ equalsTestCase{map[int]int{}, false, true, "which is not numeric"},
+ equalsTestCase{&someInt, false, true, "which is not numeric"},
+ equalsTestCase{[]int{}, false, true, "which is not numeric"},
+ equalsTestCase{"taco", false, true, "which is not numeric"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not numeric"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) PositiveNonIntegralComplex128() {
+ const kTwoTo20 = 1 << 20
+ const kExpected = kTwoTo20 + 0.25
+ matcher := Equals(complex128(kExpected))
+ ExpectEq("(1.04857625e+06+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{kExpected, true, false, ""},
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int64(kTwoTo20), false, false, ""},
+ equalsTestCase{int64(kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{uint64(kTwoTo20), false, false, ""},
+ equalsTestCase{uint64(kTwoTo20 - 1), false, false, ""},
+ equalsTestCase{float32(kExpected - 1), false, false, ""},
+ equalsTestCase{float32(kExpected + 1), false, false, ""},
+ equalsTestCase{float64(kExpected - 0.25), false, false, ""},
+ equalsTestCase{float64(kExpected + 0.25), false, false, ""},
+ equalsTestCase{complex64(kExpected - 1), false, false, ""},
+ equalsTestCase{complex64(kExpected - 1i), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1), false, false, ""},
+ equalsTestCase{complex128(kExpected - 1i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) LargePositiveComplex128() {
+ const kExpected = 1 << 65
+ matcher := Equals(complex128(kExpected))
+ ExpectEq("(3.6893488147419103e+19+0i)", matcher.Description())
+
+ floatExpected := float64(kExpected)
+ castedInt := uint64(floatExpected)
+
+ cases := []equalsTestCase{
+ // Equal values of numeric type.
+ equalsTestCase{kExpected + 0i, true, false, ""},
+ equalsTestCase{float32(kExpected), true, false, ""},
+ equalsTestCase{float64(kExpected), true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{castedInt, false, false, ""},
+ equalsTestCase{int64(0), false, false, ""},
+ equalsTestCase{int64(math.MinInt64), false, false, ""},
+ equalsTestCase{int64(math.MaxInt64), false, false, ""},
+ equalsTestCase{uint64(0), false, false, ""},
+ equalsTestCase{uint64(math.MaxUint64), false, false, ""},
+ equalsTestCase{float32(kExpected / 2), false, false, ""},
+ equalsTestCase{float64(kExpected / 2), false, false, ""},
+ equalsTestCase{complex128(kExpected + 2i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Complex128AboveExactIntegerRange() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := Equals(complex128(kTwoTo54 + 1))
+ ExpectEq("(1.8014398509481984e+16+0i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Integers.
+ equalsTestCase{int64(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{int64(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{int64(kTwoTo54 + 3), false, false, ""},
+
+ equalsTestCase{uint64(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{uint64(kTwoTo54 + 3), false, false, ""},
+
+ // Double-precision floating point.
+ equalsTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{float64(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{float64(kTwoTo54 + 3), false, false, ""},
+
+ equalsTestCase{complex128(kTwoTo54 - 2), false, false, ""},
+ equalsTestCase{complex128(kTwoTo54 - 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 0), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 1), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 2), true, false, ""},
+ equalsTestCase{complex128(kTwoTo54 + 3), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) Complex128WithNonZeroImaginaryPart() {
+ const kRealPart = 17
+ const kImagPart = 0.25i
+ const kExpected = kRealPart + kImagPart
+ matcher := Equals(complex128(kExpected))
+ ExpectEq("(17+0.25i)", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Various types of the expected value.
+ equalsTestCase{kExpected, true, false, ""},
+ equalsTestCase{kRealPart + kImagPart, true, false, ""},
+ equalsTestCase{complex64(kExpected), true, false, ""},
+ equalsTestCase{complex128(kExpected), true, false, ""},
+
+ // Non-equal values of numeric type.
+ equalsTestCase{int(kRealPart), false, false, ""},
+ equalsTestCase{int8(kRealPart), false, false, ""},
+ equalsTestCase{int16(kRealPart), false, false, ""},
+ equalsTestCase{int32(kRealPart), false, false, ""},
+ equalsTestCase{int64(kRealPart), false, false, ""},
+ equalsTestCase{uint(kRealPart), false, false, ""},
+ equalsTestCase{uint8(kRealPart), false, false, ""},
+ equalsTestCase{uint16(kRealPart), false, false, ""},
+ equalsTestCase{uint32(kRealPart), false, false, ""},
+ equalsTestCase{uint64(kRealPart), false, false, ""},
+ equalsTestCase{float32(kRealPart), false, false, ""},
+ equalsTestCase{float64(kRealPart), false, false, ""},
+ equalsTestCase{complex64(kRealPart), false, false, ""},
+ equalsTestCase{complex64(kRealPart + kImagPart + 0.5), false, false, ""},
+ equalsTestCase{complex64(kRealPart + kImagPart + 0.5i), false, false, ""},
+ equalsTestCase{complex128(kRealPart), false, false, ""},
+ equalsTestCase{complex128(kRealPart + kImagPart + 0.5), false, false, ""},
+ equalsTestCase{complex128(kRealPart + kImagPart + 0.5i), false, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Arrays
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) ArrayOfComparableType() {
+ expected := [3]uint{17, 19, 23}
+
+ matcher := Equals(expected)
+ ExpectEq("[17 19 23]", matcher.Description())
+
+ // To defeat constant de-duping by the compiler.
+ makeArray := func(i, j, k uint) [3]uint { return [3]uint{i, j, k} }
+
+ type arrayAlias [3]uint
+ type uintAlias uint
+
+ cases := []equalsTestCase{
+ // Correct types, equal.
+ equalsTestCase{expected, true, false, ""},
+ equalsTestCase{[3]uint{17, 19, 23}, true, false, ""},
+ equalsTestCase{makeArray(17, 19, 23), true, false, ""},
+
+ // Correct types, not equal.
+ equalsTestCase{[3]uint{0, 0, 0}, false, false, ""},
+ equalsTestCase{[3]uint{18, 19, 23}, false, false, ""},
+ equalsTestCase{[3]uint{17, 20, 23}, false, false, ""},
+ equalsTestCase{[3]uint{17, 19, 22}, false, false, ""},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not [3]uint"},
+ equalsTestCase{bool(false), false, true, "which is not [3]uint"},
+ equalsTestCase{int(0), false, true, "which is not [3]uint"},
+ equalsTestCase{int8(0), false, true, "which is not [3]uint"},
+ equalsTestCase{int16(0), false, true, "which is not [3]uint"},
+ equalsTestCase{int32(0), false, true, "which is not [3]uint"},
+ equalsTestCase{int64(0), false, true, "which is not [3]uint"},
+ equalsTestCase{uint(0), false, true, "which is not [3]uint"},
+ equalsTestCase{uint8(0), false, true, "which is not [3]uint"},
+ equalsTestCase{uint16(0), false, true, "which is not [3]uint"},
+ equalsTestCase{uint32(0), false, true, "which is not [3]uint"},
+ equalsTestCase{uint64(0), false, true, "which is not [3]uint"},
+ equalsTestCase{true, false, true, "which is not [3]uint"},
+ equalsTestCase{[...]int{}, false, true, "which is not [3]uint"},
+ equalsTestCase{func() {}, false, true, "which is not [3]uint"},
+ equalsTestCase{map[int]int{}, false, true, "which is not [3]uint"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not [3]uint"},
+ equalsTestCase{[2]uint{17, 19}, false, true, "which is not [3]uint"},
+ equalsTestCase{[4]uint{17, 19, 23, 0}, false, true, "which is not [3]uint"},
+ equalsTestCase{arrayAlias{17, 19, 23}, false, true, "which is not [3]uint"},
+ equalsTestCase{[3]uintAlias{17, 19, 23}, false, true, "which is not [3]uint"},
+ equalsTestCase{[3]int32{17, 19, 23}, false, true, "which is not [3]uint"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ArrayOfNonComparableType() {
+ type nonComparableArray [2]map[string]string
+ f := func() {
+ ExpectEq(nonComparableArray{}, nonComparableArray{})
+ }
+
+ ExpectThat(f, Panics(MatchesRegexp("uncomparable.*nonComparableArray")))
+}
+
+////////////////////////////////////////////////////////////////////////
+// chan
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilChan() {
+ var nilChan1 chan int
+ var nilChan2 chan int
+ var nilChan3 chan uint
+ var nonNilChan1 chan int = make(chan int)
+ var nonNilChan2 chan uint = make(chan uint)
+
+ matcher := Equals(nilChan1)
+ ExpectEq("", matcher.Description())
+
+ cases := []equalsTestCase{
+ // int channels
+ equalsTestCase{nilChan1, true, false, ""},
+ equalsTestCase{nilChan2, true, false, ""},
+ equalsTestCase{nonNilChan1, false, false, ""},
+
+ // uint channels
+ equalsTestCase{nilChan3, false, true, "which is not a chan int"},
+ equalsTestCase{nonNilChan2, false, true, "which is not a chan int"},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a chan int"},
+ equalsTestCase{bool(false), false, true, "which is not a chan int"},
+ equalsTestCase{int(0), false, true, "which is not a chan int"},
+ equalsTestCase{int8(0), false, true, "which is not a chan int"},
+ equalsTestCase{int16(0), false, true, "which is not a chan int"},
+ equalsTestCase{int32(0), false, true, "which is not a chan int"},
+ equalsTestCase{int64(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint8(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint16(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint32(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint64(0), false, true, "which is not a chan int"},
+ equalsTestCase{true, false, true, "which is not a chan int"},
+ equalsTestCase{[...]int{}, false, true, "which is not a chan int"},
+ equalsTestCase{func() {}, false, true, "which is not a chan int"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a chan int"},
+ equalsTestCase{&someInt, false, true, "which is not a chan int"},
+ equalsTestCase{[]int{}, false, true, "which is not a chan int"},
+ equalsTestCase{"taco", false, true, "which is not a chan int"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a chan int"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilChan() {
+ var nilChan1 chan int
+ var nilChan2 chan uint
+ var nonNilChan1 chan int = make(chan int)
+ var nonNilChan2 chan int = make(chan int)
+ var nonNilChan3 chan uint = make(chan uint)
+
+ matcher := Equals(nonNilChan1)
+ ExpectEq(fmt.Sprintf("%v", nonNilChan1), matcher.Description())
+
+ cases := []equalsTestCase{
+ // int channels
+ equalsTestCase{nonNilChan1, true, false, ""},
+ equalsTestCase{nonNilChan2, false, false, ""},
+ equalsTestCase{nilChan1, false, false, ""},
+
+ // uint channels
+ equalsTestCase{nilChan2, false, true, "which is not a chan int"},
+ equalsTestCase{nonNilChan3, false, true, "which is not a chan int"},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a chan int"},
+ equalsTestCase{bool(false), false, true, "which is not a chan int"},
+ equalsTestCase{int(0), false, true, "which is not a chan int"},
+ equalsTestCase{int8(0), false, true, "which is not a chan int"},
+ equalsTestCase{int16(0), false, true, "which is not a chan int"},
+ equalsTestCase{int32(0), false, true, "which is not a chan int"},
+ equalsTestCase{int64(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint8(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint16(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint32(0), false, true, "which is not a chan int"},
+ equalsTestCase{uint64(0), false, true, "which is not a chan int"},
+ equalsTestCase{true, false, true, "which is not a chan int"},
+ equalsTestCase{[...]int{}, false, true, "which is not a chan int"},
+ equalsTestCase{func() {}, false, true, "which is not a chan int"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a chan int"},
+ equalsTestCase{&someInt, false, true, "which is not a chan int"},
+ equalsTestCase{[]int{}, false, true, "which is not a chan int"},
+ equalsTestCase{"taco", false, true, "which is not a chan int"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a chan int"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) ChanDirection() {
+ var chan1 chan<- int
+ var chan2 <-chan int
+ var chan3 chan int
+
+ matcher := Equals(chan1)
+ ExpectEq(fmt.Sprintf("%v", chan1), matcher.Description())
+
+ cases := []equalsTestCase{
+ equalsTestCase{chan1, true, false, ""},
+ equalsTestCase{chan2, false, true, "which is not a chan<- int"},
+ equalsTestCase{chan3, false, true, "which is not a chan<- int"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// func
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) Functions() {
+ func1 := func() {}
+ func2 := func() {}
+ func3 := func(x int) {}
+
+ matcher := Equals(func1)
+ ExpectEq(fmt.Sprintf("%v", func1), matcher.Description())
+
+ cases := []equalsTestCase{
+ // Functions.
+ equalsTestCase{func1, true, false, ""},
+ equalsTestCase{func2, false, false, ""},
+ equalsTestCase{func3, false, false, ""},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a function"},
+ equalsTestCase{bool(false), false, true, "which is not a function"},
+ equalsTestCase{int(0), false, true, "which is not a function"},
+ equalsTestCase{int8(0), false, true, "which is not a function"},
+ equalsTestCase{int16(0), false, true, "which is not a function"},
+ equalsTestCase{int32(0), false, true, "which is not a function"},
+ equalsTestCase{int64(0), false, true, "which is not a function"},
+ equalsTestCase{uint(0), false, true, "which is not a function"},
+ equalsTestCase{uint8(0), false, true, "which is not a function"},
+ equalsTestCase{uint16(0), false, true, "which is not a function"},
+ equalsTestCase{uint32(0), false, true, "which is not a function"},
+ equalsTestCase{uint64(0), false, true, "which is not a function"},
+ equalsTestCase{true, false, true, "which is not a function"},
+ equalsTestCase{[...]int{}, false, true, "which is not a function"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a function"},
+ equalsTestCase{&someInt, false, true, "which is not a function"},
+ equalsTestCase{[]int{}, false, true, "which is not a function"},
+ equalsTestCase{"taco", false, true, "which is not a function"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a function"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// map
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilMap() {
+ var nilMap1 map[int]int
+ var nilMap2 map[int]int
+ var nilMap3 map[int]uint
+ var nonNilMap1 map[int]int = make(map[int]int)
+ var nonNilMap2 map[int]uint = make(map[int]uint)
+
+ matcher := Equals(nilMap1)
+ ExpectEq("map[]", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Correct type.
+ equalsTestCase{nilMap1, true, false, ""},
+ equalsTestCase{nilMap2, true, false, ""},
+ equalsTestCase{nilMap3, true, false, ""},
+ equalsTestCase{nonNilMap1, false, false, ""},
+ equalsTestCase{nonNilMap2, false, false, ""},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a map"},
+ equalsTestCase{bool(false), false, true, "which is not a map"},
+ equalsTestCase{int(0), false, true, "which is not a map"},
+ equalsTestCase{int8(0), false, true, "which is not a map"},
+ equalsTestCase{int16(0), false, true, "which is not a map"},
+ equalsTestCase{int32(0), false, true, "which is not a map"},
+ equalsTestCase{int64(0), false, true, "which is not a map"},
+ equalsTestCase{uint(0), false, true, "which is not a map"},
+ equalsTestCase{uint8(0), false, true, "which is not a map"},
+ equalsTestCase{uint16(0), false, true, "which is not a map"},
+ equalsTestCase{uint32(0), false, true, "which is not a map"},
+ equalsTestCase{uint64(0), false, true, "which is not a map"},
+ equalsTestCase{true, false, true, "which is not a map"},
+ equalsTestCase{[...]int{}, false, true, "which is not a map"},
+ equalsTestCase{func() {}, false, true, "which is not a map"},
+ equalsTestCase{&someInt, false, true, "which is not a map"},
+ equalsTestCase{[]int{}, false, true, "which is not a map"},
+ equalsTestCase{"taco", false, true, "which is not a map"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a map"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilMap() {
+ var nilMap1 map[int]int
+ var nilMap2 map[int]uint
+ var nonNilMap1 map[int]int = make(map[int]int)
+ var nonNilMap2 map[int]int = make(map[int]int)
+ var nonNilMap3 map[int]uint = make(map[int]uint)
+
+ matcher := Equals(nonNilMap1)
+ ExpectEq("map[]", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Correct type.
+ equalsTestCase{nonNilMap1, true, false, ""},
+ equalsTestCase{nonNilMap2, false, false, ""},
+ equalsTestCase{nonNilMap3, false, false, ""},
+ equalsTestCase{nilMap1, false, false, ""},
+ equalsTestCase{nilMap2, false, false, ""},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a map"},
+ equalsTestCase{bool(false), false, true, "which is not a map"},
+ equalsTestCase{int(0), false, true, "which is not a map"},
+ equalsTestCase{int8(0), false, true, "which is not a map"},
+ equalsTestCase{int16(0), false, true, "which is not a map"},
+ equalsTestCase{int32(0), false, true, "which is not a map"},
+ equalsTestCase{int64(0), false, true, "which is not a map"},
+ equalsTestCase{uint(0), false, true, "which is not a map"},
+ equalsTestCase{uint8(0), false, true, "which is not a map"},
+ equalsTestCase{uint16(0), false, true, "which is not a map"},
+ equalsTestCase{uint32(0), false, true, "which is not a map"},
+ equalsTestCase{uint64(0), false, true, "which is not a map"},
+ equalsTestCase{true, false, true, "which is not a map"},
+ equalsTestCase{[...]int{}, false, true, "which is not a map"},
+ equalsTestCase{func() {}, false, true, "which is not a map"},
+ equalsTestCase{&someInt, false, true, "which is not a map"},
+ equalsTestCase{[]int{}, false, true, "which is not a map"},
+ equalsTestCase{"taco", false, true, "which is not a map"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a map"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Pointers
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilPointer() {
+ var someInt int = 17
+ var someUint uint = 17
+
+ var nilInt1 *int
+ var nilInt2 *int
+ var nilUint *uint
+ var nonNilInt *int = &someInt
+ var nonNilUint *uint = &someUint
+
+ matcher := Equals(nilInt1)
+ ExpectEq("", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Correct type.
+ equalsTestCase{nilInt1, true, false, ""},
+ equalsTestCase{nilInt2, true, false, ""},
+ equalsTestCase{nonNilInt, false, false, ""},
+
+ // Incorrect type.
+ equalsTestCase{nilUint, false, true, "which is not a *int"},
+ equalsTestCase{nonNilUint, false, true, "which is not a *int"},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a *int"},
+ equalsTestCase{bool(false), false, true, "which is not a *int"},
+ equalsTestCase{int(0), false, true, "which is not a *int"},
+ equalsTestCase{int8(0), false, true, "which is not a *int"},
+ equalsTestCase{int16(0), false, true, "which is not a *int"},
+ equalsTestCase{int32(0), false, true, "which is not a *int"},
+ equalsTestCase{int64(0), false, true, "which is not a *int"},
+ equalsTestCase{uint(0), false, true, "which is not a *int"},
+ equalsTestCase{uint8(0), false, true, "which is not a *int"},
+ equalsTestCase{uint16(0), false, true, "which is not a *int"},
+ equalsTestCase{uint32(0), false, true, "which is not a *int"},
+ equalsTestCase{uint64(0), false, true, "which is not a *int"},
+ equalsTestCase{true, false, true, "which is not a *int"},
+ equalsTestCase{[...]int{}, false, true, "which is not a *int"},
+ equalsTestCase{func() {}, false, true, "which is not a *int"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a *int"},
+ equalsTestCase{[]int{}, false, true, "which is not a *int"},
+ equalsTestCase{"taco", false, true, "which is not a *int"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a *int"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilPointer() {
+ var someInt int = 17
+ var someOtherInt int = 17
+ var someUint uint = 17
+
+ var nilInt *int
+ var nilUint *uint
+ var nonNilInt1 *int = &someInt
+ var nonNilInt2 *int = &someOtherInt
+ var nonNilUint *uint = &someUint
+
+ matcher := Equals(nonNilInt1)
+ ExpectEq(fmt.Sprintf("%v", nonNilInt1), matcher.Description())
+
+ cases := []equalsTestCase{
+ // Correct type.
+ equalsTestCase{nonNilInt1, true, false, ""},
+ equalsTestCase{nonNilInt2, false, false, ""},
+ equalsTestCase{nilInt, false, false, ""},
+
+ // Incorrect type.
+ equalsTestCase{nilUint, false, true, "which is not a *int"},
+ equalsTestCase{nonNilUint, false, true, "which is not a *int"},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a *int"},
+ equalsTestCase{bool(false), false, true, "which is not a *int"},
+ equalsTestCase{int(0), false, true, "which is not a *int"},
+ equalsTestCase{int8(0), false, true, "which is not a *int"},
+ equalsTestCase{int16(0), false, true, "which is not a *int"},
+ equalsTestCase{int32(0), false, true, "which is not a *int"},
+ equalsTestCase{int64(0), false, true, "which is not a *int"},
+ equalsTestCase{uint(0), false, true, "which is not a *int"},
+ equalsTestCase{uint8(0), false, true, "which is not a *int"},
+ equalsTestCase{uint16(0), false, true, "which is not a *int"},
+ equalsTestCase{uint32(0), false, true, "which is not a *int"},
+ equalsTestCase{uint64(0), false, true, "which is not a *int"},
+ equalsTestCase{true, false, true, "which is not a *int"},
+ equalsTestCase{[...]int{}, false, true, "which is not a *int"},
+ equalsTestCase{func() {}, false, true, "which is not a *int"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a *int"},
+ equalsTestCase{[]int{}, false, true, "which is not a *int"},
+ equalsTestCase{"taco", false, true, "which is not a *int"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a *int"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Slices
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilSlice() {
+ var nilInt1 []int
+ var nilInt2 []int
+ var nilUint []uint
+
+ var nonNilInt []int = make([]int, 0)
+ var nonNilUint []uint = make([]uint, 0)
+
+ matcher := Equals(nilInt1)
+ ExpectEq("[]", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Correct type.
+ equalsTestCase{nilInt1, true, false, ""},
+ equalsTestCase{nilInt2, true, false, ""},
+ equalsTestCase{nonNilInt, false, false, ""},
+
+ // Incorrect type.
+ equalsTestCase{nilUint, false, true, "which is not a []int"},
+ equalsTestCase{nonNilUint, false, true, "which is not a []int"},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a []int"},
+ equalsTestCase{bool(false), false, true, "which is not a []int"},
+ equalsTestCase{int(0), false, true, "which is not a []int"},
+ equalsTestCase{int8(0), false, true, "which is not a []int"},
+ equalsTestCase{int16(0), false, true, "which is not a []int"},
+ equalsTestCase{int32(0), false, true, "which is not a []int"},
+ equalsTestCase{int64(0), false, true, "which is not a []int"},
+ equalsTestCase{uint(0), false, true, "which is not a []int"},
+ equalsTestCase{uint8(0), false, true, "which is not a []int"},
+ equalsTestCase{uint16(0), false, true, "which is not a []int"},
+ equalsTestCase{uint32(0), false, true, "which is not a []int"},
+ equalsTestCase{uint64(0), false, true, "which is not a []int"},
+ equalsTestCase{true, false, true, "which is not a []int"},
+ equalsTestCase{[...]int{}, false, true, "which is not a []int"},
+ equalsTestCase{func() {}, false, true, "which is not a []int"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a []int"},
+ equalsTestCase{"taco", false, true, "which is not a []int"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a []int"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilSlice() {
+ nonNil := make([]int, 0)
+ f := func() { Equals(nonNil) }
+ ExpectThat(f, Panics(HasSubstr("non-nil slice")))
+}
+
+////////////////////////////////////////////////////////////////////////
+// string
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) String() {
+ partial := "taco"
+ expected := fmt.Sprintf("%s%d", partial, 1)
+
+ matcher := Equals(expected)
+ ExpectEq("taco1", matcher.Description())
+
+ type stringAlias string
+
+ cases := []equalsTestCase{
+ // Correct types.
+ equalsTestCase{"taco1", true, false, ""},
+ equalsTestCase{"taco" + "1", true, false, ""},
+ equalsTestCase{expected, true, false, ""},
+ equalsTestCase{stringAlias("taco1"), true, false, ""},
+
+ equalsTestCase{"", false, false, ""},
+ equalsTestCase{"taco", false, false, ""},
+ equalsTestCase{"taco1\x00", false, false, ""},
+ equalsTestCase{"taco2", false, false, ""},
+ equalsTestCase{stringAlias("taco2"), false, false, ""},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a string"},
+ equalsTestCase{bool(false), false, true, "which is not a string"},
+ equalsTestCase{int(0), false, true, "which is not a string"},
+ equalsTestCase{int8(0), false, true, "which is not a string"},
+ equalsTestCase{int16(0), false, true, "which is not a string"},
+ equalsTestCase{int32(0), false, true, "which is not a string"},
+ equalsTestCase{int64(0), false, true, "which is not a string"},
+ equalsTestCase{uint(0), false, true, "which is not a string"},
+ equalsTestCase{uint8(0), false, true, "which is not a string"},
+ equalsTestCase{uint16(0), false, true, "which is not a string"},
+ equalsTestCase{uint32(0), false, true, "which is not a string"},
+ equalsTestCase{uint64(0), false, true, "which is not a string"},
+ equalsTestCase{true, false, true, "which is not a string"},
+ equalsTestCase{[...]int{}, false, true, "which is not a string"},
+ equalsTestCase{func() {}, false, true, "which is not a string"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a string"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a string"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) StringAlias() {
+ type stringAlias string
+
+ matcher := Equals(stringAlias("taco"))
+ ExpectEq("taco", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Correct types.
+ equalsTestCase{stringAlias("taco"), true, false, ""},
+ equalsTestCase{"taco", true, false, ""},
+
+ equalsTestCase{"burrito", false, false, ""},
+ equalsTestCase{stringAlias("burrito"), false, false, ""},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a string"},
+ equalsTestCase{bool(false), false, true, "which is not a string"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// struct
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) Struct() {
+ type someStruct struct{ foo uint }
+ f := func() { Equals(someStruct{17}) }
+ ExpectThat(f, Panics(HasSubstr("unsupported kind struct")))
+}
+
+////////////////////////////////////////////////////////////////////////
+// unsafe.Pointer
+////////////////////////////////////////////////////////////////////////
+
+func (t *EqualsTest) NilUnsafePointer() {
+ someInt := int(17)
+
+ var nilPtr1 unsafe.Pointer
+ var nilPtr2 unsafe.Pointer
+ var nonNilPtr unsafe.Pointer = unsafe.Pointer(&someInt)
+
+ matcher := Equals(nilPtr1)
+ ExpectEq("", matcher.Description())
+
+ cases := []equalsTestCase{
+ // Correct type.
+ equalsTestCase{nilPtr1, true, false, ""},
+ equalsTestCase{nilPtr2, true, false, ""},
+ equalsTestCase{nonNilPtr, false, false, ""},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{bool(false), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int8(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int16(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int32(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int64(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint8(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{true, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{func() {}, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{&someInt, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{[]int{}, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{"taco", false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a unsafe.Pointer"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *EqualsTest) NonNilUnsafePointer() {
+ someInt := int(17)
+ someOtherInt := int(17)
+
+ var nilPtr unsafe.Pointer
+ var nonNilPtr1 unsafe.Pointer = unsafe.Pointer(&someInt)
+ var nonNilPtr2 unsafe.Pointer = unsafe.Pointer(&someOtherInt)
+
+ matcher := Equals(nonNilPtr1)
+ ExpectEq(fmt.Sprintf("%v", nonNilPtr1), matcher.Description())
+
+ cases := []equalsTestCase{
+ // Correct type.
+ equalsTestCase{nonNilPtr1, true, false, ""},
+ equalsTestCase{nonNilPtr2, false, false, ""},
+ equalsTestCase{nilPtr, false, false, ""},
+
+ // Other types.
+ equalsTestCase{0, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{bool(false), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int8(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int16(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int32(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{int64(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint8(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint16(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint32(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{uint64(0), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{true, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{[...]int{}, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{make(chan int), false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{func() {}, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{map[int]int{}, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{&someInt, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{[]int{}, false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{"taco", false, true, "which is not a unsafe.Pointer"},
+ equalsTestCase{equalsTestCase{}, false, true, "which is not a unsafe.Pointer"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/error.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/error.go
new file mode 100644
index 0000000..8a078e3
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/error.go
@@ -0,0 +1,51 @@
+// 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
+
+// Error returns a matcher that matches non-nil values implementing the
+// built-in error interface for whom the return value of Error() matches the
+// supplied matcher.
+//
+// For example:
+//
+// err := errors.New("taco burrito")
+//
+// Error(Equals("taco burrito")) // matches err
+// Error(HasSubstr("taco")) // matches err
+// Error(HasSubstr("enchilada")) // doesn't match err
+//
+func Error(m Matcher) Matcher {
+ return &errorMatcher{m}
+}
+
+type errorMatcher struct {
+ wrappedMatcher Matcher
+}
+
+func (m *errorMatcher) Description() string {
+ return "error " + m.wrappedMatcher.Description()
+}
+
+func (m *errorMatcher) Matches(c interface{}) error {
+ // Make sure that c is an error.
+ e, ok := c.(error)
+ if !ok {
+ return NewFatalError("which is not an error")
+ }
+
+ // Pass on the error text to the wrapped matcher.
+ return m.wrappedMatcher.Matches(e.Error())
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/error_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/error_test.go
new file mode 100644
index 0000000..55780a0
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/error_test.go
@@ -0,0 +1,92 @@
+// 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/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/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))
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal.go
new file mode 100644
index 0000000..4b9d103
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal.go
@@ -0,0 +1,39 @@
+// 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
+
+import (
+ "fmt"
+ "reflect"
+)
+
+// GreaterOrEqual returns a matcher that matches integer, floating point, or
+// strings values v such that v >= x. Comparison is not defined between numeric
+// and string types, but is defined between all integer and floating point
+// types.
+//
+// x must itself be an integer, floating point, or string type; otherwise,
+// GreaterOrEqual will panic.
+func GreaterOrEqual(x interface{}) Matcher {
+ desc := fmt.Sprintf("greater than or equal to %v", x)
+
+ // Special case: make it clear that strings are strings.
+ if reflect.TypeOf(x).Kind() == reflect.String {
+ desc = fmt.Sprintf("greater than or equal to \"%s\"", x)
+ }
+
+ return transformDescription(Not(LessThan(x)), desc)
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal_test.go
new file mode 100644
index 0000000..c4fb41b
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_or_equal_test.go
@@ -0,0 +1,1101 @@
+// 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 (
+ "math"
+
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type GreaterOrEqualTest struct {
+}
+
+func init() { RegisterTestSuite(&GreaterOrEqualTest{}) }
+
+type geTestCase struct {
+ candidate interface{}
+ expectedResult bool
+ shouldBeFatal bool
+ expectedError string
+}
+
+func (t *GreaterOrEqualTest) checkTestCases(matcher Matcher, cases []geTestCase) {
+ for i, c := range cases {
+ err := matcher.Matches(c.candidate)
+
+ ExpectThat(
+ (err == nil),
+ Equals(c.expectedResult),
+ "Case %d (candidate %v)",
+ i,
+ c.candidate)
+
+ if err == nil {
+ continue
+ }
+
+ _, isFatal := err.(*FatalError)
+ ExpectEq(
+ c.shouldBeFatal,
+ isFatal,
+ "Case %d (candidate %v)",
+ i,
+ c.candidate)
+
+ ExpectThat(
+ err,
+ Error(Equals(c.expectedError)),
+ "Case %d (candidate %v)",
+ i,
+ c.candidate)
+ }
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) IntegerCandidateBadTypes() {
+ matcher := GreaterOrEqual(int(-150))
+
+ cases := []geTestCase{
+ geTestCase{true, false, true, "which is not comparable"},
+ geTestCase{complex64(-151), false, true, "which is not comparable"},
+ geTestCase{complex128(-151), false, true, "which is not comparable"},
+ geTestCase{[...]int{-151}, false, true, "which is not comparable"},
+ geTestCase{make(chan int), false, true, "which is not comparable"},
+ geTestCase{func() {}, false, true, "which is not comparable"},
+ geTestCase{map[int]int{}, false, true, "which is not comparable"},
+ geTestCase{&geTestCase{}, false, true, "which is not comparable"},
+ geTestCase{make([]int, 0), false, true, "which is not comparable"},
+ geTestCase{"-151", false, true, "which is not comparable"},
+ geTestCase{geTestCase{}, false, true, "which is not comparable"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) FloatCandidateBadTypes() {
+ matcher := GreaterOrEqual(float32(-150))
+
+ cases := []geTestCase{
+ geTestCase{true, false, true, "which is not comparable"},
+ geTestCase{complex64(-151), false, true, "which is not comparable"},
+ geTestCase{complex128(-151), false, true, "which is not comparable"},
+ geTestCase{[...]int{-151}, false, true, "which is not comparable"},
+ geTestCase{make(chan int), false, true, "which is not comparable"},
+ geTestCase{func() {}, false, true, "which is not comparable"},
+ geTestCase{map[int]int{}, false, true, "which is not comparable"},
+ geTestCase{&geTestCase{}, false, true, "which is not comparable"},
+ geTestCase{make([]int, 0), false, true, "which is not comparable"},
+ geTestCase{"-151", false, true, "which is not comparable"},
+ geTestCase{geTestCase{}, false, true, "which is not comparable"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) StringCandidateBadTypes() {
+ matcher := GreaterOrEqual("17")
+
+ cases := []geTestCase{
+ geTestCase{true, false, true, "which is not comparable"},
+ geTestCase{int(0), false, true, "which is not comparable"},
+ geTestCase{int8(0), false, true, "which is not comparable"},
+ geTestCase{int16(0), false, true, "which is not comparable"},
+ geTestCase{int32(0), false, true, "which is not comparable"},
+ geTestCase{int64(0), false, true, "which is not comparable"},
+ geTestCase{uint(0), false, true, "which is not comparable"},
+ geTestCase{uint8(0), false, true, "which is not comparable"},
+ geTestCase{uint16(0), false, true, "which is not comparable"},
+ geTestCase{uint32(0), false, true, "which is not comparable"},
+ geTestCase{uint64(0), false, true, "which is not comparable"},
+ geTestCase{float32(0), false, true, "which is not comparable"},
+ geTestCase{float64(0), false, true, "which is not comparable"},
+ geTestCase{complex64(-151), false, true, "which is not comparable"},
+ geTestCase{complex128(-151), false, true, "which is not comparable"},
+ geTestCase{[...]int{-151}, false, true, "which is not comparable"},
+ geTestCase{make(chan int), false, true, "which is not comparable"},
+ geTestCase{func() {}, false, true, "which is not comparable"},
+ geTestCase{map[int]int{}, false, true, "which is not comparable"},
+ geTestCase{&geTestCase{}, false, true, "which is not comparable"},
+ geTestCase{make([]int, 0), false, true, "which is not comparable"},
+ geTestCase{geTestCase{}, false, true, "which is not comparable"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) BadArgument() {
+ panicked := false
+
+ defer func() {
+ ExpectThat(panicked, Equals(true))
+ }()
+
+ defer func() {
+ if r := recover(); r != nil {
+ panicked = true
+ }
+ }()
+
+ GreaterOrEqual(complex128(0))
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) NegativeIntegerLiteral() {
+ matcher := GreaterOrEqual(-150)
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to -150"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-(1 << 30), false, false, ""},
+ geTestCase{-151, false, false, ""},
+ geTestCase{-150, true, false, ""},
+ geTestCase{0, true, false, ""},
+ geTestCase{17, true, false, ""},
+
+ geTestCase{int(-(1 << 30)), false, false, ""},
+ geTestCase{int(-151), false, false, ""},
+ geTestCase{int(-150), true, false, ""},
+ geTestCase{int(0), true, false, ""},
+ geTestCase{int(17), true, false, ""},
+
+ geTestCase{int8(-127), true, false, ""},
+ geTestCase{int8(0), true, false, ""},
+ geTestCase{int8(17), true, false, ""},
+
+ geTestCase{int16(-(1 << 14)), false, false, ""},
+ geTestCase{int16(-151), false, false, ""},
+ geTestCase{int16(-150), true, false, ""},
+ geTestCase{int16(0), true, false, ""},
+ geTestCase{int16(17), true, false, ""},
+
+ geTestCase{int32(-(1 << 30)), false, false, ""},
+ geTestCase{int32(-151), false, false, ""},
+ geTestCase{int32(-150), true, false, ""},
+ geTestCase{int32(0), true, false, ""},
+ geTestCase{int32(17), true, false, ""},
+
+ geTestCase{int64(-(1 << 30)), false, false, ""},
+ geTestCase{int64(-151), false, false, ""},
+ geTestCase{int64(-150), true, false, ""},
+ geTestCase{int64(0), true, false, ""},
+ geTestCase{int64(17), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint((1 << 32) - 151), true, false, ""},
+ geTestCase{uint(0), true, false, ""},
+ geTestCase{uint(17), true, false, ""},
+
+ geTestCase{uint8(0), true, false, ""},
+ geTestCase{uint8(17), true, false, ""},
+ geTestCase{uint8(253), true, false, ""},
+
+ geTestCase{uint16((1 << 16) - 151), true, false, ""},
+ geTestCase{uint16(0), true, false, ""},
+ geTestCase{uint16(17), true, false, ""},
+
+ geTestCase{uint32((1 << 32) - 151), true, false, ""},
+ geTestCase{uint32(0), true, false, ""},
+ geTestCase{uint32(17), true, false, ""},
+
+ geTestCase{uint64((1 << 64) - 151), true, false, ""},
+ geTestCase{uint64(0), true, false, ""},
+ geTestCase{uint64(17), true, false, ""},
+
+ geTestCase{uintptr((1 << 64) - 151), true, false, ""},
+ geTestCase{uintptr(0), true, false, ""},
+ geTestCase{uintptr(17), true, false, ""},
+
+ // Floating point.
+ geTestCase{float32(-(1 << 30)), false, false, ""},
+ geTestCase{float32(-151), false, false, ""},
+ geTestCase{float32(-150.1), false, false, ""},
+ geTestCase{float32(-150), true, false, ""},
+ geTestCase{float32(-149.9), true, false, ""},
+ geTestCase{float32(0), true, false, ""},
+ geTestCase{float32(17), true, false, ""},
+ geTestCase{float32(160), true, false, ""},
+
+ geTestCase{float64(-(1 << 30)), false, false, ""},
+ geTestCase{float64(-151), false, false, ""},
+ geTestCase{float64(-150.1), false, false, ""},
+ geTestCase{float64(-150), true, false, ""},
+ geTestCase{float64(-149.9), true, false, ""},
+ geTestCase{float64(0), true, false, ""},
+ geTestCase{float64(17), true, false, ""},
+ geTestCase{float64(160), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) ZeroIntegerLiteral() {
+ matcher := GreaterOrEqual(0)
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 0"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-(1 << 30), false, false, ""},
+ geTestCase{-1, false, false, ""},
+ geTestCase{0, true, false, ""},
+ geTestCase{1, true, false, ""},
+ geTestCase{17, true, false, ""},
+ geTestCase{(1 << 30), true, false, ""},
+
+ geTestCase{int(-(1 << 30)), false, false, ""},
+ geTestCase{int(-1), false, false, ""},
+ geTestCase{int(0), true, false, ""},
+ geTestCase{int(1), true, false, ""},
+ geTestCase{int(17), true, false, ""},
+
+ geTestCase{int8(-1), false, false, ""},
+ geTestCase{int8(0), true, false, ""},
+ geTestCase{int8(1), true, false, ""},
+
+ geTestCase{int16(-(1 << 14)), false, false, ""},
+ geTestCase{int16(-1), false, false, ""},
+ geTestCase{int16(0), true, false, ""},
+ geTestCase{int16(1), true, false, ""},
+ geTestCase{int16(17), true, false, ""},
+
+ geTestCase{int32(-(1 << 30)), false, false, ""},
+ geTestCase{int32(-1), false, false, ""},
+ geTestCase{int32(0), true, false, ""},
+ geTestCase{int32(1), true, false, ""},
+ geTestCase{int32(17), true, false, ""},
+
+ geTestCase{int64(-(1 << 30)), false, false, ""},
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(0), true, false, ""},
+ geTestCase{int64(1), true, false, ""},
+ geTestCase{int64(17), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint((1 << 32) - 1), true, false, ""},
+ geTestCase{uint(0), true, false, ""},
+ geTestCase{uint(17), true, false, ""},
+
+ geTestCase{uint8(0), true, false, ""},
+ geTestCase{uint8(17), true, false, ""},
+ geTestCase{uint8(253), true, false, ""},
+
+ geTestCase{uint16((1 << 16) - 1), true, false, ""},
+ geTestCase{uint16(0), true, false, ""},
+ geTestCase{uint16(17), true, false, ""},
+
+ geTestCase{uint32((1 << 32) - 1), true, false, ""},
+ geTestCase{uint32(0), true, false, ""},
+ geTestCase{uint32(17), true, false, ""},
+
+ geTestCase{uint64((1 << 64) - 1), true, false, ""},
+ geTestCase{uint64(0), true, false, ""},
+ geTestCase{uint64(17), true, false, ""},
+
+ geTestCase{uintptr((1 << 64) - 1), true, false, ""},
+ geTestCase{uintptr(0), true, false, ""},
+ geTestCase{uintptr(17), true, false, ""},
+
+ // Floating point.
+ geTestCase{float32(-(1 << 30)), false, false, ""},
+ geTestCase{float32(-1), false, false, ""},
+ geTestCase{float32(-0.1), false, false, ""},
+ geTestCase{float32(-0.0), true, false, ""},
+ geTestCase{float32(0), true, false, ""},
+ geTestCase{float32(0.1), true, false, ""},
+ geTestCase{float32(17), true, false, ""},
+ geTestCase{float32(160), true, false, ""},
+
+ geTestCase{float64(-(1 << 30)), false, false, ""},
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(-0.1), false, false, ""},
+ geTestCase{float64(-0), true, false, ""},
+ geTestCase{float64(0), true, false, ""},
+ geTestCase{float64(17), true, false, ""},
+ geTestCase{float64(160), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) PositiveIntegerLiteral() {
+ matcher := GreaterOrEqual(150)
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 150"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-1, false, false, ""},
+ geTestCase{149, false, false, ""},
+ geTestCase{150, true, false, ""},
+ geTestCase{151, true, false, ""},
+
+ geTestCase{int(-1), false, false, ""},
+ geTestCase{int(149), false, false, ""},
+ geTestCase{int(150), true, false, ""},
+ geTestCase{int(151), true, false, ""},
+
+ geTestCase{int8(-1), false, false, ""},
+ geTestCase{int8(0), false, false, ""},
+ geTestCase{int8(17), false, false, ""},
+ geTestCase{int8(127), false, false, ""},
+
+ geTestCase{int16(-1), false, false, ""},
+ geTestCase{int16(149), false, false, ""},
+ geTestCase{int16(150), true, false, ""},
+ geTestCase{int16(151), true, false, ""},
+
+ geTestCase{int32(-1), false, false, ""},
+ geTestCase{int32(149), false, false, ""},
+ geTestCase{int32(150), true, false, ""},
+ geTestCase{int32(151), true, false, ""},
+
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(149), false, false, ""},
+ geTestCase{int64(150), true, false, ""},
+ geTestCase{int64(151), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint(0), false, false, ""},
+ geTestCase{uint(149), false, false, ""},
+ geTestCase{uint(150), true, false, ""},
+ geTestCase{uint(151), true, false, ""},
+
+ geTestCase{uint8(0), false, false, ""},
+ geTestCase{uint8(127), false, false, ""},
+
+ geTestCase{uint16(0), false, false, ""},
+ geTestCase{uint16(149), false, false, ""},
+ geTestCase{uint16(150), true, false, ""},
+ geTestCase{uint16(151), true, false, ""},
+
+ geTestCase{uint32(0), false, false, ""},
+ geTestCase{uint32(149), false, false, ""},
+ geTestCase{uint32(150), true, false, ""},
+ geTestCase{uint32(151), true, false, ""},
+
+ geTestCase{uint64(0), false, false, ""},
+ geTestCase{uint64(149), false, false, ""},
+ geTestCase{uint64(150), true, false, ""},
+ geTestCase{uint64(151), true, false, ""},
+
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(149), false, false, ""},
+ geTestCase{uintptr(150), true, false, ""},
+ geTestCase{uintptr(151), true, false, ""},
+
+ // Floating point.
+ geTestCase{float32(-1), false, false, ""},
+ geTestCase{float32(149), false, false, ""},
+ geTestCase{float32(149.9), false, false, ""},
+ geTestCase{float32(150), true, false, ""},
+ geTestCase{float32(150.1), true, false, ""},
+ geTestCase{float32(151), true, false, ""},
+
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(149), false, false, ""},
+ geTestCase{float64(149.9), false, false, ""},
+ geTestCase{float64(150), true, false, ""},
+ geTestCase{float64(150.1), true, false, ""},
+ geTestCase{float64(151), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Float literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) NegativeFloatLiteral() {
+ matcher := GreaterOrEqual(-150.1)
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to -150.1"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-(1 << 30), false, false, ""},
+ geTestCase{-151, false, false, ""},
+ geTestCase{-150, true, false, ""},
+ geTestCase{0, true, false, ""},
+ geTestCase{17, true, false, ""},
+
+ geTestCase{int(-(1 << 30)), false, false, ""},
+ geTestCase{int(-151), false, false, ""},
+ geTestCase{int(-150), true, false, ""},
+ geTestCase{int(0), true, false, ""},
+ geTestCase{int(17), true, false, ""},
+
+ geTestCase{int8(-127), true, false, ""},
+ geTestCase{int8(0), true, false, ""},
+ geTestCase{int8(17), true, false, ""},
+
+ geTestCase{int16(-(1 << 14)), false, false, ""},
+ geTestCase{int16(-151), false, false, ""},
+ geTestCase{int16(-150), true, false, ""},
+ geTestCase{int16(0), true, false, ""},
+ geTestCase{int16(17), true, false, ""},
+
+ geTestCase{int32(-(1 << 30)), false, false, ""},
+ geTestCase{int32(-151), false, false, ""},
+ geTestCase{int32(-150), true, false, ""},
+ geTestCase{int32(0), true, false, ""},
+ geTestCase{int32(17), true, false, ""},
+
+ geTestCase{int64(-(1 << 30)), false, false, ""},
+ geTestCase{int64(-151), false, false, ""},
+ geTestCase{int64(-150), true, false, ""},
+ geTestCase{int64(0), true, false, ""},
+ geTestCase{int64(17), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint((1 << 32) - 151), true, false, ""},
+ geTestCase{uint(0), true, false, ""},
+ geTestCase{uint(17), true, false, ""},
+
+ geTestCase{uint8(0), true, false, ""},
+ geTestCase{uint8(17), true, false, ""},
+ geTestCase{uint8(253), true, false, ""},
+
+ geTestCase{uint16((1 << 16) - 151), true, false, ""},
+ geTestCase{uint16(0), true, false, ""},
+ geTestCase{uint16(17), true, false, ""},
+
+ geTestCase{uint32((1 << 32) - 151), true, false, ""},
+ geTestCase{uint32(0), true, false, ""},
+ geTestCase{uint32(17), true, false, ""},
+
+ geTestCase{uint64((1 << 64) - 151), true, false, ""},
+ geTestCase{uint64(0), true, false, ""},
+ geTestCase{uint64(17), true, false, ""},
+
+ geTestCase{uintptr((1 << 64) - 151), true, false, ""},
+ geTestCase{uintptr(0), true, false, ""},
+ geTestCase{uintptr(17), true, false, ""},
+
+ // Floating point.
+ geTestCase{float32(-(1 << 30)), false, false, ""},
+ geTestCase{float32(-151), false, false, ""},
+ geTestCase{float32(-150.2), false, false, ""},
+ geTestCase{float32(-150.1), true, false, ""},
+ geTestCase{float32(-150), true, false, ""},
+ geTestCase{float32(0), true, false, ""},
+ geTestCase{float32(17), true, false, ""},
+ geTestCase{float32(160), true, false, ""},
+
+ geTestCase{float64(-(1 << 30)), false, false, ""},
+ geTestCase{float64(-151), false, false, ""},
+ geTestCase{float64(-150.2), false, false, ""},
+ geTestCase{float64(-150.1), true, false, ""},
+ geTestCase{float64(-150), true, false, ""},
+ geTestCase{float64(0), true, false, ""},
+ geTestCase{float64(17), true, false, ""},
+ geTestCase{float64(160), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) PositiveFloatLiteral() {
+ matcher := GreaterOrEqual(149.9)
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 149.9"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-1, false, false, ""},
+ geTestCase{149, false, false, ""},
+ geTestCase{150, true, false, ""},
+ geTestCase{151, true, false, ""},
+
+ geTestCase{int(-1), false, false, ""},
+ geTestCase{int(149), false, false, ""},
+ geTestCase{int(150), true, false, ""},
+ geTestCase{int(151), true, false, ""},
+
+ geTestCase{int8(-1), false, false, ""},
+ geTestCase{int8(0), false, false, ""},
+ geTestCase{int8(17), false, false, ""},
+ geTestCase{int8(127), false, false, ""},
+
+ geTestCase{int16(-1), false, false, ""},
+ geTestCase{int16(149), false, false, ""},
+ geTestCase{int16(150), true, false, ""},
+ geTestCase{int16(151), true, false, ""},
+
+ geTestCase{int32(-1), false, false, ""},
+ geTestCase{int32(149), false, false, ""},
+ geTestCase{int32(150), true, false, ""},
+ geTestCase{int32(151), true, false, ""},
+
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(149), false, false, ""},
+ geTestCase{int64(150), true, false, ""},
+ geTestCase{int64(151), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint(0), false, false, ""},
+ geTestCase{uint(149), false, false, ""},
+ geTestCase{uint(150), true, false, ""},
+ geTestCase{uint(151), true, false, ""},
+
+ geTestCase{uint8(0), false, false, ""},
+ geTestCase{uint8(127), false, false, ""},
+
+ geTestCase{uint16(0), false, false, ""},
+ geTestCase{uint16(149), false, false, ""},
+ geTestCase{uint16(150), true, false, ""},
+ geTestCase{uint16(151), true, false, ""},
+
+ geTestCase{uint32(0), false, false, ""},
+ geTestCase{uint32(149), false, false, ""},
+ geTestCase{uint32(150), true, false, ""},
+ geTestCase{uint32(151), true, false, ""},
+
+ geTestCase{uint64(0), false, false, ""},
+ geTestCase{uint64(149), false, false, ""},
+ geTestCase{uint64(150), true, false, ""},
+ geTestCase{uint64(151), true, false, ""},
+
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(149), false, false, ""},
+ geTestCase{uintptr(150), true, false, ""},
+ geTestCase{uintptr(151), true, false, ""},
+
+ // Floating point.
+ geTestCase{float32(-1), false, false, ""},
+ geTestCase{float32(149), false, false, ""},
+ geTestCase{float32(149.8), false, false, ""},
+ geTestCase{float32(149.9), true, false, ""},
+ geTestCase{float32(150), true, false, ""},
+ geTestCase{float32(151), true, false, ""},
+
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(149), false, false, ""},
+ geTestCase{float64(149.8), false, false, ""},
+ geTestCase{float64(149.9), true, false, ""},
+ geTestCase{float64(150), true, false, ""},
+ geTestCase{float64(151), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Subtle cases
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableBySinglePrecision() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := GreaterOrEqual(int64(kTwoTo25 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 33554433"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-1, false, false, ""},
+ geTestCase{kTwoTo25 + 0, false, false, ""},
+ geTestCase{kTwoTo25 + 1, true, false, ""},
+ geTestCase{kTwoTo25 + 2, true, false, ""},
+
+ geTestCase{int(-1), false, false, ""},
+ geTestCase{int(kTwoTo25 + 0), false, false, ""},
+ geTestCase{int(kTwoTo25 + 1), true, false, ""},
+ geTestCase{int(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{int8(-1), false, false, ""},
+ geTestCase{int8(127), false, false, ""},
+
+ geTestCase{int16(-1), false, false, ""},
+ geTestCase{int16(0), false, false, ""},
+ geTestCase{int16(32767), false, false, ""},
+
+ geTestCase{int32(-1), false, false, ""},
+ geTestCase{int32(kTwoTo25 + 0), false, false, ""},
+ geTestCase{int32(kTwoTo25 + 1), true, false, ""},
+ geTestCase{int32(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ geTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{int64(kTwoTo25 + 2), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint(0), false, false, ""},
+ geTestCase{uint(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uint(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uint(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{uint8(0), false, false, ""},
+ geTestCase{uint8(255), false, false, ""},
+
+ geTestCase{uint16(0), false, false, ""},
+ geTestCase{uint16(65535), false, false, ""},
+
+ geTestCase{uint32(0), false, false, ""},
+ geTestCase{uint32(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uint32(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uint32(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{uint64(0), false, false, ""},
+ geTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 2), true, false, ""},
+
+ // Floating point.
+ geTestCase{float32(-1), false, false, ""},
+ geTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ geTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(kTwoTo25 - 2), false, false, ""},
+ geTestCase{float64(kTwoTo25 - 1), false, false, ""},
+ geTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ geTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{float64(kTwoTo25 + 2), true, false, ""},
+ geTestCase{float64(kTwoTo25 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Int64NotExactlyRepresentableByDoublePrecision() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := GreaterOrEqual(int64(kTwoTo54 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 18014398509481985"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-1, false, false, ""},
+ geTestCase{1 << 30, false, false, ""},
+
+ geTestCase{int(-1), false, false, ""},
+ geTestCase{int(math.MaxInt32), false, false, ""},
+
+ geTestCase{int8(-1), false, false, ""},
+ geTestCase{int8(127), false, false, ""},
+
+ geTestCase{int16(-1), false, false, ""},
+ geTestCase{int16(0), false, false, ""},
+ geTestCase{int16(32767), false, false, ""},
+
+ geTestCase{int32(-1), false, false, ""},
+ geTestCase{int32(math.MaxInt32), false, false, ""},
+
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(kTwoTo54 - 1), false, false, ""},
+ geTestCase{int64(kTwoTo54 + 0), false, false, ""},
+ geTestCase{int64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{int64(kTwoTo54 + 2), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint(0), false, false, ""},
+ geTestCase{uint(math.MaxUint32), false, false, ""},
+
+ geTestCase{uint8(0), false, false, ""},
+ geTestCase{uint8(255), false, false, ""},
+
+ geTestCase{uint16(0), false, false, ""},
+ geTestCase{uint16(65535), false, false, ""},
+
+ geTestCase{uint32(0), false, false, ""},
+ geTestCase{uint32(math.MaxUint32), false, false, ""},
+
+ geTestCase{uint64(0), false, false, ""},
+ geTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+ geTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+ geTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 - 1), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 0), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 1), true, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 2), true, false, ""},
+
+ // Floating point.
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ geTestCase{float64(kTwoTo54 - 1), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 0), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 2), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableBySinglePrecision() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := GreaterOrEqual(uint64(kTwoTo25 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 33554433"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-1, false, false, ""},
+ geTestCase{kTwoTo25 + 0, false, false, ""},
+ geTestCase{kTwoTo25 + 1, true, false, ""},
+ geTestCase{kTwoTo25 + 2, true, false, ""},
+
+ geTestCase{int(-1), false, false, ""},
+ geTestCase{int(kTwoTo25 + 0), false, false, ""},
+ geTestCase{int(kTwoTo25 + 1), true, false, ""},
+ geTestCase{int(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{int8(-1), false, false, ""},
+ geTestCase{int8(127), false, false, ""},
+
+ geTestCase{int16(-1), false, false, ""},
+ geTestCase{int16(0), false, false, ""},
+ geTestCase{int16(32767), false, false, ""},
+
+ geTestCase{int32(-1), false, false, ""},
+ geTestCase{int32(kTwoTo25 + 0), false, false, ""},
+ geTestCase{int32(kTwoTo25 + 1), true, false, ""},
+ geTestCase{int32(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ geTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{int64(kTwoTo25 + 2), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint(0), false, false, ""},
+ geTestCase{uint(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uint(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uint(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{uint8(0), false, false, ""},
+ geTestCase{uint8(255), false, false, ""},
+
+ geTestCase{uint16(0), false, false, ""},
+ geTestCase{uint16(65535), false, false, ""},
+
+ geTestCase{uint32(0), false, false, ""},
+ geTestCase{uint32(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uint32(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uint32(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{uint64(0), false, false, ""},
+ geTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 0), false, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uintptr(kTwoTo25 + 2), true, false, ""},
+
+ // Floating point.
+ geTestCase{float32(-1), false, false, ""},
+ geTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ geTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(kTwoTo25 - 2), false, false, ""},
+ geTestCase{float64(kTwoTo25 - 1), false, false, ""},
+ geTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ geTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{float64(kTwoTo25 + 2), true, false, ""},
+ geTestCase{float64(kTwoTo25 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Uint64NotExactlyRepresentableByDoublePrecision() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := GreaterOrEqual(uint64(kTwoTo54 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 18014398509481985"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{-1, false, false, ""},
+ geTestCase{1 << 30, false, false, ""},
+
+ geTestCase{int(-1), false, false, ""},
+ geTestCase{int(math.MaxInt32), false, false, ""},
+
+ geTestCase{int8(-1), false, false, ""},
+ geTestCase{int8(127), false, false, ""},
+
+ geTestCase{int16(-1), false, false, ""},
+ geTestCase{int16(0), false, false, ""},
+ geTestCase{int16(32767), false, false, ""},
+
+ geTestCase{int32(-1), false, false, ""},
+ geTestCase{int32(math.MaxInt32), false, false, ""},
+
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(kTwoTo54 - 1), false, false, ""},
+ geTestCase{int64(kTwoTo54 + 0), false, false, ""},
+ geTestCase{int64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{int64(kTwoTo54 + 2), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint(0), false, false, ""},
+ geTestCase{uint(math.MaxUint32), false, false, ""},
+
+ geTestCase{uint8(0), false, false, ""},
+ geTestCase{uint8(255), false, false, ""},
+
+ geTestCase{uint16(0), false, false, ""},
+ geTestCase{uint16(65535), false, false, ""},
+
+ geTestCase{uint32(0), false, false, ""},
+ geTestCase{uint32(math.MaxUint32), false, false, ""},
+
+ geTestCase{uint64(0), false, false, ""},
+ geTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+ geTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+ geTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+
+ geTestCase{uintptr(0), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 - 1), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 0), false, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 1), true, false, ""},
+ geTestCase{uintptr(kTwoTo54 + 2), true, false, ""},
+
+ // Floating point.
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ geTestCase{float64(kTwoTo54 - 1), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 0), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 2), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Float32AboveExactIntegerRange() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := GreaterOrEqual(float32(kTwoTo25 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 3.3554432e+07"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(kTwoTo25 - 2), false, false, ""},
+ geTestCase{int64(kTwoTo25 - 1), true, false, ""},
+ geTestCase{int64(kTwoTo25 + 0), true, false, ""},
+ geTestCase{int64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{int64(kTwoTo25 + 2), true, false, ""},
+ geTestCase{int64(kTwoTo25 + 3), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint64(0), false, false, ""},
+ geTestCase{uint64(kTwoTo25 - 2), false, false, ""},
+ geTestCase{uint64(kTwoTo25 - 1), true, false, ""},
+ geTestCase{uint64(kTwoTo25 + 0), true, false, ""},
+ geTestCase{uint64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+ geTestCase{uint64(kTwoTo25 + 3), true, false, ""},
+
+ // Floating point.
+ geTestCase{float32(-1), false, false, ""},
+ geTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ geTestCase{float32(kTwoTo25 - 1), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 0), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 1), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 2), true, false, ""},
+ geTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(kTwoTo25 - 2), false, false, ""},
+ geTestCase{float64(kTwoTo25 - 1), true, false, ""},
+ geTestCase{float64(kTwoTo25 + 0), true, false, ""},
+ geTestCase{float64(kTwoTo25 + 1), true, false, ""},
+ geTestCase{float64(kTwoTo25 + 2), true, false, ""},
+ geTestCase{float64(kTwoTo25 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) Float64AboveExactIntegerRange() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := GreaterOrEqual(float64(kTwoTo54 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to 1.8014398509481984e+16"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ // Signed integers.
+ geTestCase{int64(-1), false, false, ""},
+ geTestCase{int64(kTwoTo54 - 2), false, false, ""},
+ geTestCase{int64(kTwoTo54 - 1), true, false, ""},
+ geTestCase{int64(kTwoTo54 + 0), true, false, ""},
+ geTestCase{int64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{int64(kTwoTo54 + 2), true, false, ""},
+ geTestCase{int64(kTwoTo54 + 3), true, false, ""},
+
+ // Unsigned integers.
+ geTestCase{uint64(0), false, false, ""},
+ geTestCase{uint64(kTwoTo54 - 2), false, false, ""},
+ geTestCase{uint64(kTwoTo54 - 1), true, false, ""},
+ geTestCase{uint64(kTwoTo54 + 0), true, false, ""},
+ geTestCase{uint64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+ geTestCase{uint64(kTwoTo54 + 3), true, false, ""},
+
+ // Floating point.
+ geTestCase{float64(-1), false, false, ""},
+ geTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ geTestCase{float64(kTwoTo54 - 1), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 0), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 1), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 2), true, false, ""},
+ geTestCase{float64(kTwoTo54 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// String literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterOrEqualTest) EmptyString() {
+ matcher := GreaterOrEqual("")
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to \"\""
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ geTestCase{"", true, false, ""},
+ geTestCase{"\x00", true, false, ""},
+ geTestCase{"a", true, false, ""},
+ geTestCase{"foo", true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) SingleNullByte() {
+ matcher := GreaterOrEqual("\x00")
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to \"\x00\""
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ geTestCase{"", false, false, ""},
+ geTestCase{"\x00", true, false, ""},
+ geTestCase{"a", true, false, ""},
+ geTestCase{"foo", true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterOrEqualTest) LongerString() {
+ matcher := GreaterOrEqual("foo\x00")
+ desc := matcher.Description()
+ expectedDesc := "greater than or equal to \"foo\x00\""
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []geTestCase{
+ geTestCase{"", false, false, ""},
+ geTestCase{"\x00", false, false, ""},
+ geTestCase{"bar", false, false, ""},
+ geTestCase{"foo", false, false, ""},
+ geTestCase{"foo\x00", true, false, ""},
+ geTestCase{"fooa", true, false, ""},
+ geTestCase{"qux", true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_than.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_than.go
new file mode 100644
index 0000000..3eef321
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_than.go
@@ -0,0 +1,39 @@
+// 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
+
+import (
+ "fmt"
+ "reflect"
+)
+
+// GreaterThan returns a matcher that matches integer, floating point, or
+// strings values v such that v > x. Comparison is not defined between numeric
+// and string types, but is defined between all integer and floating point
+// types.
+//
+// x must itself be an integer, floating point, or string type; otherwise,
+// GreaterThan will panic.
+func GreaterThan(x interface{}) Matcher {
+ desc := fmt.Sprintf("greater than %v", x)
+
+ // Special case: make it clear that strings are strings.
+ if reflect.TypeOf(x).Kind() == reflect.String {
+ desc = fmt.Sprintf("greater than \"%s\"", x)
+ }
+
+ return transformDescription(Not(LessOrEqual(x)), desc)
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_than_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_than_test.go
new file mode 100644
index 0000000..1235d68
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/greater_than_test.go
@@ -0,0 +1,1077 @@
+// 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 (
+ "math"
+
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/ogletest"
+)
+
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+type GreaterThanTest struct {
+}
+
+func init() { RegisterTestSuite(&GreaterThanTest{}) }
+
+type gtTestCase struct {
+ candidate interface{}
+ expectedResult bool
+ shouldBeFatal bool
+ expectedError string
+}
+
+func (t *GreaterThanTest) checkTestCases(matcher Matcher, cases []gtTestCase) {
+ for i, c := range cases {
+ err := matcher.Matches(c.candidate)
+
+ ExpectThat(
+ (err == nil),
+ Equals(c.expectedResult),
+ "Case %d (candidate %v)",
+ i,
+ c.candidate)
+
+ if err == nil {
+ continue
+ }
+
+ _, isFatal := err.(*FatalError)
+ ExpectEq(
+ c.shouldBeFatal,
+ isFatal,
+ "Case %d (candidate %v)",
+ i,
+ c.candidate)
+
+ ExpectThat(
+ err,
+ Error(Equals(c.expectedError)),
+ "Case %d (candidate %v)",
+ i,
+ c.candidate)
+ }
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) IntegerCandidateBadTypes() {
+ matcher := GreaterThan(int(-150))
+
+ cases := []gtTestCase{
+ gtTestCase{true, false, true, "which is not comparable"},
+ gtTestCase{complex64(-151), false, true, "which is not comparable"},
+ gtTestCase{complex128(-151), false, true, "which is not comparable"},
+ gtTestCase{[...]int{-151}, false, true, "which is not comparable"},
+ gtTestCase{make(chan int), false, true, "which is not comparable"},
+ gtTestCase{func() {}, false, true, "which is not comparable"},
+ gtTestCase{map[int]int{}, false, true, "which is not comparable"},
+ gtTestCase{>TestCase{}, false, true, "which is not comparable"},
+ gtTestCase{make([]int, 0), false, true, "which is not comparable"},
+ gtTestCase{"-151", false, true, "which is not comparable"},
+ gtTestCase{gtTestCase{}, false, true, "which is not comparable"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) FloatCandidateBadTypes() {
+ matcher := GreaterThan(float32(-150))
+
+ cases := []gtTestCase{
+ gtTestCase{true, false, true, "which is not comparable"},
+ gtTestCase{complex64(-151), false, true, "which is not comparable"},
+ gtTestCase{complex128(-151), false, true, "which is not comparable"},
+ gtTestCase{[...]int{-151}, false, true, "which is not comparable"},
+ gtTestCase{make(chan int), false, true, "which is not comparable"},
+ gtTestCase{func() {}, false, true, "which is not comparable"},
+ gtTestCase{map[int]int{}, false, true, "which is not comparable"},
+ gtTestCase{>TestCase{}, false, true, "which is not comparable"},
+ gtTestCase{make([]int, 0), false, true, "which is not comparable"},
+ gtTestCase{"-151", false, true, "which is not comparable"},
+ gtTestCase{gtTestCase{}, false, true, "which is not comparable"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) StringCandidateBadTypes() {
+ matcher := GreaterThan("17")
+
+ cases := []gtTestCase{
+ gtTestCase{true, false, true, "which is not comparable"},
+ gtTestCase{int(0), false, true, "which is not comparable"},
+ gtTestCase{int8(0), false, true, "which is not comparable"},
+ gtTestCase{int16(0), false, true, "which is not comparable"},
+ gtTestCase{int32(0), false, true, "which is not comparable"},
+ gtTestCase{int64(0), false, true, "which is not comparable"},
+ gtTestCase{uint(0), false, true, "which is not comparable"},
+ gtTestCase{uint8(0), false, true, "which is not comparable"},
+ gtTestCase{uint16(0), false, true, "which is not comparable"},
+ gtTestCase{uint32(0), false, true, "which is not comparable"},
+ gtTestCase{uint64(0), false, true, "which is not comparable"},
+ gtTestCase{float32(0), false, true, "which is not comparable"},
+ gtTestCase{float64(0), false, true, "which is not comparable"},
+ gtTestCase{complex64(-151), false, true, "which is not comparable"},
+ gtTestCase{complex128(-151), false, true, "which is not comparable"},
+ gtTestCase{[...]int{-151}, false, true, "which is not comparable"},
+ gtTestCase{make(chan int), false, true, "which is not comparable"},
+ gtTestCase{func() {}, false, true, "which is not comparable"},
+ gtTestCase{map[int]int{}, false, true, "which is not comparable"},
+ gtTestCase{>TestCase{}, false, true, "which is not comparable"},
+ gtTestCase{make([]int, 0), false, true, "which is not comparable"},
+ gtTestCase{gtTestCase{}, false, true, "which is not comparable"},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) BadArgument() {
+ panicked := false
+
+ defer func() {
+ ExpectThat(panicked, Equals(true))
+ }()
+
+ defer func() {
+ if r := recover(); r != nil {
+ panicked = true
+ }
+ }()
+
+ GreaterThan(complex128(0))
+}
+
+////////////////////////////////////////////////////////////////////////
+// Integer literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) NegativeIntegerLiteral() {
+ matcher := GreaterThan(-150)
+ desc := matcher.Description()
+ expectedDesc := "greater than -150"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-(1 << 30), false, false, ""},
+ gtTestCase{-151, false, false, ""},
+ gtTestCase{-150, false, false, ""},
+ gtTestCase{-149, true, false, ""},
+ gtTestCase{0, true, false, ""},
+ gtTestCase{17, true, false, ""},
+
+ gtTestCase{int(-(1 << 30)), false, false, ""},
+ gtTestCase{int(-151), false, false, ""},
+ gtTestCase{int(-150), false, false, ""},
+ gtTestCase{int(-149), true, false, ""},
+ gtTestCase{int(0), true, false, ""},
+ gtTestCase{int(17), true, false, ""},
+
+ gtTestCase{int8(-127), true, false, ""},
+ gtTestCase{int8(0), true, false, ""},
+ gtTestCase{int8(17), true, false, ""},
+
+ gtTestCase{int16(-(1 << 14)), false, false, ""},
+ gtTestCase{int16(-151), false, false, ""},
+ gtTestCase{int16(-150), false, false, ""},
+ gtTestCase{int16(-149), true, false, ""},
+ gtTestCase{int16(0), true, false, ""},
+ gtTestCase{int16(17), true, false, ""},
+
+ gtTestCase{int32(-(1 << 30)), false, false, ""},
+ gtTestCase{int32(-151), false, false, ""},
+ gtTestCase{int32(-150), false, false, ""},
+ gtTestCase{int32(-149), true, false, ""},
+ gtTestCase{int32(0), true, false, ""},
+ gtTestCase{int32(17), true, false, ""},
+
+ gtTestCase{int64(-(1 << 30)), false, false, ""},
+ gtTestCase{int64(-151), false, false, ""},
+ gtTestCase{int64(-150), false, false, ""},
+ gtTestCase{int64(-149), true, false, ""},
+ gtTestCase{int64(0), true, false, ""},
+ gtTestCase{int64(17), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint((1 << 32) - 151), true, false, ""},
+ gtTestCase{uint(0), true, false, ""},
+ gtTestCase{uint(17), true, false, ""},
+
+ gtTestCase{uint8(0), true, false, ""},
+ gtTestCase{uint8(17), true, false, ""},
+ gtTestCase{uint8(253), true, false, ""},
+
+ gtTestCase{uint16((1 << 16) - 151), true, false, ""},
+ gtTestCase{uint16(0), true, false, ""},
+ gtTestCase{uint16(17), true, false, ""},
+
+ gtTestCase{uint32((1 << 32) - 151), true, false, ""},
+ gtTestCase{uint32(0), true, false, ""},
+ gtTestCase{uint32(17), true, false, ""},
+
+ gtTestCase{uint64((1 << 64) - 151), true, false, ""},
+ gtTestCase{uint64(0), true, false, ""},
+ gtTestCase{uint64(17), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float32(-(1 << 30)), false, false, ""},
+ gtTestCase{float32(-151), false, false, ""},
+ gtTestCase{float32(-150.1), false, false, ""},
+ gtTestCase{float32(-150), false, false, ""},
+ gtTestCase{float32(-149.9), true, false, ""},
+ gtTestCase{float32(0), true, false, ""},
+ gtTestCase{float32(17), true, false, ""},
+ gtTestCase{float32(160), true, false, ""},
+
+ gtTestCase{float64(-(1 << 30)), false, false, ""},
+ gtTestCase{float64(-151), false, false, ""},
+ gtTestCase{float64(-150.1), false, false, ""},
+ gtTestCase{float64(-150), false, false, ""},
+ gtTestCase{float64(-149.9), true, false, ""},
+ gtTestCase{float64(0), true, false, ""},
+ gtTestCase{float64(17), true, false, ""},
+ gtTestCase{float64(160), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) ZeroIntegerLiteral() {
+ matcher := GreaterThan(0)
+ desc := matcher.Description()
+ expectedDesc := "greater than 0"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-(1 << 30), false, false, ""},
+ gtTestCase{-1, false, false, ""},
+ gtTestCase{0, false, false, ""},
+ gtTestCase{1, true, false, ""},
+ gtTestCase{17, true, false, ""},
+ gtTestCase{(1 << 30), true, false, ""},
+
+ gtTestCase{int(-(1 << 30)), false, false, ""},
+ gtTestCase{int(-1), false, false, ""},
+ gtTestCase{int(0), false, false, ""},
+ gtTestCase{int(1), true, false, ""},
+ gtTestCase{int(17), true, false, ""},
+
+ gtTestCase{int8(-1), false, false, ""},
+ gtTestCase{int8(0), false, false, ""},
+ gtTestCase{int8(1), true, false, ""},
+
+ gtTestCase{int16(-(1 << 14)), false, false, ""},
+ gtTestCase{int16(-1), false, false, ""},
+ gtTestCase{int16(0), false, false, ""},
+ gtTestCase{int16(1), true, false, ""},
+ gtTestCase{int16(17), true, false, ""},
+
+ gtTestCase{int32(-(1 << 30)), false, false, ""},
+ gtTestCase{int32(-1), false, false, ""},
+ gtTestCase{int32(0), false, false, ""},
+ gtTestCase{int32(1), true, false, ""},
+ gtTestCase{int32(17), true, false, ""},
+
+ gtTestCase{int64(-(1 << 30)), false, false, ""},
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(0), false, false, ""},
+ gtTestCase{int64(1), true, false, ""},
+ gtTestCase{int64(17), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint((1 << 32) - 1), true, false, ""},
+ gtTestCase{uint(0), false, false, ""},
+ gtTestCase{uint(1), true, false, ""},
+ gtTestCase{uint(17), true, false, ""},
+
+ gtTestCase{uint8(0), false, false, ""},
+ gtTestCase{uint8(1), true, false, ""},
+ gtTestCase{uint8(17), true, false, ""},
+ gtTestCase{uint8(253), true, false, ""},
+
+ gtTestCase{uint16((1 << 16) - 1), true, false, ""},
+ gtTestCase{uint16(0), false, false, ""},
+ gtTestCase{uint16(1), true, false, ""},
+ gtTestCase{uint16(17), true, false, ""},
+
+ gtTestCase{uint32((1 << 32) - 1), true, false, ""},
+ gtTestCase{uint32(0), false, false, ""},
+ gtTestCase{uint32(1), true, false, ""},
+ gtTestCase{uint32(17), true, false, ""},
+
+ gtTestCase{uint64((1 << 64) - 1), true, false, ""},
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(1), true, false, ""},
+ gtTestCase{uint64(17), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float32(-(1 << 30)), false, false, ""},
+ gtTestCase{float32(-1), false, false, ""},
+ gtTestCase{float32(-0.1), false, false, ""},
+ gtTestCase{float32(-0.0), false, false, ""},
+ gtTestCase{float32(0), false, false, ""},
+ gtTestCase{float32(0.1), true, false, ""},
+ gtTestCase{float32(17), true, false, ""},
+ gtTestCase{float32(160), true, false, ""},
+
+ gtTestCase{float64(-(1 << 30)), false, false, ""},
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(-0.1), false, false, ""},
+ gtTestCase{float64(-0), false, false, ""},
+ gtTestCase{float64(0), false, false, ""},
+ gtTestCase{float64(0.1), true, false, ""},
+ gtTestCase{float64(17), true, false, ""},
+ gtTestCase{float64(160), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) PositiveIntegerLiteral() {
+ matcher := GreaterThan(150)
+ desc := matcher.Description()
+ expectedDesc := "greater than 150"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-1, false, false, ""},
+ gtTestCase{149, false, false, ""},
+ gtTestCase{150, false, false, ""},
+ gtTestCase{151, true, false, ""},
+
+ gtTestCase{int(-1), false, false, ""},
+ gtTestCase{int(149), false, false, ""},
+ gtTestCase{int(150), false, false, ""},
+ gtTestCase{int(151), true, false, ""},
+
+ gtTestCase{int8(-1), false, false, ""},
+ gtTestCase{int8(0), false, false, ""},
+ gtTestCase{int8(17), false, false, ""},
+ gtTestCase{int8(127), false, false, ""},
+
+ gtTestCase{int16(-1), false, false, ""},
+ gtTestCase{int16(149), false, false, ""},
+ gtTestCase{int16(150), false, false, ""},
+ gtTestCase{int16(151), true, false, ""},
+
+ gtTestCase{int32(-1), false, false, ""},
+ gtTestCase{int32(149), false, false, ""},
+ gtTestCase{int32(150), false, false, ""},
+ gtTestCase{int32(151), true, false, ""},
+
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(149), false, false, ""},
+ gtTestCase{int64(150), false, false, ""},
+ gtTestCase{int64(151), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint(0), false, false, ""},
+ gtTestCase{uint(149), false, false, ""},
+ gtTestCase{uint(150), false, false, ""},
+ gtTestCase{uint(151), true, false, ""},
+
+ gtTestCase{uint8(0), false, false, ""},
+ gtTestCase{uint8(127), false, false, ""},
+
+ gtTestCase{uint16(0), false, false, ""},
+ gtTestCase{uint16(149), false, false, ""},
+ gtTestCase{uint16(150), false, false, ""},
+ gtTestCase{uint16(151), true, false, ""},
+
+ gtTestCase{uint32(0), false, false, ""},
+ gtTestCase{uint32(149), false, false, ""},
+ gtTestCase{uint32(150), false, false, ""},
+ gtTestCase{uint32(151), true, false, ""},
+
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(149), false, false, ""},
+ gtTestCase{uint64(150), false, false, ""},
+ gtTestCase{uint64(151), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float32(-1), false, false, ""},
+ gtTestCase{float32(149), false, false, ""},
+ gtTestCase{float32(149.9), false, false, ""},
+ gtTestCase{float32(150), false, false, ""},
+ gtTestCase{float32(150.1), true, false, ""},
+ gtTestCase{float32(151), true, false, ""},
+
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(149), false, false, ""},
+ gtTestCase{float64(149.9), false, false, ""},
+ gtTestCase{float64(150), false, false, ""},
+ gtTestCase{float64(150.1), true, false, ""},
+ gtTestCase{float64(151), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Float literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) NegativeFloatLiteral() {
+ matcher := GreaterThan(-150.1)
+ desc := matcher.Description()
+ expectedDesc := "greater than -150.1"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-(1 << 30), false, false, ""},
+ gtTestCase{-151, false, false, ""},
+ gtTestCase{-150.1, false, false, ""},
+ gtTestCase{-150, true, false, ""},
+ gtTestCase{-149, true, false, ""},
+ gtTestCase{0, true, false, ""},
+ gtTestCase{17, true, false, ""},
+
+ gtTestCase{int(-(1 << 30)), false, false, ""},
+ gtTestCase{int(-151), false, false, ""},
+ gtTestCase{int(-150), true, false, ""},
+ gtTestCase{int(-149), true, false, ""},
+ gtTestCase{int(0), true, false, ""},
+ gtTestCase{int(17), true, false, ""},
+
+ gtTestCase{int8(-127), true, false, ""},
+ gtTestCase{int8(0), true, false, ""},
+ gtTestCase{int8(17), true, false, ""},
+
+ gtTestCase{int16(-(1 << 14)), false, false, ""},
+ gtTestCase{int16(-151), false, false, ""},
+ gtTestCase{int16(-150), true, false, ""},
+ gtTestCase{int16(-149), true, false, ""},
+ gtTestCase{int16(0), true, false, ""},
+ gtTestCase{int16(17), true, false, ""},
+
+ gtTestCase{int32(-(1 << 30)), false, false, ""},
+ gtTestCase{int32(-151), false, false, ""},
+ gtTestCase{int32(-150), true, false, ""},
+ gtTestCase{int32(-149), true, false, ""},
+ gtTestCase{int32(0), true, false, ""},
+ gtTestCase{int32(17), true, false, ""},
+
+ gtTestCase{int64(-(1 << 30)), false, false, ""},
+ gtTestCase{int64(-151), false, false, ""},
+ gtTestCase{int64(-150), true, false, ""},
+ gtTestCase{int64(-149), true, false, ""},
+ gtTestCase{int64(0), true, false, ""},
+ gtTestCase{int64(17), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint((1 << 32) - 151), true, false, ""},
+ gtTestCase{uint(0), true, false, ""},
+ gtTestCase{uint(17), true, false, ""},
+
+ gtTestCase{uint8(0), true, false, ""},
+ gtTestCase{uint8(17), true, false, ""},
+ gtTestCase{uint8(253), true, false, ""},
+
+ gtTestCase{uint16((1 << 16) - 151), true, false, ""},
+ gtTestCase{uint16(0), true, false, ""},
+ gtTestCase{uint16(17), true, false, ""},
+
+ gtTestCase{uint32((1 << 32) - 151), true, false, ""},
+ gtTestCase{uint32(0), true, false, ""},
+ gtTestCase{uint32(17), true, false, ""},
+
+ gtTestCase{uint64((1 << 64) - 151), true, false, ""},
+ gtTestCase{uint64(0), true, false, ""},
+ gtTestCase{uint64(17), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float32(-(1 << 30)), false, false, ""},
+ gtTestCase{float32(-151), false, false, ""},
+ gtTestCase{float32(-150.2), false, false, ""},
+ gtTestCase{float32(-150.1), false, false, ""},
+ gtTestCase{float32(-150), true, false, ""},
+ gtTestCase{float32(0), true, false, ""},
+ gtTestCase{float32(17), true, false, ""},
+ gtTestCase{float32(160), true, false, ""},
+
+ gtTestCase{float64(-(1 << 30)), false, false, ""},
+ gtTestCase{float64(-151), false, false, ""},
+ gtTestCase{float64(-150.2), false, false, ""},
+ gtTestCase{float64(-150.1), false, false, ""},
+ gtTestCase{float64(-150), true, false, ""},
+ gtTestCase{float64(0), true, false, ""},
+ gtTestCase{float64(17), true, false, ""},
+ gtTestCase{float64(160), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) PositiveFloatLiteral() {
+ matcher := GreaterThan(149.9)
+ desc := matcher.Description()
+ expectedDesc := "greater than 149.9"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-1, false, false, ""},
+ gtTestCase{149, false, false, ""},
+ gtTestCase{149.9, false, false, ""},
+ gtTestCase{150, true, false, ""},
+ gtTestCase{151, true, false, ""},
+
+ gtTestCase{int(-1), false, false, ""},
+ gtTestCase{int(149), false, false, ""},
+ gtTestCase{int(150), true, false, ""},
+ gtTestCase{int(151), true, false, ""},
+
+ gtTestCase{int8(-1), false, false, ""},
+ gtTestCase{int8(0), false, false, ""},
+ gtTestCase{int8(17), false, false, ""},
+ gtTestCase{int8(127), false, false, ""},
+
+ gtTestCase{int16(-1), false, false, ""},
+ gtTestCase{int16(149), false, false, ""},
+ gtTestCase{int16(150), true, false, ""},
+ gtTestCase{int16(151), true, false, ""},
+
+ gtTestCase{int32(-1), false, false, ""},
+ gtTestCase{int32(149), false, false, ""},
+ gtTestCase{int32(150), true, false, ""},
+ gtTestCase{int32(151), true, false, ""},
+
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(149), false, false, ""},
+ gtTestCase{int64(150), true, false, ""},
+ gtTestCase{int64(151), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint(0), false, false, ""},
+ gtTestCase{uint(149), false, false, ""},
+ gtTestCase{uint(150), true, false, ""},
+ gtTestCase{uint(151), true, false, ""},
+
+ gtTestCase{uint8(0), false, false, ""},
+ gtTestCase{uint8(127), false, false, ""},
+
+ gtTestCase{uint16(0), false, false, ""},
+ gtTestCase{uint16(149), false, false, ""},
+ gtTestCase{uint16(150), true, false, ""},
+ gtTestCase{uint16(151), true, false, ""},
+
+ gtTestCase{uint32(0), false, false, ""},
+ gtTestCase{uint32(149), false, false, ""},
+ gtTestCase{uint32(150), true, false, ""},
+ gtTestCase{uint32(151), true, false, ""},
+
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(149), false, false, ""},
+ gtTestCase{uint64(150), true, false, ""},
+ gtTestCase{uint64(151), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float32(-1), false, false, ""},
+ gtTestCase{float32(149), false, false, ""},
+ gtTestCase{float32(149.8), false, false, ""},
+ gtTestCase{float32(149.9), false, false, ""},
+ gtTestCase{float32(150), true, false, ""},
+ gtTestCase{float32(151), true, false, ""},
+
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(149), false, false, ""},
+ gtTestCase{float64(149.8), false, false, ""},
+ gtTestCase{float64(149.9), false, false, ""},
+ gtTestCase{float64(150), true, false, ""},
+ gtTestCase{float64(151), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// Subtle cases
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) Int64NotExactlyRepresentableBySinglePrecision() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := GreaterThan(int64(kTwoTo25 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than 33554433"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-1, false, false, ""},
+ gtTestCase{kTwoTo25 + 0, false, false, ""},
+ gtTestCase{kTwoTo25 + 1, false, false, ""},
+ gtTestCase{kTwoTo25 + 2, true, false, ""},
+
+ gtTestCase{int(-1), false, false, ""},
+ gtTestCase{int(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{int(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{int(kTwoTo25 + 2), true, false, ""},
+
+ gtTestCase{int8(-1), false, false, ""},
+ gtTestCase{int8(127), false, false, ""},
+
+ gtTestCase{int16(-1), false, false, ""},
+ gtTestCase{int16(0), false, false, ""},
+ gtTestCase{int16(32767), false, false, ""},
+
+ gtTestCase{int32(-1), false, false, ""},
+ gtTestCase{int32(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{int32(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{int32(kTwoTo25 + 2), true, false, ""},
+
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 2), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint(0), false, false, ""},
+ gtTestCase{uint(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{uint(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{uint(kTwoTo25 + 2), true, false, ""},
+
+ gtTestCase{uint8(0), false, false, ""},
+ gtTestCase{uint8(255), false, false, ""},
+
+ gtTestCase{uint16(0), false, false, ""},
+ gtTestCase{uint16(65535), false, false, ""},
+
+ gtTestCase{uint32(0), false, false, ""},
+ gtTestCase{uint32(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{uint32(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{uint32(kTwoTo25 + 2), true, false, ""},
+
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float32(-1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ gtTestCase{float32(kTwoTo25 - 1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 2), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 - 2), false, false, ""},
+ gtTestCase{float64(kTwoTo25 - 1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 2), true, false, ""},
+ gtTestCase{float64(kTwoTo25 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Int64NotExactlyRepresentableByDoublePrecision() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := GreaterThan(int64(kTwoTo54 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than 18014398509481985"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-1, false, false, ""},
+ gtTestCase{1 << 30, false, false, ""},
+
+ gtTestCase{int(-1), false, false, ""},
+ gtTestCase{int(math.MaxInt32), false, false, ""},
+
+ gtTestCase{int8(-1), false, false, ""},
+ gtTestCase{int8(127), false, false, ""},
+
+ gtTestCase{int16(-1), false, false, ""},
+ gtTestCase{int16(0), false, false, ""},
+ gtTestCase{int16(32767), false, false, ""},
+
+ gtTestCase{int32(-1), false, false, ""},
+ gtTestCase{int32(math.MaxInt32), false, false, ""},
+
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 2), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint(0), false, false, ""},
+ gtTestCase{uint(math.MaxUint32), false, false, ""},
+
+ gtTestCase{uint8(0), false, false, ""},
+ gtTestCase{uint8(255), false, false, ""},
+
+ gtTestCase{uint16(0), false, false, ""},
+ gtTestCase{uint16(65535), false, false, ""},
+
+ gtTestCase{uint32(0), false, false, ""},
+ gtTestCase{uint32(math.MaxUint32), false, false, ""},
+
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ gtTestCase{float64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 2), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Uint64NotExactlyRepresentableBySinglePrecision() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := GreaterThan(uint64(kTwoTo25 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than 33554433"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-1, false, false, ""},
+ gtTestCase{kTwoTo25 + 0, false, false, ""},
+ gtTestCase{kTwoTo25 + 1, false, false, ""},
+ gtTestCase{kTwoTo25 + 2, true, false, ""},
+
+ gtTestCase{int(-1), false, false, ""},
+ gtTestCase{int(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{int(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{int(kTwoTo25 + 2), true, false, ""},
+
+ gtTestCase{int8(-1), false, false, ""},
+ gtTestCase{int8(127), false, false, ""},
+
+ gtTestCase{int16(-1), false, false, ""},
+ gtTestCase{int16(0), false, false, ""},
+ gtTestCase{int16(32767), false, false, ""},
+
+ gtTestCase{int32(-1), false, false, ""},
+ gtTestCase{int32(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{int32(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{int32(kTwoTo25 + 2), true, false, ""},
+
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 2), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint(0), false, false, ""},
+ gtTestCase{uint(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{uint(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{uint(kTwoTo25 + 2), true, false, ""},
+
+ gtTestCase{uint8(0), false, false, ""},
+ gtTestCase{uint8(255), false, false, ""},
+
+ gtTestCase{uint16(0), false, false, ""},
+ gtTestCase{uint16(65535), false, false, ""},
+
+ gtTestCase{uint32(0), false, false, ""},
+ gtTestCase{uint32(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{uint32(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{uint32(kTwoTo25 + 2), true, false, ""},
+
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 2), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float32(-1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ gtTestCase{float32(kTwoTo25 - 1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 2), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 - 2), false, false, ""},
+ gtTestCase{float64(kTwoTo25 - 1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 2), true, false, ""},
+ gtTestCase{float64(kTwoTo25 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Uint64NotExactlyRepresentableByDoublePrecision() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := GreaterThan(uint64(kTwoTo54 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than 18014398509481985"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{-1, false, false, ""},
+ gtTestCase{1 << 30, false, false, ""},
+
+ gtTestCase{int(-1), false, false, ""},
+ gtTestCase{int(math.MaxInt32), false, false, ""},
+
+ gtTestCase{int8(-1), false, false, ""},
+ gtTestCase{int8(127), false, false, ""},
+
+ gtTestCase{int16(-1), false, false, ""},
+ gtTestCase{int16(0), false, false, ""},
+ gtTestCase{int16(32767), false, false, ""},
+
+ gtTestCase{int32(-1), false, false, ""},
+ gtTestCase{int32(math.MaxInt32), false, false, ""},
+
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 2), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint(0), false, false, ""},
+ gtTestCase{uint(math.MaxUint32), false, false, ""},
+
+ gtTestCase{uint8(0), false, false, ""},
+ gtTestCase{uint8(255), false, false, ""},
+
+ gtTestCase{uint16(0), false, false, ""},
+ gtTestCase{uint16(65535), false, false, ""},
+
+ gtTestCase{uint32(0), false, false, ""},
+ gtTestCase{uint32(math.MaxUint32), false, false, ""},
+
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 2), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ gtTestCase{float64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 2), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Float32AboveExactIntegerRange() {
+ // Single-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^25-1, 2^25+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo25 = 1 << 25
+ matcher := GreaterThan(float32(kTwoTo25 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than 3.3554432e+07"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(kTwoTo25 - 2), false, false, ""},
+ gtTestCase{int64(kTwoTo25 - 1), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 2), false, false, ""},
+ gtTestCase{int64(kTwoTo25 + 3), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 - 2), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 - 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 2), false, false, ""},
+ gtTestCase{uint64(kTwoTo25 + 3), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float32(-1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 - 2), false, false, ""},
+ gtTestCase{float32(kTwoTo25 - 1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 2), false, false, ""},
+ gtTestCase{float32(kTwoTo25 + 3), true, false, ""},
+
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 - 2), false, false, ""},
+ gtTestCase{float64(kTwoTo25 - 1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 0), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 1), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 2), false, false, ""},
+ gtTestCase{float64(kTwoTo25 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) Float64AboveExactIntegerRange() {
+ // Double-precision floats don't have enough bits to represent the integers
+ // near this one distinctly, so [2^54-1, 2^54+2] all receive the same value
+ // and should be treated as equivalent when floats are in the mix.
+ const kTwoTo54 = 1 << 54
+ matcher := GreaterThan(float64(kTwoTo54 + 1))
+
+ desc := matcher.Description()
+ expectedDesc := "greater than 1.8014398509481984e+16"
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ // Signed integers.
+ gtTestCase{int64(-1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 - 2), false, false, ""},
+ gtTestCase{int64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 2), false, false, ""},
+ gtTestCase{int64(kTwoTo54 + 3), true, false, ""},
+
+ // Unsigned integers.
+ gtTestCase{uint64(0), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 - 2), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 2), false, false, ""},
+ gtTestCase{uint64(kTwoTo54 + 3), true, false, ""},
+
+ // Floating point.
+ gtTestCase{float64(-1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 - 2), false, false, ""},
+ gtTestCase{float64(kTwoTo54 - 1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 0), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 1), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 2), false, false, ""},
+ gtTestCase{float64(kTwoTo54 + 3), true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+////////////////////////////////////////////////////////////////////////
+// String literals
+////////////////////////////////////////////////////////////////////////
+
+func (t *GreaterThanTest) EmptyString() {
+ matcher := GreaterThan("")
+ desc := matcher.Description()
+ expectedDesc := "greater than \"\""
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ gtTestCase{"", false, false, ""},
+ gtTestCase{"\x00", true, false, ""},
+ gtTestCase{"a", true, false, ""},
+ gtTestCase{"foo", true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) SingleNullByte() {
+ matcher := GreaterThan("\x00")
+ desc := matcher.Description()
+ expectedDesc := "greater than \"\x00\""
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ gtTestCase{"", false, false, ""},
+ gtTestCase{"\x00", false, false, ""},
+ gtTestCase{"\x00\x00", true, false, ""},
+ gtTestCase{"a", true, false, ""},
+ gtTestCase{"foo", true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
+
+func (t *GreaterThanTest) LongerString() {
+ matcher := GreaterThan("foo\x00")
+ desc := matcher.Description()
+ expectedDesc := "greater than \"foo\x00\""
+
+ ExpectThat(desc, Equals(expectedDesc))
+
+ cases := []gtTestCase{
+ gtTestCase{"", false, false, ""},
+ gtTestCase{"\x00", false, false, ""},
+ gtTestCase{"bar", false, false, ""},
+ gtTestCase{"foo", false, false, ""},
+ gtTestCase{"foo\x00", false, false, ""},
+ gtTestCase{"foo\x00\x00", true, false, ""},
+ gtTestCase{"fooa", true, false, ""},
+ gtTestCase{"qux", true, false, ""},
+ }
+
+ t.checkTestCases(matcher, cases)
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as.go
new file mode 100644
index 0000000..3b286f7
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as.go
@@ -0,0 +1,37 @@
+// Copyright 2015 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
+
+import (
+ "fmt"
+ "reflect"
+)
+
+// HasSameTypeAs returns a matcher that matches values with exactly the same
+// type as the supplied prototype.
+func HasSameTypeAs(p interface{}) Matcher {
+ expected := reflect.TypeOf(p)
+ pred := func(c interface{}) error {
+ actual := reflect.TypeOf(c)
+ if actual != expected {
+ return fmt.Errorf("which has type %v", actual)
+ }
+
+ return nil
+ }
+
+ return NewMatcher(pred, fmt.Sprintf("has type %v", expected))
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as_test.go
new file mode 100644
index 0000000..9d959e2
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_same_type_as_test.go
@@ -0,0 +1,181 @@
+// Copyright 2015 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 (
+ "io"
+ "testing"
+
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/ogletest"
+)
+
+func TestHasSameTypeAs(t *testing.T) { RunTests(t) }
+
+////////////////////////////////////////////////////////////////////////
+// Boilerplate
+////////////////////////////////////////////////////////////////////////
+
+type HasSameTypeAsTest struct {
+}
+
+func init() { RegisterTestSuite(&HasSameTypeAsTest{}) }
+
+////////////////////////////////////////////////////////////////////////
+// Tests
+////////////////////////////////////////////////////////////////////////
+
+func (t *HasSameTypeAsTest) CandidateIsLiteralNil() {
+ matcher := HasSameTypeAs(nil)
+ var err error
+
+ // Description
+ ExpectEq("has type ", matcher.Description())
+
+ // Literal nil
+ err = matcher.Matches(nil)
+ ExpectEq(nil, err)
+
+ // nil in interface variable
+ var r io.Reader
+ err = matcher.Matches(r)
+ ExpectEq(nil, err)
+
+ // int
+ err = matcher.Matches(17)
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type int")))
+
+ // string
+ err = matcher.Matches("")
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type string")))
+
+ // nil map
+ var m map[string]string
+ err = matcher.Matches(m)
+
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type map[string]string")))
+
+ // Non-nil map
+ m = make(map[string]string)
+ err = matcher.Matches(m)
+
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type map[string]string")))
+}
+
+func (t *HasSameTypeAsTest) CandidateIsNilMap() {
+ var m map[string]string
+ matcher := HasSameTypeAs(m)
+ var err error
+
+ // Description
+ ExpectEq("has type map[string]string", matcher.Description())
+
+ // nil map
+ m = nil
+ err = matcher.Matches(m)
+ ExpectEq(nil, err)
+
+ // Non-nil map
+ m = make(map[string]string)
+ err = matcher.Matches(m)
+ ExpectEq(nil, err)
+
+ // Literal nil
+ err = matcher.Matches(nil)
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type ")))
+
+ // int
+ err = matcher.Matches(17)
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type int")))
+
+ // string
+ err = matcher.Matches("")
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type string")))
+}
+
+func (t *HasSameTypeAsTest) CandidateIsNilInInterfaceVariable() {
+ var r io.Reader
+ matcher := HasSameTypeAs(r)
+ var err error
+
+ // Description
+ ExpectEq("has type ", matcher.Description())
+
+ // nil in interface variable
+ r = nil
+ err = matcher.Matches(r)
+ ExpectEq(nil, err)
+
+ // Literal nil
+ err = matcher.Matches(nil)
+ ExpectEq(nil, err)
+
+ // int
+ err = matcher.Matches(17)
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type int")))
+}
+
+func (t *HasSameTypeAsTest) CandidateIsString() {
+ matcher := HasSameTypeAs("")
+ var err error
+
+ // Description
+ ExpectEq("has type string", matcher.Description())
+
+ // string
+ err = matcher.Matches("taco")
+ ExpectEq(nil, err)
+
+ // string alias
+ type Foo string
+ err = matcher.Matches(Foo("taco"))
+ ExpectThat(err, Error(MatchesRegexp("which has type .*Foo")))
+
+ // Literal nil
+ err = matcher.Matches(nil)
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type ")))
+
+ // int
+ err = matcher.Matches(17)
+ AssertNe(nil, err)
+ ExpectThat(err, Error(Equals("which has type int")))
+}
+
+func (t *HasSameTypeAsTest) CandidateIsStringAlias() {
+ type Foo string
+ matcher := HasSameTypeAs(Foo(""))
+ var err error
+
+ // Description
+ ExpectThat(matcher.Description(), MatchesRegexp("has type .*Foo"))
+
+ // string alias
+ err = matcher.Matches(Foo("taco"))
+ ExpectEq(nil, err)
+
+ // string
+ err = matcher.Matches("taco")
+ ExpectThat(err, Error(Equals("which has type string")))
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_substr.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_substr.go
new file mode 100644
index 0000000..bf5bd6a
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_substr.go
@@ -0,0 +1,46 @@
+// 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
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "strings"
+)
+
+// HasSubstr returns a matcher that matches strings containing s as a
+// substring.
+func HasSubstr(s string) Matcher {
+ return NewMatcher(
+ func(c interface{}) error { return hasSubstr(s, c) },
+ fmt.Sprintf("has substring \"%s\"", s))
+}
+
+func hasSubstr(needle string, c interface{}) error {
+ v := reflect.ValueOf(c)
+ if v.Kind() != reflect.String {
+ return NewFatalError("which is not a string")
+ }
+
+ // Perform the substring search.
+ haystack := v.String()
+ if strings.Contains(haystack, needle) {
+ return nil
+ }
+
+ return errors.New("")
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_substr_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_substr_test.go
new file mode 100644
index 0000000..8ba2220
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/has_substr_test.go
@@ -0,0 +1,92 @@
+// 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/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/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))
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/identical_to.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/identical_to.go
new file mode 100644
index 0000000..ae6460e
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/identical_to.go
@@ -0,0 +1,134 @@
+// 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
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+)
+
+// Is the type comparable according to the definition here?
+//
+// http://weekly.golang.org/doc/go_spec.html#Comparison_operators
+//
+func isComparable(t reflect.Type) bool {
+ switch t.Kind() {
+ case reflect.Array:
+ return isComparable(t.Elem())
+
+ case reflect.Struct:
+ for i := 0; i < t.NumField(); i++ {
+ if !isComparable(t.Field(i).Type) {
+ return false
+ }
+ }
+
+ return true
+
+ case reflect.Slice, reflect.Map, reflect.Func:
+ return false
+ }
+
+ return true
+}
+
+// Should the supplied type be allowed as an argument to IdenticalTo?
+func isLegalForIdenticalTo(t reflect.Type) (bool, error) {
+ // Allow the zero type.
+ if t == nil {
+ return true, nil
+ }
+
+ // Reference types are always okay; we compare pointers.
+ switch t.Kind() {
+ case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan:
+ return true, nil
+ }
+
+ // Reject other non-comparable types.
+ if !isComparable(t) {
+ return false, errors.New(fmt.Sprintf("%v is not comparable", t))
+ }
+
+ return true, nil
+}
+
+// IdenticalTo(x) returns a matcher that matches values v with type identical
+// to x such that:
+//
+// 1. If v and x are of a reference type (slice, map, function, channel), then
+// they are either both nil or are references to the same object.
+//
+// 2. Otherwise, if v and x are not of a reference type but have a valid type,
+// then v == x.
+//
+// If v and x are both the invalid type (which results from the predeclared nil
+// value, or from nil interface variables), then the matcher is satisfied.
+//
+// This function will panic if x is of a value type that is not comparable. For
+// example, x cannot be an array of functions.
+func IdenticalTo(x interface{}) Matcher {
+ t := reflect.TypeOf(x)
+
+ // Reject illegal arguments.
+ if ok, err := isLegalForIdenticalTo(t); !ok {
+ panic("IdenticalTo: " + err.Error())
+ }
+
+ return &identicalToMatcher{x}
+}
+
+type identicalToMatcher struct {
+ x interface{}
+}
+
+func (m *identicalToMatcher) Description() string {
+ t := reflect.TypeOf(m.x)
+ return fmt.Sprintf("identical to <%v> %v", t, m.x)
+}
+
+func (m *identicalToMatcher) Matches(c interface{}) error {
+ // Make sure the candidate's type is correct.
+ t := reflect.TypeOf(m.x)
+ if ct := reflect.TypeOf(c); t != ct {
+ return NewFatalError(fmt.Sprintf("which is of type %v", ct))
+ }
+
+ // Special case: two values of the invalid type are always identical.
+ if t == nil {
+ return nil
+ }
+
+ // Handle reference types.
+ switch t.Kind() {
+ case reflect.Slice, reflect.Map, reflect.Func, reflect.Chan:
+ xv := reflect.ValueOf(m.x)
+ cv := reflect.ValueOf(c)
+ if xv.Pointer() == cv.Pointer() {
+ return nil
+ }
+
+ return errors.New("which is not an identical reference")
+ }
+
+ // Are the values equal?
+ if m.x == c {
+ return nil
+ }
+
+ return errors.New("")
+}
diff --git a/vendor/github.com/smartystreets/assertions/internal/oglematchers/identical_to_test.go b/vendor/github.com/smartystreets/assertions/internal/oglematchers/identical_to_test.go
new file mode 100644
index 0000000..047754c
--- /dev/null
+++ b/vendor/github.com/smartystreets/assertions/internal/oglematchers/identical_to_test.go
@@ -0,0 +1,849 @@
+// 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"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/oglematchers"
+ . "github.com/moul/ssh2docker/vendor/github.com/smartystreets/assertions/internal/ogletest"
+ "io"
+ "unsafe"
+)
+
+////////////////////////////////////////////////////////////////////////
+// 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