diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index f0a33c711e2121593f25171e3fb936002e887628..94e08004dae08ec961fc140d9a9e4d54d1d266bd 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -2,7 +2,7 @@
"ImportPath": "github.com/eris-ltd/eris-db",
"GoVersion": "go1.5.1",
"Packages": [
- "./cmd/erisdb/..."
+ "./..."
],
"Deps": [
{
@@ -65,6 +65,14 @@
"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": "63c9e642efad852f49e20a6f90194cae112fd2ac"
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/auth_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/auth_test.go
index b22d9ced6a77a400755c687a7e87cdaf2b9d4d5d..8fc2f233d7a7dd71a0d08c21ffd115645df8e061 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/auth_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/auth_test.go
@@ -10,7 +10,7 @@ import (
"net/http/httptest"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func TestBasicAuth(t *testing.T) {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding_test.go
index db1678e425527c726f1be3aba0d379f059aec9f7..8c25afd980a9f9ac36e0b9e65d9a4cf8285d5c5b 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/binding_test.go
@@ -9,7 +9,7 @@ import (
"net/http"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
type FooStruct struct {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/validate_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/validate_test.go
index 27ba7b6671d5fc9ebd7dc8fe80a5c58b4c5adb62..8ab0bc5246ace0820bcacb3b6a5d5763124b38c6 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/validate_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/binding/validate_test.go
@@ -7,7 +7,7 @@ package binding
import (
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
type struct1 struct {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/context_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/context_test.go
index bae3a2fe214abc5c12a1b7a7c408e850445235e3..9e9f3dda4b8ea983c96fd42c1b3ff4a302d07414 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/context_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/context_test.go
@@ -15,7 +15,7 @@ import (
"time"
"github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/manucorporat/sse"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
// Unit tests TODO
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/debug_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/debug_test.go
index 425aff0fe7f64b855455fda54fde40bfecd0f2bc..ea5896167769f444debeba3e88e60675f641c5a6 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/debug_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/debug_test.go
@@ -12,7 +12,7 @@ import (
"os"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
// TODO
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/errors_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/errors_test.go
index 748e3fe059f116de02e8d0b394b2bbe314fc5292..aa7cc3ddc05bbc39c8ea1bf13c4d56e2ef11a39c 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/errors_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/errors_test.go
@@ -9,7 +9,7 @@ import (
"errors"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func TestError(t *testing.T) {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_integration_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_integration_test.go
index f7ae0758e08892803d3eee5353b01266e3939cdc..fe2fe754249a0cf4762696477f67ca7b8467582a 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_integration_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_integration_test.go
@@ -10,7 +10,7 @@ import (
"testing"
"time"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func TestRun(t *testing.T) {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_test.go
index fc9e821233d5de654c3b8fdf9b2d08161f7a7211..96cbf572c31260b1880cf28b1daab1ef9991ddeb 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/gin_test.go
@@ -8,7 +8,7 @@ import (
"reflect"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
//TODO
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/githubapi_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/githubapi_test.go
index 2227fa6ae8fcf61d919a02873f095bc58048d168..fe2328246665397d8cbb28ec0547c708a78e3919 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/githubapi_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/githubapi_test.go
@@ -12,7 +12,7 @@ import (
"net/http/httptest"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
type route struct {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/logger_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/logger_test.go
index 1cdaa94cb5d31f220c6e08cd694256a88980e509..1d4755ec79903e774e1d0b452af8659174ef02be 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/logger_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/logger_test.go
@@ -8,7 +8,7 @@ import (
"bytes"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
//TODO
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/middleware_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/middleware_test.go
index c09a2cb48cb676bedbf8b326b40adb70ae97ade4..8af80d333d5b88142131abf6673c550775adc7f6 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/middleware_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/middleware_test.go
@@ -10,7 +10,7 @@ import (
"testing"
"github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/manucorporat/sse"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func TestMiddlewareGeneralCase(t *testing.T) {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/mode_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/mode_test.go
index 2a23d85e94f5171e4ee9c5d91f374e705ff4b421..8fd7a43b898cfef11a209e6243422396179b1ef1 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/mode_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/mode_test.go
@@ -7,7 +7,7 @@ package gin
import (
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func init() {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/path_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/path_test.go
index 01cb758a4f517a2523f7d06718a8ce7a809944f8..16eb439bdd50fb674223d60479f1e83a4603a5ab 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/path_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/path_test.go
@@ -9,7 +9,7 @@ import (
"runtime"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
var cleanTests = []struct {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery_test.go
index 39e71e816023b0efee4a8e766f957d526e77203a..aae0ef2c0097207d09e7f74ed1533bb7db8f1b9d 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/recovery_test.go
@@ -8,7 +8,7 @@ import (
"bytes"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
// TestPanicInHandler assert that panic has been recovered.
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render_test.go
index 7a6ffb7d5cf28d353cf6b98e9b09d6f552a45236..8be5220ca911c79cf95020d891d729301653b2ed 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/render/render_test.go
@@ -10,7 +10,7 @@ import (
"net/http/httptest"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
// TODO unit tests
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer_test.go
index 7306d192573c53891b53bde3c6fd1f17cdd5662b..ec7133a80d58d24b2cb6176fe610315bf3c139d3 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/response_writer_test.go
@@ -9,7 +9,7 @@ import (
"net/http/httptest"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
// TODO
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup_test.go
index 14c7421bd350aa4c56292af88b41024acb33db35..67f7f8e60e9d8ff8425ace26d93d49f60bc3eb81 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/routergroup_test.go
@@ -7,7 +7,7 @@ package gin
import (
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func init() {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/routes_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/routes_test.go
index 2f451f84eb0bc4ad96eb9029bc1585d95a81c0f6..3f5d23ed4a05dfd05d7c5fd1d76f4490276b9611 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/routes_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/routes_test.go
@@ -13,7 +13,7 @@ import (
"path/filepath"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func performRequest(r http.Handler, method, path string) *httptest.ResponseRecorder {
diff --git a/Godeps/_workspace/src/github.com/gin-gonic/gin/utils_test.go b/Godeps/_workspace/src/github.com/gin-gonic/gin/utils_test.go
index ba0cc20d9db5a9f3a641b2e48282e8a03f5f407d..e2fcf4f4ad3f821708706f54c0c0bd8a976a01d3 100644
--- a/Godeps/_workspace/src/github.com/gin-gonic/gin/utils_test.go
+++ b/Godeps/_workspace/src/github.com/gin-gonic/gin/utils_test.go
@@ -9,7 +9,7 @@ import (
"net/http"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func init() {
diff --git a/Godeps/_workspace/src/github.com/manucorporat/sse/sse_test.go b/Godeps/_workspace/src/github.com/manucorporat/sse/sse_test.go
index b1c2d9bc3a2d55ad6a68ba66f225e415fbc1192c..f1e15440afd80e113863015035c75306fc81888c 100644
--- a/Godeps/_workspace/src/github.com/manucorporat/sse/sse_test.go
+++ b/Godeps/_workspace/src/github.com/manucorporat/sse/sse_test.go
@@ -9,7 +9,7 @@ import (
"net/http/httptest"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func TestEncodeOnlyData(t *testing.T) {
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/LICENCE.txt b/Godeps/_workspace/src/github.com/stretchr/testify/LICENCE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a009ba467ce285c479dc3f4f720d72417893e11b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/LICENCE.txt
@@ -0,0 +1,9 @@
+Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
+
+Please consider promoting this project if you find it useful.
+
+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.
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions.go
new file mode 100644
index 0000000000000000000000000000000000000000..5de1ab11795ca3c4e0085f45e08c5c964b503119
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/assertions.go
@@ -0,0 +1,782 @@
+package assert
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "reflect"
+ "regexp"
+ "runtime"
+ "strings"
+ "time"
+)
+
+// TestingT is an interface wrapper around *testing.T
+type TestingT interface {
+ Errorf(format string, args ...interface{})
+}
+
+// Comparison a custom function that returns true on success and false on failure
+type Comparison func() (success bool)
+
+/*
+ Helper functions
+*/
+
+// ObjectsAreEqual determines if two objects are considered equal.
+//
+// This function does no assertion of any kind.
+func ObjectsAreEqual(expected, actual interface{}) bool {
+
+ if expected == nil || actual == nil {
+ return expected == actual
+ }
+
+ if reflect.DeepEqual(expected, actual) {
+ return true
+ }
+
+ expectedValue := reflect.ValueOf(expected)
+ actualValue := reflect.ValueOf(actual)
+ if expectedValue == actualValue {
+ return true
+ }
+
+ // Attempt comparison after type conversion
+ if actualValue.Type().ConvertibleTo(expectedValue.Type()) && expectedValue == actualValue.Convert(expectedValue.Type()) {
+ return true
+ }
+
+ // Last ditch effort
+ if fmt.Sprintf("%#v", expected) == fmt.Sprintf("%#v", actual) {
+ return true
+ }
+
+ return false
+
+}
+
+/* CallerInfo is necessary because the assert functions use the testing object
+internally, causing it to print the file:line of the assert method, rather than where
+the problem actually occured in calling code.*/
+
+// CallerInfo returns a string containing the file and line number of the assert call
+// that failed.
+func CallerInfo() string {
+
+ file := ""
+ line := 0
+ ok := false
+
+ for i := 0; ; i++ {
+ _, file, line, ok = runtime.Caller(i)
+ if !ok {
+ return ""
+ }
+ parts := strings.Split(file, "/")
+ dir := parts[len(parts)-2]
+ file = parts[len(parts)-1]
+ if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" {
+ break
+ }
+ }
+
+ return fmt.Sprintf("%s:%d", file, line)
+}
+
+// getWhitespaceString returns a string that is long enough to overwrite the default
+// output from the go testing framework.
+func getWhitespaceString() string {
+
+ _, file, line, ok := runtime.Caller(1)
+ if !ok {
+ return ""
+ }
+ parts := strings.Split(file, "/")
+ file = parts[len(parts)-1]
+
+ return strings.Repeat(" ", len(fmt.Sprintf("%s:%d: ", file, line)))
+
+}
+
+func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
+ if len(msgAndArgs) == 0 || msgAndArgs == nil {
+ return ""
+ }
+ if len(msgAndArgs) == 1 {
+ return msgAndArgs[0].(string)
+ }
+ if len(msgAndArgs) > 1 {
+ return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
+ }
+ return ""
+}
+
+// Indents all lines of the message by appending a number of tabs to each line, in an output format compatible with Go's
+// test printing (see inner comment for specifics)
+func indentMessageLines(message string, tabs int) string {
+ outBuf := new(bytes.Buffer)
+
+ for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
+ if i != 0 {
+ outBuf.WriteRune('\n')
+ }
+ for ii := 0; ii < tabs; ii++ {
+ outBuf.WriteRune('\t')
+ // Bizarrely, all lines except the first need one fewer tabs prepended, so deliberately advance the counter
+ // by 1 prematurely.
+ if ii == 0 && i > 0 {
+ ii++
+ }
+ }
+ outBuf.WriteString(scanner.Text())
+ }
+
+ return outBuf.String()
+}
+
+// Fail reports a failure through
+func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool {
+
+ message := messageFromMsgAndArgs(msgAndArgs...)
+
+ if len(message) > 0 {
+ t.Errorf("\r%s\r\tLocation:\t%s\n"+
+ "\r\tError:%s\n"+
+ "\r\tMessages:\t%s\n\r",
+ getWhitespaceString(),
+ CallerInfo(),
+ indentMessageLines(failureMessage, 2),
+ message)
+ } else {
+ t.Errorf("\r%s\r\tLocation:\t%s\n"+
+ "\r\tError:%s\n\r",
+ getWhitespaceString(),
+ CallerInfo(),
+ indentMessageLines(failureMessage, 2))
+ }
+
+ return false
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+// assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject")
+func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+
+ interfaceType := reflect.TypeOf(interfaceObject).Elem()
+
+ if !reflect.TypeOf(object).Implements(interfaceType) {
+ return Fail(t, fmt.Sprintf("Object must implement %v", interfaceType), msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// IsType asserts that the specified objects are of the same type.
+func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+
+ if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) {
+ return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...)
+ }
+
+ return true
+}
+
+// Equal asserts that two objects are equal.
+//
+// assert.Equal(t, 123, 123, "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+ if !ObjectsAreEqual(expected, actual) {
+ return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+
+ " != %#v (actual)", expected, actual), msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+// assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+ aType := reflect.TypeOf(expected)
+ bType := reflect.TypeOf(actual)
+
+ if aType != bType {
+ return Fail(t, "Types expected to match exactly", "%v != %v", aType, bType)
+ }
+
+ return Equal(t, expected, actual, msgAndArgs...)
+
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+// assert.NotNil(t, err, "err should be something")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+ success := true
+
+ if object == nil {
+ success = false
+ } else {
+ value := reflect.ValueOf(object)
+ kind := value.Kind()
+ if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
+ success = false
+ }
+ }
+
+ if !success {
+ Fail(t, "Expected not to be nil.", msgAndArgs...)
+ }
+
+ return success
+}
+
+// isNil checks if a specified object is nil or not, without Failing.
+func isNil(object interface{}) bool {
+ if object == nil {
+ return true
+ }
+
+ value := reflect.ValueOf(object)
+ kind := value.Kind()
+ if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() {
+ return true
+ }
+
+ return false
+}
+
+// Nil asserts that the specified object is nil.
+//
+// assert.Nil(t, err, "err should be nothing")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+ if isNil(object) {
+ return true
+ }
+ return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
+}
+
+var zeros = []interface{}{
+ int(0),
+ int8(0),
+ int16(0),
+ int32(0),
+ int64(0),
+ uint(0),
+ uint8(0),
+ uint16(0),
+ uint32(0),
+ uint64(0),
+ float32(0),
+ float64(0),
+}
+
+// isEmpty gets whether the specified object is considered empty or not.
+func isEmpty(object interface{}) bool {
+
+ if object == nil {
+ return true
+ } else if object == "" {
+ return true
+ } else if object == false {
+ return true
+ }
+
+ for _, v := range zeros {
+ if object == v {
+ return true
+ }
+ }
+
+ objValue := reflect.ValueOf(object)
+
+ switch objValue.Kind() {
+ case reflect.Map:
+ fallthrough
+ case reflect.Slice, reflect.Chan:
+ {
+ return (objValue.Len() == 0)
+ }
+ case reflect.Ptr:
+ {
+ switch object.(type) {
+ case *time.Time:
+ return object.(*time.Time).IsZero()
+ default:
+ return false
+ }
+ }
+ }
+ return false
+}
+
+// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+// assert.Empty(t, obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+ pass := isEmpty(object)
+ if !pass {
+ Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...)
+ }
+
+ return pass
+
+}
+
+// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+// if assert.NotEmpty(t, obj) {
+// assert.Equal(t, "two", obj[1])
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+
+ pass := !isEmpty(object)
+ if !pass {
+ Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...)
+ }
+
+ return pass
+
+}
+
+// getLen try to get length of object.
+// return (false, 0) if impossible.
+func getLen(x interface{}) (ok bool, length int) {
+ v := reflect.ValueOf(x)
+ defer func() {
+ if e := recover(); e != nil {
+ ok = false
+ }
+ }()
+ return true, v.Len()
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+// assert.Len(t, mySlice, 3, "The size of slice is not 3")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool {
+ ok, l := getLen(object)
+ if !ok {
+ return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...)
+ }
+
+ if l != length {
+ return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
+ }
+ return true
+}
+
+// True asserts that the specified value is true.
+//
+// assert.True(t, myBool, "myBool should be true")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func True(t TestingT, value bool, msgAndArgs ...interface{}) bool {
+
+ if value != true {
+ return Fail(t, "Should be true", msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// False asserts that the specified value is true.
+//
+// assert.False(t, myBool, "myBool should be false")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func False(t TestingT, value bool, msgAndArgs ...interface{}) bool {
+
+ if value != false {
+ return Fail(t, "Should be false", msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+// assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+
+ if ObjectsAreEqual(expected, actual) {
+ return Fail(t, "Should not be equal", msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// containsElement try loop over the list check if the list includes the element.
+// return (false, false) if impossible.
+// return (true, false) if element was not found.
+// return (true, true) if element was found.
+func includeElement(list interface{}, element interface{}) (ok, found bool) {
+
+ listValue := reflect.ValueOf(list)
+ elementValue := reflect.ValueOf(element)
+ defer func() {
+ if e := recover(); e != nil {
+ ok = false
+ found = false
+ }
+ }()
+
+ if reflect.TypeOf(list).Kind() == reflect.String {
+ return true, strings.Contains(listValue.String(), elementValue.String())
+ }
+
+ for i := 0; i < listValue.Len(); i++ {
+ if listValue.Index(i).Interface() == element {
+ return true, true
+ }
+ }
+ return true, false
+
+}
+
+// Contains asserts that the specified string or list(array, slice...) contains the
+// specified substring or element.
+//
+// assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
+// assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
+
+ ok, found := includeElement(s, contains)
+ if !ok {
+ return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
+ }
+ if !found {
+ return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", s, contains), msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// NotContains asserts that the specified string or list(array, slice...) does NOT contain the
+// specified substring or element.
+//
+// assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
+// assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool {
+
+ ok, found := includeElement(s, contains)
+ if !ok {
+ return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...)
+ }
+ if found {
+ return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...)
+ }
+
+ return true
+
+}
+
+// Condition uses a Comparison to assert a complex condition.
+func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool {
+ result := comp()
+ if !result {
+ Fail(t, "Condition failed!", msgAndArgs...)
+ }
+ return result
+}
+
+// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics
+// methods, and represents a simple func that takes no arguments, and returns nothing.
+type PanicTestFunc func()
+
+// didPanic returns true if the function passed to it panics. Otherwise, it returns false.
+func didPanic(f PanicTestFunc) (bool, interface{}) {
+
+ didPanic := false
+ var message interface{}
+ func() {
+
+ defer func() {
+ if message = recover(); message != nil {
+ didPanic = true
+ }
+ }()
+
+ // call the target function
+ f()
+
+ }()
+
+ return didPanic, message
+
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+// assert.Panics(t, func(){
+// GoCrazy()
+// }, "Calling GoCrazy() should panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+
+ if funcDidPanic, panicValue := didPanic(f); !funcDidPanic {
+ return Fail(t, fmt.Sprintf("func %#v should panic\n\r\tPanic value:\t%v", f, panicValue), msgAndArgs...)
+ }
+
+ return true
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+// assert.NotPanics(t, func(){
+// RemainCalm()
+// }, "Calling RemainCalm() should NOT panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+
+ if funcDidPanic, panicValue := didPanic(f); funcDidPanic {
+ return Fail(t, fmt.Sprintf("func %#v should not panic\n\r\tPanic value:\t%v", f, panicValue), msgAndArgs...)
+ }
+
+ return true
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+
+ dt := expected.Sub(actual)
+ if dt < -delta || dt > delta {
+ return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
+ }
+
+ return true
+}
+
+func toFloat(x interface{}) (float64, bool) {
+ var xf float64
+ xok := true
+
+ switch xn := x.(type) {
+ case uint8:
+ xf = float64(xn)
+ case uint16:
+ xf = float64(xn)
+ case uint32:
+ xf = float64(xn)
+ case uint64:
+ xf = float64(xn)
+ case int:
+ xf = float64(xn)
+ case int8:
+ xf = float64(xn)
+ case int16:
+ xf = float64(xn)
+ case int32:
+ xf = float64(xn)
+ case int64:
+ xf = float64(xn)
+ case float32:
+ xf = float64(xn)
+ case float64:
+ xf = float64(xn)
+ default:
+ xok = false
+ }
+
+ return xf, xok
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+
+ af, aok := toFloat(expected)
+ bf, bok := toFloat(actual)
+
+ if !aok || !bok {
+ return Fail(t, fmt.Sprintf("Parameters must be numerical"), msgAndArgs...)
+ }
+
+ dt := af - bf
+ if dt < -delta || dt > delta {
+ return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...)
+ }
+
+ return true
+}
+
+// min(|expected|, |actual|) * epsilon
+func calcEpsilonDelta(expected, actual interface{}, epsilon float64) float64 {
+ af, aok := toFloat(expected)
+ bf, bok := toFloat(actual)
+
+ if !aok || !bok {
+ // invalid input
+ return 0
+ }
+
+ if af < 0 {
+ af = -af
+ }
+ if bf < 0 {
+ bf = -bf
+ }
+ var delta float64
+ if af < bf {
+ delta = af * epsilon
+ } else {
+ delta = bf * epsilon
+ }
+ return delta
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+ delta := calcEpsilonDelta(expected, actual, epsilon)
+
+ return InDelta(t, expected, actual, delta, msgAndArgs...)
+}
+
+/*
+ Errors
+*/
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+// actualObj, err := SomeFunction()
+// if assert.NoError(t, err) {
+// assert.Equal(t, actualObj, expectedObj)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
+ if isNil(err) {
+ return true
+ }
+
+ return Fail(t, fmt.Sprintf("No error is expected but got %v", err), msgAndArgs...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+// actualObj, err := SomeFunction()
+// if assert.Error(t, err, "An error was expected") {
+// assert.Equal(t, err, expectedError)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
+
+ message := messageFromMsgAndArgs(msgAndArgs...)
+ return NotNil(t, err, "An error is expected but got nil. %s", message)
+
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+// actualObj, err := SomeFunction()
+// if assert.Error(t, err, "An error was expected") {
+// assert.Equal(t, err, expectedError)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool {
+
+ message := messageFromMsgAndArgs(msgAndArgs...)
+ if !NotNil(t, theError, "An error is expected but got nil. %s", message) {
+ return false
+ }
+ s := "An error with value \"%s\" is expected but got \"%s\". %s"
+ return Equal(t, theError.Error(), errString,
+ s, errString, theError.Error(), message)
+}
+
+// matchRegexp return true if a specified regexp matches a string.
+func matchRegexp(rx interface{}, str interface{}) bool {
+
+ var r *regexp.Regexp
+ if rr, ok := rx.(*regexp.Regexp); ok {
+ r = rr
+ } else {
+ r = regexp.MustCompile(fmt.Sprint(rx))
+ }
+
+ return (r.FindStringIndex(fmt.Sprint(str)) != nil)
+
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+// assert.Regexp(t, "start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Regexp(t TestingT, rx interface{}, str interface{}) bool {
+
+ match := matchRegexp(rx, str)
+
+ if !match {
+ Fail(t, "Expect \"%s\" to match \"%s\"")
+ }
+
+ return match
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+// assert.NotRegexp(t, "^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotRegexp(t TestingT, rx interface{}, str interface{}) bool {
+ match := matchRegexp(rx, str)
+
+ if match {
+ Fail(t, "Expect \"%s\" to NOT match \"%s\"")
+ }
+
+ return !match
+
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/doc.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..1c6de283d0bc65ff1ff8b2cde12193c16fab3686
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/doc.go
@@ -0,0 +1,150 @@
+// A set of comprehensive testing tools for use with the normal Go testing system.
+//
+// Example Usage
+//
+// The following is a complete example using assert in a standard test function:
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// )
+//
+// func TestSomething(t *testing.T) {
+//
+// var a string = "Hello"
+// var b string = "Hello"
+//
+// assert.Equal(t, a, b, "The two words should be the same.")
+//
+// }
+//
+// if you assert many times, use the below:
+//
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// )
+//
+// func TestSomething(t *testing.T) {
+// assert := assert.New(t)
+//
+// var a string = "Hello"
+// var b string = "Hello"
+//
+// assert.Equal(a, b, "The two words should be the same.")
+// }
+//
+// Assertions
+//
+// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
+// All assertion functions take, as the first argument, the `*testing.T` object provided by the
+// testing framework. This allows the assertion funcs to write the failings and other details to
+// the correct place.
+//
+// Every assertion function also takes an optional string message as the final argument,
+// allowing custom error messages to be appended to the message the assertion method outputs.
+//
+// Here is an overview of the assert functions:
+//
+// assert.Equal(t, expected, actual [, message [, format-args])
+//
+// assert.NotEqual(t, notExpected, actual [, message [, format-args]])
+//
+// assert.True(t, actualBool [, message [, format-args]])
+//
+// assert.False(t, actualBool [, message [, format-args]])
+//
+// assert.Nil(t, actualObject [, message [, format-args]])
+//
+// assert.NotNil(t, actualObject [, message [, format-args]])
+//
+// assert.Empty(t, actualObject [, message [, format-args]])
+//
+// assert.NotEmpty(t, actualObject [, message [, format-args]])
+//
+// assert.Len(t, actualObject, expectedLength, [, message [, format-args]])
+//
+// assert.Error(t, errorObject [, message [, format-args]])
+//
+// assert.NoError(t, errorObject [, message [, format-args]])
+//
+// assert.EqualError(t, theError, errString [, message [, format-args]])
+//
+// assert.Implements(t, (*MyInterface)(nil), new(MyObject) [,message [, format-args]])
+//
+// assert.IsType(t, expectedObject, actualObject [, message [, format-args]])
+//
+// assert.Contains(t, stringOrSlice, substringOrElement [, message [, format-args]])
+//
+// assert.NotContains(t, stringOrSlice, substringOrElement [, message [, format-args]])
+//
+// assert.Panics(t, func(){
+//
+// // call code that should panic
+//
+// } [, message [, format-args]])
+//
+// assert.NotPanics(t, func(){
+//
+// // call code that should not panic
+//
+// } [, message [, format-args]])
+//
+// assert.WithinDuration(t, timeA, timeB, deltaTime, [, message [, format-args]])
+//
+// assert.InDelta(t, numA, numB, delta, [, message [, format-args]])
+//
+// assert.InEpsilon(t, numA, numB, epsilon, [, message [, format-args]])
+//
+// assert package contains Assertions object. it has assertion methods.
+//
+// Here is an overview of the assert functions:
+// assert.Equal(expected, actual [, message [, format-args])
+//
+// assert.NotEqual(notExpected, actual [, message [, format-args]])
+//
+// assert.True(actualBool [, message [, format-args]])
+//
+// assert.False(actualBool [, message [, format-args]])
+//
+// assert.Nil(actualObject [, message [, format-args]])
+//
+// assert.NotNil(actualObject [, message [, format-args]])
+//
+// assert.Empty(actualObject [, message [, format-args]])
+//
+// assert.NotEmpty(actualObject [, message [, format-args]])
+//
+// assert.Len(actualObject, expectedLength, [, message [, format-args]])
+//
+// assert.Error(errorObject [, message [, format-args]])
+//
+// assert.NoError(errorObject [, message [, format-args]])
+//
+// assert.EqualError(theError, errString [, message [, format-args]])
+//
+// assert.Implements((*MyInterface)(nil), new(MyObject) [,message [, format-args]])
+//
+// assert.IsType(expectedObject, actualObject [, message [, format-args]])
+//
+// assert.Contains(stringOrSlice, substringOrElement [, message [, format-args]])
+//
+// assert.NotContains(stringOrSlice, substringOrElement [, message [, format-args]])
+//
+// assert.Panics(func(){
+//
+// // call code that should panic
+//
+// } [, message [, format-args]])
+//
+// assert.NotPanics(func(){
+//
+// // call code that should not panic
+//
+// } [, message [, format-args]])
+//
+// assert.WithinDuration(timeA, timeB, deltaTime, [, message [, format-args]])
+//
+// assert.InDelta(numA, numB, delta, [, message [, format-args]])
+//
+// assert.InEpsilon(numA, numB, epsilon, [, message [, format-args]])
+package assert
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/errors.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..ac9dc9d1d6156b64c31ac0b130e7a2b1ca86f06d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/errors.go
@@ -0,0 +1,10 @@
+package assert
+
+import (
+ "errors"
+)
+
+// AnError is an error instance useful for testing. If the code does not care
+// about error specifics, and only needs to return the error for example, this
+// error should be used to make the test code more readable.
+var AnError = errors.New("assert.AnError general error for testing")
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions.go
new file mode 100644
index 0000000000000000000000000000000000000000..e2866f8be052beaca3f0e11882325e6537030aa0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/forward_assertions.go
@@ -0,0 +1,252 @@
+package assert
+
+import "time"
+
+type Assertions struct {
+ t TestingT
+}
+
+func New(t TestingT) *Assertions {
+ return &Assertions{
+ t: t,
+ }
+}
+
+// Fail reports a failure through
+func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
+ return Fail(a.t, failureMessage, msgAndArgs...)
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+// assert.Implements((*MyInterface)(nil), new(MyObject), "MyObject")
+func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+ return Implements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// IsType asserts that the specified objects are of the same type.
+func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+ return IsType(a.t, expectedType, object, msgAndArgs...)
+}
+
+// Equal asserts that two objects are equal.
+//
+// assert.Equal(123, 123, "123 and 123 should be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Equal(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+ return Equal(a.t, expected, actual, msgAndArgs...)
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+// assert.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Exactly(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+ return Exactly(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+// assert.NotNil(err, "err should be something")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
+ return NotNil(a.t, object, msgAndArgs...)
+}
+
+// Nil asserts that the specified object is nil.
+//
+// assert.Nil(err, "err should be nothing")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
+ return Nil(a.t, object, msgAndArgs...)
+}
+
+// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or a
+// slice with len == 0.
+//
+// assert.Empty(obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
+ return Empty(a.t, object, msgAndArgs...)
+}
+
+// Empty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or a
+// slice with len == 0.
+//
+// if assert.NotEmpty(obj) {
+// assert.Equal("two", obj[1])
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
+ return NotEmpty(a.t, object, msgAndArgs...)
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+// assert.Len(mySlice, 3, "The size of slice is not 3")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
+ return Len(a.t, object, length, msgAndArgs...)
+}
+
+// True asserts that the specified value is true.
+//
+// assert.True(myBool, "myBool should be true")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
+ return True(a.t, value, msgAndArgs...)
+}
+
+// False asserts that the specified value is true.
+//
+// assert.False(myBool, "myBool should be false")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
+ return False(a.t, value, msgAndArgs...)
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+// assert.NotEqual(obj1, obj2, "two objects shouldn't be equal")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEqual(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+ return NotEqual(a.t, expected, actual, msgAndArgs...)
+}
+
+// Contains asserts that the specified string contains the specified substring.
+//
+// assert.Contains("Hello World", "World", "But 'Hello World' does contain 'World'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Contains(s, contains interface{}, msgAndArgs ...interface{}) bool {
+ return Contains(a.t, s, contains, msgAndArgs...)
+}
+
+// NotContains asserts that the specified string does NOT contain the specified substring.
+//
+// assert.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotContains(s, contains interface{}, msgAndArgs ...interface{}) bool {
+ return NotContains(a.t, s, contains, msgAndArgs...)
+}
+
+// Uses a Comparison to assert a complex condition.
+func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
+ return Condition(a.t, comp, msgAndArgs...)
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+// assert.Panics(func(){
+// GoCrazy()
+// }, "Calling GoCrazy() should panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+ return Panics(a.t, f, msgAndArgs...)
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+// assert.NotPanics(func(){
+// RemainCalm()
+// }, "Calling RemainCalm() should NOT panic")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+ return NotPanics(a.t, f, msgAndArgs...)
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+// assert.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) WithinDuration(expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+ return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InDelta(expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+ return InDelta(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InEpsilon(expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+ return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+// actualObj, err := SomeFunction()
+// if assert.NoError(err) {
+// assert.Equal(actualObj, expectedObj)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NoError(theError error, msgAndArgs ...interface{}) bool {
+ return NoError(a.t, theError, msgAndArgs...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+// actualObj, err := SomeFunction()
+// if assert.Error(err, "An error was expected") {
+// assert.Equal(err, expectedError)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Error(theError error, msgAndArgs ...interface{}) bool {
+ return Error(a.t, theError, msgAndArgs...)
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+// actualObj, err := SomeFunction()
+// if assert.Error(err, "An error was expected") {
+// assert.Equal(err, expectedError)
+// }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
+ return EqualError(a.t, theError, errString, msgAndArgs...)
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+// assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
+// assert.Regexp(t, "start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Regexp(rx interface{}, str interface{}) bool {
+ return Regexp(a.t, rx, str)
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
+// assert.NotRegexp(t, "^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotRegexp(rx interface{}, str interface{}) bool {
+ return NotRegexp(a.t, rx, str)
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions.go b/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions.go
new file mode 100644
index 0000000000000000000000000000000000000000..0bcb6db9b8b86a48cea692d9b52b6c6dbd61affa
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/assert/http_assertions.go
@@ -0,0 +1,157 @@
+package assert
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "strings"
+)
+
+// httpCode is a helper that returns HTTP code of the response. It returns -1
+// if building a new request fails.
+func httpCode(handler http.HandlerFunc, mode, url string, values url.Values) int {
+ w := httptest.NewRecorder()
+ req, err := http.NewRequest(mode, url+"?"+values.Encode(), nil)
+ if err != nil {
+ return -1
+ }
+ handler(w, req)
+ return w.Code
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+// assert.HTTPSuccess(t, myHandler, "POST", http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccess(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ code := httpCode(handler, mode, url, values)
+ if code == -1 {
+ return false
+ }
+ return code >= http.StatusOK && code <= http.StatusPartialContent
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirect(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ code := httpCode(handler, mode, url, values)
+ if code == -1 {
+ return false
+ }
+ return code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPError(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ code := httpCode(handler, mode, url, values)
+ if code == -1 {
+ return false
+ }
+ return code >= http.StatusBadRequest
+}
+
+// HttpBody is a helper that returns HTTP body of the response. It returns
+// empty string if building a new request fails.
+func HttpBody(handler http.HandlerFunc, mode, url string, values url.Values) string {
+ w := httptest.NewRecorder()
+ req, err := http.NewRequest(mode, url+"?"+values.Encode(), nil)
+ if err != nil {
+ return ""
+ }
+ handler(w, req)
+ return w.Body.String()
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+// assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+ body := HttpBody(handler, mode, url, values)
+
+ contains := strings.Contains(body, fmt.Sprint(str))
+ if !contains {
+ Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
+ }
+
+ return contains
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+// assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+ body := HttpBody(handler, mode, url, values)
+
+ contains := strings.Contains(body, fmt.Sprint(str))
+ if contains {
+ Fail(t, "Expected response body for %s to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)
+ }
+
+ return !contains
+}
+
+//
+// Assertions Wrappers
+//
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+// assert.HTTPSuccess(myHandler, "POST", http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ return HTTPSuccess(a.t, handler, mode, url, values)
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+// assert.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ return HTTPRedirect(a.t, handler, mode, url, values)
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+// assert.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPError(handler http.HandlerFunc, mode, url string, values url.Values) bool {
+ return HTTPError(a.t, handler, mode, url, values)
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+// assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+ return HTTPBodyContains(a.t, handler, mode, url, values, str)
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+// assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {
+ return HTTPBodyNotContains(a.t, handler, mode, url, values, str)
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/suite/doc.go b/Godeps/_workspace/src/github.com/stretchr/testify/suite/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..3731eaa30427e7ed1ba52c69c995f6619e5b1f7c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/suite/doc.go
@@ -0,0 +1,65 @@
+// The suite package contains logic for creating testing suite structs
+// and running the methods on those structs as tests. The most useful
+// piece of this package is that you can create setup/teardown methods
+// on your testing suites, which will run before/after the whole suite
+// or individual tests (depending on which interface(s) you
+// implement).
+//
+// A testing suite is usually built by first extending the built-in
+// suite functionality from suite.Suite in testify. Alternatively,
+// you could reproduce that logic on your own if you wanted (you
+// just need to implement the TestingSuite interface from
+// suite/interfaces.go).
+//
+// After that, you can implement any of the interfaces in
+// suite/interfaces.go to add setup/teardown functionality to your
+// suite, and add any methods that start with "Test" to add tests.
+// Methods that do not match any suite interfaces and do not begin
+// with "Test" will not be run by testify, and can safely be used as
+// helper methods.
+//
+// Once you've built your testing suite, you need to run the suite
+// (using suite.Run from testify) inside any function that matches the
+// identity that "go test" is already looking for (i.e.
+// func(*testing.T)).
+//
+// Regular expression to select test suites specified command-line
+// argument "-run". Regular expression to select the methods
+// of test suites specified command-line argument "-m".
+// Suite object has assertion methods.
+//
+// A crude example:
+// // Basic imports
+// import (
+// "testing"
+// "github.com/stretchr/testify/assert"
+// "github.com/stretchr/testify/suite"
+// )
+//
+// // Define the suite, and absorb the built-in basic suite
+// // functionality from testify - including a T() method which
+// // returns the current testing context
+// type ExampleTestSuite struct {
+// suite.Suite
+// VariableThatShouldStartAtFive int
+// }
+//
+// // Make sure that VariableThatShouldStartAtFive is set to five
+// // before each test
+// func (suite *ExampleTestSuite) SetupTest() {
+// suite.VariableThatShouldStartAtFive = 5
+// }
+//
+// // All methods that begin with "Test" are run as tests within a
+// // suite.
+// func (suite *ExampleTestSuite) TestExample() {
+// assert.Equal(suite.T(), suite.VariableThatShouldStartAtFive, 5)
+// suite.Equal(suite.VariableThatShouldStartAtFive, 5)
+// }
+//
+// // In order for 'go test' to run this suite, we need to create
+// // a normal test function and pass our suite to suite.Run
+// func TestExampleTestSuite(t *testing.T) {
+// suite.Run(t, new(ExampleTestSuite))
+// }
+package suite
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/suite/interfaces.go b/Godeps/_workspace/src/github.com/stretchr/testify/suite/interfaces.go
new file mode 100644
index 0000000000000000000000000000000000000000..20969472c7ddcdef351f5a70c32503b19019130b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/suite/interfaces.go
@@ -0,0 +1,34 @@
+package suite
+
+import "testing"
+
+// TestingSuite can store and return the current *testing.T context
+// generated by 'go test'.
+type TestingSuite interface {
+ T() *testing.T
+ SetT(*testing.T)
+}
+
+// SetupAllSuite has a SetupSuite method, which will run before the
+// tests in the suite are run.
+type SetupAllSuite interface {
+ SetupSuite()
+}
+
+// SetupTestSuite has a SetupTest method, which will run before each
+// test in the suite.
+type SetupTestSuite interface {
+ SetupTest()
+}
+
+// TearDownAllSuite has a TearDownSuite method, which will run after
+// all the tests in the suite have been run.
+type TearDownAllSuite interface {
+ TearDownSuite()
+}
+
+// TearDownTestSuite has a TearDownTest method, which will run after
+// each test in the suite.
+type TearDownTestSuite interface {
+ TearDownTest()
+}
diff --git a/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite.go b/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite.go
new file mode 100644
index 0000000000000000000000000000000000000000..8f7fe7e629cdc1a2f57cac1ad0a61f3687249ddc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/stretchr/testify/suite/suite.go
@@ -0,0 +1,89 @@
+package suite
+
+import (
+ "flag"
+ "fmt"
+ "os"
+ "reflect"
+ "regexp"
+ "testing"
+
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
+)
+
+var matchMethod = flag.String("m", "", "regular expression to select tests of the suite to run")
+
+// Suite is a basic testing suite with methods for storing and
+// retrieving the current *testing.T context.
+type Suite struct {
+ *assert.Assertions
+ t *testing.T
+}
+
+// T retrieves the current *testing.T context.
+func (suite *Suite) T() *testing.T {
+ return suite.t
+}
+
+// SetT sets the current *testing.T context.
+func (suite *Suite) SetT(t *testing.T) {
+ suite.t = t
+ suite.Assertions = assert.New(t)
+}
+
+// Run takes a testing suite and runs all of the tests attached
+// to it.
+func Run(t *testing.T, suite TestingSuite) {
+ suite.SetT(t)
+
+ if setupAllSuite, ok := suite.(SetupAllSuite); ok {
+ setupAllSuite.SetupSuite()
+ }
+
+ methodFinder := reflect.TypeOf(suite)
+ tests := []testing.InternalTest{}
+ for index := 0; index < methodFinder.NumMethod(); index++ {
+ method := methodFinder.Method(index)
+ ok, err := methodFilter(method.Name)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "testify: invalid regexp for -m: %s\n", err)
+ os.Exit(1)
+ }
+ if ok {
+ test := testing.InternalTest{
+ Name: method.Name,
+ F: func(t *testing.T) {
+ parentT := suite.T()
+ suite.SetT(t)
+ if setupTestSuite, ok := suite.(SetupTestSuite); ok {
+ setupTestSuite.SetupTest()
+ }
+ method.Func.Call([]reflect.Value{reflect.ValueOf(suite)})
+ if tearDownTestSuite, ok := suite.(TearDownTestSuite); ok {
+ tearDownTestSuite.TearDownTest()
+ }
+ suite.SetT(parentT)
+ },
+ }
+ tests = append(tests, test)
+ }
+ }
+
+ if !testing.RunTests(func(_, _ string) (bool, error) { return true, nil },
+ tests) {
+ t.Fail()
+ }
+
+ if tearDownAllSuite, ok := suite.(TearDownAllSuite); ok {
+ tearDownAllSuite.TearDownSuite()
+ }
+}
+
+// Filtering method according to set regular expression
+// specified command-line argument -m
+func methodFilter(name string) (bool, error) {
+ if ok, _ := regexp.MatchString("^Test", name); !ok {
+ return false, nil
+ }
+ return regexp.MatchString(*matchMethod, name)
+}
diff --git a/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors_test.go b/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors_test.go
index b190af07ef388d324419ce760fc265aaf7808df6..3fca7178f7dcec3f0e18951623daa5dfb2f6406c 100644
--- a/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors_test.go
+++ b/Godeps/_workspace/src/github.com/tommy351/gin-cors/cors_test.go
@@ -8,7 +8,7 @@ import (
"time"
"github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/gin-gonic/gin"
- "github.com/stretchr/testify/assert"
+ "github.com/eris-ltd/eris-db/Godeps/_workspace/src/github.com/stretchr/testify/assert"
)
func init() {