diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
deleted file mode 100644
index d3c54ebeb5d6d3f94b7219798f7603800dc8d421..0000000000000000000000000000000000000000
--- a/Godeps/Godeps.json
+++ /dev/null
@@ -1,194 +0,0 @@
-{
- "ImportPath": "github.com/eris-ltd/eris-db",
- "GoVersion": "go1.4.2",
- "Packages": [
- "./..."
- ],
- "Deps": [
- {
- "ImportPath": "code.google.com/p/go.crypto/ripemd160",
- "Comment": "null-236",
- "Rev": "69e2a90ed92d03812364aeb947b7068dc42e561e"
- },
- {
- "ImportPath": "code.google.com/p/mxk/go1/flowcontrol",
- "Comment": "null-12",
- "Rev": "5ff2502e25566863e8a0136c7aae8838e4c7de39"
- },
- {
- "ImportPath": "github.com/agl/ed25519/edwards25519",
- "Rev": "d2b94fd789ea21d12fac1a4443dd3a3f79cda72c"
- },
- {
- "ImportPath": "github.com/gin-gonic/gin",
- "Comment": "v1.0rc1-99-gd6425f1",
- "Rev": "d6425f1692d4aa170ece887b62bb75c9c4da5829"
- },
- {
- "ImportPath": "github.com/gorilla/websocket",
- "Rev": "6fd0f867fef40c540fa05c59f86396de10a632a6"
- },
- {
- "ImportPath": "github.com/inconshreveable/log15/stack",
- "Comment": "v2.3-38-g352fceb",
- "Rev": "352fceb48e895bd1dd0b9f5d3ae8f8516c49af0f"
- },
- {
- "ImportPath": "github.com/inconshreveable/log15/term",
- "Comment": "v2.3-38-g352fceb",
- "Rev": "352fceb48e895bd1dd0b9f5d3ae8f8516c49af0f"
- },
- {
- "ImportPath": "github.com/manucorporat/sse",
- "Rev": "c142f0f1baea5cef7f98a8a6c222f6134368c1f5"
- },
- {
- "ImportPath": "github.com/mattn/go-colorable",
- "Rev": "d67e0b7d1797975196499f79bcc322c08b9f218b"
- },
- {
- "ImportPath": "github.com/naoina/go-stringutil",
- "Rev": "360db0db4b01d34e12a2ec042c09e7d37fece761"
- },
- {
- "ImportPath": "github.com/naoina/toml",
- "Rev": "7b2dffbeaee47506726f29e36d19cf4ee90d361b"
- },
- {
- "ImportPath": "github.com/sfreiberg/gotwilio",
- "Rev": "b7230c284bd0c1614c94d00b9998c49f9a2737d8"
- },
- {
- "ImportPath": "github.com/stretchr/testify/assert",
- "Rev": "de7fcff264cd05cc0c90c509ea789a436a0dd206"
- },
- {
- "ImportPath": "github.com/stretchr/testify/suite",
- "Rev": "de7fcff264cd05cc0c90c509ea789a436a0dd206"
- },
- {
- "ImportPath": "github.com/syndtr/goleveldb/leveldb",
- "Rev": "315fcfb05d4d46d4354b313d146ef688dda272a9"
- },
- {
- "ImportPath": "github.com/syndtr/gosnappy/snappy",
- "Rev": "156a073208e131d7d2e212cb749feae7c339e846"
- },
- {
- "ImportPath": "github.com/tendermint/ed25519",
- "Rev": "533fb6548e2071076888eda3c38749d707ba49bc"
- },
- {
- "ImportPath": "github.com/tendermint/log15",
- "Comment": "v2.3-33-g105a1be",
- "Rev": "105a1beefe3379227a0d61733a29fd2c34f7080c"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/account",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/alert",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/binary",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/blockchain",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/common",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/config",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/consensus",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/db",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/events",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/logger",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/mempool",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/merkle",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/node",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/p2p",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/rpc/core",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/rpc/server",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/rpc/types",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/state",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/types",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tendermint/tendermint/vm",
- "Rev": "46bd0e5d51692347647bb2e250fd0e637fc63a11"
- },
- {
- "ImportPath": "github.com/tommy351/gin-cors",
- "Rev": "f7219a698f21b23d73ae9330d3c5842951ce0b6a"
- },
- {
- "ImportPath": "golang.org/x/net/context",
- "Rev": "3cffabab72adf04f8e3b01c5baf775361837b5fe"
- },
- {
- "ImportPath": "golang.org/x/net/netutil",
- "Rev": "3cffabab72adf04f8e3b01c5baf775361837b5fe"
- },
- {
- "ImportPath": "gopkg.in/bluesuncorp/validator.v5",
- "Comment": "v5.7.1",
- "Rev": "df95f9de27b8022e57f8ce09448cee6b1170bb3d"
- },
- {
- "ImportPath": "gopkg.in/fatih/set.v0",
- "Comment": "v0.1.0-3-g27c4092",
- "Rev": "27c40922c40b43fe04554d8223a402af3ea333f3"
- },
- {
- "ImportPath": "gopkg.in/tylerb/graceful.v1",
- "Comment": "v1.1",
- "Rev": "ff79a7f00848198d26054b472aafb1043c4b3507"
- }
- ]
-}
diff --git a/Godeps/Readme b/Godeps/Readme
deleted file mode 100644
index 4e61f8e5ef75161801409e9197ea133574d258e9..0000000000000000000000000000000000000000
--- a/Godeps/Readme
+++ /dev/null
@@ -1,6 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-
-See https://github.com/tools/godep for more information.
diff --git a/Godeps/_workspace/.gitignore b/Godeps/_workspace/.gitignore
deleted file mode 100644
index f037d684ef2bd64c0ed8a87d7e85977324b277de..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/pkg
-/bin
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/context.go b/Godeps/_workspace/src/golang.org/x/net/context/context.go
deleted file mode 100644
index ef2f3e86fececf4f60a8a7196cc7ef6631fe9919..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/golang.org/x/net/context/context.go
+++ /dev/null
@@ -1,447 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package context defines the Context type, which carries deadlines,
-// cancelation signals, and other request-scoped values across API boundaries
-// and between processes.
-//
-// Incoming requests to a server should create a Context, and outgoing calls to
-// servers should accept a Context. The chain of function calls between must
-// propagate the Context, optionally replacing it with a modified copy created
-// using WithDeadline, WithTimeout, WithCancel, or WithValue.
-//
-// Programs that use Contexts should follow these rules to keep interfaces
-// consistent across packages and enable static analysis tools to check context
-// propagation:
-//
-// Do not store Contexts inside a struct type; instead, pass a Context
-// explicitly to each function that needs it. The Context should be the first
-// parameter, typically named ctx:
-//
-// func DoSomething(ctx context.Context, arg Arg) error {
-// // ... use ctx ...
-// }
-//
-// Do not pass a nil Context, even if a function permits it. Pass context.TODO
-// if you are unsure about which Context to use.
-//
-// Use context Values only for request-scoped data that transits processes and
-// APIs, not for passing optional parameters to functions.
-//
-// The same Context may be passed to functions running in different goroutines;
-// Contexts are safe for simultaneous use by multiple goroutines.
-//
-// See http://blog.golang.org/context for example code for a server that uses
-// Contexts.
-package context
-
-import (
- "errors"
- "fmt"
- "sync"
- "time"
-)
-
-// A Context carries a deadline, a cancelation signal, and other values across
-// API boundaries.
-//
-// Context's methods may be called by multiple goroutines simultaneously.
-type Context interface {
- // Deadline returns the time when work done on behalf of this context
- // should be canceled. Deadline returns ok==false when no deadline is
- // set. Successive calls to Deadline return the same results.
- Deadline() (deadline time.Time, ok bool)
-
- // Done returns a channel that's closed when work done on behalf of this
- // context should be canceled. Done may return nil if this context can
- // never be canceled. Successive calls to Done return the same value.
- //
- // WithCancel arranges for Done to be closed when cancel is called;
- // WithDeadline arranges for Done to be closed when the deadline
- // expires; WithTimeout arranges for Done to be closed when the timeout
- // elapses.
- //
- // Done is provided for use in select statements:
- //
- // // Stream generates values with DoSomething and sends them to out
- // // until DoSomething returns an error or ctx.Done is closed.
- // func Stream(ctx context.Context, out <-chan Value) error {
- // for {
- // v, err := DoSomething(ctx)
- // if err != nil {
- // return err
- // }
- // select {
- // case <-ctx.Done():
- // return ctx.Err()
- // case out <- v:
- // }
- // }
- // }
- //
- // See http://blog.golang.org/pipelines for more examples of how to use
- // a Done channel for cancelation.
- Done() <-chan struct{}
-
- // Err returns a non-nil error value after Done is closed. Err returns
- // Canceled if the context was canceled or DeadlineExceeded if the
- // context's deadline passed. No other values for Err are defined.
- // After Done is closed, successive calls to Err return the same value.
- Err() error
-
- // Value returns the value associated with this context for key, or nil
- // if no value is associated with key. Successive calls to Value with
- // the same key returns the same result.
- //
- // Use context values only for request-scoped data that transits
- // processes and API boundaries, not for passing optional parameters to
- // functions.
- //
- // A key identifies a specific value in a Context. Functions that wish
- // to store values in Context typically allocate a key in a global
- // variable then use that key as the argument to context.WithValue and
- // Context.Value. A key can be any type that supports equality;
- // packages should define keys as an unexported type to avoid
- // collisions.
- //
- // Packages that define a Context key should provide type-safe accessors
- // for the values stores using that key:
- //
- // // Package user defines a User type that's stored in Contexts.
- // package user
- //
- // import "golang.org/x/net/context"
- //
- // // User is the type of value stored in the Contexts.
- // type User struct {...}
- //
- // // key is an unexported type for keys defined in this package.
- // // This prevents collisions with keys defined in other packages.
- // type key int
- //
- // // userKey is the key for user.User values in Contexts. It is
- // // unexported; clients use user.NewContext and user.FromContext
- // // instead of using this key directly.
- // var userKey key = 0
- //
- // // NewContext returns a new Context that carries value u.
- // func NewContext(ctx context.Context, u *User) context.Context {
- // return context.WithValue(ctx, userKey, u)
- // }
- //
- // // FromContext returns the User value stored in ctx, if any.
- // func FromContext(ctx context.Context) (*User, bool) {
- // u, ok := ctx.Value(userKey).(*User)
- // return u, ok
- // }
- Value(key interface{}) interface{}
-}
-
-// Canceled is the error returned by Context.Err when the context is canceled.
-var Canceled = errors.New("context canceled")
-
-// DeadlineExceeded is the error returned by Context.Err when the context's
-// deadline passes.
-var DeadlineExceeded = errors.New("context deadline exceeded")
-
-// An emptyCtx is never canceled, has no values, and has no deadline. It is not
-// struct{}, since vars of this type must have distinct addresses.
-type emptyCtx int
-
-func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {
- return
-}
-
-func (*emptyCtx) Done() <-chan struct{} {
- return nil
-}
-
-func (*emptyCtx) Err() error {
- return nil
-}
-
-func (*emptyCtx) Value(key interface{}) interface{} {
- return nil
-}
-
-func (e *emptyCtx) String() string {
- switch e {
- case background:
- return "context.Background"
- case todo:
- return "context.TODO"
- }
- return "unknown empty Context"
-}
-
-var (
- background = new(emptyCtx)
- todo = new(emptyCtx)
-)
-
-// Background returns a non-nil, empty Context. It is never canceled, has no
-// values, and has no deadline. It is typically used by the main function,
-// initialization, and tests, and as the top-level Context for incoming
-// requests.
-func Background() Context {
- return background
-}
-
-// TODO returns a non-nil, empty Context. Code should use context.TODO when
-// it's unclear which Context to use or it's is not yet available (because the
-// surrounding function has not yet been extended to accept a Context
-// parameter). TODO is recognized by static analysis tools that determine
-// whether Contexts are propagated correctly in a program.
-func TODO() Context {
- return todo
-}
-
-// A CancelFunc tells an operation to abandon its work.
-// A CancelFunc does not wait for the work to stop.
-// After the first call, subsequent calls to a CancelFunc do nothing.
-type CancelFunc func()
-
-// WithCancel returns a copy of parent with a new Done channel. The returned
-// context's Done channel is closed when the returned cancel function is called
-// or when the parent context's Done channel is closed, whichever happens first.
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete.
-func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
- c := newCancelCtx(parent)
- propagateCancel(parent, &c)
- return &c, func() { c.cancel(true, Canceled) }
-}
-
-// newCancelCtx returns an initialized cancelCtx.
-func newCancelCtx(parent Context) cancelCtx {
- return cancelCtx{
- Context: parent,
- done: make(chan struct{}),
- }
-}
-
-// propagateCancel arranges for child to be canceled when parent is.
-func propagateCancel(parent Context, child canceler) {
- if parent.Done() == nil {
- return // parent is never canceled
- }
- if p, ok := parentCancelCtx(parent); ok {
- p.mu.Lock()
- if p.err != nil {
- // parent has already been canceled
- child.cancel(false, p.err)
- } else {
- if p.children == nil {
- p.children = make(map[canceler]bool)
- }
- p.children[child] = true
- }
- p.mu.Unlock()
- } else {
- go func() {
- select {
- case <-parent.Done():
- child.cancel(false, parent.Err())
- case <-child.Done():
- }
- }()
- }
-}
-
-// parentCancelCtx follows a chain of parent references until it finds a
-// *cancelCtx. This function understands how each of the concrete types in this
-// package represents its parent.
-func parentCancelCtx(parent Context) (*cancelCtx, bool) {
- for {
- switch c := parent.(type) {
- case *cancelCtx:
- return c, true
- case *timerCtx:
- return &c.cancelCtx, true
- case *valueCtx:
- parent = c.Context
- default:
- return nil, false
- }
- }
-}
-
-// removeChild removes a context from its parent.
-func removeChild(parent Context, child canceler) {
- p, ok := parentCancelCtx(parent)
- if !ok {
- return
- }
- p.mu.Lock()
- if p.children != nil {
- delete(p.children, child)
- }
- p.mu.Unlock()
-}
-
-// A canceler is a context type that can be canceled directly. The
-// implementations are *cancelCtx and *timerCtx.
-type canceler interface {
- cancel(removeFromParent bool, err error)
- Done() <-chan struct{}
-}
-
-// A cancelCtx can be canceled. When canceled, it also cancels any children
-// that implement canceler.
-type cancelCtx struct {
- Context
-
- done chan struct{} // closed by the first cancel call.
-
- mu sync.Mutex
- children map[canceler]bool // set to nil by the first cancel call
- err error // set to non-nil by the first cancel call
-}
-
-func (c *cancelCtx) Done() <-chan struct{} {
- return c.done
-}
-
-func (c *cancelCtx) Err() error {
- c.mu.Lock()
- defer c.mu.Unlock()
- return c.err
-}
-
-func (c *cancelCtx) String() string {
- return fmt.Sprintf("%v.WithCancel", c.Context)
-}
-
-// cancel closes c.done, cancels each of c's children, and, if
-// removeFromParent is true, removes c from its parent's children.
-func (c *cancelCtx) cancel(removeFromParent bool, err error) {
- if err == nil {
- panic("context: internal error: missing cancel error")
- }
- c.mu.Lock()
- if c.err != nil {
- c.mu.Unlock()
- return // already canceled
- }
- c.err = err
- close(c.done)
- for child := range c.children {
- // NOTE: acquiring the child's lock while holding parent's lock.
- child.cancel(false, err)
- }
- c.children = nil
- c.mu.Unlock()
-
- if removeFromParent {
- removeChild(c.Context, c)
- }
-}
-
-// WithDeadline returns a copy of the parent context with the deadline adjusted
-// to be no later than d. If the parent's deadline is already earlier than d,
-// WithDeadline(parent, d) is semantically equivalent to parent. The returned
-// context's Done channel is closed when the deadline expires, when the returned
-// cancel function is called, or when the parent context's Done channel is
-// closed, whichever happens first.
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete.
-func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) {
- if cur, ok := parent.Deadline(); ok && cur.Before(deadline) {
- // The current deadline is already sooner than the new one.
- return WithCancel(parent)
- }
- c := &timerCtx{
- cancelCtx: newCancelCtx(parent),
- deadline: deadline,
- }
- propagateCancel(parent, c)
- d := deadline.Sub(time.Now())
- if d <= 0 {
- c.cancel(true, DeadlineExceeded) // deadline has already passed
- return c, func() { c.cancel(true, Canceled) }
- }
- c.mu.Lock()
- defer c.mu.Unlock()
- if c.err == nil {
- c.timer = time.AfterFunc(d, func() {
- c.cancel(true, DeadlineExceeded)
- })
- }
- return c, func() { c.cancel(true, Canceled) }
-}
-
-// A timerCtx carries a timer and a deadline. It embeds a cancelCtx to
-// implement Done and Err. It implements cancel by stopping its timer then
-// delegating to cancelCtx.cancel.
-type timerCtx struct {
- cancelCtx
- timer *time.Timer // Under cancelCtx.mu.
-
- deadline time.Time
-}
-
-func (c *timerCtx) Deadline() (deadline time.Time, ok bool) {
- return c.deadline, true
-}
-
-func (c *timerCtx) String() string {
- return fmt.Sprintf("%v.WithDeadline(%s [%s])", c.cancelCtx.Context, c.deadline, c.deadline.Sub(time.Now()))
-}
-
-func (c *timerCtx) cancel(removeFromParent bool, err error) {
- c.cancelCtx.cancel(false, err)
- if removeFromParent {
- // Remove this timerCtx from its parent cancelCtx's children.
- removeChild(c.cancelCtx.Context, c)
- }
- c.mu.Lock()
- if c.timer != nil {
- c.timer.Stop()
- c.timer = nil
- }
- c.mu.Unlock()
-}
-
-// WithTimeout returns WithDeadline(parent, time.Now().Add(timeout)).
-//
-// Canceling this context releases resources associated with it, so code should
-// call cancel as soon as the operations running in this Context complete:
-//
-// func slowOperationWithTimeout(ctx context.Context) (Result, error) {
-// ctx, cancel := context.WithTimeout(ctx, 100*time.Millisecond)
-// defer cancel() // releases resources if slowOperation completes before timeout elapses
-// return slowOperation(ctx)
-// }
-func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
- return WithDeadline(parent, time.Now().Add(timeout))
-}
-
-// WithValue returns a copy of parent in which the value associated with key is
-// val.
-//
-// Use context Values only for request-scoped data that transits processes and
-// APIs, not for passing optional parameters to functions.
-func WithValue(parent Context, key interface{}, val interface{}) Context {
- return &valueCtx{parent, key, val}
-}
-
-// A valueCtx carries a key-value pair. It implements Value for that key and
-// delegates all other calls to the embedded Context.
-type valueCtx struct {
- Context
- key, val interface{}
-}
-
-func (c *valueCtx) String() string {
- return fmt.Sprintf("%v.WithValue(%#v, %#v)", c.Context, c.key, c.val)
-}
-
-func (c *valueCtx) Value(key interface{}) interface{} {
- if c.key == key {
- return c.val
- }
- return c.Context.Value(key)
-}
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/context_test.go b/Godeps/_workspace/src/golang.org/x/net/context/context_test.go
deleted file mode 100644
index faf67722a0f975f8b60ee314e3ef2b84f0dc1a5f..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/golang.org/x/net/context/context_test.go
+++ /dev/null
@@ -1,575 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package context
-
-import (
- "fmt"
- "math/rand"
- "runtime"
- "strings"
- "sync"
- "testing"
- "time"
-)
-
-// otherContext is a Context that's not one of the types defined in context.go.
-// This lets us test code paths that differ based on the underlying type of the
-// Context.
-type otherContext struct {
- Context
-}
-
-func TestBackground(t *testing.T) {
- c := Background()
- if c == nil {
- t.Fatalf("Background returned nil")
- }
- select {
- case x := <-c.Done():
- t.Errorf("<-c.Done() == %v want nothing (it should block)", x)
- default:
- }
- if got, want := fmt.Sprint(c), "context.Background"; got != want {
- t.Errorf("Background().String() = %q want %q", got, want)
- }
-}
-
-func TestTODO(t *testing.T) {
- c := TODO()
- if c == nil {
- t.Fatalf("TODO returned nil")
- }
- select {
- case x := <-c.Done():
- t.Errorf("<-c.Done() == %v want nothing (it should block)", x)
- default:
- }
- if got, want := fmt.Sprint(c), "context.TODO"; got != want {
- t.Errorf("TODO().String() = %q want %q", got, want)
- }
-}
-
-func TestWithCancel(t *testing.T) {
- c1, cancel := WithCancel(Background())
-
- if got, want := fmt.Sprint(c1), "context.Background.WithCancel"; got != want {
- t.Errorf("c1.String() = %q want %q", got, want)
- }
-
- o := otherContext{c1}
- c2, _ := WithCancel(o)
- contexts := []Context{c1, o, c2}
-
- for i, c := range contexts {
- if d := c.Done(); d == nil {
- t.Errorf("c[%d].Done() == %v want non-nil", i, d)
- }
- if e := c.Err(); e != nil {
- t.Errorf("c[%d].Err() == %v want nil", i, e)
- }
-
- select {
- case x := <-c.Done():
- t.Errorf("<-c.Done() == %v want nothing (it should block)", x)
- default:
- }
- }
-
- cancel()
- time.Sleep(100 * time.Millisecond) // let cancelation propagate
-
- for i, c := range contexts {
- select {
- case <-c.Done():
- default:
- t.Errorf("<-c[%d].Done() blocked, but shouldn't have", i)
- }
- if e := c.Err(); e != Canceled {
- t.Errorf("c[%d].Err() == %v want %v", i, e, Canceled)
- }
- }
-}
-
-func TestParentFinishesChild(t *testing.T) {
- // Context tree:
- // parent -> cancelChild
- // parent -> valueChild -> timerChild
- parent, cancel := WithCancel(Background())
- cancelChild, stop := WithCancel(parent)
- defer stop()
- valueChild := WithValue(parent, "key", "value")
- timerChild, stop := WithTimeout(valueChild, 10000*time.Hour)
- defer stop()
-
- select {
- case x := <-parent.Done():
- t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)
- case x := <-cancelChild.Done():
- t.Errorf("<-cancelChild.Done() == %v want nothing (it should block)", x)
- case x := <-timerChild.Done():
- t.Errorf("<-timerChild.Done() == %v want nothing (it should block)", x)
- case x := <-valueChild.Done():
- t.Errorf("<-valueChild.Done() == %v want nothing (it should block)", x)
- default:
- }
-
- // The parent's children should contain the two cancelable children.
- pc := parent.(*cancelCtx)
- cc := cancelChild.(*cancelCtx)
- tc := timerChild.(*timerCtx)
- pc.mu.Lock()
- if len(pc.children) != 2 || !pc.children[cc] || !pc.children[tc] {
- t.Errorf("bad linkage: pc.children = %v, want %v and %v",
- pc.children, cc, tc)
- }
- pc.mu.Unlock()
-
- if p, ok := parentCancelCtx(cc.Context); !ok || p != pc {
- t.Errorf("bad linkage: parentCancelCtx(cancelChild.Context) = %v, %v want %v, true", p, ok, pc)
- }
- if p, ok := parentCancelCtx(tc.Context); !ok || p != pc {
- t.Errorf("bad linkage: parentCancelCtx(timerChild.Context) = %v, %v want %v, true", p, ok, pc)
- }
-
- cancel()
-
- pc.mu.Lock()
- if len(pc.children) != 0 {
- t.Errorf("pc.cancel didn't clear pc.children = %v", pc.children)
- }
- pc.mu.Unlock()
-
- // parent and children should all be finished.
- check := func(ctx Context, name string) {
- select {
- case <-ctx.Done():
- default:
- t.Errorf("<-%s.Done() blocked, but shouldn't have", name)
- }
- if e := ctx.Err(); e != Canceled {
- t.Errorf("%s.Err() == %v want %v", name, e, Canceled)
- }
- }
- check(parent, "parent")
- check(cancelChild, "cancelChild")
- check(valueChild, "valueChild")
- check(timerChild, "timerChild")
-
- // WithCancel should return a canceled context on a canceled parent.
- precanceledChild := WithValue(parent, "key", "value")
- select {
- case <-precanceledChild.Done():
- default:
- t.Errorf("<-precanceledChild.Done() blocked, but shouldn't have")
- }
- if e := precanceledChild.Err(); e != Canceled {
- t.Errorf("precanceledChild.Err() == %v want %v", e, Canceled)
- }
-}
-
-func TestChildFinishesFirst(t *testing.T) {
- cancelable, stop := WithCancel(Background())
- defer stop()
- for _, parent := range []Context{Background(), cancelable} {
- child, cancel := WithCancel(parent)
-
- select {
- case x := <-parent.Done():
- t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)
- case x := <-child.Done():
- t.Errorf("<-child.Done() == %v want nothing (it should block)", x)
- default:
- }
-
- cc := child.(*cancelCtx)
- pc, pcok := parent.(*cancelCtx) // pcok == false when parent == Background()
- if p, ok := parentCancelCtx(cc.Context); ok != pcok || (ok && pc != p) {
- t.Errorf("bad linkage: parentCancelCtx(cc.Context) = %v, %v want %v, %v", p, ok, pc, pcok)
- }
-
- if pcok {
- pc.mu.Lock()
- if len(pc.children) != 1 || !pc.children[cc] {
- t.Errorf("bad linkage: pc.children = %v, cc = %v", pc.children, cc)
- }
- pc.mu.Unlock()
- }
-
- cancel()
-
- if pcok {
- pc.mu.Lock()
- if len(pc.children) != 0 {
- t.Errorf("child's cancel didn't remove self from pc.children = %v", pc.children)
- }
- pc.mu.Unlock()
- }
-
- // child should be finished.
- select {
- case <-child.Done():
- default:
- t.Errorf("<-child.Done() blocked, but shouldn't have")
- }
- if e := child.Err(); e != Canceled {
- t.Errorf("child.Err() == %v want %v", e, Canceled)
- }
-
- // parent should not be finished.
- select {
- case x := <-parent.Done():
- t.Errorf("<-parent.Done() == %v want nothing (it should block)", x)
- default:
- }
- if e := parent.Err(); e != nil {
- t.Errorf("parent.Err() == %v want nil", e)
- }
- }
-}
-
-func testDeadline(c Context, wait time.Duration, t *testing.T) {
- select {
- case <-time.After(wait):
- t.Fatalf("context should have timed out")
- case <-c.Done():
- }
- if e := c.Err(); e != DeadlineExceeded {
- t.Errorf("c.Err() == %v want %v", e, DeadlineExceeded)
- }
-}
-
-func TestDeadline(t *testing.T) {
- c, _ := WithDeadline(Background(), time.Now().Add(100*time.Millisecond))
- if got, prefix := fmt.Sprint(c), "context.Background.WithDeadline("; !strings.HasPrefix(got, prefix) {
- t.Errorf("c.String() = %q want prefix %q", got, prefix)
- }
- testDeadline(c, 200*time.Millisecond, t)
-
- c, _ = WithDeadline(Background(), time.Now().Add(100*time.Millisecond))
- o := otherContext{c}
- testDeadline(o, 200*time.Millisecond, t)
-
- c, _ = WithDeadline(Background(), time.Now().Add(100*time.Millisecond))
- o = otherContext{c}
- c, _ = WithDeadline(o, time.Now().Add(300*time.Millisecond))
- testDeadline(c, 200*time.Millisecond, t)
-}
-
-func TestTimeout(t *testing.T) {
- c, _ := WithTimeout(Background(), 100*time.Millisecond)
- if got, prefix := fmt.Sprint(c), "context.Background.WithDeadline("; !strings.HasPrefix(got, prefix) {
- t.Errorf("c.String() = %q want prefix %q", got, prefix)
- }
- testDeadline(c, 200*time.Millisecond, t)
-
- c, _ = WithTimeout(Background(), 100*time.Millisecond)
- o := otherContext{c}
- testDeadline(o, 200*time.Millisecond, t)
-
- c, _ = WithTimeout(Background(), 100*time.Millisecond)
- o = otherContext{c}
- c, _ = WithTimeout(o, 300*time.Millisecond)
- testDeadline(c, 200*time.Millisecond, t)
-}
-
-func TestCanceledTimeout(t *testing.T) {
- c, _ := WithTimeout(Background(), 200*time.Millisecond)
- o := otherContext{c}
- c, cancel := WithTimeout(o, 400*time.Millisecond)
- cancel()
- time.Sleep(100 * time.Millisecond) // let cancelation propagate
- select {
- case <-c.Done():
- default:
- t.Errorf("<-c.Done() blocked, but shouldn't have")
- }
- if e := c.Err(); e != Canceled {
- t.Errorf("c.Err() == %v want %v", e, Canceled)
- }
-}
-
-type key1 int
-type key2 int
-
-var k1 = key1(1)
-var k2 = key2(1) // same int as k1, different type
-var k3 = key2(3) // same type as k2, different int
-
-func TestValues(t *testing.T) {
- check := func(c Context, nm, v1, v2, v3 string) {
- if v, ok := c.Value(k1).(string); ok == (len(v1) == 0) || v != v1 {
- t.Errorf(`%s.Value(k1).(string) = %q, %t want %q, %t`, nm, v, ok, v1, len(v1) != 0)
- }
- if v, ok := c.Value(k2).(string); ok == (len(v2) == 0) || v != v2 {
- t.Errorf(`%s.Value(k2).(string) = %q, %t want %q, %t`, nm, v, ok, v2, len(v2) != 0)
- }
- if v, ok := c.Value(k3).(string); ok == (len(v3) == 0) || v != v3 {
- t.Errorf(`%s.Value(k3).(string) = %q, %t want %q, %t`, nm, v, ok, v3, len(v3) != 0)
- }
- }
-
- c0 := Background()
- check(c0, "c0", "", "", "")
-
- c1 := WithValue(Background(), k1, "c1k1")
- check(c1, "c1", "c1k1", "", "")
-
- if got, want := fmt.Sprint(c1), `context.Background.WithValue(1, "c1k1")`; got != want {
- t.Errorf("c.String() = %q want %q", got, want)
- }
-
- c2 := WithValue(c1, k2, "c2k2")
- check(c2, "c2", "c1k1", "c2k2", "")
-
- c3 := WithValue(c2, k3, "c3k3")
- check(c3, "c2", "c1k1", "c2k2", "c3k3")
-
- c4 := WithValue(c3, k1, nil)
- check(c4, "c4", "", "c2k2", "c3k3")
-
- o0 := otherContext{Background()}
- check(o0, "o0", "", "", "")
-
- o1 := otherContext{WithValue(Background(), k1, "c1k1")}
- check(o1, "o1", "c1k1", "", "")
-
- o2 := WithValue(o1, k2, "o2k2")
- check(o2, "o2", "c1k1", "o2k2", "")
-
- o3 := otherContext{c4}
- check(o3, "o3", "", "c2k2", "c3k3")
-
- o4 := WithValue(o3, k3, nil)
- check(o4, "o4", "", "c2k2", "")
-}
-
-func TestAllocs(t *testing.T) {
- bg := Background()
- for _, test := range []struct {
- desc string
- f func()
- limit float64
- gccgoLimit float64
- }{
- {
- desc: "Background()",
- f: func() { Background() },
- limit: 0,
- gccgoLimit: 0,
- },
- {
- desc: fmt.Sprintf("WithValue(bg, %v, nil)", k1),
- f: func() {
- c := WithValue(bg, k1, nil)
- c.Value(k1)
- },
- limit: 3,
- gccgoLimit: 3,
- },
- {
- desc: "WithTimeout(bg, 15*time.Millisecond)",
- f: func() {
- c, _ := WithTimeout(bg, 15*time.Millisecond)
- <-c.Done()
- },
- limit: 8,
- gccgoLimit: 13,
- },
- {
- desc: "WithCancel(bg)",
- f: func() {
- c, cancel := WithCancel(bg)
- cancel()
- <-c.Done()
- },
- limit: 5,
- gccgoLimit: 8,
- },
- {
- desc: "WithTimeout(bg, 100*time.Millisecond)",
- f: func() {
- c, cancel := WithTimeout(bg, 100*time.Millisecond)
- cancel()
- <-c.Done()
- },
- limit: 8,
- gccgoLimit: 25,
- },
- } {
- limit := test.limit
- if runtime.Compiler == "gccgo" {
- // gccgo does not yet do escape analysis.
- // TOOD(iant): Remove this when gccgo does do escape analysis.
- limit = test.gccgoLimit
- }
- if n := testing.AllocsPerRun(100, test.f); n > limit {
- t.Errorf("%s allocs = %f want %d", test.desc, n, int(limit))
- }
- }
-}
-
-func TestSimultaneousCancels(t *testing.T) {
- root, cancel := WithCancel(Background())
- m := map[Context]CancelFunc{root: cancel}
- q := []Context{root}
- // Create a tree of contexts.
- for len(q) != 0 && len(m) < 100 {
- parent := q[0]
- q = q[1:]
- for i := 0; i < 4; i++ {
- ctx, cancel := WithCancel(parent)
- m[ctx] = cancel
- q = append(q, ctx)
- }
- }
- // Start all the cancels in a random order.
- var wg sync.WaitGroup
- wg.Add(len(m))
- for _, cancel := range m {
- go func(cancel CancelFunc) {
- cancel()
- wg.Done()
- }(cancel)
- }
- // Wait on all the contexts in a random order.
- for ctx := range m {
- select {
- case <-ctx.Done():
- case <-time.After(1 * time.Second):
- buf := make([]byte, 10<<10)
- n := runtime.Stack(buf, true)
- t.Fatalf("timed out waiting for <-ctx.Done(); stacks:\n%s", buf[:n])
- }
- }
- // Wait for all the cancel functions to return.
- done := make(chan struct{})
- go func() {
- wg.Wait()
- close(done)
- }()
- select {
- case <-done:
- case <-time.After(1 * time.Second):
- buf := make([]byte, 10<<10)
- n := runtime.Stack(buf, true)
- t.Fatalf("timed out waiting for cancel functions; stacks:\n%s", buf[:n])
- }
-}
-
-func TestInterlockedCancels(t *testing.T) {
- parent, cancelParent := WithCancel(Background())
- child, cancelChild := WithCancel(parent)
- go func() {
- parent.Done()
- cancelChild()
- }()
- cancelParent()
- select {
- case <-child.Done():
- case <-time.After(1 * time.Second):
- buf := make([]byte, 10<<10)
- n := runtime.Stack(buf, true)
- t.Fatalf("timed out waiting for child.Done(); stacks:\n%s", buf[:n])
- }
-}
-
-func TestLayersCancel(t *testing.T) {
- testLayers(t, time.Now().UnixNano(), false)
-}
-
-func TestLayersTimeout(t *testing.T) {
- testLayers(t, time.Now().UnixNano(), true)
-}
-
-func testLayers(t *testing.T, seed int64, testTimeout bool) {
- rand.Seed(seed)
- errorf := func(format string, a ...interface{}) {
- t.Errorf(fmt.Sprintf("seed=%d: %s", seed, format), a...)
- }
- const (
- timeout = 200 * time.Millisecond
- minLayers = 30
- )
- type value int
- var (
- vals []*value
- cancels []CancelFunc
- numTimers int
- ctx = Background()
- )
- for i := 0; i < minLayers || numTimers == 0 || len(cancels) == 0 || len(vals) == 0; i++ {
- switch rand.Intn(3) {
- case 0:
- v := new(value)
- ctx = WithValue(ctx, v, v)
- vals = append(vals, v)
- case 1:
- var cancel CancelFunc
- ctx, cancel = WithCancel(ctx)
- cancels = append(cancels, cancel)
- case 2:
- var cancel CancelFunc
- ctx, cancel = WithTimeout(ctx, timeout)
- cancels = append(cancels, cancel)
- numTimers++
- }
- }
- checkValues := func(when string) {
- for _, key := range vals {
- if val := ctx.Value(key).(*value); key != val {
- errorf("%s: ctx.Value(%p) = %p want %p", when, key, val, key)
- }
- }
- }
- select {
- case <-ctx.Done():
- errorf("ctx should not be canceled yet")
- default:
- }
- if s, prefix := fmt.Sprint(ctx), "context.Background."; !strings.HasPrefix(s, prefix) {
- t.Errorf("ctx.String() = %q want prefix %q", s, prefix)
- }
- t.Log(ctx)
- checkValues("before cancel")
- if testTimeout {
- select {
- case <-ctx.Done():
- case <-time.After(timeout + timeout/10):
- errorf("ctx should have timed out")
- }
- checkValues("after timeout")
- } else {
- cancel := cancels[rand.Intn(len(cancels))]
- cancel()
- select {
- case <-ctx.Done():
- default:
- errorf("ctx should be canceled")
- }
- checkValues("after cancel")
- }
-}
-
-func TestCancelRemoves(t *testing.T) {
- checkChildren := func(when string, ctx Context, want int) {
- if got := len(ctx.(*cancelCtx).children); got != want {
- t.Errorf("%s: context has %d children, want %d", when, got, want)
- }
- }
-
- ctx, _ := WithCancel(Background())
- checkChildren("after creation", ctx, 0)
- _, cancel := WithCancel(ctx)
- checkChildren("with WithCancel child ", ctx, 1)
- cancel()
- checkChildren("after cancelling WithCancel child", ctx, 0)
-
- ctx, _ = WithCancel(Background())
- checkChildren("after creation", ctx, 0)
- _, cancel = WithTimeout(ctx, 60*time.Minute)
- checkChildren("with WithTimeout child ", ctx, 1)
- cancel()
- checkChildren("after cancelling WithTimeout child", ctx, 0)
-}
diff --git a/Godeps/_workspace/src/golang.org/x/net/context/withtimeout_test.go b/Godeps/_workspace/src/golang.org/x/net/context/withtimeout_test.go
deleted file mode 100644
index 1a6006dc1ee5f7b76442afd3b3097578f168e697..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/golang.org/x/net/context/withtimeout_test.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package context_test
-
-import (
- "fmt"
- "time"
-
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/golang.org/x/net/context"
-)
-
-func ExampleWithTimeout() {
- // Pass a context with a timeout to tell a blocking function that it
- // should abandon its work after the timeout elapses.
- ctx, _ := context.WithTimeout(context.Background(), 100*time.Millisecond)
- select {
- case <-time.After(200 * time.Millisecond):
- fmt.Println("overslept")
- case <-ctx.Done():
- fmt.Println(ctx.Err()) // prints "context deadline exceeded"
- }
- // Output:
- // context deadline exceeded
-}
diff --git a/Godeps/_workspace/src/golang.org/x/net/netutil/listen.go b/Godeps/_workspace/src/golang.org/x/net/netutil/listen.go
deleted file mode 100644
index a2591f833c367df473924c9b21152dfd9dfc0848..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/golang.org/x/net/netutil/listen.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package netutil provides network utility functions, complementing the more
-// common ones in the net package.
-package netutil
-
-import (
- "net"
- "sync"
-)
-
-// LimitListener returns a Listener that accepts at most n simultaneous
-// connections from the provided Listener.
-func LimitListener(l net.Listener, n int) net.Listener {
- return &limitListener{l, make(chan struct{}, n)}
-}
-
-type limitListener struct {
- net.Listener
- sem chan struct{}
-}
-
-func (l *limitListener) acquire() { l.sem <- struct{}{} }
-func (l *limitListener) release() { <-l.sem }
-
-func (l *limitListener) Accept() (net.Conn, error) {
- l.acquire()
- c, err := l.Listener.Accept()
- if err != nil {
- l.release()
- return nil, err
- }
- return &limitListenerConn{Conn: c, release: l.release}, nil
-}
-
-type limitListenerConn struct {
- net.Conn
- releaseOnce sync.Once
- release func()
-}
-
-func (l *limitListenerConn) Close() error {
- err := l.Conn.Close()
- l.releaseOnce.Do(l.release)
- return err
-}
diff --git a/Godeps/_workspace/src/golang.org/x/net/netutil/listen_test.go b/Godeps/_workspace/src/golang.org/x/net/netutil/listen_test.go
deleted file mode 100644
index ac87e0ee4a9a688622541088d0f77f9d8ffcd03e..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/golang.org/x/net/netutil/listen_test.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.3
-
-// (We only run this test on Go 1.3 because the HTTP client timeout behavior
-// was bad in previous releases, causing occasional deadlocks.)
-
-package netutil
-
-import (
- "errors"
- "fmt"
- "io"
- "io/ioutil"
- "net"
- "net/http"
- "sync"
- "sync/atomic"
- "testing"
- "time"
-)
-
-func TestLimitListener(t *testing.T) {
- const (
- max = 5
- num = 200
- )
-
- l, err := net.Listen("tcp", "127.0.0.1:0")
- if err != nil {
- t.Fatalf("Listen: %v", err)
- }
- defer l.Close()
- l = LimitListener(l, max)
-
- var open int32
- go http.Serve(l, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- if n := atomic.AddInt32(&open, 1); n > max {
- t.Errorf("%d open connections, want <= %d", n, max)
- }
- defer atomic.AddInt32(&open, -1)
- time.Sleep(10 * time.Millisecond)
- fmt.Fprint(w, "some body")
- }))
-
- var wg sync.WaitGroup
- var failed int32
- for i := 0; i < num; i++ {
- wg.Add(1)
- go func() {
- defer wg.Done()
- c := http.Client{Timeout: 3 * time.Second}
- r, err := c.Get("http://" + l.Addr().String())
- if err != nil {
- t.Logf("Get: %v", err)
- atomic.AddInt32(&failed, 1)
- return
- }
- defer r.Body.Close()
- io.Copy(ioutil.Discard, r.Body)
- }()
- }
- wg.Wait()
-
- // We expect some Gets to fail as the kernel's accept queue is filled,
- // but most should succeed.
- if failed >= num/2 {
- t.Errorf("too many Gets failed: %v", failed)
- }
-}
-
-type errorListener struct {
- net.Listener
-}
-
-func (errorListener) Accept() (net.Conn, error) {
- return nil, errFake
-}
-
-var errFake = errors.New("fake error from errorListener")
-
-// This used to hang.
-func TestLimitListenerError(t *testing.T) {
- donec := make(chan bool, 1)
- go func() {
- const n = 2
- ll := LimitListener(errorListener{}, n)
- for i := 0; i < n+1; i++ {
- _, err := ll.Accept()
- if err != errFake {
- t.Fatalf("Accept error = %v; want errFake", err)
- }
- }
- donec <- true
- }()
- select {
- case <-donec:
- case <-time.After(5 * time.Second):
- t.Fatal("timeout. deadlock?")
- }
-}
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/.gitignore b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/.gitignore
deleted file mode 100644
index 415902041c853f9d77290ef92c94043b0d30abfc..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/.gitignore
+++ /dev/null
@@ -1,26 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
-*.prof
-*.test
-*.out
\ No newline at end of file
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/.travis.yml b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/.travis.yml
deleted file mode 100644
index 68398d9f152d5b07e90a55adc00e5006436e58dd..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/.travis.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-language: go
-
-notificaitons:
- email:
- recipients: bluesuncorp01@gmail.com
- on_success: change
- on_failure: always
-
-go:
- - 1.2
- - 1.3
- - 1.4
- - tip
\ No newline at end of file
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/LICENSE b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/LICENSE
deleted file mode 100644
index 6a2ae9aa4da89106ff7fec2ca042d48c14a0a159..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Dean Karn
-
-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/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/README.md b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/README.md
deleted file mode 100644
index c1e9d00cfddae372708ada9681bf588026df55f9..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/README.md
+++ /dev/null
@@ -1,44 +0,0 @@
-Package validator
-================
-[](https://travis-ci.org/bluesuncorp/validator)
-[](https://godoc.org/gopkg.in/bluesuncorp/validator.v5)
-
-Package validator implements value validations for structs and individual fields based on tags.
-It is also capable of Cross Field and Cross Struct validations.
-
-Installation
-============
-
-Use go get.
-
- go get gopkg.in/bluesuncorp/validator.v5
-
-or to update
-
- go get -u gopkg.in/bluesuncorp/validator.v5
-
-Then import the validator package into your own code.
-
- import "gopkg.in/bluesuncorp/validator.v5"
-
-Usage and documentation
-=======================
-
-Please see http://godoc.org/gopkg.in/bluesuncorp/validator.v5 for detailed usage docs.
-
-How to Contribute
-=================
-
-There will always be a development branch for each version i.e. `v1-development`. In order to contribute,
-please make your pull requests against those branches.
-
-If the changes being proposed or requested are breaking changes, please create an issue, for discussion
-or create a pull request against the highest development branch for example this package has a
-v1 and v1-development branch however, there will also be a v2-development brach even though v2 doesn't exist yet.
-
-I strongly encourage everyone whom creates a custom validation function to contribute them and
-help make this package even better.
-
-License
-=======
-Distributed under MIT License, please see license file in code for more details.
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/baked_in.go b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/baked_in.go
deleted file mode 100644
index ed69eb3002d055e773bf81ff39b21ba13703ce62..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/baked_in.go
+++ /dev/null
@@ -1,864 +0,0 @@
-package validator
-
-import (
- "fmt"
- "net/url"
- "reflect"
- "strconv"
- "strings"
- "time"
- "unicode/utf8"
-)
-
-// BakedInValidators is the default map of ValidationFunc
-// you can add, remove or even replace items to suite your needs,
-// or even disregard and use your own map if so desired.
-var BakedInValidators = map[string]Func{
- "required": hasValue,
- "len": hasLengthOf,
- "min": hasMinOf,
- "max": hasMaxOf,
- "eq": isEq,
- "ne": isNe,
- "lt": isLt,
- "lte": isLte,
- "gt": isGt,
- "gte": isGte,
- "eqfield": isEqField,
- "nefield": isNeField,
- "gtefield": isGteField,
- "gtfield": isGtField,
- "ltefield": isLteField,
- "ltfield": isLtField,
- "alpha": isAlpha,
- "alphanum": isAlphanum,
- "numeric": isNumeric,
- "number": isNumber,
- "hexadecimal": isHexadecimal,
- "hexcolor": isHexcolor,
- "rgb": isRgb,
- "rgba": isRgba,
- "hsl": isHsl,
- "hsla": isHsla,
- "email": isEmail,
- "url": isURL,
- "uri": isURI,
- "base64": isBase64,
- "contains": contains,
- "containsany": containsAny,
- "containsrune": containsRune,
- "excludes": excludes,
- "excludesall": excludesAll,
- "excludesrune": excludesRune,
-}
-
-func excludesRune(top interface{}, current interface{}, field interface{}, param string) bool {
- return !containsRune(top, current, field, param)
-}
-
-func excludesAll(top interface{}, current interface{}, field interface{}, param string) bool {
- return !containsAny(top, current, field, param)
-}
-
-func excludes(top interface{}, current interface{}, field interface{}, param string) bool {
- return !contains(top, current, field, param)
-}
-
-func containsRune(top interface{}, current interface{}, field interface{}, param string) bool {
- r, _ := utf8.DecodeRuneInString(param)
-
- return strings.ContainsRune(field.(string), r)
-}
-
-func containsAny(top interface{}, current interface{}, field interface{}, param string) bool {
- return strings.ContainsAny(field.(string), param)
-}
-
-func contains(top interface{}, current interface{}, field interface{}, param string) bool {
- return strings.Contains(field.(string), param)
-}
-
-func isNeField(top interface{}, current interface{}, field interface{}, param string) bool {
- return !isEqField(top, current, field, param)
-}
-
-func isNe(top interface{}, current interface{}, field interface{}, param string) bool {
- return !isEq(top, current, field, param)
-}
-
-func isEqField(top interface{}, current interface{}, field interface{}, param string) bool {
-
- if current == nil {
- panic("struct not passed for cross validation")
- }
-
- currentVal := reflect.ValueOf(current)
-
- if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
- currentVal = reflect.ValueOf(currentVal.Elem().Interface())
- }
-
- var currentFielVal reflect.Value
-
- switch currentVal.Kind() {
-
- case reflect.Struct:
-
- if currentVal.Type() == reflect.TypeOf(time.Time{}) {
- currentFielVal = currentVal
- break
- }
-
- f := currentVal.FieldByName(param)
-
- if f.Kind() == reflect.Invalid {
- panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
- }
-
- currentFielVal = f
-
- default:
-
- currentFielVal = currentVal
- }
-
- if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
-
- currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
- }
-
- fv := reflect.ValueOf(field)
-
- switch fv.Kind() {
-
- case reflect.String:
- return fv.String() == currentFielVal.String()
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-
- return fv.Int() == currentFielVal.Int()
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-
- return fv.Uint() == currentFielVal.Uint()
-
- case reflect.Float32, reflect.Float64:
-
- return fv.Float() == currentFielVal.Float()
- case reflect.Slice, reflect.Map, reflect.Array:
-
- return int64(fv.Len()) == int64(currentFielVal.Len())
- case reflect.Struct:
-
- if fv.Type() == reflect.TypeOf(time.Time{}) {
-
- if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
- panic("Bad Top Level field type")
- }
-
- t := currentFielVal.Interface().(time.Time)
- fieldTime := field.(time.Time)
-
- return fieldTime.Equal(t)
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isEq(top interface{}, current interface{}, field interface{}, param string) bool {
-
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.String:
-
- return st.String() == param
-
- case reflect.Slice, reflect.Map, reflect.Array:
- p := asInt(param)
-
- return int64(st.Len()) == p
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- p := asInt(param)
-
- return st.Int() == p
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- p := asUint(param)
-
- return st.Uint() == p
-
- case reflect.Float32, reflect.Float64:
- p := asFloat(param)
-
- return st.Float() == p
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isBase64(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(base64Regex, field)
-}
-
-func isURI(top interface{}, current interface{}, field interface{}, param string) bool {
-
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.String:
- _, err := url.ParseRequestURI(field.(string))
-
- return err == nil
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isURL(top interface{}, current interface{}, field interface{}, param string) bool {
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.String:
- url, err := url.ParseRequestURI(field.(string))
-
- if err != nil {
- return false
- }
-
- if len(url.Scheme) == 0 {
- return false
- }
-
- return err == nil
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isEmail(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(emailRegex, field)
-}
-
-func isHsla(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(hslaRegex, field)
-}
-
-func isHsl(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(hslRegex, field)
-}
-
-func isRgba(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(rgbaRegex, field)
-}
-
-func isRgb(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(rgbRegex, field)
-}
-
-func isHexcolor(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(hexcolorRegex, field)
-}
-
-func isHexadecimal(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(hexadecimalRegex, field)
-}
-
-func isNumber(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(numberRegex, field)
-}
-
-func isNumeric(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(numericRegex, field)
-}
-
-func isAlphanum(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(alphaNumericRegex, field)
-}
-
-func isAlpha(top interface{}, current interface{}, field interface{}, param string) bool {
- return matchesRegex(alphaRegex, field)
-}
-
-func hasValue(top interface{}, current interface{}, field interface{}, param string) bool {
-
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.Slice, reflect.Map, reflect.Array:
- return field != nil && int64(st.Len()) > 0
-
- default:
- return field != nil && field != reflect.Zero(reflect.TypeOf(field)).Interface()
- }
-}
-
-func isGteField(top interface{}, current interface{}, field interface{}, param string) bool {
-
- if current == nil {
- panic("struct not passed for cross validation")
- }
-
- currentVal := reflect.ValueOf(current)
-
- if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
- currentVal = reflect.ValueOf(currentVal.Elem().Interface())
- }
-
- var currentFielVal reflect.Value
-
- switch currentVal.Kind() {
-
- case reflect.Struct:
-
- if currentVal.Type() == reflect.TypeOf(time.Time{}) {
- currentFielVal = currentVal
- break
- }
-
- f := currentVal.FieldByName(param)
-
- if f.Kind() == reflect.Invalid {
- panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
- }
-
- currentFielVal = f
-
- default:
-
- currentFielVal = currentVal
- }
-
- if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
-
- currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
- }
-
- fv := reflect.ValueOf(field)
-
- switch fv.Kind() {
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-
- return fv.Int() >= currentFielVal.Int()
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-
- return fv.Uint() >= currentFielVal.Uint()
-
- case reflect.Float32, reflect.Float64:
-
- return fv.Float() >= currentFielVal.Float()
-
- case reflect.Struct:
-
- if fv.Type() == reflect.TypeOf(time.Time{}) {
-
- if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
- panic("Bad Top Level field type")
- }
-
- t := currentFielVal.Interface().(time.Time)
- fieldTime := field.(time.Time)
-
- return fieldTime.After(t) || fieldTime.Equal(t)
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isGtField(top interface{}, current interface{}, field interface{}, param string) bool {
-
- if current == nil {
- panic("struct not passed for cross validation")
- }
-
- currentVal := reflect.ValueOf(current)
-
- if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
- currentVal = reflect.ValueOf(currentVal.Elem().Interface())
- }
-
- var currentFielVal reflect.Value
-
- switch currentVal.Kind() {
-
- case reflect.Struct:
-
- if currentVal.Type() == reflect.TypeOf(time.Time{}) {
- currentFielVal = currentVal
- break
- }
-
- f := currentVal.FieldByName(param)
-
- if f.Kind() == reflect.Invalid {
- panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
- }
-
- currentFielVal = f
-
- default:
-
- currentFielVal = currentVal
- }
-
- if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
-
- currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
- }
-
- fv := reflect.ValueOf(field)
-
- switch fv.Kind() {
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-
- return fv.Int() > currentFielVal.Int()
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-
- return fv.Uint() > currentFielVal.Uint()
-
- case reflect.Float32, reflect.Float64:
-
- return fv.Float() > currentFielVal.Float()
-
- case reflect.Struct:
-
- if fv.Type() == reflect.TypeOf(time.Time{}) {
-
- if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
- panic("Bad Top Level field type")
- }
-
- t := currentFielVal.Interface().(time.Time)
- fieldTime := field.(time.Time)
-
- return fieldTime.After(t)
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isGte(top interface{}, current interface{}, field interface{}, param string) bool {
-
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.String:
- p := asInt(param)
-
- return int64(len(st.String())) >= p
-
- case reflect.Slice, reflect.Map, reflect.Array:
- p := asInt(param)
-
- return int64(st.Len()) >= p
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- p := asInt(param)
-
- return st.Int() >= p
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- p := asUint(param)
-
- return st.Uint() >= p
-
- case reflect.Float32, reflect.Float64:
- p := asFloat(param)
-
- return st.Float() >= p
-
- case reflect.Struct:
-
- if st.Type() == reflect.TypeOf(time.Time{}) {
-
- now := time.Now().UTC()
- t := field.(time.Time)
-
- return t.After(now) || t.Equal(now)
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isGt(top interface{}, current interface{}, field interface{}, param string) bool {
-
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.String:
- p := asInt(param)
-
- return int64(len(st.String())) > p
-
- case reflect.Slice, reflect.Map, reflect.Array:
- p := asInt(param)
-
- return int64(st.Len()) > p
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- p := asInt(param)
-
- return st.Int() > p
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- p := asUint(param)
-
- return st.Uint() > p
-
- case reflect.Float32, reflect.Float64:
- p := asFloat(param)
-
- return st.Float() > p
- case reflect.Struct:
-
- if st.Type() == reflect.TypeOf(time.Time{}) {
-
- return field.(time.Time).After(time.Now().UTC())
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-// length tests whether a variable's length is equal to a given
-// value. For strings it tests the number of characters whereas
-// for maps and slices it tests the number of items.
-func hasLengthOf(top interface{}, current interface{}, field interface{}, param string) bool {
-
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.String:
- p := asInt(param)
-
- return int64(len(st.String())) == p
-
- case reflect.Slice, reflect.Map, reflect.Array:
- p := asInt(param)
-
- return int64(st.Len()) == p
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- p := asInt(param)
-
- return st.Int() == p
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- p := asUint(param)
-
- return st.Uint() == p
-
- case reflect.Float32, reflect.Float64:
- p := asFloat(param)
-
- return st.Float() == p
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-// min tests whether a variable value is larger or equal to a given
-// number. For number types, it's a simple lesser-than test; for
-// strings it tests the number of characters whereas for maps
-// and slices it tests the number of items.
-func hasMinOf(top interface{}, current interface{}, field interface{}, param string) bool {
-
- return isGte(top, current, field, param)
-}
-
-func isLteField(top interface{}, current interface{}, field interface{}, param string) bool {
-
- if current == nil {
- panic("struct not passed for cross validation")
- }
-
- currentVal := reflect.ValueOf(current)
-
- if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
- currentVal = reflect.ValueOf(currentVal.Elem().Interface())
- }
-
- var currentFielVal reflect.Value
-
- switch currentVal.Kind() {
-
- case reflect.Struct:
-
- if currentVal.Type() == reflect.TypeOf(time.Time{}) {
- currentFielVal = currentVal
- break
- }
-
- f := currentVal.FieldByName(param)
-
- if f.Kind() == reflect.Invalid {
- panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
- }
-
- currentFielVal = f
-
- default:
-
- currentFielVal = currentVal
- }
-
- if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
-
- currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
- }
-
- fv := reflect.ValueOf(field)
-
- switch fv.Kind() {
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-
- return fv.Int() <= currentFielVal.Int()
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-
- return fv.Uint() <= currentFielVal.Uint()
-
- case reflect.Float32, reflect.Float64:
-
- return fv.Float() <= currentFielVal.Float()
-
- case reflect.Struct:
-
- if fv.Type() == reflect.TypeOf(time.Time{}) {
-
- if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
- panic("Bad Top Level field type")
- }
-
- t := currentFielVal.Interface().(time.Time)
- fieldTime := field.(time.Time)
-
- return fieldTime.Before(t) || fieldTime.Equal(t)
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isLtField(top interface{}, current interface{}, field interface{}, param string) bool {
-
- if current == nil {
- panic("struct not passed for cross validation")
- }
-
- currentVal := reflect.ValueOf(current)
-
- if currentVal.Kind() == reflect.Ptr && !currentVal.IsNil() {
- currentVal = reflect.ValueOf(currentVal.Elem().Interface())
- }
-
- var currentFielVal reflect.Value
-
- switch currentVal.Kind() {
-
- case reflect.Struct:
-
- if currentVal.Type() == reflect.TypeOf(time.Time{}) {
- currentFielVal = currentVal
- break
- }
-
- f := currentVal.FieldByName(param)
-
- if f.Kind() == reflect.Invalid {
- panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
- }
-
- currentFielVal = f
-
- default:
-
- currentFielVal = currentVal
- }
-
- if currentFielVal.Kind() == reflect.Ptr && !currentFielVal.IsNil() {
-
- currentFielVal = reflect.ValueOf(currentFielVal.Elem().Interface())
- }
-
- fv := reflect.ValueOf(field)
-
- switch fv.Kind() {
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-
- return fv.Int() < currentFielVal.Int()
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-
- return fv.Uint() < currentFielVal.Uint()
-
- case reflect.Float32, reflect.Float64:
-
- return fv.Float() < currentFielVal.Float()
-
- case reflect.Struct:
-
- if fv.Type() == reflect.TypeOf(time.Time{}) {
-
- if currentFielVal.Type() != reflect.TypeOf(time.Time{}) {
- panic("Bad Top Level field type")
- }
-
- t := currentFielVal.Interface().(time.Time)
- fieldTime := field.(time.Time)
-
- return fieldTime.Before(t)
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isLte(top interface{}, current interface{}, field interface{}, param string) bool {
-
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.String:
- p := asInt(param)
-
- return int64(len(st.String())) <= p
-
- case reflect.Slice, reflect.Map, reflect.Array:
- p := asInt(param)
-
- return int64(st.Len()) <= p
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- p := asInt(param)
-
- return st.Int() <= p
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- p := asUint(param)
-
- return st.Uint() <= p
-
- case reflect.Float32, reflect.Float64:
- p := asFloat(param)
-
- return st.Float() <= p
-
- case reflect.Struct:
-
- if st.Type() == reflect.TypeOf(time.Time{}) {
-
- now := time.Now().UTC()
- t := field.(time.Time)
-
- return t.Before(now) || t.Equal(now)
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-func isLt(top interface{}, current interface{}, field interface{}, param string) bool {
-
- st := reflect.ValueOf(field)
-
- switch st.Kind() {
-
- case reflect.String:
- p := asInt(param)
-
- return int64(len(st.String())) < p
-
- case reflect.Slice, reflect.Map, reflect.Array:
- p := asInt(param)
-
- return int64(st.Len()) < p
-
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- p := asInt(param)
-
- return st.Int() < p
-
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- p := asUint(param)
-
- return st.Uint() < p
-
- case reflect.Float32, reflect.Float64:
- p := asFloat(param)
-
- return st.Float() < p
-
- case reflect.Struct:
-
- if st.Type() == reflect.TypeOf(time.Time{}) {
-
- return field.(time.Time).Before(time.Now().UTC())
- }
- }
-
- panic(fmt.Sprintf("Bad field type %T", field))
-}
-
-// max tests whether a variable value is lesser than a given
-// value. For numbers, it's a simple lesser-than test; for
-// strings it tests the number of characters whereas for maps
-// and slices it tests the number of items.
-func hasMaxOf(top interface{}, current interface{}, field interface{}, param string) bool {
-
- return isLte(top, current, field, param)
-}
-
-// asInt retuns the parameter as a int64
-// or panics if it can't convert
-func asInt(param string) int64 {
-
- i, err := strconv.ParseInt(param, 0, 64)
- panicIf(err)
-
- return i
-}
-
-// asUint returns the parameter as a uint64
-// or panics if it can't convert
-func asUint(param string) uint64 {
-
- i, err := strconv.ParseUint(param, 0, 64)
- panicIf(err)
-
- return i
-}
-
-// asFloat returns the parameter as a float64
-// or panics if it can't convert
-func asFloat(param string) float64 {
-
- i, err := strconv.ParseFloat(param, 64)
- panicIf(err)
-
- return i
-}
-
-func panicIf(err error) {
- if err != nil {
- panic(err.Error())
- }
-}
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/doc.go b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/doc.go
deleted file mode 100644
index 5282cf539f5d14727fdcf639c9eb87074f4e432c..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/doc.go
+++ /dev/null
@@ -1,395 +0,0 @@
-/*
-Package validator implements value validations for structs and individual fields based on tags. It can also handle Cross Field and Cross Struct validation for nested structs.
-
-Validate
-
- validate := validator.New("validate", validator.BakedInValidators)
-
- errs := validate.Struct(//your struct)
- valErr := validate.Field(field, "omitempty,min=1,max=10")
-
-A simple example usage:
-
- type UserDetail struct {
- Details string `validate:"-"`
- }
-
- type User struct {
- Name string `validate:"required,max=60"`
- PreferedName string `validate:"omitempty,max=60"`
- Sub UserDetail
- }
-
- user := &User {
- Name: "",
- }
-
- // errs will contain a hierarchical list of errors
- // using the StructErrors struct
- // or nil if no errors exist
- errs := validate.Struct(user)
-
- // in this case 1 error Name is required
- errs.Struct will be "User"
- errs.StructErrors will be empty <-- fields that were structs
- errs.Errors will have 1 error of type FieldError
-
- NOTE: Anonymous Structs - they don't have names so expect the Struct name
- within StructErrors to be blank.
-
-Error Handling
-
-The error can be used like so
-
- fieldErr, _ := errs["Name"]
- fieldErr.Field // "Name"
- fieldErr.ErrorTag // "required"
-
-Both StructErrors and FieldError implement the Error interface but it's
-intended use is for development + debugging, not a production error message.
-
- fieldErr.Error() // Field validation for "Name" failed on the "required" tag
- errs.Error()
- // Struct: User
- // Field validation for "Name" failed on the "required" tag
-
-Why not a better error message? because this library intends for you to handle your own error messages
-
-Why should I handle my own errors? Many reasons, for us building an internationalized application
-I needed to know the field and what validation failed so that I could provide an error in the users specific language.
-
- if fieldErr.Field == "Name" {
- switch fieldErr.ErrorTag
- case "required":
- return "Translated string based on field + error"
- default:
- return "Translated string based on field"
- }
-
-The hierarchical error structure is hard to work with sometimes.. Agreed Flatten function to the rescue!
-Flatten will return a map of FieldError's but the field name will be namespaced.
-
- // if UserDetail Details field failed validation
- Field will be "Sub.Details"
-
- // for Name
- Field will be "Name"
-
-Custom Functions
-
-Custom functions can be added
-
- //Structure
- func customFunc(top interface{}, current interface{}, field interface{}, param string) bool {
-
- if whatever {
- return false
- }
-
- return true
- }
-
- validate.AddFunction("custom tag name", customFunc)
- // NOTES: using the same tag name as an existing function
- // will overwrite the existing one
-
-Cross Field Validation
-
-Cross Field Validation can be implemented, for example Start & End Date range validation
-
- // NOTE: when calling validate.Struct(val) val will be the top level struct passed
- // into the function
- // when calling validate.FieldWithValue(val, field, tag) val will be
- // whatever you pass, struct, field...
- // when calling validate.Field(field, tag) val will be nil
- //
- // Because of the specific requirements and field names within each persons project that
- // uses this library it is likely that custom functions will need to be created for your
- // Cross Field Validation needs, however there are some build in Generic Cross Field validations,
- // see Baked In Validators and Tags below
-
- func isDateRangeValid(val interface{}, field interface{}, param string) bool {
-
- myStruct := val.(myStructType)
-
- if myStruct.Start.After(field.(time.Time)) {
- return false
- }
-
- return true
- }
-
-Multiple Validators
-
-Multiple validators on a field will process in the order defined
-
- type Test struct {
- Field `validate:"max=10,min=1"`
- }
-
- // max will be checked then min
-
-Bad Validator definitions are not handled by the library
-
- type Test struct {
- Field `validate:"min=10,max=0"`
- }
-
- // this definition of min max will never validate
-
-Baked In Validators and Tags
-
-NOTE: Baked In Cross field validation only compares fields on the same struct,
-if cross field + cross struct validation is needed your own custom validator
-should be implemented.
-
-NOTE2: comma is the default separator of validation tags, if you wish to have a comma
-included within the parameter i.e. excludesall=, you will need to use the UTF-8 hex
-representation 0x2C, which is replaced in the code as a comma, so the above will
-become excludesall=0x2C
-
-Here is a list of the current built in validators:
-
- -
- Tells the validation to skip this struct field; this is particularily
- handy in ignoring embedded structs from being validated. (Usage: -)
-
- |
- This is the 'or' operator allowing multiple validators to be used and
- accepted. (Usage: rbg|rgba) <-- this would allow either rgb or rgba
- colors to be accepted. This can also be combined with 'and' for example
- ( Usage: omitempty,rgb|rgba)
-
- structonly
- When a field that is a nest struct in encountered and contains this flag
- any validation on the nested struct such as "required" will be run, but
- none of the nested struct fields will be validated. This is usefull if
- inside of you program you know the struct will be valid, but need to
- verify it has been assigned.
-
- omitempty
- Allows conitional validation, for example if a field is not set with
- a value (Determined by the required validator) then other validation
- such as min or max won't run, but if a value is set validation will run.
- (Usage: omitempty)
-
- required
- This validates that the value is not the data types default value.
- For numbers ensures value is not zero. For strings ensures value is
- not "". For slices, arrays, and maps, ensures the length is not zero.
- (Usage: required)
-
- len
- For numbers, max will ensure that the value is
- equal to the parameter given. For strings, it checks that
- the string length is exactly that number of characters. For slices,
- arrays, and maps, validates the number of items. (Usage: len=10)
-
- max
- For numbers, max will ensure that the value is
- less than or equal to the parameter given. For strings, it checks
- that the string length is at most that number of characters. For
- slices, arrays, and maps, validates the number of items. (Usage: max=10)
-
- min
- For numbers, min will ensure that the value is
- greater or equal to the parameter given. For strings, it checks that
- the string length is at least that number of characters. For slices,
- arrays, and maps, validates the number of items. (Usage: min=10)
-
- eq
- For strings & numbers, eq will ensure that the value is
- equal to the parameter given. For slices, arrays, and maps,
- validates the number of items. (Usage: eq=10)
-
- ne
- For strings & numbers, eq will ensure that the value is not
- equal to the parameter given. For slices, arrays, and maps,
- validates the number of items. (Usage: eq=10)
-
- gt
- For numbers, this will ensure that the value is greater than the
- parameter given. For strings, it checks that the string length
- is greater than that number of characters. For slices, arrays
- and maps it validates the number of items. (Usage: gt=10)
- For time.Time ensures the time value is greater than time.Now.UTC()
- (Usage: gt)
-
- gte
- Same as 'min' above. Kept both to make terminology with 'len' easier
- (Usage: gte=10)
- For time.Time ensures the time value is greater than or equal to time.Now.UTC()
- (Usage: gte)
-
- lt
- For numbers, this will ensure that the value is
- less than the parameter given. For strings, it checks
- that the string length is less than that number of characters.
- For slices, arrays, and maps it validates the number of items.
- (Usage: lt=10)
- For time.Time ensures the time value is less than time.Now.UTC()
- (Usage: lt)
-
- lte
- Same as 'max' above. Kept both to make terminology with 'len' easier
- (Usage: lte=10)
- For time.Time ensures the time value is less than or equal to time.Now.UTC()
- (Usage: lte)
-
- eqfield
- This will validate the field value against another fields value either within
- a struct or passed in field.
- usage examples are for validation of a password and confirm password:
- Validation on Password field using validate.Struct Usage(eqfield=ConfirmPassword)
- Validating by field validate.FieldWithValue(password, confirmpassword, "eqfield")
-
- nefield
- This will validate the field value against another fields value either within
- a struct or passed in field.
- usage examples are for ensuring two colors are not the same:
- Validation on Color field using validate.Struct Usage(nefield=Color2)
- Validating by field validate.FieldWithValue(color1, color2, "nefield")
-
- gtfield
- Only valid for Numbers and time.Time types, this will validate the field value
- against another fields value either within a struct or passed in field.
- usage examples are for validation of a Start and End date:
- Validation on End field using validate.Struct Usage(gtfield=Start)
- Validating by field validate.FieldWithValue(start, end, "gtfield")
-
- gtefield
- Only valid for Numbers and time.Time types, this will validate the field value
- against another fields value either within a struct or passed in field.
- usage examples are for validation of a Start and End date:
- Validation on End field using validate.Struct Usage(gtefield=Start)
- Validating by field validate.FieldWithValue(start, end, "gtefield")
-
- ltfield
- Only valid for Numbers and time.Time types, this will validate the field value
- against another fields value either within a struct or passed in field.
- usage examples are for validation of a Start and End date:
- Validation on End field using validate.Struct Usage(ltfield=Start)
- Validating by field validate.FieldWithValue(start, end, "ltfield")
-
- ltefield
- Only valid for Numbers and time.Time types, this will validate the field value
- against another fields value either within a struct or passed in field.
- usage examples are for validation of a Start and End date:
- Validation on End field using validate.Struct Usage(ltefield=Start)
- Validating by field validate.FieldWithValue(start, end, "ltefield")
-
- alpha
- This validates that a string value contains alpha characters only
- (Usage: alpha)
-
- alphanum
- This validates that a string value contains alphanumeric characters only
- (Usage: alphanum)
-
- numeric
- This validates that a string value contains a basic numeric value.
- basic excludes exponents etc...
- (Usage: numeric)
-
- hexadecimal
- This validates that a string value contains a valid hexadecimal.
- (Usage: hexadecimal)
-
- hexcolor
- This validates that a string value contains a valid hex color including
- hashtag (#)
- (Usage: hexcolor)
-
- rgb
- This validates that a string value contains a valid rgb color
- (Usage: rgb)
-
- rgba
- This validates that a string value contains a valid rgba color
- (Usage: rgba)
-
- hsl
- This validates that a string value contains a valid hsl color
- (Usage: hsl)
-
- hsla
- This validates that a string value contains a valid hsla color
- (Usage: hsla)
-
- email
- This validates that a string value contains a valid email
- This may not conform to all possibilities of any rfc standard, but neither
- does any email provider accept all posibilities...
- (Usage: email)
-
- url
- This validates that a string value contains a valid url
- This will accept any url the golang request uri accepts but must contain
- a schema for example http:// or rtmp://
- (Usage: url)
-
- uri
- This validates that a string value contains a valid uri
- This will accept any uri the golang request uri accepts (Usage: uri)
-
- base64
- This validates that a string value contains a valid base64 value.
- Although an empty string is valid base64 this will report an empty string
- as an error, if you wish to accept an empty string as valid you can use
- this with the omitempty tag. (Usage: base64)
-
- contains
- This validates that a string value contains the substring value.
- (Usage: contains=@)
-
- containsany
- This validates that a string value contains any Unicode code points
- in the substring value. (Usage: containsany=!@#?)
-
- containsrune
- This validates that a string value contains the supplied rune value.
- (Usage: containsrune=@)
-
- excludes
- This validates that a string value does not contain the substring value.
- (Usage: excludes=@)
-
- excludesall
- This validates that a string value does not contain any Unicode code
- points in the substring value. (Usage: excludesall=!@#?)
-
- excludesrune
- This validates that a string value does not contain the supplied rune value.
- (Usage: excludesrune=@)
-
-Validator notes:
-
- regex
- a regex validator won't be added because commas and = signs can be part of
- a regex which conflict with the validation definitions, although workarounds
- can be made, they take away from using pure regex's. Furthermore it's quick
- and dirty but the regex's become harder to maintain and are not reusable, so
- it's as much a programming philosiphy as anything.
-
- In place of this new validator functions should be created; a regex can be
- used within the validator function and even be precompiled for better efficiency
- within regexes.go.
-
- And the best reason, you can submit a pull request and we can keep on adding to the
- validation library of this package!
-
-Panics
-
-This package panics when bad input is provided, this is by design, bad code like that should not make it to production.
-
- type Test struct {
- TestField string `validate:"nonexistantfunction=1"`
- }
-
- t := &Test{
- TestField: "Test"
- }
-
- validate.Struct(t) // this will panic
-*/
-package validator
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/regexes.go b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/regexes.go
deleted file mode 100644
index e5ed0fae008a516fcad4a7eaf553a9bb0242b407..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/regexes.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package validator
-
-import "regexp"
-
-const (
- alphaRegexString = "^[a-zA-Z]+$"
- alphaNumericRegexString = "^[a-zA-Z0-9]+$"
- numericRegexString = "^[-+]?[0-9]+(?:\\.[0-9]+)?$"
- numberRegexString = "^[0-9]+$"
- hexadecimalRegexString = "^[0-9a-fA-F]+$"
- hexcolorRegexString = "^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$"
- rgbRegexString = "^rgb\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*\\)$"
- rgbaRegexString = "^rgba\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*((0.[1-9]*)|[01])\\s*\\)$"
- hslRegexString = "^hsl\\(\\s*(0|[1-9]\\d?|[12]\\d\\d|3[0-5]\\d|360)\\s*,\\s*((0|[1-9]\\d?|100)%)\\s*,\\s*((0|[1-9]\\d?|100)%)\\s*\\)$"
- hslaRegexString = "^hsla\\(\\s*(0|[1-9]\\d?|[12]\\d\\d|3[0-5]\\d|360)\\s*,\\s*((0|[1-9]\\d?|100)%)\\s*,\\s*((0|[1-9]\\d?|100)%)\\s*,\\s*((0.[1-9]*)|[01])\\s*\\)$"
- emailRegexString = "^(((([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+(\\.([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+)*)|((\\x22)((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])([a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.)+(([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])([a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.?$"
- base64RegexString = "(?:^(?:[A-Za-z0-9+\\/]{4}\\n?)*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=)$)"
-)
-
-var (
- alphaRegex = regexp.MustCompile(alphaRegexString)
- alphaNumericRegex = regexp.MustCompile(alphaNumericRegexString)
- numericRegex = regexp.MustCompile(numericRegexString)
- numberRegex = regexp.MustCompile(numberRegexString)
- hexadecimalRegex = regexp.MustCompile(hexadecimalRegexString)
- hexcolorRegex = regexp.MustCompile(hexcolorRegexString)
- rgbRegex = regexp.MustCompile(rgbRegexString)
- rgbaRegex = regexp.MustCompile(rgbaRegexString)
- hslRegex = regexp.MustCompile(hslRegexString)
- hslaRegex = regexp.MustCompile(hslaRegexString)
- emailRegex = regexp.MustCompile(emailRegexString)
- base64Regex = regexp.MustCompile(base64RegexString)
-)
-
-func matchesRegex(regex *regexp.Regexp, field interface{}) bool {
- fieldAsString := field.(string) //this will panic inherently
- return regex.MatchString(fieldAsString)
-}
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/validator.go b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/validator.go
deleted file mode 100644
index 33110f68ed24693c55acd3a9525b17178b999068..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/validator.go
+++ /dev/null
@@ -1,571 +0,0 @@
-/**
- * Package validator
- *
- * MISC:
- * - anonymous structs - they don't have names so expect the Struct name within StructErrors to be blank
- *
- */
-
-package validator
-
-import (
- "bytes"
- "errors"
- "fmt"
- "reflect"
- "strings"
- "sync"
- "time"
- "unicode"
-)
-
-const (
- utf8HexComma = "0x2C"
- tagSeparator = ","
- orSeparator = "|"
- noValidationTag = "-"
- tagKeySeparator = "="
- structOnlyTag = "structonly"
- omitempty = "omitempty"
- fieldErrMsg = "Field validation for \"%s\" failed on the \"%s\" tag"
- structErrMsg = "Struct:%s\n"
-)
-
-var structPool *pool
-
-// Pool holds a channelStructErrors.
-type pool struct {
- pool chan *StructErrors
-}
-
-// NewPool creates a new pool of Clients.
-func newPool(max int) *pool {
- return &pool{
- pool: make(chan *StructErrors, max),
- }
-}
-
-// Borrow a StructErrors from the pool.
-func (p *pool) Borrow() *StructErrors {
- var c *StructErrors
-
- select {
- case c = <-p.pool:
- default:
- c = &StructErrors{
- Errors: map[string]*FieldError{},
- StructErrors: map[string]*StructErrors{},
- }
- }
-
- return c
-}
-
-// Return returns a StructErrors to the pool.
-func (p *pool) Return(c *StructErrors) {
-
- // c.Struct = ""
-
- select {
- case p.pool <- c:
- default:
- // let it go, let it go...
- }
-}
-
-type cachedTags struct {
- keyVals [][]string
- isOrVal bool
-}
-
-type cachedField struct {
- index int
- name string
- tags []*cachedTags
- tag string
- kind reflect.Kind
- typ reflect.Type
- isTime bool
-}
-
-type cachedStruct struct {
- children int
- name string
- kind reflect.Kind
- fields []*cachedField
-}
-
-type structsCacheMap struct {
- lock sync.RWMutex
- m map[reflect.Type]*cachedStruct
-}
-
-func (s *structsCacheMap) Get(key reflect.Type) (*cachedStruct, bool) {
- s.lock.RLock()
- defer s.lock.RUnlock()
- value, ok := s.m[key]
- return value, ok
-}
-
-func (s *structsCacheMap) Set(key reflect.Type, value *cachedStruct) {
- s.lock.Lock()
- defer s.lock.Unlock()
- s.m[key] = value
-}
-
-var structCache = &structsCacheMap{m: map[reflect.Type]*cachedStruct{}}
-
-type fieldsCacheMap struct {
- lock sync.RWMutex
- m map[string][]*cachedTags
-}
-
-func (s *fieldsCacheMap) Get(key string) ([]*cachedTags, bool) {
- s.lock.RLock()
- defer s.lock.RUnlock()
- value, ok := s.m[key]
- return value, ok
-}
-
-func (s *fieldsCacheMap) Set(key string, value []*cachedTags) {
- s.lock.Lock()
- defer s.lock.Unlock()
- s.m[key] = value
-}
-
-var fieldsCache = &fieldsCacheMap{m: map[string][]*cachedTags{}}
-
-// FieldError contains a single field's validation error along
-// with other properties that may be needed for error message creation
-type FieldError struct {
- Field string
- Tag string
- Kind reflect.Kind
- Type reflect.Type
- Param string
- Value interface{}
-}
-
-// This is intended for use in development + debugging and not intended to be a production error message.
-// it also allows FieldError to be used as an Error interface
-func (e *FieldError) Error() string {
- return fmt.Sprintf(fieldErrMsg, e.Field, e.Tag)
-}
-
-// StructErrors is hierarchical list of field and struct validation errors
-// for a non hierarchical representation please see the Flatten method for StructErrors
-type StructErrors struct {
- // Name of the Struct
- Struct string
- // Struct Field Errors
- Errors map[string]*FieldError
- // Struct Fields of type struct and their errors
- // key = Field Name of current struct, but internally Struct will be the actual struct name unless anonymous struct, it will be blank
- StructErrors map[string]*StructErrors
-}
-
-// This is intended for use in development + debugging and not intended to be a production error message.
-// it also allows StructErrors to be used as an Error interface
-func (e *StructErrors) Error() string {
- buff := bytes.NewBufferString(fmt.Sprintf(structErrMsg, e.Struct))
-
- for _, err := range e.Errors {
- buff.WriteString(err.Error())
- buff.WriteString("\n")
- }
-
- for _, err := range e.StructErrors {
- buff.WriteString(err.Error())
- }
-
- return buff.String()
-}
-
-// Flatten flattens the StructErrors hierarchical structure into a flat namespace style field name
-// for those that want/need it
-func (e *StructErrors) Flatten() map[string]*FieldError {
-
- if e == nil {
- return nil
- }
-
- errs := map[string]*FieldError{}
-
- for _, f := range e.Errors {
-
- errs[f.Field] = f
- }
-
- for key, val := range e.StructErrors {
-
- otherErrs := val.Flatten()
-
- for _, f2 := range otherErrs {
-
- f2.Field = fmt.Sprintf("%s.%s", key, f2.Field)
- errs[f2.Field] = f2
- }
- }
-
- return errs
-}
-
-// Func accepts all values needed for file and cross field validation
-// top = top level struct when validating by struct otherwise nil
-// current = current level struct when validating by struct otherwise optional comparison value
-// f = field value for validation
-// param = parameter used in validation i.e. gt=0 param would be 0
-type Func func(top interface{}, current interface{}, f interface{}, param string) bool
-
-// Validate implements the Validate Struct
-// NOTE: Fields within are not thread safe and that is on purpose
-// Functions and Tags should all be predifined before use, so subscribe to the philosiphy
-// or make it thread safe on your end
-type Validate struct {
- // tagName being used.
- tagName string
- // validateFuncs is a map of validation functions and the tag keys
- validationFuncs map[string]Func
-}
-
-// New creates a new Validate instance for use.
-func New(tagName string, funcs map[string]Func) *Validate {
-
- structPool = newPool(10)
-
- return &Validate{
- tagName: tagName,
- validationFuncs: funcs,
- }
-}
-
-// SetTag sets tagName of the Validator to one of your choosing after creation
-// perhaps to dodge a tag name conflict in a specific section of code
-// NOTE: this method is not thread-safe
-func (v *Validate) SetTag(tagName string) {
- v.tagName = tagName
-}
-
-// SetStructPoolMax sets the struct pools max size. this may be usefull for fine grained
-// performance tuning towards your application, however, the default should be fine for
-// nearly all cases. only increase if you have a deeply nested struct structure.
-// NOTE: this method is not thread-safe
-// NOTE: this is only here to keep compatibility with v5, in v6 the method will be removed
-// and the max pool size will be passed into the New function
-func (v *Validate) SetMaxStructPoolSize(max int) {
- structPool = newPool(max)
-}
-
-// AddFunction adds a validation Func to a Validate's map of validators denoted by the key
-// NOTE: if the key already exists, it will get replaced.
-// NOTE: this method is not thread-safe
-func (v *Validate) AddFunction(key string, f Func) error {
-
- if len(key) == 0 {
- return errors.New("Function Key cannot be empty")
- }
-
- if f == nil {
- return errors.New("Function cannot be empty")
- }
-
- v.validationFuncs[key] = f
-
- return nil
-}
-
-// Struct validates a struct, even it's nested structs, and returns a struct containing the errors
-// NOTE: Nested Arrays, or Maps of structs do not get validated only the Array or Map itself; the reason is that there is no good
-// way to represent or report which struct within the array has the error, besides can validate the struct prior to adding it to
-// the Array or Map.
-func (v *Validate) Struct(s interface{}) *StructErrors {
-
- return v.structRecursive(s, s, s)
-}
-
-// structRecursive validates a struct recursivly and passes the top level and current struct around for use in validator functions and returns a struct containing the errors
-func (v *Validate) structRecursive(top interface{}, current interface{}, s interface{}) *StructErrors {
-
- structValue := reflect.ValueOf(s)
-
- if structValue.Kind() == reflect.Ptr && !structValue.IsNil() {
- return v.structRecursive(top, current, structValue.Elem().Interface())
- }
-
- if structValue.Kind() != reflect.Struct && structValue.Kind() != reflect.Interface {
- panic("interface passed for validation is not a struct")
- }
-
- structType := reflect.TypeOf(s)
-
- var structName string
- var numFields int
- var cs *cachedStruct
- var isCached bool
-
- cs, isCached = structCache.Get(structType)
-
- if isCached {
- structName = cs.name
- numFields = cs.children
- } else {
- structName = structType.Name()
- numFields = structValue.NumField()
- cs = &cachedStruct{name: structName, children: numFields}
- structCache.Set(structType, cs)
- }
-
- validationErrors := structPool.Borrow()
- validationErrors.Struct = structName
-
- for i := 0; i < numFields; i++ {
-
- var valueField reflect.Value
- var cField *cachedField
- var typeField reflect.StructField
-
- if isCached {
- cField = cs.fields[i]
- valueField = structValue.Field(cField.index)
-
- if valueField.Kind() == reflect.Ptr && !valueField.IsNil() {
- valueField = valueField.Elem()
- }
- } else {
- valueField = structValue.Field(i)
-
- if valueField.Kind() == reflect.Ptr && !valueField.IsNil() {
- valueField = valueField.Elem()
- }
-
- typeField = structType.Field(i)
-
- cField = &cachedField{index: i, tag: typeField.Tag.Get(v.tagName)}
-
- if cField.tag == noValidationTag {
- cs.children--
- continue
- }
-
- // if no validation and not a struct (which may containt fields for validation)
- if cField.tag == "" && ((valueField.Kind() != reflect.Struct && valueField.Kind() != reflect.Interface) || valueField.Type() == reflect.TypeOf(time.Time{})) {
- cs.children--
- continue
- }
-
- cField.name = typeField.Name
- cField.kind = valueField.Kind()
- cField.typ = valueField.Type()
- }
-
- // this can happen if the first cache value was nil
- // but the second actually has a value
- if cField.kind == reflect.Ptr {
- cField.kind = valueField.Kind()
- }
-
- switch cField.kind {
-
- case reflect.Struct, reflect.Interface:
-
- if !unicode.IsUpper(rune(cField.name[0])) {
- cs.children--
- continue
- }
-
- if cField.isTime || valueField.Type() == reflect.TypeOf(time.Time{}) {
-
- cField.isTime = true
-
- if fieldError := v.fieldWithNameAndValue(top, current, valueField.Interface(), cField.tag, cField.name, false, cField); fieldError != nil {
- validationErrors.Errors[fieldError.Field] = fieldError
- // free up memory reference
- fieldError = nil
- }
-
- } else {
-
- if strings.Contains(cField.tag, structOnlyTag) {
- cs.children--
- continue
- }
-
- if structErrors := v.structRecursive(top, valueField.Interface(), valueField.Interface()); structErrors != nil {
- validationErrors.StructErrors[cField.name] = structErrors
- // free up memory map no longer needed
- structErrors = nil
- }
- }
-
- default:
-
- if fieldError := v.fieldWithNameAndValue(top, current, valueField.Interface(), cField.tag, cField.name, false, cField); fieldError != nil {
- validationErrors.Errors[fieldError.Field] = fieldError
- // free up memory reference
- fieldError = nil
- }
- }
-
- if !isCached {
- cs.fields = append(cs.fields, cField)
- }
- }
-
- if len(validationErrors.Errors) == 0 && len(validationErrors.StructErrors) == 0 {
- structPool.Return(validationErrors)
- return nil
- }
-
- return validationErrors
-}
-
-// Field allows validation of a single field, still using tag style validation to check multiple errors
-func (v *Validate) Field(f interface{}, tag string) *FieldError {
-
- return v.FieldWithValue(nil, f, tag)
-}
-
-// FieldWithValue allows validation of a single field, possibly even against another fields value, still using tag style validation to check multiple errors
-func (v *Validate) FieldWithValue(val interface{}, f interface{}, tag string) *FieldError {
-
- return v.fieldWithNameAndValue(nil, val, f, tag, "", true, nil)
-}
-
-func (v *Validate) fieldWithNameAndValue(val interface{}, current interface{}, f interface{}, tag string, name string, isSingleField bool, cacheField *cachedField) *FieldError {
-
- var cField *cachedField
- var isCached bool
-
- // This is a double check if coming from validate.Struct but need to be here in case function is called directly
- if tag == noValidationTag {
- return nil
- }
-
- if strings.Contains(tag, omitempty) && !hasValue(val, current, f, "") {
- return nil
- }
-
- if cacheField == nil {
- valueField := reflect.ValueOf(f)
-
- if valueField.Kind() == reflect.Ptr && !valueField.IsNil() {
- valueField = valueField.Elem()
- f = valueField.Interface()
- }
-
- cField = &cachedField{name: name, kind: valueField.Kind(), tag: tag, typ: valueField.Type()}
- } else {
- cField = cacheField
- }
-
- switch cField.kind {
-
- case reflect.Struct, reflect.Interface, reflect.Invalid:
-
- if cField.typ != reflect.TypeOf(time.Time{}) {
- panic("Invalid field passed to ValidateFieldWithTag")
- }
- }
-
- if len(cField.tags) == 0 {
-
- if isSingleField {
- cField.tags, isCached = fieldsCache.Get(tag)
- }
-
- if !isCached {
-
- for _, t := range strings.Split(tag, tagSeparator) {
-
- orVals := strings.Split(t, orSeparator)
- cTag := &cachedTags{isOrVal: len(orVals) > 1, keyVals: make([][]string, len(orVals))}
- cField.tags = append(cField.tags, cTag)
-
- for i, val := range orVals {
- vals := strings.SplitN(val, tagKeySeparator, 2)
-
- key := strings.TrimSpace(vals[0])
-
- if len(key) == 0 {
- panic(fmt.Sprintf("Invalid validation tag on field %s", name))
- }
-
- param := ""
- if len(vals) > 1 {
- param = strings.Replace(vals[1], utf8HexComma, ",", -1)
- }
-
- cTag.keyVals[i] = []string{key, param}
- }
- }
-
- if isSingleField {
- fieldsCache.Set(cField.tag, cField.tags)
- }
- }
- }
-
- var fieldErr *FieldError
- var err error
-
- for _, cTag := range cField.tags {
-
- if cTag.isOrVal {
-
- errTag := ""
-
- for _, val := range cTag.keyVals {
-
- fieldErr, err = v.fieldWithNameAndSingleTag(val, current, f, val[0], val[1], name)
-
- if err == nil {
- return nil
- }
-
- errTag += orSeparator + fieldErr.Tag
- }
-
- errTag = strings.TrimLeft(errTag, orSeparator)
-
- fieldErr.Tag = errTag
- fieldErr.Kind = cField.kind
- fieldErr.Type = cField.typ
-
- return fieldErr
- }
-
- if fieldErr, err = v.fieldWithNameAndSingleTag(val, current, f, cTag.keyVals[0][0], cTag.keyVals[0][1], name); err != nil {
-
- fieldErr.Kind = cField.kind
- fieldErr.Type = cField.typ
-
- return fieldErr
- }
- }
-
- return nil
-}
-
-func (v *Validate) fieldWithNameAndSingleTag(val interface{}, current interface{}, f interface{}, key string, param string, name string) (*FieldError, error) {
-
- // OK to continue because we checked it's existance before getting into this loop
- if key == omitempty {
- return nil, nil
- }
-
- valFunc, ok := v.validationFuncs[key]
- if !ok {
- panic(fmt.Sprintf("Undefined validation function on field %s", name))
- }
-
- if err := valFunc(val, current, f, param); err {
- return nil, nil
- }
-
- return &FieldError{
- Field: name,
- Tag: key,
- Value: f,
- Param: param,
- }, errors.New(key)
-}
diff --git a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/validator_test.go b/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/validator_test.go
deleted file mode 100644
index aa8c74957f9e563f3eb39d6cea8f798aeaf7fdbf..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/bluesuncorp/validator.v5/validator_test.go
+++ /dev/null
@@ -1,2497 +0,0 @@
-package validator
-
-import (
- "fmt"
- "path"
- "reflect"
- "runtime"
- "testing"
- "time"
-)
-
-// NOTES:
-// - Run "go test" to run tests
-// - Run "gocov test | gocov report" to report on test converage by file
-// - Run "gocov test | gocov annotate -" to report on all code and functions, those ,marked with "MISS" were never called
-//
-//
-// go test -cpuprofile cpu.out
-// ./validator.test -test.bench=. -test.cpuprofile=cpu.prof
-// go tool pprof validator.test cpu.prof
-//
-//
-// go test -memprofile mem.out
-
-type I interface {
- Foo() string
-}
-
-type Impl struct {
- F string `validate:"len=3"`
-}
-
-func (i *Impl) Foo() string {
- return i.F
-}
-
-type SubTest struct {
- Test string `validate:"required"`
-}
-
-type TestInterface struct {
- Iface I
-}
-
-type TestString struct {
- BlankTag string `validate:""`
- Required string `validate:"required"`
- Len string `validate:"len=10"`
- Min string `validate:"min=1"`
- Max string `validate:"max=10"`
- MinMax string `validate:"min=1,max=10"`
- Lt string `validate:"lt=10"`
- Lte string `validate:"lte=10"`
- Gt string `validate:"gt=10"`
- Gte string `validate:"gte=10"`
- OmitEmpty string `validate:"omitempty,min=1,max=10"`
- Sub *SubTest
- SubIgnore *SubTest `validate:"-"`
- Anonymous struct {
- A string `validate:"required"`
- }
- Iface I
-}
-
-type TestInt32 struct {
- Required int `validate:"required"`
- Len int `validate:"len=10"`
- Min int `validate:"min=1"`
- Max int `validate:"max=10"`
- MinMax int `validate:"min=1,max=10"`
- Lt int `validate:"lt=10"`
- Lte int `validate:"lte=10"`
- Gt int `validate:"gt=10"`
- Gte int `validate:"gte=10"`
- OmitEmpty int `validate:"omitempty,min=1,max=10"`
-}
-
-type TestUint64 struct {
- Required uint64 `validate:"required"`
- Len uint64 `validate:"len=10"`
- Min uint64 `validate:"min=1"`
- Max uint64 `validate:"max=10"`
- MinMax uint64 `validate:"min=1,max=10"`
- OmitEmpty uint64 `validate:"omitempty,min=1,max=10"`
-}
-
-type TestFloat64 struct {
- Required float64 `validate:"required"`
- Len float64 `validate:"len=10"`
- Min float64 `validate:"min=1"`
- Max float64 `validate:"max=10"`
- MinMax float64 `validate:"min=1,max=10"`
- Lte float64 `validate:"lte=10"`
- OmitEmpty float64 `validate:"omitempty,min=1,max=10"`
-}
-
-type TestSlice struct {
- Required []int `validate:"required"`
- Len []int `validate:"len=10"`
- Min []int `validate:"min=1"`
- Max []int `validate:"max=10"`
- MinMax []int `validate:"min=1,max=10"`
- OmitEmpty []int `validate:"omitempty,min=1,max=10"`
-}
-
-var validate = New("validate", BakedInValidators)
-
-func IsEqual(t *testing.T, val1, val2 interface{}) bool {
- v1 := reflect.ValueOf(val1)
- v2 := reflect.ValueOf(val2)
-
- if v1.Kind() == reflect.Ptr {
- v1 = v1.Elem()
- }
-
- if v2.Kind() == reflect.Ptr {
- v2 = v2.Elem()
- }
-
- if !v1.IsValid() && !v2.IsValid() {
- return true
- }
-
- v1Underlying := reflect.Zero(reflect.TypeOf(v1)).Interface()
- v2Underlying := reflect.Zero(reflect.TypeOf(v2)).Interface()
-
- if v1 == v1Underlying {
- if v2 == v2Underlying {
- goto CASE4
- } else {
- goto CASE3
- }
- } else {
- if v2 == v2Underlying {
- goto CASE2
- } else {
- goto CASE1
- }
- }
-
-CASE1:
- return reflect.DeepEqual(v1.Interface(), v2.Interface())
-
-CASE2:
- return reflect.DeepEqual(v1.Interface(), v2)
-CASE3:
- return reflect.DeepEqual(v1, v2.Interface())
-CASE4:
- return reflect.DeepEqual(v1, v2)
-}
-
-func Equal(t *testing.T, val1, val2 interface{}) {
- EqualSkip(t, 2, val1, val2)
-}
-
-func EqualSkip(t *testing.T, skip int, val1, val2 interface{}) {
-
- if !IsEqual(t, val1, val2) {
-
- _, file, line, _ := runtime.Caller(skip)
- fmt.Printf("%s:%d %v does not equal %v\n", path.Base(file), line, val1, val2)
- t.FailNow()
- }
-}
-
-func NotEqual(t *testing.T, val1, val2 interface{}) {
- NotEqualSkip(t, 2, val1, val2)
-}
-
-func NotEqualSkip(t *testing.T, skip int, val1, val2 interface{}) {
-
- if IsEqual(t, val1, val2) {
- _, file, line, _ := runtime.Caller(skip)
- fmt.Printf("%s:%d %v should not be equal %v\n", path.Base(file), line, val1, val2)
- t.FailNow()
- }
-}
-
-func PanicMatches(t *testing.T, fn func(), matches string) {
- PanicMatchesSkip(t, 2, fn, matches)
-}
-
-func PanicMatchesSkip(t *testing.T, skip int, fn func(), matches string) {
-
- _, file, line, _ := runtime.Caller(skip)
-
- defer func() {
- if r := recover(); r != nil {
- err := fmt.Sprintf("%s", r)
-
- if err != matches {
- fmt.Printf("%s:%d Panic... expected [%s] received [%s]", path.Base(file), line, matches, err)
- t.FailNow()
- }
- }
- }()
-
- fn()
-}
-
-func AssertStruct(t *testing.T, s *StructErrors, structFieldName string, expectedStructName string) *StructErrors {
-
- val, ok := s.StructErrors[structFieldName]
- EqualSkip(t, 2, ok, true)
- NotEqualSkip(t, 2, val, nil)
- EqualSkip(t, 2, val.Struct, expectedStructName)
-
- return val
-}
-
-func AssertFieldError(t *testing.T, s *StructErrors, field string, expectedTag string) {
-
- val, ok := s.Errors[field]
- EqualSkip(t, 2, ok, true)
- NotEqualSkip(t, 2, val, nil)
- EqualSkip(t, 2, val.Field, field)
- EqualSkip(t, 2, val.Tag, expectedTag)
-}
-
-func AssertMapFieldError(t *testing.T, s map[string]*FieldError, field string, expectedTag string) {
-
- val, ok := s[field]
- EqualSkip(t, 2, ok, true)
- NotEqualSkip(t, 2, val, nil)
- EqualSkip(t, 2, val.Field, field)
- EqualSkip(t, 2, val.Tag, expectedTag)
-}
-
-func TestExcludesRuneValidation(t *testing.T) {
-
- tests := []struct {
- Value string `validate:"excludesrune=☻"`
- Tag string
- ExpectedNil bool
- }{
- {Value: "a☺b☻c☹d", Tag: "excludesrune=☻", ExpectedNil: false},
- {Value: "abcd", Tag: "excludesrune=☻", ExpectedNil: true},
- }
-
- for i, s := range tests {
- err := validate.Field(s.Value, s.Tag)
-
- if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, err)
- }
-
- errs := validate.Struct(s)
-
- if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, errs)
- }
- }
-}
-
-func TestExcludesAllValidation(t *testing.T) {
-
- tests := []struct {
- Value string `validate:"excludesall=@!{}[]"`
- Tag string
- ExpectedNil bool
- }{
- {Value: "abcd@!jfk", Tag: "excludesall=@!{}[]", ExpectedNil: false},
- {Value: "abcdefg", Tag: "excludesall=@!{}[]", ExpectedNil: true},
- }
-
- for i, s := range tests {
- err := validate.Field(s.Value, s.Tag)
-
- if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, err)
- }
-
- errs := validate.Struct(s)
-
- if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, errs)
- }
- }
-
- username := "joeybloggs "
-
- err := validate.Field(username, "excludesall=@ ")
- NotEqual(t, err, nil)
-
- excluded := ","
-
- err = validate.Field(excluded, "excludesall=!@#$%^&*()_+.0x2C?")
- NotEqual(t, err, nil)
-
- excluded = "="
-
- err = validate.Field(excluded, "excludesall=!@#$%^&*()_+.0x2C=?")
- NotEqual(t, err, nil)
-}
-
-func TestExcludesValidation(t *testing.T) {
-
- tests := []struct {
- Value string `validate:"excludes=@"`
- Tag string
- ExpectedNil bool
- }{
- {Value: "abcd@!jfk", Tag: "excludes=@", ExpectedNil: false},
- {Value: "abcdq!jfk", Tag: "excludes=@", ExpectedNil: true},
- }
-
- for i, s := range tests {
- err := validate.Field(s.Value, s.Tag)
-
- if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, err)
- }
-
- errs := validate.Struct(s)
-
- if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, errs)
- }
- }
-}
-
-func TestContainsRuneValidation(t *testing.T) {
-
- tests := []struct {
- Value string `validate:"containsrune=☻"`
- Tag string
- ExpectedNil bool
- }{
- {Value: "a☺b☻c☹d", Tag: "containsrune=☻", ExpectedNil: true},
- {Value: "abcd", Tag: "containsrune=☻", ExpectedNil: false},
- }
-
- for i, s := range tests {
- err := validate.Field(s.Value, s.Tag)
-
- if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, err)
- }
-
- errs := validate.Struct(s)
-
- if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, errs)
- }
- }
-}
-
-func TestContainsAnyValidation(t *testing.T) {
-
- tests := []struct {
- Value string `validate:"containsany=@!{}[]"`
- Tag string
- ExpectedNil bool
- }{
- {Value: "abcd@!jfk", Tag: "containsany=@!{}[]", ExpectedNil: true},
- {Value: "abcdefg", Tag: "containsany=@!{}[]", ExpectedNil: false},
- }
-
- for i, s := range tests {
- err := validate.Field(s.Value, s.Tag)
-
- if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, err)
- }
-
- errs := validate.Struct(s)
-
- if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, errs)
- }
- }
-}
-
-func TestContainsValidation(t *testing.T) {
-
- tests := []struct {
- Value string `validate:"contains=@"`
- Tag string
- ExpectedNil bool
- }{
- {Value: "abcd@!jfk", Tag: "contains=@", ExpectedNil: true},
- {Value: "abcdq!jfk", Tag: "contains=@", ExpectedNil: false},
- }
-
- for i, s := range tests {
- err := validate.Field(s.Value, s.Tag)
-
- if (s.ExpectedNil && err != nil) || (!s.ExpectedNil && err == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, err)
- }
-
- errs := validate.Struct(s)
-
- if (s.ExpectedNil && errs != nil) || (!s.ExpectedNil && errs == nil) {
- t.Fatalf("Index: %d failed Error: %s", i, errs)
- }
- }
-}
-
-func TestIsNeFieldValidation(t *testing.T) {
-
- var j uint64
- var k float64
- s := "abcd"
- i := 1
- j = 1
- k = 1.543
- arr := []string{"test"}
- now := time.Now().UTC()
-
- var j2 uint64
- var k2 float64
- s2 := "abcdef"
- i2 := 3
- j2 = 2
- k2 = 1.5434456
- arr2 := []string{"test", "test2"}
- arr3 := []string{"test"}
- now2 := now
-
- err := validate.FieldWithValue(s, s2, "nefield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(i2, i, "nefield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(j2, j, "nefield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(k2, k, "nefield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(arr2, arr, "nefield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(now2, now, "nefield")
- NotEqual(t, err, nil)
-
- err = validate.FieldWithValue(arr3, arr, "nefield")
- NotEqual(t, err, nil)
-
- type Test struct {
- Start *time.Time `validate:"nefield=End"`
- End *time.Time
- }
-
- sv := &Test{
- Start: &now,
- End: &now,
- }
-
- errs := validate.Struct(sv)
- NotEqual(t, errs, nil)
-
- now3 := time.Now().UTC()
-
- sv = &Test{
- Start: &now,
- End: &now3,
- }
-
- errs = validate.Struct(sv)
- Equal(t, errs, nil)
-
- channel := make(chan string)
-
- PanicMatches(t, func() { validate.FieldWithValue(nil, 1, "nefield") }, "struct not passed for cross validation")
- PanicMatches(t, func() { validate.FieldWithValue(5, channel, "nefield") }, "Bad field type chan string")
- PanicMatches(t, func() { validate.FieldWithValue(5, now, "nefield") }, "Bad Top Level field type")
-
- type Test2 struct {
- Start *time.Time `validate:"nefield=NonExistantField"`
- End *time.Time
- }
-
- sv2 := &Test2{
- Start: &now,
- End: &now,
- }
-
- PanicMatches(t, func() { validate.Struct(sv2) }, "Field \"NonExistantField\" not found in struct")
-}
-
-func TestIsNeValidation(t *testing.T) {
-
- var j uint64
- var k float64
- s := "abcdef"
- i := 3
- j = 2
- k = 1.5434
- arr := []string{"test"}
- now := time.Now().UTC()
-
- err := validate.Field(s, "ne=abcd")
- Equal(t, err, nil)
-
- err = validate.Field(i, "ne=1")
- Equal(t, err, nil)
-
- err = validate.Field(j, "ne=1")
- Equal(t, err, nil)
-
- err = validate.Field(k, "ne=1.543")
- Equal(t, err, nil)
-
- err = validate.Field(arr, "ne=2")
- Equal(t, err, nil)
-
- err = validate.Field(arr, "ne=1")
- NotEqual(t, err, nil)
-
- PanicMatches(t, func() { validate.Field(now, "ne=now") }, "Bad field type time.Time")
-}
-
-func TestIsEqFieldValidation(t *testing.T) {
-
- var j uint64
- var k float64
- s := "abcd"
- i := 1
- j = 1
- k = 1.543
- arr := []string{"test"}
- now := time.Now().UTC()
-
- var j2 uint64
- var k2 float64
- s2 := "abcd"
- i2 := 1
- j2 = 1
- k2 = 1.543
- arr2 := []string{"test"}
- arr3 := []string{"test", "test2"}
- now2 := now
-
- err := validate.FieldWithValue(s, s2, "eqfield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(i2, i, "eqfield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(j2, j, "eqfield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(k2, k, "eqfield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(arr2, arr, "eqfield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(now2, now, "eqfield")
- Equal(t, err, nil)
-
- err = validate.FieldWithValue(arr3, arr, "eqfield")
- NotEqual(t, err, nil)
-
- type Test struct {
- Start *time.Time `validate:"eqfield=End"`
- End *time.Time
- }
-
- sv := &Test{
- Start: &now,
- End: &now,
- }
-
- errs := validate.Struct(sv)
- Equal(t, errs, nil)
-
- now3 := time.Now().UTC()
-
- sv = &Test{
- Start: &now,
- End: &now3,
- }
-
- errs = validate.Struct(sv)
- NotEqual(t, errs, nil)
-
- channel := make(chan string)
-
- PanicMatches(t, func() { validate.FieldWithValue(nil, 1, "eqfield") }, "struct not passed for cross validation")
- PanicMatches(t, func() { validate.FieldWithValue(5, channel, "eqfield") }, "Bad field type chan string")
- PanicMatches(t, func() { validate.FieldWithValue(5, now, "eqfield") }, "Bad Top Level field type")
-
- type Test2 struct {
- Start *time.Time `validate:"eqfield=NonExistantField"`
- End *time.Time
- }
-
- sv2 := &Test2{
- Start: &now,
- End: &now,
- }
-
- PanicMatches(t, func() { validate.Struct(sv2) }, "Field \"NonExistantField\" not found in struct")
-}
-
-func TestIsEqValidation(t *testing.T) {
-
- var j uint64
- var k float64
- s := "abcd"
- i := 1
- j = 1
- k = 1.543
- arr := []string{"test"}
- now := time.Now().UTC()
-
- err := validate.Field(s, "eq=abcd")
- Equal(t, err, nil)
-
- err = validate.Field(i, "eq=1")
- Equal(t, err, nil)
-
- err = validate.Field(j, "eq=1")
- Equal(t, err, nil)
-
- err = validate.Field(k, "eq=1.543")
- Equal(t, err, nil)
-
- err = validate.Field(arr, "eq=1")
- Equal(t, err, nil)
-
- err = validate.Field(arr, "eq=2")
- NotEqual(t, err, nil)
-
- PanicMatches(t, func() { validate.Field(now, "eq=now") }, "Bad field type time.Time")
-}
-
-func TestBase64Validation(t *testing.T) {
-
- s := "dW5pY29ybg=="
-
- err := validate.Field(s, "base64")
- Equal(t, err, nil)
-
- s = "dGhpIGlzIGEgdGVzdCBiYXNlNjQ="
- err = validate.Field(s, "base64")
- Equal(t, err, nil)
-
- s = ""
- err = validate.Field(s, "base64")
- NotEqual(t, err, nil)
-
- s = "dW5pY29ybg== foo bar"
- err = validate.Field(s, "base64")
- NotEqual(t, err, nil)
-}
-
-func TestStructOnlyValidation(t *testing.T) {
-
- type Inner struct {
- Test string `validate:"len=5"`
- }
-
- type Outer struct {
- InnerStruct *Inner `validate:"required,structonly"`
- }
-
- outer := &Outer{
- InnerStruct: nil,
- }
-
- errs := validate.Struct(outer).Flatten()
- NotEqual(t, errs, nil)
-
- inner := &Inner{
- Test: "1234",
- }
-
- outer = &Outer{
- InnerStruct: inner,
- }
-
- errs = validate.Struct(outer).Flatten()
- NotEqual(t, errs, nil)
- Equal(t, len(errs), 0)
-}
-
-func TestGtField(t *testing.T) {
-
- type TimeTest struct {
- Start *time.Time `validate:"required,gt"`
- End *time.Time `validate:"required,gt,gtfield=Start"`
- }
-
- now := time.Now()
- start := now.Add(time.Hour * 24)
- end := start.Add(time.Hour * 24)
-
- timeTest := &TimeTest{
- Start: &start,
- End: &end,
- }
-
- errs := validate.Struct(timeTest)
- Equal(t, errs, nil)
-
- timeTest = &TimeTest{
- Start: &end,
- End: &start,
- }
-
- errs2 := validate.Struct(timeTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "End", "gtfield")
-
- err3 := validate.FieldWithValue(&start, &end, "gtfield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(&end, &start, "gtfield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "gtfield")
-
- type IntTest struct {
- Val1 int `validate:"required"`
- Val2 int `validate:"required,gtfield=Val1"`
- }
-
- intTest := &IntTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs = validate.Struct(intTest)
- Equal(t, errs, nil)
-
- intTest = &IntTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs2 = validate.Struct(intTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "gtfield")
-
- err3 = validate.FieldWithValue(int(1), int(5), "gtfield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(int(5), int(1), "gtfield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "gtfield")
-
- type UIntTest struct {
- Val1 uint `validate:"required"`
- Val2 uint `validate:"required,gtfield=Val1"`
- }
-
- uIntTest := &UIntTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs = validate.Struct(uIntTest)
- Equal(t, errs, nil)
-
- uIntTest = &UIntTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs2 = validate.Struct(uIntTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "gtfield")
-
- err3 = validate.FieldWithValue(uint(1), uint(5), "gtfield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(uint(5), uint(1), "gtfield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "gtfield")
-
- type FloatTest struct {
- Val1 float64 `validate:"required"`
- Val2 float64 `validate:"required,gtfield=Val1"`
- }
-
- floatTest := &FloatTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs = validate.Struct(floatTest)
- Equal(t, errs, nil)
-
- floatTest = &FloatTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs2 = validate.Struct(floatTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "gtfield")
-
- err3 = validate.FieldWithValue(float32(1), float32(5), "gtfield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(float32(5), float32(1), "gtfield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "gtfield")
-
- PanicMatches(t, func() { validate.FieldWithValue(nil, 1, "gtfield") }, "struct not passed for cross validation")
- PanicMatches(t, func() { validate.FieldWithValue(5, "T", "gtfield") }, "Bad field type string")
- PanicMatches(t, func() { validate.FieldWithValue(5, start, "gtfield") }, "Bad Top Level field type")
-
- type TimeTest2 struct {
- Start *time.Time `validate:"required"`
- End *time.Time `validate:"required,gtfield=NonExistantField"`
- }
-
- timeTest2 := &TimeTest2{
- Start: &start,
- End: &end,
- }
-
- PanicMatches(t, func() { validate.Struct(timeTest2) }, "Field \"NonExistantField\" not found in struct")
-}
-
-func TestLtField(t *testing.T) {
-
- type TimeTest struct {
- Start *time.Time `validate:"required,lt,ltfield=End"`
- End *time.Time `validate:"required,lt"`
- }
-
- now := time.Now()
- start := now.Add(time.Hour * 24 * -1 * 2)
- end := start.Add(time.Hour * 24)
-
- timeTest := &TimeTest{
- Start: &start,
- End: &end,
- }
-
- errs := validate.Struct(timeTest)
- Equal(t, errs, nil)
-
- timeTest = &TimeTest{
- Start: &end,
- End: &start,
- }
-
- errs2 := validate.Struct(timeTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Start", "ltfield")
-
- err3 := validate.FieldWithValue(&end, &start, "ltfield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(&start, &end, "ltfield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "ltfield")
-
- type IntTest struct {
- Val1 int `validate:"required"`
- Val2 int `validate:"required,ltfield=Val1"`
- }
-
- intTest := &IntTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs = validate.Struct(intTest)
- Equal(t, errs, nil)
-
- intTest = &IntTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs2 = validate.Struct(intTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "ltfield")
-
- err3 = validate.FieldWithValue(int(5), int(1), "ltfield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(int(1), int(5), "ltfield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "ltfield")
-
- type UIntTest struct {
- Val1 uint `validate:"required"`
- Val2 uint `validate:"required,ltfield=Val1"`
- }
-
- uIntTest := &UIntTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs = validate.Struct(uIntTest)
- Equal(t, errs, nil)
-
- uIntTest = &UIntTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs2 = validate.Struct(uIntTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "ltfield")
-
- err3 = validate.FieldWithValue(uint(5), uint(1), "ltfield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(uint(1), uint(5), "ltfield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "ltfield")
-
- type FloatTest struct {
- Val1 float64 `validate:"required"`
- Val2 float64 `validate:"required,ltfield=Val1"`
- }
-
- floatTest := &FloatTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs = validate.Struct(floatTest)
- Equal(t, errs, nil)
-
- floatTest = &FloatTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs2 = validate.Struct(floatTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "ltfield")
-
- err3 = validate.FieldWithValue(float32(5), float32(1), "ltfield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(float32(1), float32(5), "ltfield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "ltfield")
-
- PanicMatches(t, func() { validate.FieldWithValue(nil, 5, "ltfield") }, "struct not passed for cross validation")
- PanicMatches(t, func() { validate.FieldWithValue(1, "T", "ltfield") }, "Bad field type string")
- PanicMatches(t, func() { validate.FieldWithValue(1, end, "ltfield") }, "Bad Top Level field type")
-
- type TimeTest2 struct {
- Start *time.Time `validate:"required"`
- End *time.Time `validate:"required,ltfield=NonExistantField"`
- }
-
- timeTest2 := &TimeTest2{
- Start: &end,
- End: &start,
- }
-
- PanicMatches(t, func() { validate.Struct(timeTest2) }, "Field \"NonExistantField\" not found in struct")
-}
-
-func TestLteField(t *testing.T) {
-
- type TimeTest struct {
- Start *time.Time `validate:"required,lte,ltefield=End"`
- End *time.Time `validate:"required,lte"`
- }
-
- now := time.Now()
- start := now.Add(time.Hour * 24 * -1 * 2)
- end := start.Add(time.Hour * 24)
-
- timeTest := &TimeTest{
- Start: &start,
- End: &end,
- }
-
- errs := validate.Struct(timeTest)
- Equal(t, errs, nil)
-
- timeTest = &TimeTest{
- Start: &end,
- End: &start,
- }
-
- errs2 := validate.Struct(timeTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Start", "ltefield")
-
- err3 := validate.FieldWithValue(&end, &start, "ltefield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(&start, &end, "ltefield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "ltefield")
-
- type IntTest struct {
- Val1 int `validate:"required"`
- Val2 int `validate:"required,ltefield=Val1"`
- }
-
- intTest := &IntTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs = validate.Struct(intTest)
- Equal(t, errs, nil)
-
- intTest = &IntTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs2 = validate.Struct(intTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "ltefield")
-
- err3 = validate.FieldWithValue(int(5), int(1), "ltefield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(int(1), int(5), "ltefield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "ltefield")
-
- type UIntTest struct {
- Val1 uint `validate:"required"`
- Val2 uint `validate:"required,ltefield=Val1"`
- }
-
- uIntTest := &UIntTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs = validate.Struct(uIntTest)
- Equal(t, errs, nil)
-
- uIntTest = &UIntTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs2 = validate.Struct(uIntTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "ltefield")
-
- err3 = validate.FieldWithValue(uint(5), uint(1), "ltefield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(uint(1), uint(5), "ltefield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "ltefield")
-
- type FloatTest struct {
- Val1 float64 `validate:"required"`
- Val2 float64 `validate:"required,ltefield=Val1"`
- }
-
- floatTest := &FloatTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs = validate.Struct(floatTest)
- Equal(t, errs, nil)
-
- floatTest = &FloatTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs2 = validate.Struct(floatTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "ltefield")
-
- err3 = validate.FieldWithValue(float32(5), float32(1), "ltefield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(float32(1), float32(5), "ltefield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "ltefield")
-
- PanicMatches(t, func() { validate.FieldWithValue(nil, 5, "ltefield") }, "struct not passed for cross validation")
- PanicMatches(t, func() { validate.FieldWithValue(1, "T", "ltefield") }, "Bad field type string")
- PanicMatches(t, func() { validate.FieldWithValue(1, end, "ltefield") }, "Bad Top Level field type")
-
- type TimeTest2 struct {
- Start *time.Time `validate:"required"`
- End *time.Time `validate:"required,ltefield=NonExistantField"`
- }
-
- timeTest2 := &TimeTest2{
- Start: &end,
- End: &start,
- }
-
- PanicMatches(t, func() { validate.Struct(timeTest2) }, "Field \"NonExistantField\" not found in struct")
-}
-
-func TestGteField(t *testing.T) {
-
- type TimeTest struct {
- Start *time.Time `validate:"required,gte"`
- End *time.Time `validate:"required,gte,gtefield=Start"`
- }
-
- now := time.Now()
- start := now.Add(time.Hour * 24)
- end := start.Add(time.Hour * 24)
-
- timeTest := &TimeTest{
- Start: &start,
- End: &end,
- }
-
- errs := validate.Struct(timeTest)
- Equal(t, errs, nil)
-
- timeTest = &TimeTest{
- Start: &end,
- End: &start,
- }
-
- errs2 := validate.Struct(timeTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "End", "gtefield")
-
- err3 := validate.FieldWithValue(&start, &end, "gtefield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(&end, &start, "gtefield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "gtefield")
-
- type IntTest struct {
- Val1 int `validate:"required"`
- Val2 int `validate:"required,gtefield=Val1"`
- }
-
- intTest := &IntTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs = validate.Struct(intTest)
- Equal(t, errs, nil)
-
- intTest = &IntTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs2 = validate.Struct(intTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "gtefield")
-
- err3 = validate.FieldWithValue(int(1), int(5), "gtefield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(int(5), int(1), "gtefield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "gtefield")
-
- type UIntTest struct {
- Val1 uint `validate:"required"`
- Val2 uint `validate:"required,gtefield=Val1"`
- }
-
- uIntTest := &UIntTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs = validate.Struct(uIntTest)
- Equal(t, errs, nil)
-
- uIntTest = &UIntTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs2 = validate.Struct(uIntTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "gtefield")
-
- err3 = validate.FieldWithValue(uint(1), uint(5), "gtefield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(uint(5), uint(1), "gtefield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "gtefield")
-
- type FloatTest struct {
- Val1 float64 `validate:"required"`
- Val2 float64 `validate:"required,gtefield=Val1"`
- }
-
- floatTest := &FloatTest{
- Val1: 1,
- Val2: 5,
- }
-
- errs = validate.Struct(floatTest)
- Equal(t, errs, nil)
-
- floatTest = &FloatTest{
- Val1: 5,
- Val2: 1,
- }
-
- errs2 = validate.Struct(floatTest).Flatten()
- NotEqual(t, errs2, nil)
- AssertMapFieldError(t, errs2, "Val2", "gtefield")
-
- err3 = validate.FieldWithValue(float32(1), float32(5), "gtefield")
- Equal(t, err3, nil)
-
- err3 = validate.FieldWithValue(float32(5), float32(1), "gtefield")
- NotEqual(t, err3, nil)
- Equal(t, err3.Tag, "gtefield")
-
- PanicMatches(t, func() { validate.FieldWithValue(nil, 1, "gtefield") }, "struct not passed for cross validation")
- PanicMatches(t, func() { validate.FieldWithValue(5, "T", "gtefield") }, "Bad field type string")
- PanicMatches(t, func() { validate.FieldWithValue(5, start, "gtefield") }, "Bad Top Level field type")
-
- type TimeTest2 struct {
- Start *time.Time `validate:"required"`
- End *time.Time `validate:"required,gtefield=NonExistantField"`
- }
-
- timeTest2 := &TimeTest2{
- Start: &start,
- End: &end,
- }
-
- PanicMatches(t, func() { validate.Struct(timeTest2) }, "Field \"NonExistantField\" not found in struct")
-}
-
-func TestValidateByTagAndValue(t *testing.T) {
-
- val := "test"
- field := "test"
- err := validate.FieldWithValue(val, field, "required")
- Equal(t, err, nil)
-
- fn := func(val interface{}, current interface{}, field interface{}, param string) bool {
-
- return current.(string) == field.(string)
- }
-
- validate.AddFunction("isequaltestfunc", fn)
-
- err = validate.FieldWithValue(val, field, "isequaltestfunc")
- Equal(t, err, nil)
-
- val = "unequal"
-
- err = validate.FieldWithValue(val, field, "isequaltestfunc")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "isequaltestfunc")
-}
-
-func TestAddFunctions(t *testing.T) {
-
- fn := func(val interface{}, current interface{}, field interface{}, param string) bool {
-
- return true
- }
-
- validate := New("validateme", BakedInValidators)
-
- err := validate.AddFunction("new", fn)
- Equal(t, err, nil)
-
- err = validate.AddFunction("", fn)
- NotEqual(t, err, nil)
-
- validate.AddFunction("new", nil)
- NotEqual(t, err, nil)
-
- err = validate.AddFunction("new", fn)
- Equal(t, err, nil)
-}
-
-func TestChangeTag(t *testing.T) {
-
- validate := New("validateme", BakedInValidators)
- validate.SetTag("val")
-
- type Test struct {
- Name string `val:"len=4"`
- }
- s := &Test{
- Name: "TEST",
- }
-
- err := validate.Struct(s)
- Equal(t, err, nil)
-}
-
-func TestUnexposedStruct(t *testing.T) {
-
- type Test struct {
- Name string
- unexposed struct {
- A string `validate:"required"`
- }
- }
-
- s := &Test{
- Name: "TEST",
- }
-
- err := validate.Struct(s)
- Equal(t, err, nil)
-}
-
-func TestBadParams(t *testing.T) {
-
- i := 1
- err := validate.Field(i, "-")
- Equal(t, err, nil)
-
- PanicMatches(t, func() { validate.Field(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax")
- PanicMatches(t, func() { validate.Field(i, "len=a") }, "strconv.ParseInt: parsing \"a\": invalid syntax")
-
- var ui uint = 1
- PanicMatches(t, func() { validate.Field(ui, "len=a") }, "strconv.ParseUint: parsing \"a\": invalid syntax")
-
- f := 1.23
- PanicMatches(t, func() { validate.Field(f, "len=a") }, "strconv.ParseFloat: parsing \"a\": invalid syntax")
-}
-
-func TestLength(t *testing.T) {
-
- i := true
- PanicMatches(t, func() { validate.Field(i, "len") }, "Bad field type bool")
-}
-
-func TestIsGt(t *testing.T) {
-
- myMap := map[string]string{}
- err := validate.Field(myMap, "gt=0")
- NotEqual(t, err, nil)
-
- f := 1.23
- err = validate.Field(f, "gt=5")
- NotEqual(t, err, nil)
-
- var ui uint = 5
- err = validate.Field(ui, "gt=10")
- NotEqual(t, err, nil)
-
- i := true
- PanicMatches(t, func() { validate.Field(i, "gt") }, "Bad field type bool")
-
- tm := time.Now().UTC()
- tm = tm.Add(time.Hour * 24)
-
- err = validate.Field(tm, "gt")
- Equal(t, err, nil)
-
- t2 := time.Now().UTC()
-
- err = validate.Field(t2, "gt")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "gt")
-
- type Test struct {
- Now *time.Time `validate:"gt"`
- }
- s := &Test{
- Now: &tm,
- }
-
- errs := validate.Struct(s)
- Equal(t, errs, nil)
-
- s = &Test{
- Now: &t2,
- }
-
- errs = validate.Struct(s)
- NotEqual(t, errs, nil)
-}
-
-func TestIsGte(t *testing.T) {
-
- i := true
- PanicMatches(t, func() { validate.Field(i, "gte") }, "Bad field type bool")
-
- t1 := time.Now().UTC()
- t1 = t1.Add(time.Hour * 24)
-
- err := validate.Field(t1, "gte")
- Equal(t, err, nil)
-
- t2 := time.Now().UTC()
-
- err = validate.Field(t2, "gte")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "gte")
- Equal(t, err.Type, reflect.TypeOf(time.Time{}))
-
- type Test struct {
- Now *time.Time `validate:"gte"`
- }
- s := &Test{
- Now: &t1,
- }
-
- errs := validate.Struct(s)
- Equal(t, errs, nil)
-
- s = &Test{
- Now: &t2,
- }
-
- errs = validate.Struct(s)
- NotEqual(t, errs, nil)
-}
-
-func TestIsLt(t *testing.T) {
-
- myMap := map[string]string{}
- err := validate.Field(myMap, "lt=0")
- NotEqual(t, err, nil)
-
- f := 1.23
- err = validate.Field(f, "lt=0")
- NotEqual(t, err, nil)
-
- var ui uint = 5
- err = validate.Field(ui, "lt=0")
- NotEqual(t, err, nil)
-
- i := true
- PanicMatches(t, func() { validate.Field(i, "lt") }, "Bad field type bool")
-
- t1 := time.Now().UTC()
-
- err = validate.Field(t1, "lt")
- Equal(t, err, nil)
-
- t2 := time.Now().UTC()
- t2 = t2.Add(time.Hour * 24)
-
- err = validate.Field(t2, "lt")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "lt")
-
- type Test struct {
- Now *time.Time `validate:"lt"`
- }
-
- s := &Test{
- Now: &t1,
- }
-
- errs := validate.Struct(s)
- Equal(t, errs, nil)
-
- s = &Test{
- Now: &t2,
- }
-
- errs = validate.Struct(s)
- NotEqual(t, errs, nil)
-}
-
-func TestIsLte(t *testing.T) {
-
- i := true
- PanicMatches(t, func() { validate.Field(i, "lte") }, "Bad field type bool")
-
- t1 := time.Now().UTC()
-
- err := validate.Field(t1, "lte")
- Equal(t, err, nil)
-
- t2 := time.Now().UTC()
- t2 = t2.Add(time.Hour * 24)
-
- err = validate.Field(t2, "lte")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "lte")
-
- type Test struct {
- Now *time.Time `validate:"lte"`
- }
-
- s := &Test{
- Now: &t1,
- }
-
- errs := validate.Struct(s)
- Equal(t, errs, nil)
-
- s = &Test{
- Now: &t2,
- }
-
- errs = validate.Struct(s)
- NotEqual(t, errs, nil)
-}
-
-func TestUrl(t *testing.T) {
-
- var tests = []struct {
- param string
- expected bool
- }{
- {"http://foo.bar#com", true},
- {"http://foobar.com", true},
- {"https://foobar.com", true},
- {"foobar.com", false},
- {"http://foobar.coffee/", true},
- {"http://foobar.ä¸Â文网/", true},
- {"http://foobar.org/", true},
- {"http://foobar.org:8080/", true},
- {"ftp://foobar.ru/", true},
- {"http://user:pass@www.foobar.com/", true},
- {"http://127.0.0.1/", true},
- {"http://duckduckgo.com/?q=%2F", true},
- {"http://localhost:3000/", true},
- {"http://foobar.com/?foo=bar#baz=qux", true},
- {"http://foobar.com?foo=bar", true},
- {"http://www.xn--froschgrn-x9a.net/", true},
- {"", false},
- {"xyz://foobar.com", true},
- {"invalid.", false},
- {".com", false},
- {"rtmp://foobar.com", true},
- {"http://www.foo_bar.com/", true},
- {"http://localhost:3000/", true},
- {"http://foobar.com#baz=qux", true},
- {"http://foobar.com/t$-_.+!*\\'(),", true},
- {"http://www.foobar.com/~foobar", true},
- {"http://www.-foobar.com/", true},
- {"http://www.foo---bar.com/", true},
- {"mailto:someone@example.com", true},
- {"irc://irc.server.org/channel", true},
- {"irc://#channel@network", true},
- {"/abs/test/dir", false},
- {"./rel/test/dir", false},
- }
- for i, test := range tests {
-
- err := validate.Field(test.param, "url")
-
- if test.expected == true {
- if !IsEqual(t, err, nil) {
- t.Fatalf("Index: %d URL failed Error: %s", i, err)
- }
- } else {
- if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "url") {
- t.Fatalf("Index: %d URL failed Error: %s", i, err)
- }
- }
- }
-
- i := 1
- PanicMatches(t, func() { validate.Field(i, "url") }, "Bad field type int")
-}
-
-func TestUri(t *testing.T) {
-
- var tests = []struct {
- param string
- expected bool
- }{
- {"http://foo.bar#com", true},
- {"http://foobar.com", true},
- {"https://foobar.com", true},
- {"foobar.com", false},
- {"http://foobar.coffee/", true},
- {"http://foobar.ä¸Â文网/", true},
- {"http://foobar.org/", true},
- {"http://foobar.org:8080/", true},
- {"ftp://foobar.ru/", true},
- {"http://user:pass@www.foobar.com/", true},
- {"http://127.0.0.1/", true},
- {"http://duckduckgo.com/?q=%2F", true},
- {"http://localhost:3000/", true},
- {"http://foobar.com/?foo=bar#baz=qux", true},
- {"http://foobar.com?foo=bar", true},
- {"http://www.xn--froschgrn-x9a.net/", true},
- {"", false},
- {"xyz://foobar.com", true},
- {"invalid.", false},
- {".com", false},
- {"rtmp://foobar.com", true},
- {"http://www.foo_bar.com/", true},
- {"http://localhost:3000/", true},
- {"http://foobar.com#baz=qux", true},
- {"http://foobar.com/t$-_.+!*\\'(),", true},
- {"http://www.foobar.com/~foobar", true},
- {"http://www.-foobar.com/", true},
- {"http://www.foo---bar.com/", true},
- {"mailto:someone@example.com", true},
- {"irc://irc.server.org/channel", true},
- {"irc://#channel@network", true},
- {"/abs/test/dir", true},
- {"./rel/test/dir", false},
- }
- for i, test := range tests {
-
- err := validate.Field(test.param, "uri")
-
- if test.expected == true {
- if !IsEqual(t, err, nil) {
- t.Fatalf("Index: %d URI failed Error: %s", i, err)
- }
- } else {
- if IsEqual(t, err, nil) || !IsEqual(t, err.Tag, "uri") {
- t.Fatalf("Index: %d URI failed Error: %s", i, err)
- }
- }
- }
-
- i := 1
- PanicMatches(t, func() { validate.Field(i, "uri") }, "Bad field type int")
-}
-
-func TestOrTag(t *testing.T) {
- s := "rgba(0,31,255,0.5)"
- err := validate.Field(s, "rgb|rgba")
- Equal(t, err, nil)
-
- s = "rgba(0,31,255,0.5)"
- err = validate.Field(s, "rgb|rgba|len=18")
- Equal(t, err, nil)
-
- s = "this ain't right"
- err = validate.Field(s, "rgb|rgba")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "rgb|rgba")
-
- s = "this ain't right"
- err = validate.Field(s, "rgb|rgba|len=10")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "rgb|rgba|len")
-
- s = "this is right"
- err = validate.Field(s, "rgb|rgba|len=13")
- Equal(t, err, nil)
-
- s = ""
- err = validate.Field(s, "omitempty,rgb|rgba")
- Equal(t, err, nil)
-}
-
-func TestHsla(t *testing.T) {
-
- s := "hsla(360,100%,100%,1)"
- err := validate.Field(s, "hsla")
- Equal(t, err, nil)
-
- s = "hsla(360,100%,100%,0.5)"
- err = validate.Field(s, "hsla")
- Equal(t, err, nil)
-
- s = "hsla(0,0%,0%, 0)"
- err = validate.Field(s, "hsla")
- Equal(t, err, nil)
-
- s = "hsl(361,100%,50%,1)"
- err = validate.Field(s, "hsla")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsla")
-
- s = "hsl(361,100%,50%)"
- err = validate.Field(s, "hsla")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsla")
-
- s = "hsla(361,100%,50%)"
- err = validate.Field(s, "hsla")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsla")
-
- s = "hsla(360,101%,50%)"
- err = validate.Field(s, "hsla")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsla")
-
- s = "hsla(360,100%,101%)"
- err = validate.Field(s, "hsla")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsla")
-
- i := 1
- PanicMatches(t, func() { validate.Field(i, "hsla") }, "interface conversion: interface is int, not string")
-}
-
-func TestHsl(t *testing.T) {
-
- s := "hsl(360,100%,50%)"
- err := validate.Field(s, "hsl")
- Equal(t, err, nil)
-
- s = "hsl(0,0%,0%)"
- err = validate.Field(s, "hsl")
- Equal(t, err, nil)
-
- s = "hsl(361,100%,50%)"
- err = validate.Field(s, "hsl")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsl")
-
- s = "hsl(361,101%,50%)"
- err = validate.Field(s, "hsl")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsl")
-
- s = "hsl(361,100%,101%)"
- err = validate.Field(s, "hsl")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsl")
-
- s = "hsl(-10,100%,100%)"
- err = validate.Field(s, "hsl")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hsl")
-
- i := 1
- PanicMatches(t, func() { validate.Field(i, "hsl") }, "interface conversion: interface is int, not string")
-}
-
-func TestRgba(t *testing.T) {
-
- s := "rgba(0,31,255,0.5)"
- err := validate.Field(s, "rgba")
- Equal(t, err, nil)
-
- s = "rgba(0,31,255,0.12)"
- err = validate.Field(s, "rgba")
- Equal(t, err, nil)
-
- s = "rgba( 0, 31, 255, 0.5)"
- err = validate.Field(s, "rgba")
- Equal(t, err, nil)
-
- s = "rgb(0, 31, 255)"
- err = validate.Field(s, "rgba")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "rgba")
-
- s = "rgb(1,349,275,0.5)"
- err = validate.Field(s, "rgba")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "rgba")
-
- s = "rgb(01,31,255,0.5)"
- err = validate.Field(s, "rgba")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "rgba")
-
- i := 1
- PanicMatches(t, func() { validate.Field(i, "rgba") }, "interface conversion: interface is int, not string")
-}
-
-func TestRgb(t *testing.T) {
-
- s := "rgb(0,31,255)"
- err := validate.Field(s, "rgb")
- Equal(t, err, nil)
-
- s = "rgb(0, 31, 255)"
- err = validate.Field(s, "rgb")
- Equal(t, err, nil)
-
- s = "rgb(1,349,275)"
- err = validate.Field(s, "rgb")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "rgb")
-
- s = "rgb(01,31,255)"
- err = validate.Field(s, "rgb")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "rgb")
-
- s = "rgba(0,31,255)"
- err = validate.Field(s, "rgb")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "rgb")
-
- i := 1
- PanicMatches(t, func() { validate.Field(i, "rgb") }, "interface conversion: interface is int, not string")
-}
-
-func TestEmail(t *testing.T) {
-
- s := "test@mail.com"
- err := validate.Field(s, "email")
- Equal(t, err, nil)
-
- s = ""
- err = validate.Field(s, "email")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "email")
-
- s = "test@email"
- err = validate.Field(s, "email")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "email")
-
- s = "test@email."
- err = validate.Field(s, "email")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "email")
-
- s = "@email.com"
- err = validate.Field(s, "email")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "email")
-
- i := true
- PanicMatches(t, func() { validate.Field(i, "email") }, "interface conversion: interface is bool, not string")
-}
-
-func TestHexColor(t *testing.T) {
-
- s := "#fff"
- err := validate.Field(s, "hexcolor")
- Equal(t, err, nil)
-
- s = "#c2c2c2"
- err = validate.Field(s, "hexcolor")
- Equal(t, err, nil)
-
- s = "fff"
- err = validate.Field(s, "hexcolor")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hexcolor")
-
- s = "fffFF"
- err = validate.Field(s, "hexcolor")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hexcolor")
-
- i := true
- PanicMatches(t, func() { validate.Field(i, "hexcolor") }, "interface conversion: interface is bool, not string")
-}
-
-func TestHexadecimal(t *testing.T) {
-
- s := "ff0044"
- err := validate.Field(s, "hexadecimal")
- Equal(t, err, nil)
-
- s = "abcdefg"
- err = validate.Field(s, "hexadecimal")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "hexadecimal")
-
- i := true
- PanicMatches(t, func() { validate.Field(i, "hexadecimal") }, "interface conversion: interface is bool, not string")
-}
-
-func TestNumber(t *testing.T) {
-
- s := "1"
- err := validate.Field(s, "number")
- Equal(t, err, nil)
-
- s = "+1"
- err = validate.Field(s, "number")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "number")
-
- s = "-1"
- err = validate.Field(s, "number")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "number")
-
- s = "1.12"
- err = validate.Field(s, "number")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "number")
-
- s = "+1.12"
- err = validate.Field(s, "number")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "number")
-
- s = "-1.12"
- err = validate.Field(s, "number")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "number")
-
- s = "1."
- err = validate.Field(s, "number")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "number")
-
- s = "1.o"
- err = validate.Field(s, "number")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "number")
-
- i := 1
- PanicMatches(t, func() { validate.Field(i, "number") }, "interface conversion: interface is int, not string")
-}
-
-func TestNumeric(t *testing.T) {
-
- s := "1"
- err := validate.Field(s, "numeric")
- Equal(t, err, nil)
-
- s = "+1"
- err = validate.Field(s, "numeric")
- Equal(t, err, nil)
-
- s = "-1"
- err = validate.Field(s, "numeric")
- Equal(t, err, nil)
-
- s = "1.12"
- err = validate.Field(s, "numeric")
- Equal(t, err, nil)
-
- s = "+1.12"
- err = validate.Field(s, "numeric")
- Equal(t, err, nil)
-
- s = "-1.12"
- err = validate.Field(s, "numeric")
- Equal(t, err, nil)
-
- s = "1."
- err = validate.Field(s, "numeric")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "numeric")
-
- s = "1.o"
- err = validate.Field(s, "numeric")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "numeric")
-
- i := 1
- PanicMatches(t, func() { validate.Field(i, "numeric") }, "interface conversion: interface is int, not string")
-}
-
-func TestAlphaNumeric(t *testing.T) {
-
- s := "abcd123"
- err := validate.Field(s, "alphanum")
- Equal(t, err, nil)
-
- s = "abc!23"
- err = validate.Field(s, "alphanum")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "alphanum")
-
- PanicMatches(t, func() { validate.Field(1, "alphanum") }, "interface conversion: interface is int, not string")
-}
-
-func TestAlpha(t *testing.T) {
-
- s := "abcd"
- err := validate.Field(s, "alpha")
- Equal(t, err, nil)
-
- s = "abc1"
- err = validate.Field(s, "alpha")
- NotEqual(t, err, nil)
- Equal(t, err.Tag, "alpha")
-
- PanicMatches(t, func() { validate.Field(1, "alpha") }, "interface conversion: interface is int, not string")
-}
-
-func TestFlattening(t *testing.T) {
-
- tSuccess := &TestString{
- Required: "Required",
- Len: "length==10",
- Min: "min=1",
- Max: "1234567890",
- MinMax: "12345",
- Lt: "012345678",
- Lte: "0123456789",
- Gt: "01234567890",
- Gte: "0123456789",
- OmitEmpty: "",
- Sub: &SubTest{
- Test: "1",
- },
- SubIgnore: &SubTest{
- Test: "",
- },
- Anonymous: struct {
- A string `validate:"required"`
- }{
- A: "1",
- },
- Iface: &Impl{
- F: "123",
- },
- }
-
- err1 := validate.Struct(tSuccess).Flatten()
- Equal(t, len(err1), 0)
-
- tFail := &TestString{
- Required: "",
- Len: "",
- Min: "",
- Max: "12345678901",
- MinMax: "",
- OmitEmpty: "12345678901",
- Sub: &SubTest{
- Test: "",
- },
- Anonymous: struct {
- A string `validate:"required"`
- }{
- A: "",
- },
- Iface: &Impl{
- F: "12",
- },
- }
-
- err2 := validate.Struct(tFail).Flatten()
-
- // Assert Top Level
- NotEqual(t, err2, nil)
-
- // Assert Fields
- AssertMapFieldError(t, err2, "Len", "len")
- AssertMapFieldError(t, err2, "Gt", "gt")
- AssertMapFieldError(t, err2, "Gte", "gte")
-
- // Assert Struct Field
- AssertMapFieldError(t, err2, "Sub.Test", "required")
-
- // Assert Anonymous Struct Field
- AssertMapFieldError(t, err2, "Anonymous.A", "required")
-
- // Assert Interface Field
- AssertMapFieldError(t, err2, "Iface.F", "len")
-}
-
-func TestStructStringValidation(t *testing.T) {
-
- validate.SetMaxStructPoolSize(11)
-
- tSuccess := &TestString{
- Required: "Required",
- Len: "length==10",
- Min: "min=1",
- Max: "1234567890",
- MinMax: "12345",
- Lt: "012345678",
- Lte: "0123456789",
- Gt: "01234567890",
- Gte: "0123456789",
- OmitEmpty: "",
- Sub: &SubTest{
- Test: "1",
- },
- SubIgnore: &SubTest{
- Test: "",
- },
- Anonymous: struct {
- A string `validate:"required"`
- }{
- A: "1",
- },
- Iface: &Impl{
- F: "123",
- },
- }
-
- err := validate.Struct(tSuccess)
- Equal(t, err, nil)
-
- tFail := &TestString{
- Required: "",
- Len: "",
- Min: "",
- Max: "12345678901",
- MinMax: "",
- Lt: "0123456789",
- Lte: "01234567890",
- Gt: "1",
- Gte: "1",
- OmitEmpty: "12345678901",
- Sub: &SubTest{
- Test: "",
- },
- Anonymous: struct {
- A string `validate:"required"`
- }{
- A: "",
- },
- Iface: &Impl{
- F: "12",
- },
- }
-
- err = validate.Struct(tFail)
-
- // Assert Top Level
- NotEqual(t, err, nil)
- Equal(t, err.Struct, "TestString")
- Equal(t, len(err.Errors), 10)
- Equal(t, len(err.StructErrors), 3)
-
- // Assert Fields
- AssertFieldError(t, err, "Required", "required")
- AssertFieldError(t, err, "Len", "len")
- AssertFieldError(t, err, "Min", "min")
- AssertFieldError(t, err, "Max", "max")
- AssertFieldError(t, err, "MinMax", "min")
- AssertFieldError(t, err, "Gt", "gt")
- AssertFieldError(t, err, "Gte", "gte")
- AssertFieldError(t, err, "OmitEmpty", "max")
-
- // Assert Anonymous embedded struct
- AssertStruct(t, err, "Anonymous", "")
-
- // Assert SubTest embedded struct
- val := AssertStruct(t, err, "Sub", "SubTest")
- Equal(t, len(val.Errors), 1)
- Equal(t, len(val.StructErrors), 0)
-
- AssertFieldError(t, val, "Test", "required")
-
- errors := err.Error()
- NotEqual(t, errors, nil)
-}
-
-func TestStructInt32Validation(t *testing.T) {
-
- tSuccess := &TestInt32{
- Required: 1,
- Len: 10,
- Min: 1,
- Max: 10,
- MinMax: 5,
- Lt: 9,
- Lte: 10,
- Gt: 11,
- Gte: 10,
- OmitEmpty: 0,
- }
-
- err := validate.Struct(tSuccess)
- Equal(t, err, nil)
-
- tFail := &TestInt32{
- Required: 0,
- Len: 11,
- Min: -1,
- Max: 11,
- MinMax: -1,
- Lt: 10,
- Lte: 11,
- Gt: 10,
- Gte: 9,
- OmitEmpty: 11,
- }
-
- err = validate.Struct(tFail)
-
- // Assert Top Level
- NotEqual(t, err, nil)
- Equal(t, err.Struct, "TestInt32")
- Equal(t, len(err.Errors), 10)
- Equal(t, len(err.StructErrors), 0)
-
- // Assert Fields
- AssertFieldError(t, err, "Required", "required")
- AssertFieldError(t, err, "Len", "len")
- AssertFieldError(t, err, "Min", "min")
- AssertFieldError(t, err, "Max", "max")
- AssertFieldError(t, err, "MinMax", "min")
- AssertFieldError(t, err, "Lt", "lt")
- AssertFieldError(t, err, "Lte", "lte")
- AssertFieldError(t, err, "Gt", "gt")
- AssertFieldError(t, err, "Gte", "gte")
- AssertFieldError(t, err, "OmitEmpty", "max")
-}
-
-func TestStructUint64Validation(t *testing.T) {
-
- tSuccess := &TestUint64{
- Required: 1,
- Len: 10,
- Min: 1,
- Max: 10,
- MinMax: 5,
- OmitEmpty: 0,
- }
-
- err := validate.Struct(tSuccess)
- Equal(t, err, nil)
-
- tFail := &TestUint64{
- Required: 0,
- Len: 11,
- Min: 0,
- Max: 11,
- MinMax: 0,
- OmitEmpty: 11,
- }
-
- err = validate.Struct(tFail)
-
- // Assert Top Level
- NotEqual(t, err, nil)
- Equal(t, err.Struct, "TestUint64")
- Equal(t, len(err.Errors), 6)
- Equal(t, len(err.StructErrors), 0)
-
- // Assert Fields
- AssertFieldError(t, err, "Required", "required")
- AssertFieldError(t, err, "Len", "len")
- AssertFieldError(t, err, "Min", "min")
- AssertFieldError(t, err, "Max", "max")
- AssertFieldError(t, err, "MinMax", "min")
- AssertFieldError(t, err, "OmitEmpty", "max")
-}
-
-func TestStructFloat64Validation(t *testing.T) {
-
- tSuccess := &TestFloat64{
- Required: 1,
- Len: 10,
- Min: 1,
- Max: 10,
- MinMax: 5,
- OmitEmpty: 0,
- }
-
- err := validate.Struct(tSuccess)
- Equal(t, err, nil)
-
- tFail := &TestFloat64{
- Required: 0,
- Len: 11,
- Min: 0,
- Max: 11,
- MinMax: 0,
- OmitEmpty: 11,
- }
-
- err = validate.Struct(tFail)
-
- // Assert Top Level
- NotEqual(t, err, nil)
- Equal(t, err.Struct, "TestFloat64")
- Equal(t, len(err.Errors), 6)
- Equal(t, len(err.StructErrors), 0)
-
- // Assert Fields
- AssertFieldError(t, err, "Required", "required")
- AssertFieldError(t, err, "Len", "len")
- AssertFieldError(t, err, "Min", "min")
- AssertFieldError(t, err, "Max", "max")
- AssertFieldError(t, err, "MinMax", "min")
- AssertFieldError(t, err, "OmitEmpty", "max")
-}
-
-func TestStructSliceValidation(t *testing.T) {
-
- tSuccess := &TestSlice{
- Required: []int{1},
- Len: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
- Min: []int{1, 2},
- Max: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
- MinMax: []int{1, 2, 3, 4, 5},
- OmitEmpty: []int{},
- }
-
- err := validate.Struct(tSuccess)
- Equal(t, err, nil)
-
- tFail := &TestSlice{
- Required: []int{},
- Len: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
- Min: []int{},
- Max: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
- MinMax: []int{},
- OmitEmpty: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
- }
-
- err = validate.Struct(tFail)
-
- // Assert Top Level
- NotEqual(t, err, nil)
- Equal(t, err.Struct, "TestSlice")
- Equal(t, len(err.Errors), 6)
- Equal(t, len(err.StructErrors), 0)
-
- // Assert Fields
- AssertFieldError(t, err, "Required", "required")
- AssertFieldError(t, err, "Len", "len")
- AssertFieldError(t, err, "Min", "min")
- AssertFieldError(t, err, "Max", "max")
- AssertFieldError(t, err, "MinMax", "min")
- AssertFieldError(t, err, "OmitEmpty", "max")
-}
-
-func TestInvalidStruct(t *testing.T) {
- s := &SubTest{
- Test: "1",
- }
-
- PanicMatches(t, func() { validate.Struct(s.Test) }, "interface passed for validation is not a struct")
-}
-
-func TestInvalidField(t *testing.T) {
- s := &SubTest{
- Test: "1",
- }
-
- PanicMatches(t, func() { validate.Field(s, "required") }, "Invalid field passed to ValidateFieldWithTag")
-}
-
-func TestInvalidTagField(t *testing.T) {
- s := &SubTest{
- Test: "1",
- }
-
- PanicMatches(t, func() { validate.Field(s.Test, "") }, fmt.Sprintf("Invalid validation tag on field %s", ""))
-}
-
-func TestInvalidValidatorFunction(t *testing.T) {
- s := &SubTest{
- Test: "1",
- }
-
- PanicMatches(t, func() { validate.Field(s.Test, "zzxxBadFunction") }, fmt.Sprintf("Undefined validation function on field %s", ""))
-}
-
-func BenchmarkValidateField(b *testing.B) {
- for n := 0; n < b.N; n++ {
- validate.Field("1", "len=1")
- }
-}
-
-func BenchmarkValidateStructSimple(b *testing.B) {
-
- type Foo struct {
- StringValue string `validate:"min=5,max=10"`
- IntValue int `validate:"min=5,max=10"`
- }
-
- validFoo := &Foo{StringValue: "Foobar", IntValue: 7}
- invalidFoo := &Foo{StringValue: "Fo", IntValue: 3}
-
- for n := 0; n < b.N; n++ {
- validate.Struct(validFoo)
- validate.Struct(invalidFoo)
- }
-}
-
-// func BenchmarkTemplateParallelSimple(b *testing.B) {
-
-// type Foo struct {
-// StringValue string `validate:"min=5,max=10"`
-// IntValue int `validate:"min=5,max=10"`
-// }
-
-// validFoo := &Foo{StringValue: "Foobar", IntValue: 7}
-// invalidFoo := &Foo{StringValue: "Fo", IntValue: 3}
-
-// b.RunParallel(func(pb *testing.PB) {
-// for pb.Next() {
-// validate.Struct(validFoo)
-// validate.Struct(invalidFoo)
-// }
-// })
-// }
-
-func BenchmarkValidateStructLarge(b *testing.B) {
-
- tFail := &TestString{
- Required: "",
- Len: "",
- Min: "",
- Max: "12345678901",
- MinMax: "",
- Lt: "0123456789",
- Lte: "01234567890",
- Gt: "1",
- Gte: "1",
- OmitEmpty: "12345678901",
- Sub: &SubTest{
- Test: "",
- },
- Anonymous: struct {
- A string `validate:"required"`
- }{
- A: "",
- },
- Iface: &Impl{
- F: "12",
- },
- }
-
- tSuccess := &TestString{
- Required: "Required",
- Len: "length==10",
- Min: "min=1",
- Max: "1234567890",
- MinMax: "12345",
- Lt: "012345678",
- Lte: "0123456789",
- Gt: "01234567890",
- Gte: "0123456789",
- OmitEmpty: "",
- Sub: &SubTest{
- Test: "1",
- },
- SubIgnore: &SubTest{
- Test: "",
- },
- Anonymous: struct {
- A string `validate:"required"`
- }{
- A: "1",
- },
- Iface: &Impl{
- F: "123",
- },
- }
-
- for n := 0; n < b.N; n++ {
- validate.Struct(tSuccess)
- validate.Struct(tFail)
- }
-}
-
-// func BenchmarkTemplateParallelLarge(b *testing.B) {
-
-// tFail := &TestString{
-// Required: "",
-// Len: "",
-// Min: "",
-// Max: "12345678901",
-// MinMax: "",
-// Lt: "0123456789",
-// Lte: "01234567890",
-// Gt: "1",
-// Gte: "1",
-// OmitEmpty: "12345678901",
-// Sub: &SubTest{
-// Test: "",
-// },
-// Anonymous: struct {
-// A string `validate:"required"`
-// }{
-// A: "",
-// },
-// Iface: &Impl{
-// F: "12",
-// },
-// }
-
-// tSuccess := &TestString{
-// Required: "Required",
-// Len: "length==10",
-// Min: "min=1",
-// Max: "1234567890",
-// MinMax: "12345",
-// Lt: "012345678",
-// Lte: "0123456789",
-// Gt: "01234567890",
-// Gte: "0123456789",
-// OmitEmpty: "",
-// Sub: &SubTest{
-// Test: "1",
-// },
-// SubIgnore: &SubTest{
-// Test: "",
-// },
-// Anonymous: struct {
-// A string `validate:"required"`
-// }{
-// A: "1",
-// },
-// Iface: &Impl{
-// F: "123",
-// },
-// }
-
-// b.RunParallel(func(pb *testing.PB) {
-// for pb.Next() {
-// validate.Struct(tSuccess)
-// validate.Struct(tFail)
-// }
-// })
-// }
diff --git a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/.travis.yml b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/.travis.yml
deleted file mode 100644
index b05e4c53fa829889472c8bc28e83f1fb6df8406b..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/.travis.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-language: go
-go: 1.2
-
diff --git a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/LICENSE.md b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/LICENSE.md
deleted file mode 100644
index 25fdaf639dfc039992d059805e51377d3174ae87..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/LICENSE.md
+++ /dev/null
@@ -1,20 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 Fatih Arslan
-
-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/Godeps/_workspace/src/gopkg.in/fatih/set.v0/README.md b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/README.md
deleted file mode 100644
index 23afdd98d316570f12cbe8b11eb910d626a4f319..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/README.md
+++ /dev/null
@@ -1,245 +0,0 @@
-# Set [](https://godoc.org/gopkg.in/fatih/set.v0) [](https://travis-ci.org/fatih/set)
-
-Set is a basic and simple, hash-based, **Set** data structure implementation
-in Go (Golang).
-
-Set provides both threadsafe and non-threadsafe implementations of a generic
-set data structure. The thread safety encompasses all operations on one set.
-Operations on multiple sets are consistent in that the elements of each set
-used was valid at exactly one point in time between the start and the end of
-the operation. Because it's thread safe, you can use it concurrently with your
-goroutines.
-
-For usage see examples below or click on the godoc badge.
-
-## Install and Usage
-
-Install the package with:
-
-```bash
-go get gopkg.in/fatih/set.v0
-```
-
-Import it with:
-
-```go
-import "gopkg.in/fatih/set.v0"
-```
-
-and use `set` as the package name inside the code.
-
-## Examples
-
-#### Initialization of a new Set
-
-```go
-
-// create a set with zero items
-s := set.New()
-s := set.NewNonTS() // non thread-safe version
-
-// ... or with some initial values
-s := set.New("istanbul", "frankfurt", 30.123, "san francisco", 1234)
-s := set.NewNonTS("kenya", "ethiopia", "sumatra")
-
-```
-
-#### Basic Operations
-
-```go
-// add items
-s.Add("istanbul")
-s.Add("istanbul") // nothing happens if you add duplicate item
-
-// add multiple items
-s.Add("ankara", "san francisco", 3.14)
-
-// remove item
-s.Remove("frankfurt")
-s.Remove("frankfurt") // nothing happes if you remove a nonexisting item
-
-// remove multiple items
-s.Remove("barcelona", 3.14, "ankara")
-
-// removes an arbitary item and return it
-item := s.Pop()
-
-// create a new copy
-other := s.Copy()
-
-// remove all items
-s.Clear()
-
-// number of items in the set
-len := s.Size()
-
-// return a list of items
-items := s.List()
-
-// string representation of set
-fmt.Printf("set is %s", s.String())
-
-```
-
-#### Check Operations
-
-```go
-// check for set emptiness, returns true if set is empty
-s.IsEmpty()
-
-// check for a single item exist
-s.Has("istanbul")
-
-// ... or for multiple items. This will return true if all of the items exist.
-s.Has("istanbul", "san francisco", 3.14)
-
-// create two sets for the following checks...
-s := s.New("1", "2", "3", "4", "5")
-t := s.New("1", "2", "3")
-
-
-// check if they are the same
-if !s.IsEqual(t) {
- fmt.Println("s is not equal to t")
-}
-
-// if s contains all elements of t
-if s.IsSubset(t) {
- fmt.Println("t is a subset of s")
-}
-
-// ... or if s is a superset of t
-if t.IsSuperset(s) {
- fmt.Println("s is a superset of t")
-}
-
-
-```
-
-#### Set Operations
-
-
-```go
-// let us initialize two sets with some values
-a := set.New("ankara", "berlin", "san francisco")
-b := set.New("frankfurt", "berlin")
-
-// creates a new set with the items in a and b combined.
-// [frankfurt, berlin, ankara, san francisco]
-c := set.Union(a, b)
-
-// contains items which is in both a and b
-// [berlin]
-c := set.Intersection(a, b)
-
-// contains items which are in a but not in b
-// [ankara, san francisco]
-c := set.Difference(a, b)
-
-// contains items which are in one of either, but not in both.
-// [frankfurt, ankara, san francisco]
-c := set.SymmetricDifference(a, b)
-
-```
-
-```go
-// like Union but saves the result back into a.
-a.Merge(b)
-
-// removes the set items which are in b from a and saves the result back into a.
-a.Separate(b)
-
-```
-
-#### Multiple Set Operations
-
-```go
-a := set.New("1", "3", "4", "5")
-b := set.New("2", "3", "4", "5")
-c := set.New("4", "5", "6", "7")
-
-// creates a new set with items in a, b and c
-// [1 2 3 4 5 6 7]
-u := set.Union(a, b, c)
-
-// creates a new set with items in a but not in b and c
-// [1]
-u := set.Difference(a, b, c)
-
-// creates a new set with items that are common to a, b and c
-// [5]
-u := set.Intersection(a, b, c)
-```
-
-#### Helper methods
-
-The Slice functions below are a convenient way to extract or convert your Set data
-into basic data types.
-
-
-```go
-// create a set of mixed types
-s := set.New("ankara", "5", "8", "san francisco", 13, 21)
-
-
-// convert s into a slice of strings (type is []string)
-// [ankara 5 8 san francisco]
-t := set.StringSlice(s)
-
-
-// u contains a slice of ints (type is []int)
-// [13, 21]
-u := set.IntSlice(s)
-
-```
-
-#### Concurrent safe usage
-
-Below is an example of a concurrent way that uses set. We call ten functions
-concurrently and wait until they are finished. It basically creates a new
-string for each goroutine and adds it to our set.
-
-```go
-package main
-
-import (
- "fmt"
- "github.com/fatih/set"
- "strconv"
- "sync"
-)
-
-func main() {
- var wg sync.WaitGroup // this is just for waiting until all goroutines finish
-
- // Initialize our thread safe Set
- s := set.New()
-
- // Add items concurrently (item1, item2, and so on)
- for i := 0; i < 10; i++ {
- wg.Add(1)
- go func(i int) {
- item := "item" + strconv.Itoa(i)
- fmt.Println("adding", item)
- s.Add(item)
- wg.Done()
- }(i)
- }
-
- // Wait until all concurrent calls finished and print our set
- wg.Wait()
- fmt.Println(s)
-}
-```
-
-## Credits
-
- * [Fatih Arslan](https://github.com/fatih)
- * [Arne Hormann](https://github.com/arnehormann)
- * [Sam Boyer](https://github.com/sdboyer)
- * [Ralph Loizzo](https://github.com/friartech)
-
-## License
-
-The MIT License (MIT) - see LICENSE.md for more details
-
diff --git a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set.go b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set.go
deleted file mode 100644
index ac0240ce7080cab8a5c84170e86f6f0885b1e1fa..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set.go
+++ /dev/null
@@ -1,121 +0,0 @@
-// Package set provides both threadsafe and non-threadsafe implementations of
-// a generic set data structure. In the threadsafe set, safety encompasses all
-// operations on one set. Operations on multiple sets are consistent in that
-// the elements of each set used was valid at exactly one point in time
-// between the start and the end of the operation.
-package set
-
-// Interface is describing a Set. Sets are an unordered, unique list of values.
-type Interface interface {
- New(items ...interface{}) Interface
- Add(items ...interface{})
- Remove(items ...interface{})
- Pop() interface{}
- Has(items ...interface{}) bool
- Size() int
- Clear()
- IsEmpty() bool
- IsEqual(s Interface) bool
- IsSubset(s Interface) bool
- IsSuperset(s Interface) bool
- Each(func(interface{}) bool)
- String() string
- List() []interface{}
- Copy() Interface
- Merge(s Interface)
- Separate(s Interface)
-}
-
-// helpful to not write everywhere struct{}{}
-var keyExists = struct{}{}
-
-// Union is the merger of multiple sets. It returns a new set with all the
-// elements present in all the sets that are passed.
-//
-// The dynamic type of the returned set is determined by the first passed set's
-// implementation of the New() method.
-func Union(set1, set2 Interface, sets ...Interface) Interface {
- u := set1.Copy()
- set2.Each(func(item interface{}) bool {
- u.Add(item)
- return true
- })
- for _, set := range sets {
- set.Each(func(item interface{}) bool {
- u.Add(item)
- return true
- })
- }
-
- return u
-}
-
-// Difference returns a new set which contains items which are in in the first
-// set but not in the others. Unlike the Difference() method you can use this
-// function separately with multiple sets.
-func Difference(set1, set2 Interface, sets ...Interface) Interface {
- s := set1.Copy()
- s.Separate(set2)
- for _, set := range sets {
- s.Separate(set) // seperate is thread safe
- }
- return s
-}
-
-// Intersection returns a new set which contains items that only exist in all given sets.
-func Intersection(set1, set2 Interface, sets ...Interface) Interface {
- all := Union(set1, set2, sets...)
- result := Union(set1, set2, sets...)
-
- all.Each(func(item interface{}) bool {
- if !set1.Has(item) || !set2.Has(item) {
- result.Remove(item)
- }
-
- for _, set := range sets {
- if !set.Has(item) {
- result.Remove(item)
- }
- }
- return true
- })
- return result
-}
-
-// SymmetricDifference returns a new set which s is the difference of items which are in
-// one of either, but not in both.
-func SymmetricDifference(s Interface, t Interface) Interface {
- u := Difference(s, t)
- v := Difference(t, s)
- return Union(u, v)
-}
-
-// StringSlice is a helper function that returns a slice of strings of s. If
-// the set contains mixed types of items only items of type string are returned.
-func StringSlice(s Interface) []string {
- slice := make([]string, 0)
- for _, item := range s.List() {
- v, ok := item.(string)
- if !ok {
- continue
- }
-
- slice = append(slice, v)
- }
- return slice
-}
-
-// IntSlice is a helper function that returns a slice of ints of s. If
-// the set contains mixed types of items only items of type int are returned.
-func IntSlice(s Interface) []int {
- slice := make([]int, 0)
- for _, item := range s.List() {
- v, ok := item.(int)
- if !ok {
- continue
- }
-
- slice = append(slice, v)
- }
- return slice
-}
diff --git a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_nots.go b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_nots.go
deleted file mode 100644
index ec1ab2285f75d12586970a70595b9204b6cb0ba6..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_nots.go
+++ /dev/null
@@ -1,195 +0,0 @@
-package set
-
-import (
- "fmt"
- "strings"
-)
-
-// Provides a common set baseline for both threadsafe and non-ts Sets.
-type set struct {
- m map[interface{}]struct{} // struct{} doesn't take up space
-}
-
-// SetNonTS defines a non-thread safe set data structure.
-type SetNonTS struct {
- set
-}
-
-// NewNonTS creates and initialize a new non-threadsafe Set.
-// It accepts a variable number of arguments to populate the initial set.
-// If nothing is passed a SetNonTS with zero size is created.
-func NewNonTS(items ...interface{}) *SetNonTS {
- s := &SetNonTS{}
- s.m = make(map[interface{}]struct{})
-
- // Ensure interface compliance
- var _ Interface = s
-
- s.Add(items...)
- return s
-}
-
-// New creates and initalizes a new Set interface. It accepts a variable
-// number of arguments to populate the initial set. If nothing is passed a
-// zero size Set based on the struct is created.
-func (s *set) New(items ...interface{}) Interface {
- return NewNonTS(items...)
-}
-
-// Add includes the specified items (one or more) to the set. The underlying
-// Set s is modified. If passed nothing it silently returns.
-func (s *set) Add(items ...interface{}) {
- if len(items) == 0 {
- return
- }
-
- for _, item := range items {
- s.m[item] = keyExists
- }
-}
-
-// Remove deletes the specified items from the set. The underlying Set s is
-// modified. If passed nothing it silently returns.
-func (s *set) Remove(items ...interface{}) {
- if len(items) == 0 {
- return
- }
-
- for _, item := range items {
- delete(s.m, item)
- }
-}
-
-// Pop deletes and return an item from the set. The underlying Set s is
-// modified. If set is empty, nil is returned.
-func (s *set) Pop() interface{} {
- for item := range s.m {
- delete(s.m, item)
- return item
- }
- return nil
-}
-
-// Has looks for the existence of items passed. It returns false if nothing is
-// passed. For multiple items it returns true only if all of the items exist.
-func (s *set) Has(items ...interface{}) bool {
- // assume checked for empty item, which not exist
- if len(items) == 0 {
- return false
- }
-
- has := true
- for _, item := range items {
- if _, has = s.m[item]; !has {
- break
- }
- }
- return has
-}
-
-// Size returns the number of items in a set.
-func (s *set) Size() int {
- return len(s.m)
-}
-
-// Clear removes all items from the set.
-func (s *set) Clear() {
- s.m = make(map[interface{}]struct{})
-}
-
-// IsEmpty reports whether the Set is empty.
-func (s *set) IsEmpty() bool {
- return s.Size() == 0
-}
-
-// IsEqual test whether s and t are the same in size and have the same items.
-func (s *set) IsEqual(t Interface) bool {
- // Force locking only if given set is threadsafe.
- if conv, ok := t.(*Set); ok {
- conv.l.RLock()
- defer conv.l.RUnlock()
- }
-
- // return false if they are no the same size
- if sameSize := len(s.m) == t.Size(); !sameSize {
- return false
- }
-
- equal := true
- t.Each(func(item interface{}) bool {
- _, equal = s.m[item]
- return equal // if false, Each() will end
- })
-
- return equal
-}
-
-// IsSubset tests whether t is a subset of s.
-func (s *set) IsSubset(t Interface) (subset bool) {
- subset = true
-
- t.Each(func(item interface{}) bool {
- _, subset = s.m[item]
- return subset
- })
-
- return
-}
-
-// IsSuperset tests whether t is a superset of s.
-func (s *set) IsSuperset(t Interface) bool {
- return t.IsSubset(s)
-}
-
-// Each traverses the items in the Set, calling the provided function for each
-// set member. Traversal will continue until all items in the Set have been
-// visited, or if the closure returns false.
-func (s *set) Each(f func(item interface{}) bool) {
- for item := range s.m {
- if !f(item) {
- break
- }
- }
-}
-
-// String returns a string representation of s
-func (s *set) String() string {
- t := make([]string, 0, len(s.List()))
- for _, item := range s.List() {
- t = append(t, fmt.Sprintf("%v", item))
- }
-
- return fmt.Sprintf("[%s]", strings.Join(t, ", "))
-}
-
-// List returns a slice of all items. There is also StringSlice() and
-// IntSlice() methods for returning slices of type string or int.
-func (s *set) List() []interface{} {
- list := make([]interface{}, 0, len(s.m))
-
- for item := range s.m {
- list = append(list, item)
- }
-
- return list
-}
-
-// Copy returns a new Set with a copy of s.
-func (s *set) Copy() Interface {
- return NewNonTS(s.List()...)
-}
-
-// Merge is like Union, however it modifies the current set it's applied on
-// with the given t set.
-func (s *set) Merge(t Interface) {
- t.Each(func(item interface{}) bool {
- s.m[item] = keyExists
- return true
- })
-}
-
-// it's not the opposite of Merge.
-// Separate removes the set items containing in t from set s. Please aware that
-func (s *set) Separate(t Interface) {
- s.Remove(t.List()...)
-}
diff --git a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_nots_test.go b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_nots_test.go
deleted file mode 100644
index fd599699f2bae4aa9c32fcae33352af274566c3e..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_nots_test.go
+++ /dev/null
@@ -1,282 +0,0 @@
-package set
-
-import (
- "reflect"
- "strings"
- "testing"
-)
-
-func TestSetNonTS_NewNonTS_parameters(t *testing.T) {
- s := NewNonTS("string", "another_string", 1, 3.14)
-
- if s.Size() != 4 {
- t.Error("NewNonTS: calling with parameters should create a set with size of four")
- }
-}
-
-func TestSetNonTS_Add(t *testing.T) {
- s := NewNonTS()
- s.Add(1)
- s.Add(2)
- s.Add(2) // duplicate
- s.Add("fatih")
- s.Add("zeynep")
- s.Add("zeynep") // another duplicate
-
- if s.Size() != 4 {
- t.Error("Add: items are not unique. The set size should be four")
- }
-
- if !s.Has(1, 2, "fatih", "zeynep") {
- t.Error("Add: added items are not availabile in the set.")
- }
-}
-
-func TestSetNonTS_Add_multiple(t *testing.T) {
- s := NewNonTS()
- s.Add("ankara", "san francisco", 3.14)
-
- if s.Size() != 3 {
- t.Error("Add: items are not unique. The set size should be three")
- }
-
- if !s.Has("ankara", "san francisco", 3.14) {
- t.Error("Add: added items are not availabile in the set.")
- }
-}
-
-func TestSetNonTS_Remove(t *testing.T) {
- s := NewNonTS()
- s.Add(1)
- s.Add(2)
- s.Add("fatih")
-
- s.Remove(1)
- if s.Size() != 2 {
- t.Error("Remove: set size should be two after removing")
- }
-
- s.Remove(1)
- if s.Size() != 2 {
- t.Error("Remove: set size should be not change after trying to remove a non-existing item")
- }
-
- s.Remove(2)
- s.Remove("fatih")
- if s.Size() != 0 {
- t.Error("Remove: set size should be zero")
- }
-
- s.Remove("fatih") // try to remove something from a zero length set
-}
-
-func TestSetNonTS_Remove_multiple(t *testing.T) {
- s := NewNonTS()
- s.Add("ankara", "san francisco", 3.14, "istanbul")
- s.Remove("ankara", "san francisco", 3.14)
-
- if s.Size() != 1 {
- t.Error("Remove: items are not unique. The set size should be four")
- }
-
- if !s.Has("istanbul") {
- t.Error("Add: added items are not availabile in the set.")
- }
-}
-
-func TestSetNonTS_Pop(t *testing.T) {
- s := NewNonTS()
- s.Add(1)
- s.Add(2)
- s.Add("fatih")
-
- a := s.Pop()
- if s.Size() != 2 {
- t.Error("Pop: set size should be two after popping out")
- }
-
- if s.Has(a) {
- t.Error("Pop: returned item should not exist")
- }
-
- s.Pop()
- s.Pop()
- b := s.Pop()
- if b != nil {
- t.Error("Pop: should return nil because set is empty")
- }
-
- s.Pop() // try to remove something from a zero length set
-}
-
-func TestSetNonTS_Has(t *testing.T) {
- s := NewNonTS("1", "2", "3", "4")
-
- if !s.Has("1") {
- t.Error("Has: the item 1 exist, but 'Has' is returning false")
- }
-
- if !s.Has("1", "2", "3", "4") {
- t.Error("Has: the items all exist, but 'Has' is returning false")
- }
-}
-
-func TestSetNonTS_Clear(t *testing.T) {
- s := NewNonTS()
- s.Add(1)
- s.Add("istanbul")
- s.Add("san francisco")
-
- s.Clear()
- if s.Size() != 0 {
- t.Error("Clear: set size should be zero")
- }
-}
-
-func TestSetNonTS_IsEmpty(t *testing.T) {
- s := NewNonTS()
-
- empty := s.IsEmpty()
- if !empty {
- t.Error("IsEmpty: set is empty, it should be true")
- }
-
- s.Add(2)
- s.Add(3)
- notEmpty := s.IsEmpty()
-
- if notEmpty {
- t.Error("IsEmpty: set is filled, it should be false")
- }
-}
-
-func TestSetNonTS_IsEqual(t *testing.T) {
- s := NewNonTS("1", "2", "3")
- u := NewNonTS("1", "2", "3")
-
- ok := s.IsEqual(u)
- if !ok {
- t.Error("IsEqual: set s and t are equal. However it returns false")
- }
-
- // same size, different content
- a := NewNonTS("1", "2", "3")
- b := NewNonTS("4", "5", "6")
-
- ok = a.IsEqual(b)
- if ok {
- t.Error("IsEqual: set a and b are now equal (1). However it returns true")
- }
-
- // different size, similar content
- a = NewNonTS("1", "2", "3")
- b = NewNonTS("1", "2", "3", "4")
-
- ok = a.IsEqual(b)
- if ok {
- t.Error("IsEqual: set s and t are now equal (2). However it returns true")
- }
-
-}
-
-func TestSetNonTS_IsSubset(t *testing.T) {
- s := NewNonTS("1", "2", "3", "4")
- u := NewNonTS("1", "2", "3")
-
- ok := s.IsSubset(u)
- if !ok {
- t.Error("IsSubset: u is a subset of s. However it returns false")
- }
-
- ok = u.IsSubset(s)
- if ok {
- t.Error("IsSubset: s is not a subset of u. However it returns true")
- }
-
-}
-
-func TestSetNonTS_IsSuperset(t *testing.T) {
- s := NewNonTS("1", "2", "3", "4")
- u := NewNonTS("1", "2", "3")
-
- ok := u.IsSuperset(s)
- if !ok {
- t.Error("IsSuperset: s is a superset of u. However it returns false")
- }
-
- ok = s.IsSuperset(u)
- if ok {
- t.Error("IsSuperset: u is not a superset of u. However it returns true")
- }
-
-}
-
-func TestSetNonTS_String(t *testing.T) {
- s := NewNonTS()
- if s.String() != "[]" {
- t.Errorf("String: output is not what is excepted '%s'", s.String())
- }
-
- s.Add("1", "2", "3", "4")
- if !strings.HasPrefix(s.String(), "[") {
- t.Error("String: output should begin with a square bracket")
- }
-
- if !strings.HasSuffix(s.String(), "]") {
- t.Error("String: output should end with a square bracket")
- }
-
-}
-
-func TestSetNonTS_List(t *testing.T) {
- s := NewNonTS("1", "2", "3", "4")
-
- // this returns a slice of interface{}
- if len(s.List()) != 4 {
- t.Error("List: slice size should be four.")
- }
-
- for _, item := range s.List() {
- r := reflect.TypeOf(item)
- if r.Kind().String() != "string" {
- t.Error("List: slice item should be a string")
- }
- }
-}
-
-func TestSetNonTS_Copy(t *testing.T) {
- s := NewNonTS("1", "2", "3", "4")
- r := s.Copy()
-
- if !s.IsEqual(r) {
- t.Error("Copy: set s and r are not equal")
- }
-}
-
-func TestSetNonTS_Merge(t *testing.T) {
- s := NewNonTS("1", "2", "3")
- r := NewNonTS("3", "4", "5")
- s.Merge(r)
-
- if s.Size() != 5 {
- t.Error("Merge: the set doesn't have all items in it.")
- }
-
- if !s.Has("1", "2", "3", "4", "5") {
- t.Error("Merge: merged items are not availabile in the set.")
- }
-}
-
-func TestSetNonTS_Separate(t *testing.T) {
- s := NewNonTS("1", "2", "3")
- r := NewNonTS("3", "5")
- s.Separate(r)
-
- if s.Size() != 2 {
- t.Error("Separate: the set doesn't have all items in it.")
- }
-
- if !s.Has("1", "2") {
- t.Error("Separate: items after separation are not availabile in the set.")
- }
-}
diff --git a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_test.go b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_test.go
deleted file mode 100644
index 83dd5806d0cb0c1bdc95b813f2e2c65669c020ed..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_test.go
+++ /dev/null
@@ -1,188 +0,0 @@
-package set
-
-import (
- "reflect"
- "testing"
-)
-
-func Test_Union(t *testing.T) {
- s := New("1", "2", "3")
- r := New("3", "4", "5")
- x := NewNonTS("5", "6", "7")
-
- u := Union(s, r, x)
- if settype := reflect.TypeOf(u).String(); settype != "*set.Set" {
- t.Error("Union should derive its set type from the first passed set, got", settype)
- }
- if u.Size() != 7 {
- t.Error("Union: the merged set doesn't have all items in it.")
- }
-
- if !u.Has("1", "2", "3", "4", "5", "6", "7") {
- t.Error("Union: merged items are not availabile in the set.")
- }
-
- z := Union(x, r)
- if z.Size() != 5 {
- t.Error("Union: Union of 2 sets doesn't have the proper number of items.")
- }
- if settype := reflect.TypeOf(z).String(); settype != "*set.SetNonTS" {
- t.Error("Union should derive its set type from the first passed set, got", settype)
- }
-
-}
-
-func Test_Difference(t *testing.T) {
- s := New("1", "2", "3")
- r := New("3", "4", "5")
- x := New("5", "6", "7")
- u := Difference(s, r, x)
-
- if u.Size() != 2 {
- t.Error("Difference: the set doesn't have all items in it.")
- }
-
- if !u.Has("1", "2") {
- t.Error("Difference: items are not availabile in the set.")
- }
-
- y := Difference(r, r)
- if y.Size() != 0 {
- t.Error("Difference: size should be zero")
- }
-
-}
-
-func Test_Intersection(t *testing.T) {
- s1 := New("1", "3", "4", "5")
- s2 := New("2", "3", "5", "6")
- s3 := New("4", "5", "6", "7")
- u := Intersection(s1, s2, s3)
-
- if u.Size() != 1 {
- t.Error("Intersection: the set doesn't have all items in it.")
- }
-
- if !u.Has("5") {
- t.Error("Intersection: items after intersection are not availabile in the set.")
- }
-}
-
-func Test_SymmetricDifference(t *testing.T) {
- s := New("1", "2", "3")
- r := New("3", "4", "5")
- u := SymmetricDifference(s, r)
-
- if u.Size() != 4 {
- t.Error("SymmetricDifference: the set doesn't have all items in it.")
- }
-
- if !u.Has("1", "2", "4", "5") {
- t.Error("SymmetricDifference: items are not availabile in the set.")
- }
-}
-
-func Test_StringSlice(t *testing.T) {
- s := New("san francisco", "istanbul", 3.14, 1321, "ankara")
- u := StringSlice(s)
-
- if len(u) != 3 {
- t.Error("StringSlice: slice should only have three items")
- }
-
- for _, item := range u {
- r := reflect.TypeOf(item)
- if r.Kind().String() != "string" {
- t.Error("StringSlice: slice item should be a string")
- }
- }
-}
-
-func Test_IntSlice(t *testing.T) {
- s := New("san francisco", "istanbul", 3.14, 1321, "ankara", 8876)
- u := IntSlice(s)
-
- if len(u) != 2 {
- t.Error("IntSlice: slice should only have two items")
- }
-
- for _, item := range u {
- r := reflect.TypeOf(item)
- if r.Kind().String() != "int" {
- t.Error("Intslice: slice item should be a int")
- }
- }
-}
-
-func BenchmarkSetEquality(b *testing.B) {
- s := New()
- u := New()
-
- for i := 0; i < b.N; i++ {
- s.Add(i)
- u.Add(i)
- }
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- s.IsEqual(u)
- }
-}
-
-func BenchmarkSubset(b *testing.B) {
- s := New()
- u := New()
-
- for i := 0; i < b.N; i++ {
- s.Add(i)
- u.Add(i)
- }
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- s.IsSubset(u)
- }
-}
-
-func benchmarkIntersection(b *testing.B, numberOfItems int) {
- s1 := New()
- s2 := New()
-
- for i := 0; i < numberOfItems/2; i++ {
- s1.Add(i)
- }
- for i := 0; i < numberOfItems; i++ {
- s2.Add(i)
- }
-
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- Intersection(s1, s2)
- }
-}
-
-func BenchmarkIntersection10(b *testing.B) {
- benchmarkIntersection(b, 10)
-}
-
-func BenchmarkIntersection100(b *testing.B) {
- benchmarkIntersection(b, 100)
-}
-
-func BenchmarkIntersection1000(b *testing.B) {
- benchmarkIntersection(b, 1000)
-}
-
-func BenchmarkIntersection10000(b *testing.B) {
- benchmarkIntersection(b, 10000)
-}
-
-func BenchmarkIntersection100000(b *testing.B) {
- benchmarkIntersection(b, 100000)
-}
-
-func BenchmarkIntersection1000000(b *testing.B) {
- benchmarkIntersection(b, 1000000)
-}
diff --git a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_ts.go b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_ts.go
deleted file mode 100644
index 50f532565befb06d9af6020ed8759385916e4a7e..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_ts.go
+++ /dev/null
@@ -1,200 +0,0 @@
-package set
-
-import (
- "sync"
-)
-
-// Set defines a thread safe set data structure.
-type Set struct {
- set
- l sync.RWMutex // we name it because we don't want to expose it
-}
-
-// New creates and initialize a new Set. It's accept a variable number of
-// arguments to populate the initial set. If nothing passed a Set with zero
-// size is created.
-func New(items ...interface{}) *Set {
- s := &Set{}
- s.m = make(map[interface{}]struct{})
-
- // Ensure interface compliance
- var _ Interface = s
-
- s.Add(items...)
- return s
-}
-
-// New creates and initalizes a new Set interface. It accepts a variable
-// number of arguments to populate the initial set. If nothing is passed a
-// zero size Set based on the struct is created.
-func (s *Set) New(items ...interface{}) Interface {
- return New(items...)
-}
-
-// Add includes the specified items (one or more) to the set. The underlying
-// Set s is modified. If passed nothing it silently returns.
-func (s *Set) Add(items ...interface{}) {
- if len(items) == 0 {
- return
- }
-
- s.l.Lock()
- defer s.l.Unlock()
-
- for _, item := range items {
- s.m[item] = keyExists
- }
-}
-
-// Remove deletes the specified items from the set. The underlying Set s is
-// modified. If passed nothing it silently returns.
-func (s *Set) Remove(items ...interface{}) {
- if len(items) == 0 {
- return
- }
-
- s.l.Lock()
- defer s.l.Unlock()
-
- for _, item := range items {
- delete(s.m, item)
- }
-}
-
-// Pop deletes and return an item from the set. The underlying Set s is
-// modified. If set is empty, nil is returned.
-func (s *Set) Pop() interface{} {
- s.l.RLock()
- for item := range s.m {
- s.l.RUnlock()
- s.l.Lock()
- delete(s.m, item)
- s.l.Unlock()
- return item
- }
- s.l.RUnlock()
- return nil
-}
-
-// Has looks for the existence of items passed. It returns false if nothing is
-// passed. For multiple items it returns true only if all of the items exist.
-func (s *Set) Has(items ...interface{}) bool {
- // assume checked for empty item, which not exist
- if len(items) == 0 {
- return false
- }
-
- s.l.RLock()
- defer s.l.RUnlock()
-
- has := true
- for _, item := range items {
- if _, has = s.m[item]; !has {
- break
- }
- }
- return has
-}
-
-// Size returns the number of items in a set.
-func (s *Set) Size() int {
- s.l.RLock()
- defer s.l.RUnlock()
-
- l := len(s.m)
- return l
-}
-
-// Clear removes all items from the set.
-func (s *Set) Clear() {
- s.l.Lock()
- defer s.l.Unlock()
-
- s.m = make(map[interface{}]struct{})
-}
-
-// IsEqual test whether s and t are the same in size and have the same items.
-func (s *Set) IsEqual(t Interface) bool {
- s.l.RLock()
- defer s.l.RUnlock()
-
- // Force locking only if given set is threadsafe.
- if conv, ok := t.(*Set); ok {
- conv.l.RLock()
- defer conv.l.RUnlock()
- }
-
- // return false if they are no the same size
- if sameSize := len(s.m) == t.Size(); !sameSize {
- return false
- }
-
- equal := true
- t.Each(func(item interface{}) bool {
- _, equal = s.m[item]
- return equal // if false, Each() will end
- })
-
- return equal
-}
-
-// IsSubset tests whether t is a subset of s.
-func (s *Set) IsSubset(t Interface) (subset bool) {
- s.l.RLock()
- defer s.l.RUnlock()
-
- subset = true
-
- t.Each(func(item interface{}) bool {
- _, subset = s.m[item]
- return subset
- })
-
- return
-}
-
-// Each traverses the items in the Set, calling the provided function for each
-// set member. Traversal will continue until all items in the Set have been
-// visited, or if the closure returns false.
-func (s *Set) Each(f func(item interface{}) bool) {
- s.l.RLock()
- defer s.l.RUnlock()
-
- for item := range s.m {
- if !f(item) {
- break
- }
- }
-}
-
-// List returns a slice of all items. There is also StringSlice() and
-// IntSlice() methods for returning slices of type string or int.
-func (s *Set) List() []interface{} {
- s.l.RLock()
- defer s.l.RUnlock()
-
- list := make([]interface{}, 0, len(s.m))
-
- for item := range s.m {
- list = append(list, item)
- }
-
- return list
-}
-
-// Copy returns a new Set with a copy of s.
-func (s *Set) Copy() Interface {
- return New(s.List()...)
-}
-
-// Merge is like Union, however it modifies the current set it's applied on
-// with the given t set.
-func (s *Set) Merge(t Interface) {
- s.l.Lock()
- defer s.l.Unlock()
-
- t.Each(func(item interface{}) bool {
- s.m[item] = keyExists
- return true
- })
-}
diff --git a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_ts_test.go b/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_ts_test.go
deleted file mode 100644
index 8d2f509d0f29777b3bb7fb3b74ec3a088f03b79a..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/fatih/set.v0/set_ts_test.go
+++ /dev/null
@@ -1,321 +0,0 @@
-package set
-
-import (
- "reflect"
- "strconv"
- "strings"
- "testing"
-)
-
-func TestSet_New(t *testing.T) {
- s := New()
-
- if s.Size() != 0 {
- t.Error("New: calling without any parameters should create a set with zero size")
- }
-
- u := s.New()
- if u.Size() != 0 {
- t.Error("New: creating a new set via s.New() should create a set with zero size")
- }
-}
-
-func TestSet_New_parameters(t *testing.T) {
- s := New("string", "another_string", 1, 3.14)
-
- if s.Size() != 4 {
- t.Error("New: calling with parameters should create a set with size of four")
- }
-}
-
-func TestSet_Add(t *testing.T) {
- s := New()
- s.Add(1)
- s.Add(2)
- s.Add(2) // duplicate
- s.Add("fatih")
- s.Add("zeynep")
- s.Add("zeynep") // another duplicate
-
- if s.Size() != 4 {
- t.Error("Add: items are not unique. The set size should be four")
- }
-
- if !s.Has(1, 2, "fatih", "zeynep") {
- t.Error("Add: added items are not availabile in the set.")
- }
-}
-
-func TestSet_Add_multiple(t *testing.T) {
- s := New()
- s.Add("ankara", "san francisco", 3.14)
-
- if s.Size() != 3 {
- t.Error("Add: items are not unique. The set size should be three")
- }
-
- if !s.Has("ankara", "san francisco", 3.14) {
- t.Error("Add: added items are not availabile in the set.")
- }
-}
-
-func TestSet_Remove(t *testing.T) {
- s := New()
- s.Add(1)
- s.Add(2)
- s.Add("fatih")
-
- s.Remove(1)
- if s.Size() != 2 {
- t.Error("Remove: set size should be two after removing")
- }
-
- s.Remove(1)
- if s.Size() != 2 {
- t.Error("Remove: set size should be not change after trying to remove a non-existing item")
- }
-
- s.Remove(2)
- s.Remove("fatih")
- if s.Size() != 0 {
- t.Error("Remove: set size should be zero")
- }
-
- s.Remove("fatih") // try to remove something from a zero length set
-}
-
-func TestSet_Remove_multiple(t *testing.T) {
- s := New()
- s.Add("ankara", "san francisco", 3.14, "istanbul")
- s.Remove("ankara", "san francisco", 3.14)
-
- if s.Size() != 1 {
- t.Error("Remove: items are not unique. The set size should be four")
- }
-
- if !s.Has("istanbul") {
- t.Error("Add: added items are not availabile in the set.")
- }
-}
-
-func TestSet_Pop(t *testing.T) {
- s := New()
- s.Add(1)
- s.Add(2)
- s.Add("fatih")
-
- a := s.Pop()
- if s.Size() != 2 {
- t.Error("Pop: set size should be two after popping out")
- }
-
- if s.Has(a) {
- t.Error("Pop: returned item should not exist")
- }
-
- s.Pop()
- s.Pop()
- b := s.Pop()
- if b != nil {
- t.Error("Pop: should return nil because set is empty")
- }
-
- s.Pop() // try to remove something from a zero length set
-}
-
-func TestSet_Has(t *testing.T) {
- s := New("1", "2", "3", "4")
-
- if !s.Has("1") {
- t.Error("Has: the item 1 exist, but 'Has' is returning false")
- }
-
- if !s.Has("1", "2", "3", "4") {
- t.Error("Has: the items all exist, but 'Has' is returning false")
- }
-}
-
-func TestSet_Clear(t *testing.T) {
- s := New()
- s.Add(1)
- s.Add("istanbul")
- s.Add("san francisco")
-
- s.Clear()
- if s.Size() != 0 {
- t.Error("Clear: set size should be zero")
- }
-}
-
-func TestSet_IsEmpty(t *testing.T) {
- s := New()
-
- empty := s.IsEmpty()
- if !empty {
- t.Error("IsEmpty: set is empty, it should be true")
- }
-
- s.Add(2)
- s.Add(3)
- notEmpty := s.IsEmpty()
-
- if notEmpty {
- t.Error("IsEmpty: set is filled, it should be false")
- }
-}
-
-func TestSet_IsEqual(t *testing.T) {
- s := New("1", "2", "3")
- u := New("1", "2", "3")
-
- ok := s.IsEqual(u)
- if !ok {
- t.Error("IsEqual: set s and t are equal. However it returns false")
- }
-
- // same size, different content
- a := New("1", "2", "3")
- b := New("4", "5", "6")
-
- ok = a.IsEqual(b)
- if ok {
- t.Error("IsEqual: set a and b are now equal (1). However it returns true")
- }
-
- // different size, similar content
- a = New("1", "2", "3")
- b = New("1", "2", "3", "4")
-
- ok = a.IsEqual(b)
- if ok {
- t.Error("IsEqual: set s and t are now equal (2). However it returns true")
- }
-
-}
-
-func TestSet_IsSubset(t *testing.T) {
- s := New("1", "2", "3", "4")
- u := New("1", "2", "3")
-
- ok := s.IsSubset(u)
- if !ok {
- t.Error("IsSubset: u is a subset of s. However it returns false")
- }
-
- ok = u.IsSubset(s)
- if ok {
- t.Error("IsSubset: s is not a subset of u. However it returns true")
- }
-
-}
-
-func TestSet_IsSuperset(t *testing.T) {
- s := New("1", "2", "3", "4")
- u := New("1", "2", "3")
-
- ok := u.IsSuperset(s)
- if !ok {
- t.Error("IsSuperset: s is a superset of u. However it returns false")
- }
-
- ok = s.IsSuperset(u)
- if ok {
- t.Error("IsSuperset: u is not a superset of u. However it returns true")
- }
-
-}
-
-func TestSet_String(t *testing.T) {
- s := New()
- if s.String() != "[]" {
- t.Errorf("String: output is not what is excepted '%s'", s.String())
- }
-
- s.Add("1", "2", "3", "4")
- if !strings.HasPrefix(s.String(), "[") {
- t.Error("String: output should begin with a square bracket")
- }
-
- if !strings.HasSuffix(s.String(), "]") {
- t.Error("String: output should end with a square bracket")
- }
-}
-
-func TestSet_List(t *testing.T) {
- s := New("1", "2", "3", "4")
-
- // this returns a slice of interface{}
- if len(s.List()) != 4 {
- t.Error("List: slice size should be four.")
- }
-
- for _, item := range s.List() {
- r := reflect.TypeOf(item)
- if r.Kind().String() != "string" {
- t.Error("List: slice item should be a string")
- }
- }
-}
-
-func TestSet_Copy(t *testing.T) {
- s := New("1", "2", "3", "4")
- r := s.Copy()
-
- if !s.IsEqual(r) {
- t.Error("Copy: set s and r are not equal")
- }
-}
-
-func TestSet_Merge(t *testing.T) {
- s := New("1", "2", "3")
- r := New("3", "4", "5")
- s.Merge(r)
-
- if s.Size() != 5 {
- t.Error("Merge: the set doesn't have all items in it.")
- }
-
- if !s.Has("1", "2", "3", "4", "5") {
- t.Error("Merge: merged items are not availabile in the set.")
- }
-}
-
-func TestSet_Separate(t *testing.T) {
- s := New("1", "2", "3")
- r := New("3", "5")
- s.Separate(r)
-
- if s.Size() != 2 {
- t.Error("Separate: the set doesn't have all items in it.")
- }
-
- if !s.Has("1", "2") {
- t.Error("Separate: items after separation are not availabile in the set.")
- }
-}
-
-func TestSet_RaceAdd(t *testing.T) {
- // Create two sets. Add concurrently items to each of them. Remove from the
- // other one.
- // "go test -race" should detect this if the library is not thread-safe.
- s := New()
- u := New()
-
- go func() {
- for i := 0; i < 1000; i++ {
- item := "item" + strconv.Itoa(i)
- go func(i int) {
- s.Add(item)
- u.Add(item)
- }(i)
- }
- }()
-
- for i := 0; i < 1000; i++ {
- item := "item" + strconv.Itoa(i)
- go func(i int) {
- s.Add(item)
- u.Add(item)
- }(i)
- }
-}
diff --git a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/.gitignore b/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/.gitignore
deleted file mode 100644
index 836562412fe8a44fa99a515eeff68d2bc1a86daa..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/.gitignore
+++ /dev/null
@@ -1,23 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
diff --git a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/LICENSE b/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/LICENSE
deleted file mode 100644
index a4f2f281ba0ae71f99177d0d789eabb3b0298a46..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Tyler Bunnell
-
-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/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/README.md b/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/README.md
deleted file mode 100644
index 531249a73ef7d72bdf0c8eb01bfc3b5e2238f919..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/README.md
+++ /dev/null
@@ -1,137 +0,0 @@
-graceful [](http://godoc.org/github.com/tylerb/graceful) [](https://drone.io/github.com/tylerb/graceful/latest) [](https://coveralls.io/r/tylerb/graceful?branch=dronedebug) [](https://gitter.im/tylerb/graceful?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-========
-
-Graceful is a Go 1.3+ package enabling graceful shutdown of http.Handler servers.
-
-## Installation
-
-To install, simply execute:
-
-```
-go get gopkg.in/tylerb/graceful.v1
-```
-
-I am using [gopkg.in](http://labix.org/gopkg.in) to control releases.
-
-## Usage
-
-Using Graceful is easy. Simply create your http.Handler and pass it to the `Run` function:
-
-```go
-package main
-
-import (
- "gopkg.in/tylerb/graceful.v1"
- "net/http"
- "fmt"
- "time"
-)
-
-func main() {
- mux := http.NewServeMux()
- mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
- fmt.Fprintf(w, "Welcome to the home page!")
- })
-
- graceful.Run(":3001",10*time.Second,mux)
-}
-```
-
-Another example, using [Negroni](https://github.com/codegangsta/negroni), functions in much the same manner:
-
-```go
-package main
-
-import (
- "github.com/codegangsta/negroni"
- "gopkg.in/tylerb/graceful.v1"
- "net/http"
- "fmt"
- "time"
-)
-
-func main() {
- mux := http.NewServeMux()
- mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
- fmt.Fprintf(w, "Welcome to the home page!")
- })
-
- n := negroni.Classic()
- n.UseHandler(mux)
- //n.Run(":3000")
- graceful.Run(":3001",10*time.Second,n)
-}
-```
-
-In addition to Run there are the http.Server counterparts ListenAndServe, ListenAndServeTLS and Serve, which allow you to configure HTTPS, custom timeouts and error handling.
-Graceful may also be used by instantiating its Server type directly, which embeds an http.Server:
-
-```go
-mux := // ...
-
-srv := &graceful.Server{
- Timeout: 10 * time.Second,
-
- Server: &http.Server{
- Addr: ":1234",
- Handler: mux,
- },
-}
-
-srv.ListenAndServe()
-```
-
-This form allows you to set the ConnState callback, which works in the same way as in http.Server:
-
-```go
-mux := // ...
-
-srv := &graceful.Server{
- Timeout: 10 * time.Second,
-
- ConnState: func(conn net.Conn, state http.ConnState) {
- // conn has a new state
- },
-
- Server: &http.Server{
- Addr: ":1234",
- Handler: mux,
- },
-}
-
-srv.ListenAndServe()
-```
-
-## Behaviour
-
-When Graceful is sent a SIGINT or SIGTERM (possibly from ^C or a kill command), it:
-
-1. Disables keepalive connections.
-2. Closes the listening socket, allowing another process to listen on that port immediately.
-3. Starts a timer of `timeout` duration to give active requests a chance to finish.
-4. When timeout expires, closes all active connections.
-5. Closes the `stopChan`, waking up any blocking goroutines.
-6. Returns from the function, allowing the server to terminate.
-
-## Notes
-
-If the `timeout` argument to `Run` is 0, the server never times out, allowing all active requests to complete.
-
-If you wish to stop the server in some way other than an OS signal, you may call the `Stop()` function.
-This function stops the server, gracefully, using the new timeout value you provide. The `StopChan()` function
-returns a channel on which you can block while waiting for the server to stop. This channel will be closed when
-the server is stopped, allowing your execution to proceed. Multiple goroutines can block on this channel at the
-same time and all will be signalled when stopping is complete.
-
-## Contributing
-
-If you would like to contribute, please:
-
-1. Create a GitHub issue regarding the contribution. Features and bugs should be discussed beforehand.
-2. Fork the repository.
-3. Create a pull request with your solution. This pull request should reference and close the issues (Fix #2).
-
-All pull requests should:
-
-1. Pass [gometalinter -t .](https://github.com/alecthomas/gometalinter) with no warnings.
-2. Be `go fmt` formatted.
diff --git a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful.go b/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful.go
deleted file mode 100644
index f503206c6ba47c152bde4e321e444da2c8baca4d..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful.go
+++ /dev/null
@@ -1,319 +0,0 @@
-package graceful
-
-import (
- "crypto/tls"
- "log"
- "net"
- "net/http"
- "os"
- "os/signal"
- "sync"
- "syscall"
- "time"
-
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/golang.org/x/net/netutil"
-)
-
-// Server wraps an http.Server with graceful connection handling.
-// It may be used directly in the same way as http.Server, or may
-// be constructed with the global functions in this package.
-//
-// Example:
-// srv := &graceful.Server{
-// Timeout: 5 * time.Second,
-// Server: &http.Server{Addr: ":1234", Handler: handler},
-// }
-// srv.ListenAndServe()
-type Server struct {
- *http.Server
-
- // Timeout is the duration to allow outstanding requests to survive
- // before forcefully terminating them.
- Timeout time.Duration
-
- // Limit the number of outstanding requests
- ListenLimit int
-
- // ConnState specifies an optional callback function that is
- // called when a client connection changes state. This is a proxy
- // to the underlying http.Server's ConnState, and the original
- // must not be set directly.
- ConnState func(net.Conn, http.ConnState)
-
- // ShutdownInitiated is an optional callback function that is called
- // when shutdown is initiated. It can be used to notify the client
- // side of long lived connections (e.g. websockets) to reconnect.
- ShutdownInitiated func()
-
- // NoSignalHandling prevents graceful from automatically shutting down
- // on SIGINT and SIGTERM. If set to true, you must shut down the server
- // manually with Stop().
- NoSignalHandling bool
-
- // interrupt signals the listener to stop serving connections,
- // and the server to shut down.
- interrupt chan os.Signal
-
- // stopChan is the channel on which callers may block while waiting for
- // the server to stop.
- stopChan chan struct{}
-
- // stopLock is used to protect access to the stopChan.
- stopLock sync.RWMutex
-
- // connections holds all connections managed by graceful
- connections map[net.Conn]struct{}
-}
-
-// Run serves the http.Handler with graceful shutdown enabled.
-//
-// timeout is the duration to wait until killing active requests and stopping the server.
-// If timeout is 0, the server never times out. It waits for all active requests to finish.
-func Run(addr string, timeout time.Duration, n http.Handler) {
- srv := &Server{
- Timeout: timeout,
- Server: &http.Server{Addr: addr, Handler: n},
- }
-
- if err := srv.ListenAndServe(); err != nil {
- if opErr, ok := err.(*net.OpError); !ok || (ok && opErr.Op != "accept") {
- logger := log.New(os.Stdout, "[graceful] ", 0)
- logger.Fatal(err)
- }
- }
-}
-
-// ListenAndServe is equivalent to http.Server.ListenAndServe with graceful shutdown enabled.
-//
-// timeout is the duration to wait until killing active requests and stopping the server.
-// If timeout is 0, the server never times out. It waits for all active requests to finish.
-func ListenAndServe(server *http.Server, timeout time.Duration) error {
- srv := &Server{Timeout: timeout, Server: server}
- return srv.ListenAndServe()
-}
-
-// ListenAndServe is equivalent to http.Server.ListenAndServe with graceful shutdown enabled.
-func (srv *Server) ListenAndServe() error {
- // Create the listener so we can control their lifetime
- addr := srv.Addr
- if addr == "" {
- addr = ":http"
- }
- l, err := net.Listen("tcp", addr)
- if err != nil {
- return err
- }
-
- if srv.ListenLimit != 0 {
- l = netutil.LimitListener(l, srv.ListenLimit)
- }
- return srv.Serve(l)
-}
-
-// ListenAndServeTLS is equivalent to http.Server.ListenAndServeTLS with graceful shutdown enabled.
-//
-// timeout is the duration to wait until killing active requests and stopping the server.
-// If timeout is 0, the server never times out. It waits for all active requests to finish.
-func ListenAndServeTLS(server *http.Server, certFile, keyFile string, timeout time.Duration) error {
- srv := &Server{Timeout: timeout, Server: server}
- return srv.ListenAndServeTLS(certFile, keyFile)
-}
-
-// ListenAndServeTLS is equivalent to http.Server.ListenAndServeTLS with graceful shutdown enabled.
-func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error {
- // Create the listener ourselves so we can control its lifetime
- addr := srv.Addr
- if addr == "" {
- addr = ":https"
- }
-
- config := &tls.Config{}
- if srv.TLSConfig != nil {
- *config = *srv.TLSConfig
- }
- if config.NextProtos == nil {
- config.NextProtos = []string{"http/1.1"}
- }
-
- var err error
- config.Certificates = make([]tls.Certificate, 1)
- config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)
- if err != nil {
- return err
- }
-
- conn, err := net.Listen("tcp", addr)
- if err != nil {
- return err
- }
-
- tlsListener := tls.NewListener(conn, config)
- return srv.Serve(tlsListener)
-}
-
-// ListenAndServeTLSConfig can be used with an existing TLS config and is equivalent to
-// http.Server.ListenAndServeTLS with graceful shutdown enabled,
-func (srv *Server) ListenAndServeTLSConfig(config *tls.Config) error {
- addr := srv.Addr
- if addr == "" {
- addr = ":https"
- }
-
- conn, err := net.Listen("tcp", addr)
- if err != nil {
- return err
- }
-
- tlsListener := tls.NewListener(conn, config)
- return srv.Serve(tlsListener)
-}
-
-// Serve is equivalent to http.Server.Serve with graceful shutdown enabled.
-//
-// timeout is the duration to wait until killing active requests and stopping the server.
-// If timeout is 0, the server never times out. It waits for all active requests to finish.
-func Serve(server *http.Server, l net.Listener, timeout time.Duration) error {
- srv := &Server{Timeout: timeout, Server: server}
- return srv.Serve(l)
-}
-
-// Serve is equivalent to http.Server.Serve with graceful shutdown enabled.
-func (srv *Server) Serve(listener net.Listener) error {
- // Track connection state
- add := make(chan net.Conn)
- remove := make(chan net.Conn)
-
- srv.Server.ConnState = func(conn net.Conn, state http.ConnState) {
- switch state {
- case http.StateNew:
- add <- conn
- case http.StateClosed, http.StateHijacked:
- remove <- conn
- }
- if srv.ConnState != nil {
- srv.ConnState(conn, state)
- }
- }
-
- // Manage open connections
- shutdown := make(chan chan struct{})
- kill := make(chan struct{})
- go srv.manageConnections(add, remove, shutdown, kill)
-
- interrupt := srv.interruptChan()
-
- // Set up the interrupt handler
- if !srv.NoSignalHandling {
- signal.Notify(interrupt, syscall.SIGINT, syscall.SIGTERM)
- }
-
- go srv.handleInterrupt(interrupt, listener)
-
- // Serve with graceful listener.
- // Execution blocks here until listener.Close() is called, above.
- err := srv.Server.Serve(listener)
-
- srv.shutdown(shutdown, kill)
-
- return err
-}
-
-// Stop instructs the type to halt operations and close
-// the stop channel when it is finished.
-//
-// timeout is grace period for which to wait before shutting
-// down the server. The timeout value passed here will override the
-// timeout given when constructing the server, as this is an explicit
-// command to stop the server.
-func (srv *Server) Stop(timeout time.Duration) {
- srv.Timeout = timeout
- interrupt := srv.interruptChan()
- interrupt <- syscall.SIGINT
-}
-
-// StopChan gets the stop channel which will block until
-// stopping has completed, at which point it is closed.
-// Callers should never close the stop channel.
-func (srv *Server) StopChan() <-chan struct{} {
- srv.stopLock.Lock()
- if srv.stopChan == nil {
- srv.stopChan = make(chan struct{})
- }
- srv.stopLock.Unlock()
- return srv.stopChan
-}
-
-func (srv *Server) manageConnections(add, remove chan net.Conn, shutdown chan chan struct{}, kill chan struct{}) {
- {
- var done chan struct{}
- srv.connections = map[net.Conn]struct{}{}
- for {
- select {
- case conn := <-add:
- srv.connections[conn] = struct{}{}
- case conn := <-remove:
- delete(srv.connections, conn)
- if done != nil && len(srv.connections) == 0 {
- done <- struct{}{}
- return
- }
- case done = <-shutdown:
- if len(srv.connections) == 0 {
- done <- struct{}{}
- return
- }
- case <-kill:
- for k := range srv.connections {
- _ = k.Close() // nothing to do here if it errors
- }
- return
- }
- }
- }
-}
-
-func (srv *Server) interruptChan() chan os.Signal {
- srv.stopLock.Lock()
- if srv.interrupt == nil {
- srv.interrupt = make(chan os.Signal, 1)
- }
- srv.stopLock.Unlock()
-
- return srv.interrupt
-}
-
-func (srv *Server) handleInterrupt(interrupt chan os.Signal, listener net.Listener) {
- <-interrupt
-
- srv.SetKeepAlivesEnabled(false)
- _ = listener.Close() // we are shutting down anyway. ignore error.
-
- if srv.ShutdownInitiated != nil {
- srv.ShutdownInitiated()
- }
-
- signal.Stop(interrupt)
- close(interrupt)
-}
-
-func (srv *Server) shutdown(shutdown chan chan struct{}, kill chan struct{}) {
- // Request done notification
- done := make(chan struct{})
- shutdown <- done
-
- if srv.Timeout > 0 {
- select {
- case <-done:
- case <-time.After(srv.Timeout):
- close(kill)
- }
- } else {
- <-done
- }
- // Close the stopChan to wake up any blocked goroutines.
- srv.stopLock.Lock()
- if srv.stopChan != nil {
- close(srv.stopChan)
- }
- srv.stopLock.Unlock()
-}
diff --git a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful_test.go b/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful_test.go
deleted file mode 100644
index c7382736c1cd74ac6b4a18857d7eecd470f8251c..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/graceful_test.go
+++ /dev/null
@@ -1,379 +0,0 @@
-package graceful
-
-import (
- "fmt"
- "io"
- "net"
- "net/http"
- "net/url"
- "os"
- "reflect"
- "sync"
- "syscall"
- "testing"
- "time"
-)
-
-var (
- killTime = 500 * time.Millisecond
- timeoutTime = 1000 * time.Millisecond
- waitTime = 100 * time.Millisecond
-)
-
-func runQuery(t *testing.T, expected int, shouldErr bool, wg *sync.WaitGroup, once *sync.Once) {
- wg.Add(1)
- defer wg.Done()
- client := http.Client{}
- r, err := client.Get("http://localhost:3000")
- if shouldErr && err == nil {
- once.Do(func() {
- t.Fatal("Expected an error but none was encountered.")
- })
- } else if shouldErr && err != nil {
- if checkErr(t, err, once) {
- return
- }
- }
- if r != nil && r.StatusCode != expected {
- once.Do(func() {
- t.Fatalf("Incorrect status code on response. Expected %d. Got %d", expected, r.StatusCode)
- })
- } else if r == nil {
- once.Do(func() {
- t.Fatal("No response when a response was expected.")
- })
- }
-}
-
-func checkErr(t *testing.T, err error, once *sync.Once) bool {
- if err.(*url.Error).Err == io.EOF {
- return true
- }
- errno := err.(*url.Error).Err.(*net.OpError).Err.(syscall.Errno)
- if errno == syscall.ECONNREFUSED {
- return true
- } else if err != nil {
- once.Do(func() {
- t.Fatal("Error on Get:", err)
- })
- }
- return false
-}
-
-func createListener(sleep time.Duration) (*http.Server, net.Listener, error) {
- mux := http.NewServeMux()
- mux.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
- time.Sleep(sleep)
- rw.WriteHeader(http.StatusOK)
- })
-
- server := &http.Server{Addr: ":3000", Handler: mux}
- l, err := net.Listen("tcp", ":3000")
- if err != nil {
- fmt.Println(err)
- }
- return server, l, err
-}
-
-func runServer(timeout, sleep time.Duration, c chan os.Signal) error {
- server, l, err := createListener(sleep)
- if err != nil {
- return err
- }
-
- srv := &Server{Timeout: timeout, Server: server, interrupt: c}
- return srv.Serve(l)
-}
-
-func launchTestQueries(t *testing.T, wg *sync.WaitGroup, c chan os.Signal) {
- var once sync.Once
- for i := 0; i < 8; i++ {
- go runQuery(t, http.StatusOK, false, wg, &once)
- }
-
- time.Sleep(waitTime)
- c <- os.Interrupt
- time.Sleep(waitTime)
-
- for i := 0; i < 8; i++ {
- go runQuery(t, 0, true, wg, &once)
- }
-
- wg.Done()
-}
-
-func TestGracefulRun(t *testing.T) {
- c := make(chan os.Signal, 1)
-
- var wg sync.WaitGroup
- wg.Add(1)
-
- go func() {
- runServer(killTime, killTime/2, c)
- wg.Done()
- }()
-
- wg.Add(1)
- go launchTestQueries(t, &wg, c)
- wg.Wait()
-}
-
-func TestGracefulRunTimesOut(t *testing.T) {
- c := make(chan os.Signal, 1)
-
- var wg sync.WaitGroup
- wg.Add(1)
-
- go func() {
- runServer(killTime, killTime*10, c)
- wg.Done()
- }()
-
- var once sync.Once
- wg.Add(1)
- go func() {
- for i := 0; i < 8; i++ {
- go runQuery(t, 0, true, &wg, &once)
- }
- time.Sleep(waitTime)
- c <- os.Interrupt
- time.Sleep(waitTime)
- for i := 0; i < 8; i++ {
- go runQuery(t, 0, true, &wg, &once)
- }
- wg.Done()
- }()
-
- wg.Wait()
-
-}
-
-func TestGracefulRunDoesntTimeOut(t *testing.T) {
- c := make(chan os.Signal, 1)
-
- var wg sync.WaitGroup
- wg.Add(1)
-
- go func() {
- runServer(0, killTime*2, c)
- wg.Done()
- }()
-
- wg.Add(1)
- go launchTestQueries(t, &wg, c)
- wg.Wait()
-}
-
-func TestGracefulRunNoRequests(t *testing.T) {
- c := make(chan os.Signal, 1)
-
- var wg sync.WaitGroup
- wg.Add(1)
-
- go func() {
- runServer(0, killTime*2, c)
- wg.Done()
- }()
-
- c <- os.Interrupt
-
- wg.Wait()
-
-}
-
-func TestGracefulForwardsConnState(t *testing.T) {
- c := make(chan os.Signal, 1)
- states := make(map[http.ConnState]int)
- var stateLock sync.Mutex
-
- connState := func(conn net.Conn, state http.ConnState) {
- stateLock.Lock()
- states[state]++
- stateLock.Unlock()
- }
-
- var wg sync.WaitGroup
- wg.Add(1)
-
- expected := map[http.ConnState]int{
- http.StateNew: 8,
- http.StateActive: 8,
- http.StateClosed: 8,
- }
-
- go func() {
- server, l, _ := createListener(killTime / 2)
- srv := &Server{
- ConnState: connState,
- Timeout: killTime,
- Server: server,
- interrupt: c,
- }
- srv.Serve(l)
-
- wg.Done()
- }()
-
- wg.Add(1)
- go launchTestQueries(t, &wg, c)
- wg.Wait()
-
- stateLock.Lock()
- if !reflect.DeepEqual(states, expected) {
- t.Errorf("Incorrect connection state tracking.\n actual: %v\nexpected: %v\n", states, expected)
- }
- stateLock.Unlock()
-}
-
-func TestGracefulExplicitStop(t *testing.T) {
- server, l, err := createListener(1 * time.Millisecond)
- if err != nil {
- t.Fatal(err)
- }
-
- srv := &Server{Timeout: killTime, Server: server}
-
- go func() {
- go srv.Serve(l)
- time.Sleep(waitTime)
- srv.Stop(killTime)
- }()
-
- // block on the stopChan until the server has shut down
- select {
- case <-srv.StopChan():
- case <-time.After(timeoutTime):
- t.Fatal("Timed out while waiting for explicit stop to complete")
- }
-}
-
-func TestGracefulExplicitStopOverride(t *testing.T) {
- server, l, err := createListener(1 * time.Millisecond)
- if err != nil {
- t.Fatal(err)
- }
-
- srv := &Server{Timeout: killTime, Server: server}
-
- go func() {
- go srv.Serve(l)
- time.Sleep(waitTime)
- srv.Stop(killTime / 2)
- }()
-
- // block on the stopChan until the server has shut down
- select {
- case <-srv.StopChan():
- case <-time.After(killTime):
- t.Fatal("Timed out while waiting for explicit stop to complete")
- }
-}
-
-func TestShutdownInitiatedCallback(t *testing.T) {
- server, l, err := createListener(1 * time.Millisecond)
- if err != nil {
- t.Fatal(err)
- }
-
- called := make(chan struct{})
- cb := func() { close(called) }
-
- srv := &Server{Server: server, ShutdownInitiated: cb}
-
- go func() {
- go srv.Serve(l)
- time.Sleep(waitTime)
- srv.Stop(killTime)
- }()
-
- select {
- case <-called:
- case <-time.After(killTime):
- t.Fatal("Timed out while waiting for ShutdownInitiated callback to be called")
- }
-}
-func hijackingListener(srv *Server) (*http.Server, net.Listener, error) {
- mux := http.NewServeMux()
- mux.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
- conn, bufrw, err := rw.(http.Hijacker).Hijack()
- if err != nil {
- http.Error(rw, "webserver doesn't support hijacking", http.StatusInternalServerError)
- return
- }
-
- defer conn.Close()
-
- bufrw.WriteString("HTTP/1.1 200 OK\r\n\r\n")
- bufrw.Flush()
- })
-
- server := &http.Server{Addr: ":3000", Handler: mux}
- l, err := net.Listen("tcp", ":3000")
- return server, l, err
-}
-
-func TestNotifyClosed(t *testing.T) {
- c := make(chan os.Signal, 1)
-
- var wg sync.WaitGroup
- wg.Add(1)
-
- srv := &Server{Timeout: killTime, interrupt: c}
- server, l, err := hijackingListener(srv)
- if err != nil {
- t.Fatal(err)
- }
-
- srv.Server = server
-
- go func() {
- srv.Serve(l)
- wg.Done()
- }()
-
- var once sync.Once
- for i := 0; i < 8; i++ {
- runQuery(t, http.StatusOK, false, &wg, &once)
- }
-
- srv.Stop(0)
-
- // block on the stopChan until the server has shut down
- select {
- case <-srv.StopChan():
- case <-time.After(timeoutTime):
- t.Fatal("Timed out while waiting for explicit stop to complete")
- }
-
- if len(srv.connections) > 0 {
- t.Fatal("hijacked connections should not be managed")
- }
-
-}
-
-func TestStopDeadlock(t *testing.T) {
- c := make(chan struct{})
-
- server, l, err := createListener(1 * time.Millisecond)
- if err != nil {
- t.Fatal(err)
- }
-
- srv := &Server{Server: server, NoSignalHandling: true}
-
- go func() {
- time.Sleep(waitTime)
- srv.Serve(l)
- }()
-
- go func() {
- srv.Stop(0)
- close(c)
- }()
-
- select {
- case <-c:
- case <-time.After(timeoutTime):
- t.Fatal("Timed out while waiting for explicit stop to complete")
- }
-}
diff --git a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/tests/main.go b/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/tests/main.go
deleted file mode 100644
index 8c8fa204605104c47d7e982b48c27c0a05ff60e5..0000000000000000000000000000000000000000
--- a/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1/tests/main.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package main
-
-import (
- "fmt"
- "sync"
-
- "github.com/codegangsta/negroni"
- "github.com/tylerb/graceful"
-)
-
-func main() {
-
- var wg sync.WaitGroup
-
- wg.Add(3)
- go func() {
- n := negroni.New()
- fmt.Println("Launching server on :3000")
- graceful.Run(":3000", 0, n)
- fmt.Println("Terminated server on :3000")
- wg.Done()
- }()
- go func() {
- n := negroni.New()
- fmt.Println("Launching server on :3001")
- graceful.Run(":3001", 0, n)
- fmt.Println("Terminated server on :3001")
- wg.Done()
- }()
- go func() {
- n := negroni.New()
- fmt.Println("Launching server on :3002")
- graceful.Run(":3002", 0, n)
- fmt.Println("Terminated server on :3002")
- wg.Done()
- }()
- fmt.Println("Press ctrl+c. All servers should terminate.")
- wg.Wait()
-
-}
diff --git a/client/ws_client.go b/client/ws_client.go
index d07d9598bb355d928a8f9f6d2e7b4f553786e2cd..2f562927f6a99bb19852570f46b185f0e3da6c7b 100644
--- a/client/ws_client.go
+++ b/client/ws_client.go
@@ -3,7 +3,7 @@ package client
import (
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gorilla/websocket"
+ "github.com/gorilla/websocket"
"net/http"
)
diff --git a/cmd/erisdbss/main.go b/cmd/erisdbss/main.go
index ce3283363748e31e8a612bd8b8d4a4f360aac461..69e5542e17a0bb17b733b16a336dec9573aa81fa 100644
--- a/cmd/erisdbss/main.go
+++ b/cmd/erisdbss/main.go
@@ -1,7 +1,7 @@
package main
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/gin-gonic/gin"
ess "github.com/eris-ltd/eris-db/erisdb/erisdbss"
"github.com/eris-ltd/eris-db/server"
"os"
diff --git a/erisdb/codec.go b/erisdb/codec.go
index 3d7bece602f1135d16d21eff23c7c31904119f1e..e47a13559c8b50296576a4ab30bb6f4322196692 100644
--- a/erisdb/codec.go
+++ b/erisdb/codec.go
@@ -1,7 +1,7 @@
package erisdb
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
+ "github.com/tendermint/tendermint/binary"
rpc "github.com/eris-ltd/eris-db/rpc"
"io"
"io/ioutil"
diff --git a/erisdb/erisdbss/http.go b/erisdb/erisdbss/http.go
index abd0d1f310ee8a749321a47a29ff4c19a49eee71..3c447f4779b63b2459c1b3c6700c785a67ffd504 100644
--- a/erisdb/erisdbss/http.go
+++ b/erisdb/erisdbss/http.go
@@ -3,10 +3,10 @@ package erisdbss
import (
"bytes"
"encoding/json"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
- . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/gin-gonic/gin"
+ "github.com/tendermint/tendermint/binary"
+ . "github.com/tendermint/tendermint/common"
+ "github.com/tendermint/tendermint/state"
"github.com/eris-ltd/eris-db/server"
"net/http"
"os"
diff --git a/erisdb/erisdbss/log.go b/erisdb/erisdbss/log.go
index 37760e9c26334c5751d2e5da0200e196234cda2c..719216427a0cbd239e0ae187dcfac8bf14604a72 100644
--- a/erisdb/erisdbss/log.go
+++ b/erisdb/erisdbss/log.go
@@ -1,7 +1,7 @@
package erisdbss
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ "github.com/tendermint/log15"
)
var log = log15.New("module", "eris/serverserver")
diff --git a/erisdb/erisdbss/server_manager.go b/erisdb/erisdbss/server_manager.go
index f6f958621134cf8608ae4d2a80202843fb2fc5db..485689c5d2a606b2516e1ce830d0fda398ad5e92 100644
--- a/erisdb/erisdbss/server_manager.go
+++ b/erisdb/erisdbss/server_manager.go
@@ -3,8 +3,8 @@ package erisdbss
import (
"bufio"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
- . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
+ "github.com/tendermint/tendermint/binary"
+ . "github.com/tendermint/tendermint/common"
"github.com/eris-ltd/eris-db/files"
"github.com/eris-ltd/eris-db/server"
"os"
diff --git a/erisdb/event_cache_test.go b/erisdb/event_cache_test.go
index c1532adb07f3498f531c7c605381437d4e47711d..5dc824588b76e33bd88c9e40e5e27a301dc3d52e 100644
--- a/erisdb/event_cache_test.go
+++ b/erisdb/event_cache_test.go
@@ -3,7 +3,7 @@ package erisdb
import (
"encoding/hex"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/assert"
"runtime"
"testing"
"time"
diff --git a/erisdb/json_service.go b/erisdb/json_service.go
index 887d270709e7269d68166bc9c1e690f0923e8640..b15426770f4d1f2190202f8f3d9544f4170bcbf8 100644
--- a/erisdb/json_service.go
+++ b/erisdb/json_service.go
@@ -3,7 +3,7 @@ package erisdb
import (
"encoding/json"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
+ "github.com/gin-gonic/gin"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
rpc "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
diff --git a/erisdb/methods.go b/erisdb/methods.go
index 95871fb7af676050e98cdd8e64e6f267e0645de1..ebee38d535ee97c457f5329bc95b8f8785289baf 100644
--- a/erisdb/methods.go
+++ b/erisdb/methods.go
@@ -4,7 +4,7 @@ import (
"crypto/rand"
"encoding/hex"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/tendermint/tendermint/types"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
rpc "github.com/eris-ltd/eris-db/rpc"
"strings"
diff --git a/erisdb/middleware_test.go b/erisdb/middleware_test.go
index 6a40a277d2b4ace7397da1180540628dca325f98..3a320ca3627fa99f0f482f587f26c6d1320f8e17 100644
--- a/erisdb/middleware_test.go
+++ b/erisdb/middleware_test.go
@@ -1,7 +1,7 @@
package erisdb
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/assert"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
"testing"
)
diff --git a/erisdb/params.go b/erisdb/params.go
index dc0c532af12b6286e11ce471b1a0f68851186f1c..9c14801a61f063338af085620f565bf1aca546a9 100644
--- a/erisdb/params.go
+++ b/erisdb/params.go
@@ -1,8 +1,8 @@
package erisdb
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/tendermint/tendermint/account"
+ "github.com/tendermint/tendermint/types"
"github.com/eris-ltd/eris-db/erisdb/pipe"
)
diff --git a/erisdb/pipe/accounts.go b/erisdb/pipe/accounts.go
index 081cd242d4f60cda0904856614e50e3be00665e5..17e80e89432d3315290912c5b7406cc432bdff08 100644
--- a/erisdb/pipe/accounts.go
+++ b/erisdb/pipe/accounts.go
@@ -4,10 +4,10 @@ import (
"bytes"
"encoding/hex"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
- cmn "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
- cs "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
- mempl "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool"
+ "github.com/tendermint/tendermint/account"
+ cmn "github.com/tendermint/tendermint/common"
+ cs "github.com/tendermint/tendermint/consensus"
+ mempl "github.com/tendermint/tendermint/mempool"
"sync"
)
diff --git a/erisdb/pipe/blockchain.go b/erisdb/pipe/blockchain.go
index b0704d7cf571a2fd192649420e7de16a2bbcd02b..aaebbf887afb95abdf26fab857b67d34b26778d4 100644
--- a/erisdb/pipe/blockchain.go
+++ b/erisdb/pipe/blockchain.go
@@ -2,10 +2,10 @@ package pipe
import (
"fmt"
- bc "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/blockchain"
- dbm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/db"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ bc "github.com/tendermint/tendermint/blockchain"
+ dbm "github.com/tendermint/tendermint/db"
+ "github.com/tendermint/tendermint/state"
+ "github.com/tendermint/tendermint/types"
"math"
"strconv"
"strings"
diff --git a/erisdb/pipe/config.go b/erisdb/pipe/config.go
index a7e51520ff5f6865287a991ba815d026b10e4f78..3a2f232116c0dc7c828bd8aeed9b4f493fd2448c 100644
--- a/erisdb/pipe/config.go
+++ b/erisdb/pipe/config.go
@@ -1,8 +1,8 @@
package pipe
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
- cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
+ "github.com/tendermint/log15"
+ cfg "github.com/tendermint/tendermint/config"
)
var log = log15.New("module", "eris/erisdb_pipe")
diff --git a/erisdb/pipe/consensus.go b/erisdb/pipe/consensus.go
index 344dc877427d3e9eac4023699e36f3a6862dc463..324e17b19931430893f9ca66cb8bf1a0b1c23fe9 100644
--- a/erisdb/pipe/consensus.go
+++ b/erisdb/pipe/consensus.go
@@ -1,10 +1,10 @@
package pipe
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/binary"
- cm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/tendermint/tendermint/binary"
+ cm "github.com/tendermint/tendermint/consensus"
+ "github.com/tendermint/tendermint/p2p"
+ "github.com/tendermint/tendermint/state"
)
// The consensus struct.
diff --git a/erisdb/pipe/events.go b/erisdb/pipe/events.go
index 9171ea5146fe9f397c5b1e73f77e3171b8371a94..7f145897634a7dd54e8c97d537a325e5db8e91d7 100644
--- a/erisdb/pipe/events.go
+++ b/erisdb/pipe/events.go
@@ -1,7 +1,7 @@
package pipe
import (
- evts "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/events"
+ evts "github.com/tendermint/tendermint/events"
)
// TODO improve
diff --git a/erisdb/pipe/net.go b/erisdb/pipe/net.go
index 914b49d1f4022b8f4577502947470220615f0002..fe7b6e6f3c0445483b7aaad8f35c193980ef5c01 100644
--- a/erisdb/pipe/net.go
+++ b/erisdb/pipe/net.go
@@ -1,7 +1,7 @@
package pipe
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
+ "github.com/tendermint/tendermint/p2p"
)
// The net struct.
diff --git a/erisdb/pipe/pipe.go b/erisdb/pipe/pipe.go
index a3526895791668b1551665c2ae682529038ed518..d5569211b287a39af0238eb9ca9232c027ebf47f 100644
--- a/erisdb/pipe/pipe.go
+++ b/erisdb/pipe/pipe.go
@@ -2,9 +2,9 @@
package pipe
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/node"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/tendermint/tendermint/account"
+ "github.com/tendermint/tendermint/node"
+ "github.com/tendermint/tendermint/types"
)
type (
diff --git a/erisdb/pipe/transactor.go b/erisdb/pipe/transactor.go
index 81d536f6c93926fdbb6829483e52fd725806adec..5fe910cef5a8ae1288281513f373bb7468510158 100644
--- a/erisdb/pipe/transactor.go
+++ b/erisdb/pipe/transactor.go
@@ -3,13 +3,13 @@ package pipe
import (
"encoding/hex"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
- cmn "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
- cs "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
- mempl "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/mempool"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/vm"
+ "github.com/tendermint/tendermint/account"
+ cmn "github.com/tendermint/tendermint/common"
+ cs "github.com/tendermint/tendermint/consensus"
+ mempl "github.com/tendermint/tendermint/mempool"
+ "github.com/tendermint/tendermint/state"
+ "github.com/tendermint/tendermint/types"
+ "github.com/tendermint/tendermint/vm"
"sync"
)
diff --git a/erisdb/pipe/types.go b/erisdb/pipe/types.go
index bf75a020ab7ed865cabdb92db4d6e644d0d0c8f2..2901ec7107a702bb766d582b5c8413f5b31b67bb 100644
--- a/erisdb/pipe/types.go
+++ b/erisdb/pipe/types.go
@@ -1,11 +1,11 @@
package pipe
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
- csus "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus"
- ctypes "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/consensus/types"
- sm "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/tendermint/tendermint/account"
+ csus "github.com/tendermint/tendermint/consensus"
+ ctypes "github.com/tendermint/tendermint/consensus/types"
+ sm "github.com/tendermint/tendermint/state"
+ "github.com/tendermint/tendermint/types"
)
type (
diff --git a/erisdb/restServer.go b/erisdb/restServer.go
index b7821f8ae7a165165617ecc89d7067494be51082..620a7c18292827f34fb3c0d2745527c89681e1ad 100644
--- a/erisdb/restServer.go
+++ b/erisdb/restServer.go
@@ -3,8 +3,8 @@ package erisdb
import (
"encoding/hex"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/gin-gonic/gin"
+ "github.com/tendermint/tendermint/types"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
rpc "github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
diff --git a/erisdb/serve.go b/erisdb/serve.go
index b40fcfcb35ae4a774e89292e03c6cab01f935343..56ea5d32654f873c2ea657c48472304d36110d59 100644
--- a/erisdb/serve.go
+++ b/erisdb/serve.go
@@ -3,12 +3,12 @@
package erisdb
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
- . "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/common"
- cfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config"
- tmcfg "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/config/tendermint"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/node"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/p2p"
+ "github.com/tendermint/log15"
+ . "github.com/tendermint/tendermint/common"
+ cfg "github.com/tendermint/tendermint/config"
+ tmcfg "github.com/tendermint/tendermint/config/tendermint"
+ "github.com/tendermint/tendermint/node"
+ "github.com/tendermint/tendermint/p2p"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
"github.com/eris-ltd/eris-db/server"
"path"
diff --git a/files/files_test.go b/files/files_test.go
index bdfa44265a19b727a8ef9dad251632bcaec26f18..2d9cdc23ed1646f3acb242904015df3ba1418945 100644
--- a/files/files_test.go
+++ b/files/files_test.go
@@ -2,7 +2,7 @@ package files
import (
"bytes"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/assert"
"os"
"path"
"testing"
diff --git a/files/log.go b/files/log.go
index 9067bf137b741db2a06094b0de429054bfcc493e..a18f6b6a6ec7420d469269b33832a2e5cc277a43 100644
--- a/files/log.go
+++ b/files/log.go
@@ -1,7 +1,7 @@
package files
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ "github.com/tendermint/log15"
)
var log = log15.New("module", "eris/server/files")
diff --git a/rpc/rpc_test.go b/rpc/rpc_test.go
index a5debf5f78621a45beda0440ebcd95fbfe9bc8e6..bfafa4c2f9861f01192de0ad9b9aba05897d304d 100644
--- a/rpc/rpc_test.go
+++ b/rpc/rpc_test.go
@@ -1,7 +1,7 @@
package rpc
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/assert"
"testing"
)
diff --git a/server/config.go b/server/config.go
index d50d7dd93087675d4cb4e70753932de9d3945446..340182a36605c65ef139dfead1f8262b2c559af0 100644
--- a/server/config.go
+++ b/server/config.go
@@ -1,7 +1,7 @@
package server
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/naoina/toml"
+ "github.com/naoina/toml"
"github.com/eris-ltd/eris-db/files"
)
diff --git a/server/log.go b/server/log.go
index 09e6fbdad3708856ff9bfa14bc8e2236a99ba1eb..aacad33d92109b6353e54b91b438b3f2f7e746f3 100644
--- a/server/log.go
+++ b/server/log.go
@@ -1,7 +1,7 @@
package server
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ "github.com/tendermint/log15"
)
var log = log15.New("module", "eris/server")
diff --git a/server/logging.go b/server/logging.go
index 8b1ba444e437a70995ea69461d4d3c31e0500228..a5a70031af162f749641075bd1dd01e32087946e 100644
--- a/server/logging.go
+++ b/server/logging.go
@@ -2,7 +2,7 @@ package server
import (
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ "github.com/tendermint/log15"
"os"
)
diff --git a/server/server.go b/server/server.go
index e3e334c6b897b72930f4a41f2cf5c2a628954c3c..aa4004f17738e095346d3f48ed970422ac8fa5a5 100644
--- a/server/server.go
+++ b/server/server.go
@@ -3,9 +3,9 @@ package server
import (
"crypto/tls"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- cors "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tommy351/gin-cors"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/gopkg.in/tylerb/graceful.v1"
+ "github.com/gin-gonic/gin"
+ cors "github.com/tommy351/gin-cors"
+ "gopkg.in/tylerb/graceful.v1"
"net"
"net/http"
"time"
diff --git a/server/server_test.go b/server/server_test.go
index a857e6af249d14d3954ac42e80c98ee7a8b18ae1..6a1a2c784f2375c874cd25ea88c2e5d8bf86a64c 100644
--- a/server/server_test.go
+++ b/server/server_test.go
@@ -2,7 +2,7 @@ package server
import (
//"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/assert"
"testing"
)
diff --git a/server/websocket.go b/server/websocket.go
index 3925a549c5d737ffe31362965f5c711c8541ba5a..06e1a6c226b23504f4ad5e48d225198b462171a3 100644
--- a/server/websocket.go
+++ b/server/websocket.go
@@ -2,8 +2,8 @@ package server
import (
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gorilla/websocket"
+ "github.com/gin-gonic/gin"
+ "github.com/gorilla/websocket"
"net/http"
"sync"
"time"
diff --git a/test/filters/filter_test.go b/test/filters/filter_test.go
index adfbc98b2918a47670718af17f831ff86b9c199e..ba0905f2d9f1710b82a46d230ac68fec15ca4e1a 100644
--- a/test/filters/filter_test.go
+++ b/test/filters/filter_test.go
@@ -2,7 +2,7 @@ package filters
import (
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/suite"
+ "github.com/stretchr/testify/suite"
. "github.com/eris-ltd/eris-db/erisdb/pipe"
"sync"
"testing"
diff --git a/test/mock/mock_web_api_test.go b/test/mock/mock_web_api_test.go
index c0421b7d845ef83fe4ac7a7509ce6a4219bb1a6b..738d6feb62f704f6e186305a7663d5b3e63db24e 100644
--- a/test/mock/mock_web_api_test.go
+++ b/test/mock/mock_web_api_test.go
@@ -5,10 +5,10 @@ import (
"bytes"
"fmt"
// edb "github.com/eris-ltd/erisdb/erisdb"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/suite"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/suite"
+ "github.com/tendermint/log15"
+ "github.com/tendermint/tendermint/account"
edb "github.com/eris-ltd/eris-db/erisdb"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
"github.com/eris-ltd/eris-db/rpc"
diff --git a/test/mock/pipe.go b/test/mock/pipe.go
index bbfa1e9c0db3cae253761b12a1f86d966501f374..835bd8e51740c23eaf5d9220ae289cfbfa58031e 100644
--- a/test/mock/pipe.go
+++ b/test/mock/pipe.go
@@ -1,8 +1,8 @@
package mock
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/tendermint/tendermint/account"
+ "github.com/tendermint/tendermint/types"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
td "github.com/eris-ltd/eris-db/test/testdata/testdata"
)
diff --git a/test/server/http_burst_test.go b/test/server/http_burst_test.go
index cc415a0e7aefdedbaff975774ca8ab0f88b312e2..2ac5dbcc09a8201c2bde87e2f2114587205408ff 100644
--- a/test/server/http_burst_test.go
+++ b/test/server/http_burst_test.go
@@ -2,7 +2,7 @@ package server
import (
// "fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/assert"
"net/http"
"testing"
"time"
diff --git a/test/server/scumbag.go b/test/server/scumbag.go
index dbf50eff00cb111f2eb1e60fea15286c7e361e01..807206012dc390c919a5c88dd26c64c7abb29d65 100644
--- a/test/server/scumbag.go
+++ b/test/server/scumbag.go
@@ -2,8 +2,8 @@ package server
import (
"encoding/json"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ "github.com/gin-gonic/gin"
+ "github.com/tendermint/log15"
"github.com/eris-ltd/eris-db/rpc"
"github.com/eris-ltd/eris-db/server"
"os"
diff --git a/test/server/ws_burst_test.go b/test/server/ws_burst_test.go
index 709172984a8e6c209dc50f2d88723b03866097e9..b46ef89b9c0c36fff5d1162b6312898374851bd7 100644
--- a/test/server/ws_burst_test.go
+++ b/test/server/ws_burst_test.go
@@ -1,7 +1,7 @@
package server
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/assert"
"github.com/eris-ltd/eris-db/client"
"github.com/eris-ltd/eris-db/server"
"testing"
diff --git a/test/testdata/filters/testdata_filters.go b/test/testdata/filters/testdata_filters.go
index 51bd863397734d106f8c5484096c27329c5a136b..a6ab388e76f10316d21c6f484ffc8bb25903c3c6 100644
--- a/test/testdata/filters/testdata_filters.go
+++ b/test/testdata/filters/testdata_filters.go
@@ -3,7 +3,7 @@ package filters
import (
edb "github.com/eris-ltd/eris-db/erisdb"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
+ "github.com/tendermint/tendermint/state"
)
var testDataJson = `{
diff --git a/test/testdata/testdata/testdata.go b/test/testdata/testdata/testdata.go
index 1ba598b4611e9e4cd4e840bf7bcd4fc32ae79033..9b818cfa7cce59fc1d709f1575645cbb7ea76b1e 100644
--- a/test/testdata/testdata/testdata.go
+++ b/test/testdata/testdata/testdata.go
@@ -3,9 +3,9 @@ package testdata
import (
edb "github.com/eris-ltd/eris-db/erisdb"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/state"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/types"
+ "github.com/tendermint/tendermint/account"
+ "github.com/tendermint/tendermint/state"
+ "github.com/tendermint/tendermint/types"
)
var testDataJson = `{
diff --git a/test/web_api/query_test.go b/test/web_api/query_test.go
index acfa17eebe72e5a45b3259cabee27afab4454bce..82e3721045cccad6270f3c9d99cc74acc1a8c7c1 100644
--- a/test/web_api/query_test.go
+++ b/test/web_api/query_test.go
@@ -4,7 +4,7 @@ package web_api
import (
"bytes"
"fmt"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/suite"
+ "github.com/stretchr/testify/suite"
edb "github.com/eris-ltd/eris-db/erisdb"
ess "github.com/eris-ltd/eris-db/erisdb/erisdbss"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
diff --git a/test/web_api/shared.go b/test/web_api/shared.go
index d2571aa3cc85549b4cca7b83b29cab588b531809..de34827b995e168e66098ec923350dd54b9d0b37 100644
--- a/test/web_api/shared.go
+++ b/test/web_api/shared.go
@@ -1,8 +1,8 @@
package web_api
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/log15"
+ "github.com/gin-gonic/gin"
+ "github.com/tendermint/log15"
"os"
"runtime"
)
diff --git a/test/web_api/web_api_test.go b/test/web_api/web_api_test.go
index da93f9ec17a697529f562f3c059a074339143c23..ac55fccb407c769c1156aadfa41bd29c37172f48 100644
--- a/test/web_api/web_api_test.go
+++ b/test/web_api/web_api_test.go
@@ -5,9 +5,9 @@ import (
"bytes"
"fmt"
// edb "github.com/eris-ltd/erisdb/erisdb"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/suite"
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/tendermint/tendermint/account"
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/suite"
+ "github.com/tendermint/tendermint/account"
edb "github.com/eris-ltd/eris-db/erisdb"
ess "github.com/eris-ltd/eris-db/erisdb/erisdbss"
ep "github.com/eris-ltd/eris-db/erisdb/pipe"
diff --git a/util/util_test.go b/util/util_test.go
index 69046d219592a4d071331a09855db0c998003e56..deef5ebb81a9af2c5fe4074d10662ebab3bdb145 100644
--- a/util/util_test.go
+++ b/util/util_test.go
@@ -1,7 +1,7 @@
package util
import (
- "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/assert"
"testing"
)