Cirrus: add vendor_check_task

* Make sure that all vendored dependencies are in sync with the code and
  the vendor.conf by running `make vendor` with a follow-up status check
  of the git tree.

* Vendor ginkgo and gomega to include the test dependencies.

Signed-off-by: Chris Evic <cevich@redhat.com>
Signed-off-by: Valentin Rothberg <rothberg@redhat.com>

97 files changed, 5704 insertions, 0 deletions

diff --git a/vendor/github.com/onsi/gomega/matchers/and.go b/vendor/github.com/onsi/gomega/matchers/and.go
new file mode 100644
index 000000000..d83a29164
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/and.go
@@ -0,0 +1,63 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+	"github.com/onsi/gomega/internal/oraclematcher"
+	"github.com/onsi/gomega/types"
+)
+
+type AndMatcher struct {
+	Matchers []types.GomegaMatcher
+
+	// state
+	firstFailedMatcher types.GomegaMatcher
+}
+
+func (m *AndMatcher) Match(actual interface{}) (success bool, err error) {
+	m.firstFailedMatcher = nil
+	for _, matcher := range m.Matchers {
+		success, err := matcher.Match(actual)
+		if !success || err != nil {
+			m.firstFailedMatcher = matcher
+			return false, err
+		}
+	}
+	return true, nil
+}
+
+func (m *AndMatcher) FailureMessage(actual interface{}) (message string) {
+	return m.firstFailedMatcher.FailureMessage(actual)
+}
+
+func (m *AndMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	// not the most beautiful list of matchers, but not bad either...
+	return format.Message(actual, fmt.Sprintf("To not satisfy all of these matchers: %s", m.Matchers))
+}
+
+func (m *AndMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+	/*
+		Example with 3 matchers: A, B, C
+
+		Match evaluates them: T, F, <?>  => F
+		So match is currently F, what should MatchMayChangeInTheFuture() return?
+		Seems like it only depends on B, since currently B MUST change to allow the result to become T
+
+		Match eval: T, T, T  => T
+		So match is currently T, what should MatchMayChangeInTheFuture() return?
+		Seems to depend on ANY of them being able to change to F.
+	*/
+
+	if m.firstFailedMatcher == nil {
+		// so all matchers succeeded.. Any one of them changing would change the result.
+		for _, matcher := range m.Matchers {
+			if oraclematcher.MatchMayChangeInTheFuture(matcher, actual) {
+				return true
+			}
+		}
+		return false // none of were going to change
+	}
+	// one of the matchers failed.. it must be able to change in order to affect the result
+	return oraclematcher.MatchMayChangeInTheFuture(m.firstFailedMatcher, actual)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/and_test.go b/vendor/github.com/onsi/gomega/matchers/and_test.go
new file mode 100644
index 000000000..acf778cd6
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/and_test.go
@@ -0,0 +1,103 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+	"github.com/onsi/gomega/types"
+)
+
+// sample data
+var (
+	// example input
+	input = "hi"
+	// some matchers that succeed against the input
+	true1 = HaveLen(2)
+	true2 = Equal("hi")
+	true3 = MatchRegexp("hi")
+	// some matchers that fail against the input.
+	false1 = HaveLen(1)
+	false2 = Equal("hip")
+	false3 = MatchRegexp("hope")
+)
+
+// verifyFailureMessage expects the matcher to fail with the given input, and verifies the failure message.
+func verifyFailureMessage(m types.GomegaMatcher, input string, expectedFailureMsgFragment string) {
+	Expect(m.Match(input)).To(BeFalse())
+	Expect(m.FailureMessage(input)).To(Equal(
+		"Expected\n    <string>: " + input + "\n" + expectedFailureMsgFragment))
+}
+
+var _ = Describe("AndMatcher", func() {
+	It("works with positive cases", func() {
+		Expect(input).To(And())
+		Expect(input).To(And(true1))
+		Expect(input).To(And(true1, true2))
+		Expect(input).To(And(true1, true2, true3))
+
+		// use alias
+		Expect(input).To(SatisfyAll(true1, true2, true3))
+	})
+
+	It("works with negative cases", func() {
+		Expect(input).ToNot(And(false1, false2))
+		Expect(input).ToNot(And(true1, true2, false3))
+		Expect(input).ToNot(And(true1, false2, false3))
+		Expect(input).ToNot(And(false1, true1, true2))
+	})
+
+	Context("failure messages", func() {
+		Context("when match fails", func() {
+			It("gives a descriptive message", func() {
+				verifyFailureMessage(And(false1, true1), input, "to have length 1")
+				verifyFailureMessage(And(true1, false2), input, "to equal\n    <string>: hip")
+				verifyFailureMessage(And(true1, true2, false3), input, "to match regular expression\n    <string>: hope")
+			})
+		})
+
+		Context("when match succeeds, but expected it to fail", func() {
+			It("gives a descriptive message", func() {
+				verifyFailureMessage(Not(And(true1, true2)), input,
+					`To not satisfy all of these matchers: [%!s(*matchers.HaveLenMatcher=&{2}) %!s(*matchers.EqualMatcher=&{hi})]`)
+			})
+		})
+	})
+
+	Context("MatchMayChangeInTheFuture", func() {
+		Context("Match returned false", func() {
+			Context("returns value of the failed matcher", func() {
+				It("false if failed matcher not going to change", func() {
+					// 3 matchers: 1st returns true, 2nd returns false and is not going to change, 3rd is never called
+					m := And(Not(BeNil()), Or(), Equal(1))
+					Expect(m.Match("hi")).To(BeFalse())
+					Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse()) // empty Or() indicates not going to change
+				})
+				It("true if failed matcher indicates it might change", func() {
+					// 3 matchers: 1st returns true, 2nd returns false and "might" change, 3rd is never called
+					m := And(Not(BeNil()), Equal(5), Equal(1))
+					Expect(m.Match("hi")).To(BeFalse())
+					Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // Equal(5) indicates it might change
+				})
+			})
+		})
+		Context("Match returned true", func() {
+			It("returns true if any of the matchers could change", func() {
+				// 3 matchers, all return true, and all could change
+				m := And(Not(BeNil()), Equal("hi"), HaveLen(2))
+				Expect(m.Match("hi")).To(BeTrue())
+				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // all 3 of these matchers default to 'true'
+			})
+			It("returns false if none of the matchers could change", func() {
+				// empty And() has the property of always matching, and never can change since there are no sub-matchers that could change
+				m := And()
+				Expect(m.Match("anything")).To(BeTrue())
+				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("anything")).To(BeFalse())
+
+				// And() with 3 sub-matchers that return true, and can't change
+				m = And(And(), And(), And())
+				Expect(m.Match("hi")).To(BeTrue())
+				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse()) // the 3 empty And()'s won't change
+			})
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher.go b/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher.go
new file mode 100644
index 000000000..51f8be6ae
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher.go
@@ -0,0 +1,35 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type AssignableToTypeOfMatcher struct {
+	Expected interface{}
+}
+
+func (matcher *AssignableToTypeOfMatcher) Match(actual interface{}) (success bool, err error) {
+	if actual == nil && matcher.Expected == nil {
+		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
+	} else if matcher.Expected == nil {
+		return false, fmt.Errorf("Refusing to compare type to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
+	} else if actual == nil {
+		return false, nil
+	}
+
+	actualType := reflect.TypeOf(actual)
+	expectedType := reflect.TypeOf(matcher.Expected)
+
+	return actualType.AssignableTo(expectedType), nil
+}
+
+func (matcher *AssignableToTypeOfMatcher) FailureMessage(actual interface{}) string {
+	return format.Message(actual, fmt.Sprintf("to be assignable to the type: %T", matcher.Expected))
+}
+
+func (matcher *AssignableToTypeOfMatcher) NegatedFailureMessage(actual interface{}) string {
+	return format.Message(actual, fmt.Sprintf("not to be assignable to the type: %T", matcher.Expected))
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher_test.go
new file mode 100644
index 000000000..471a46d97
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher_test.go
@@ -0,0 +1,46 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("AssignableToTypeOf", func() {
+	Context("When asserting assignability between types", func() {
+		It("should do the right thing", func() {
+			Expect(0).Should(BeAssignableToTypeOf(0))
+			Expect(5).Should(BeAssignableToTypeOf(-1))
+			Expect("foo").Should(BeAssignableToTypeOf("bar"))
+			Expect(struct{ Foo string }{}).Should(BeAssignableToTypeOf(struct{ Foo string }{}))
+
+			Expect(0).ShouldNot(BeAssignableToTypeOf("bar"))
+			Expect(5).ShouldNot(BeAssignableToTypeOf(struct{ Foo string }{}))
+			Expect("foo").ShouldNot(BeAssignableToTypeOf(42))
+		})
+	})
+
+	Context("When asserting nil values", func() {
+		It("should error", func() {
+			success, err := (&AssignableToTypeOfMatcher{Expected: nil}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+
+		Context("When actual is nil and expected is not nil", func() {
+			It("should return false without error", func() {
+				success, err := (&AssignableToTypeOfMatcher{Expected: 17}).Match(nil)
+				Expect(success).Should(BeFalse())
+				Expect(err).ShouldNot(HaveOccurred())
+			})
+		})
+
+		Context("When actual is not nil and expected is nil", func() {
+			It("should error", func() {
+				success, err := (&AssignableToTypeOfMatcher{Expected: nil}).Match(17)
+				Expect(success).Should(BeFalse())
+				Expect(err).Should(HaveOccurred())
+			})
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/attributes_slice.go b/vendor/github.com/onsi/gomega/matchers/attributes_slice.go
new file mode 100644
index 000000000..355b362f4
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/attributes_slice.go
@@ -0,0 +1,14 @@
+package matchers
+
+import (
+	"encoding/xml"
+	"strings"
+)
+
+type attributesSlice []xml.Attr
+
+func (attrs attributesSlice) Len() int { return len(attrs) }
+func (attrs attributesSlice) Less(i, j int) bool {
+	return strings.Compare(attrs[i].Name.Local, attrs[j].Name.Local) == -1
+}
+func (attrs attributesSlice) Swap(i, j int) { attrs[i], attrs[j] = attrs[j], attrs[i] }
diff --git a/vendor/github.com/onsi/gomega/matchers/be_a_directory.go b/vendor/github.com/onsi/gomega/matchers/be_a_directory.go
new file mode 100644
index 000000000..7b6975e41
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_a_directory.go
@@ -0,0 +1,54 @@
+package matchers
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/onsi/gomega/format"
+)
+
+type notADirectoryError struct {
+	os.FileInfo
+}
+
+func (t notADirectoryError) Error() string {
+	fileInfo := os.FileInfo(t)
+	switch {
+	case fileInfo.Mode().IsRegular():
+		return "file is a regular file"
+	default:
+		return fmt.Sprintf("file mode is: %s", fileInfo.Mode().String())
+	}
+}
+
+type BeADirectoryMatcher struct {
+	expected interface{}
+	err      error
+}
+
+func (matcher *BeADirectoryMatcher) Match(actual interface{}) (success bool, err error) {
+	actualFilename, ok := actual.(string)
+	if !ok {
+		return false, fmt.Errorf("BeADirectoryMatcher matcher expects a file path")
+	}
+
+	fileInfo, err := os.Stat(actualFilename)
+	if err != nil {
+		matcher.err = err
+		return false, nil
+	}
+
+	if !fileInfo.Mode().IsDir() {
+		matcher.err = notADirectoryError{fileInfo}
+		return false, nil
+	}
+	return true, nil
+}
+
+func (matcher *BeADirectoryMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("to be a directory: %s", matcher.err))
+}
+
+func (matcher *BeADirectoryMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("not be a directory"))
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_a_directory_test.go b/vendor/github.com/onsi/gomega/matchers/be_a_directory_test.go
new file mode 100644
index 000000000..bc8742763
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_a_directory_test.go
@@ -0,0 +1,40 @@
+package matchers_test
+
+import (
+	"io/ioutil"
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeADirectoryMatcher", func() {
+	Context("when passed a string", func() {
+		It("should do the right thing", func() {
+			Expect("/dne/test").ShouldNot(BeADirectory())
+
+			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
+			Expect(err).ShouldNot(HaveOccurred())
+			defer os.Remove(tmpFile.Name())
+			Expect(tmpFile.Name()).ShouldNot(BeADirectory())
+
+			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
+			Expect(err).ShouldNot(HaveOccurred())
+			defer os.Remove(tmpDir)
+			Expect(tmpDir).Should(BeADirectory())
+		})
+	})
+
+	Context("when passed something else", func() {
+		It("should error", func() {
+			success, err := (&BeADirectoryMatcher{}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeADirectoryMatcher{}).Match(true)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_a_regular_file.go b/vendor/github.com/onsi/gomega/matchers/be_a_regular_file.go
new file mode 100644
index 000000000..e239131fb
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_a_regular_file.go
@@ -0,0 +1,54 @@
+package matchers
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/onsi/gomega/format"
+)
+
+type notARegularFileError struct {
+	os.FileInfo
+}
+
+func (t notARegularFileError) Error() string {
+	fileInfo := os.FileInfo(t)
+	switch {
+	case fileInfo.IsDir():
+		return "file is a directory"
+	default:
+		return fmt.Sprintf("file mode is: %s", fileInfo.Mode().String())
+	}
+}
+
+type BeARegularFileMatcher struct {
+	expected interface{}
+	err      error
+}
+
+func (matcher *BeARegularFileMatcher) Match(actual interface{}) (success bool, err error) {
+	actualFilename, ok := actual.(string)
+	if !ok {
+		return false, fmt.Errorf("BeARegularFileMatcher matcher expects a file path")
+	}
+
+	fileInfo, err := os.Stat(actualFilename)
+	if err != nil {
+		matcher.err = err
+		return false, nil
+	}
+
+	if !fileInfo.Mode().IsRegular() {
+		matcher.err = notARegularFileError{fileInfo}
+		return false, nil
+	}
+	return true, nil
+}
+
+func (matcher *BeARegularFileMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("to be a regular file: %s", matcher.err))
+}
+
+func (matcher *BeARegularFileMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("not be a regular file"))
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_a_regular_file_test.go b/vendor/github.com/onsi/gomega/matchers/be_a_regular_file_test.go
new file mode 100644
index 000000000..eae06a03e
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_a_regular_file_test.go
@@ -0,0 +1,40 @@
+package matchers_test
+
+import (
+	"io/ioutil"
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeARegularFileMatcher", func() {
+	Context("when passed a string", func() {
+		It("should do the right thing", func() {
+			Expect("/dne/test").ShouldNot(BeARegularFile())
+
+			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
+			Expect(err).ShouldNot(HaveOccurred())
+			defer os.Remove(tmpFile.Name())
+			Expect(tmpFile.Name()).Should(BeARegularFile())
+
+			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
+			Expect(err).ShouldNot(HaveOccurred())
+			defer os.Remove(tmpDir)
+			Expect(tmpDir).ShouldNot(BeARegularFile())
+		})
+	})
+
+	Context("when passed something else", func() {
+		It("should error", func() {
+			success, err := (&BeARegularFileMatcher{}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeARegularFileMatcher{}).Match(true)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_an_existing_file.go b/vendor/github.com/onsi/gomega/matchers/be_an_existing_file.go
new file mode 100644
index 000000000..d42eba223
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_an_existing_file.go
@@ -0,0 +1,38 @@
+package matchers
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeAnExistingFileMatcher struct {
+	expected interface{}
+}
+
+func (matcher *BeAnExistingFileMatcher) Match(actual interface{}) (success bool, err error) {
+	actualFilename, ok := actual.(string)
+	if !ok {
+		return false, fmt.Errorf("BeAnExistingFileMatcher matcher expects a file path")
+	}
+
+	if _, err = os.Stat(actualFilename); err != nil {
+		switch {
+		case os.IsNotExist(err):
+			return false, nil
+		default:
+			return false, err
+		}
+	}
+
+	return true, nil
+}
+
+func (matcher *BeAnExistingFileMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("to exist"))
+}
+
+func (matcher *BeAnExistingFileMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("not to exist"))
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_an_existing_file_test.go b/vendor/github.com/onsi/gomega/matchers/be_an_existing_file_test.go
new file mode 100644
index 000000000..e28bd0d65
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_an_existing_file_test.go
@@ -0,0 +1,40 @@
+package matchers_test
+
+import (
+	"io/ioutil"
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeAnExistingFileMatcher", func() {
+	Context("when passed a string", func() {
+		It("should do the right thing", func() {
+			Expect("/dne/test").ShouldNot(BeAnExistingFile())
+
+			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
+			Expect(err).ShouldNot(HaveOccurred())
+			defer os.Remove(tmpFile.Name())
+			Expect(tmpFile.Name()).Should(BeAnExistingFile())
+
+			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
+			Expect(err).ShouldNot(HaveOccurred())
+			defer os.Remove(tmpDir)
+			Expect(tmpDir).Should(BeAnExistingFile())
+		})
+	})
+
+	Context("when passed something else", func() {
+		It("should error", func() {
+			success, err := (&BeAnExistingFileMatcher{}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeAnExistingFileMatcher{}).Match(true)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_closed_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_closed_matcher.go
new file mode 100644
index 000000000..80c9c8bb1
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_closed_matcher.go
@@ -0,0 +1,46 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeClosedMatcher struct {
+}
+
+func (matcher *BeClosedMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isChan(actual) {
+		return false, fmt.Errorf("BeClosed matcher expects a channel.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	channelType := reflect.TypeOf(actual)
+	channelValue := reflect.ValueOf(actual)
+
+	if channelType.ChanDir() == reflect.SendDir {
+		return false, fmt.Errorf("BeClosed matcher cannot determine if a send-only channel is closed or open.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	winnerIndex, _, open := reflect.Select([]reflect.SelectCase{
+		{Dir: reflect.SelectRecv, Chan: channelValue},
+		{Dir: reflect.SelectDefault},
+	})
+
+	var closed bool
+	if winnerIndex == 0 {
+		closed = !open
+	} else if winnerIndex == 1 {
+		closed = false
+	}
+
+	return closed, nil
+}
+
+func (matcher *BeClosedMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be closed")
+}
+
+func (matcher *BeClosedMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be open")
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_closed_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_closed_matcher_test.go
new file mode 100644
index 000000000..c2e49ab50
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_closed_matcher_test.go
@@ -0,0 +1,70 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeClosedMatcher", func() {
+	Context("when passed a channel", func() {
+		It("should do the right thing", func() {
+			openChannel := make(chan bool)
+			Expect(openChannel).ShouldNot(BeClosed())
+
+			var openReaderChannel <-chan bool
+			openReaderChannel = openChannel
+			Expect(openReaderChannel).ShouldNot(BeClosed())
+
+			closedChannel := make(chan bool)
+			close(closedChannel)
+
+			Expect(closedChannel).Should(BeClosed())
+
+			var closedReaderChannel <-chan bool
+			closedReaderChannel = closedChannel
+			Expect(closedReaderChannel).Should(BeClosed())
+		})
+	})
+
+	Context("when passed a send-only channel", func() {
+		It("should error", func() {
+			openChannel := make(chan bool)
+			var openWriterChannel chan<- bool
+			openWriterChannel = openChannel
+
+			success, err := (&BeClosedMatcher{}).Match(openWriterChannel)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			closedChannel := make(chan bool)
+			close(closedChannel)
+
+			var closedWriterChannel chan<- bool
+			closedWriterChannel = closedChannel
+
+			success, err = (&BeClosedMatcher{}).Match(closedWriterChannel)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+		})
+	})
+
+	Context("when passed something else", func() {
+		It("should error", func() {
+			var nilChannel chan bool
+
+			success, err := (&BeClosedMatcher{}).Match(nilChannel)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeClosedMatcher{}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeClosedMatcher{}).Match(7)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_empty_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_empty_matcher.go
new file mode 100644
index 000000000..8b00311b0
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_empty_matcher.go
@@ -0,0 +1,27 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeEmptyMatcher struct {
+}
+
+func (matcher *BeEmptyMatcher) Match(actual interface{}) (success bool, err error) {
+	length, ok := lengthOf(actual)
+	if !ok {
+		return false, fmt.Errorf("BeEmpty matcher expects a string/array/map/channel/slice.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	return length == 0, nil
+}
+
+func (matcher *BeEmptyMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be empty")
+}
+
+func (matcher *BeEmptyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to be empty")
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_empty_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_empty_matcher_test.go
new file mode 100644
index 000000000..132480cfc
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_empty_matcher_test.go
@@ -0,0 +1,52 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeEmpty", func() {
+	Context("when passed a supported type", func() {
+		It("should do the right thing", func() {
+			Expect("").Should(BeEmpty())
+			Expect(" ").ShouldNot(BeEmpty())
+
+			Expect([0]int{}).Should(BeEmpty())
+			Expect([1]int{1}).ShouldNot(BeEmpty())
+
+			Expect([]int{}).Should(BeEmpty())
+			Expect([]int{1}).ShouldNot(BeEmpty())
+
+			Expect(map[string]int{}).Should(BeEmpty())
+			Expect(map[string]int{"a": 1}).ShouldNot(BeEmpty())
+
+			c := make(chan bool, 1)
+			Expect(c).Should(BeEmpty())
+			c <- true
+			Expect(c).ShouldNot(BeEmpty())
+		})
+	})
+
+	Context("when passed a correctly typed nil", func() {
+		It("should be true", func() {
+			var nilSlice []int
+			Expect(nilSlice).Should(BeEmpty())
+
+			var nilMap map[int]string
+			Expect(nilMap).Should(BeEmpty())
+		})
+	})
+
+	Context("when passed an unsupported type", func() {
+		It("should error", func() {
+			success, err := (&BeEmptyMatcher{}).Match(0)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeEmptyMatcher{}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher.go
new file mode 100644
index 000000000..97ab20a4e
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher.go
@@ -0,0 +1,34 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeEquivalentToMatcher struct {
+	Expected interface{}
+}
+
+func (matcher *BeEquivalentToMatcher) Match(actual interface{}) (success bool, err error) {
+	if actual == nil && matcher.Expected == nil {
+		return false, fmt.Errorf("Both actual and expected must not be nil.")
+	}
+
+	convertedActual := actual
+
+	if actual != nil && matcher.Expected != nil && reflect.TypeOf(actual).ConvertibleTo(reflect.TypeOf(matcher.Expected)) {
+		convertedActual = reflect.ValueOf(actual).Convert(reflect.TypeOf(matcher.Expected)).Interface()
+	}
+
+	return reflect.DeepEqual(convertedActual, matcher.Expected), nil
+}
+
+func (matcher *BeEquivalentToMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be equivalent to", matcher.Expected)
+}
+
+func (matcher *BeEquivalentToMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to be equivalent to", matcher.Expected)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher_test.go
new file mode 100644
index 000000000..4d9d11d2d
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher_test.go
@@ -0,0 +1,50 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeEquivalentTo", func() {
+	Context("when asserting that nil is equivalent to nil", func() {
+		It("should error", func() {
+			success, err := (&BeEquivalentToMatcher{Expected: nil}).Match(nil)
+
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("When asserting on nil", func() {
+		It("should do the right thing", func() {
+			Expect("foo").ShouldNot(BeEquivalentTo(nil))
+			Expect(nil).ShouldNot(BeEquivalentTo(3))
+			Expect([]int{1, 2}).ShouldNot(BeEquivalentTo(nil))
+		})
+	})
+
+	Context("When asserting on type aliases", func() {
+		It("should the right thing", func() {
+			Expect(StringAlias("foo")).Should(BeEquivalentTo("foo"))
+			Expect("foo").Should(BeEquivalentTo(StringAlias("foo")))
+			Expect(StringAlias("foo")).ShouldNot(BeEquivalentTo("bar"))
+			Expect("foo").ShouldNot(BeEquivalentTo(StringAlias("bar")))
+		})
+	})
+
+	Context("When asserting on numbers", func() {
+		It("should convert actual to expected and do the right thing", func() {
+			Expect(5).Should(BeEquivalentTo(5))
+			Expect(5.0).Should(BeEquivalentTo(5.0))
+			Expect(5).Should(BeEquivalentTo(5.0))
+
+			Expect(5).ShouldNot(BeEquivalentTo("5"))
+			Expect(5).ShouldNot(BeEquivalentTo(3))
+
+			//Here be dragons!
+			Expect(5.1).Should(BeEquivalentTo(5))
+			Expect(5).ShouldNot(BeEquivalentTo(5.1))
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_false_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_false_matcher.go
new file mode 100644
index 000000000..91d3b779e
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_false_matcher.go
@@ -0,0 +1,26 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeFalseMatcher struct {
+}
+
+func (matcher *BeFalseMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isBool(actual) {
+		return false, fmt.Errorf("Expected a boolean.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	return actual == false, nil
+}
+
+func (matcher *BeFalseMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be false")
+}
+
+func (matcher *BeFalseMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to be false")
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_false_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_false_matcher_test.go
new file mode 100644
index 000000000..25e70633d
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_false_matcher_test.go
@@ -0,0 +1,20 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeFalse", func() {
+	It("should handle true and false correctly", func() {
+		Expect(true).ShouldNot(BeFalse())
+		Expect(false).Should(BeFalse())
+	})
+
+	It("should only support booleans", func() {
+		success, err := (&BeFalseMatcher{}).Match("foo")
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(HaveOccurred())
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_identical_to.go b/vendor/github.com/onsi/gomega/matchers/be_identical_to.go
new file mode 100644
index 000000000..fdcda4d1f
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_identical_to.go
@@ -0,0 +1,37 @@
+package matchers
+
+import (
+	"fmt"
+	"runtime"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeIdenticalToMatcher struct {
+	Expected interface{}
+}
+
+func (matcher *BeIdenticalToMatcher) Match(actual interface{}) (success bool, matchErr error) {
+	if actual == nil && matcher.Expected == nil {
+		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
+	}
+
+	defer func() {
+		if r := recover(); r != nil {
+			if _, ok := r.(runtime.Error); ok {
+				success = false
+				matchErr = nil
+			}
+		}
+	}()
+
+	return actual == matcher.Expected, nil
+}
+
+func (matcher *BeIdenticalToMatcher) FailureMessage(actual interface{}) string {
+	return format.Message(actual, "to be identical to", matcher.Expected)
+}
+
+func (matcher *BeIdenticalToMatcher) NegatedFailureMessage(actual interface{}) string {
+	return format.Message(actual, "not to be identical to", matcher.Expected)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_identical_to_test.go b/vendor/github.com/onsi/gomega/matchers/be_identical_to_test.go
new file mode 100644
index 000000000..7fdd56eed
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_identical_to_test.go
@@ -0,0 +1,61 @@
+package matchers_test
+
+import (
+	"errors"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeIdenticalTo", func() {
+	Context("when asserting that nil equals nil", func() {
+		It("should error", func() {
+			success, err := (&BeIdenticalToMatcher{Expected: nil}).Match(nil)
+
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	It("should treat the same pointer to a struct as identical", func() {
+		mySpecialStruct := myCustomType{}
+		Expect(&mySpecialStruct).Should(BeIdenticalTo(&mySpecialStruct))
+		Expect(&myCustomType{}).ShouldNot(BeIdenticalTo(&mySpecialStruct))
+	})
+
+	It("should be strict about types", func() {
+		Expect(5).ShouldNot(BeIdenticalTo("5"))
+		Expect(5).ShouldNot(BeIdenticalTo(5.0))
+		Expect(5).ShouldNot(BeIdenticalTo(3))
+	})
+
+	It("should treat primtives as identical", func() {
+		Expect("5").Should(BeIdenticalTo("5"))
+		Expect("5").ShouldNot(BeIdenticalTo("55"))
+
+		Expect(5.55).Should(BeIdenticalTo(5.55))
+		Expect(5.55).ShouldNot(BeIdenticalTo(6.66))
+
+		Expect(5).Should(BeIdenticalTo(5))
+		Expect(5).ShouldNot(BeIdenticalTo(55))
+	})
+
+	It("should treat the same pointers to a slice as identical", func() {
+		mySlice := []int{1, 2}
+		Expect(&mySlice).Should(BeIdenticalTo(&mySlice))
+		Expect(&mySlice).ShouldNot(BeIdenticalTo(&[]int{1, 2}))
+	})
+
+	It("should treat the same pointers to a map as identical", func() {
+		myMap := map[string]string{"a": "b", "c": "d"}
+		Expect(&myMap).Should(BeIdenticalTo(&myMap))
+		Expect(myMap).ShouldNot(BeIdenticalTo(map[string]string{"a": "b", "c": "d"}))
+	})
+
+	It("should treat the same pointers to an error as identical", func() {
+		myError := errors.New("foo")
+		Expect(&myError).Should(BeIdenticalTo(&myError))
+		Expect(errors.New("foo")).ShouldNot(BeIdenticalTo(errors.New("bar")))
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_nil_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_nil_matcher.go
new file mode 100644
index 000000000..7ee84fe1b
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_nil_matcher.go
@@ -0,0 +1,18 @@
+package matchers
+
+import "github.com/onsi/gomega/format"
+
+type BeNilMatcher struct {
+}
+
+func (matcher *BeNilMatcher) Match(actual interface{}) (success bool, err error) {
+	return isNil(actual), nil
+}
+
+func (matcher *BeNilMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be nil")
+}
+
+func (matcher *BeNilMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to be nil")
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_nil_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_nil_matcher_test.go
new file mode 100644
index 000000000..c35aa3d7c
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_nil_matcher_test.go
@@ -0,0 +1,28 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("BeNil", func() {
+	It("should succeed when passed nil", func() {
+		Expect(nil).Should(BeNil())
+	})
+
+	It("should succeed when passed a typed nil", func() {
+		var a []int
+		Expect(a).Should(BeNil())
+	})
+
+	It("should succeed when passing nil pointer", func() {
+		var f *struct{}
+		Expect(f).Should(BeNil())
+	})
+
+	It("should not succeed when not passed nil", func() {
+		Expect(0).ShouldNot(BeNil())
+		Expect(false).ShouldNot(BeNil())
+		Expect("").ShouldNot(BeNil())
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go
new file mode 100644
index 000000000..9f4f77eec
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go
@@ -0,0 +1,132 @@
+package matchers
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeNumericallyMatcher struct {
+	Comparator string
+	CompareTo  []interface{}
+}
+
+func (matcher *BeNumericallyMatcher) FailureMessage(actual interface{}) (message string) {
+	return matcher.FormatFailureMessage(actual, false)
+}
+
+func (matcher *BeNumericallyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return matcher.FormatFailureMessage(actual, true)
+}
+
+func (matcher *BeNumericallyMatcher) FormatFailureMessage(actual interface{}, negated bool) (message string) {
+	if len(matcher.CompareTo) == 1 {
+		message = fmt.Sprintf("to be %s", matcher.Comparator)
+	} else {
+		message = fmt.Sprintf("to be within %v of %s", matcher.CompareTo[1], matcher.Comparator)
+	}
+	if negated {
+		message = "not " + message
+	}
+	return format.Message(actual, message, matcher.CompareTo[0])
+}
+
+func (matcher *BeNumericallyMatcher) Match(actual interface{}) (success bool, err error) {
+	if len(matcher.CompareTo) == 0 || len(matcher.CompareTo) > 2 {
+		return false, fmt.Errorf("BeNumerically requires 1 or 2 CompareTo arguments.  Got:\n%s", format.Object(matcher.CompareTo, 1))
+	}
+	if !isNumber(actual) {
+		return false, fmt.Errorf("Expected a number.  Got:\n%s", format.Object(actual, 1))
+	}
+	if !isNumber(matcher.CompareTo[0]) {
+		return false, fmt.Errorf("Expected a number.  Got:\n%s", format.Object(matcher.CompareTo[0], 1))
+	}
+	if len(matcher.CompareTo) == 2 && !isNumber(matcher.CompareTo[1]) {
+		return false, fmt.Errorf("Expected a number.  Got:\n%s", format.Object(matcher.CompareTo[0], 1))
+	}
+
+	switch matcher.Comparator {
+	case "==", "~", ">", ">=", "<", "<=":
+	default:
+		return false, fmt.Errorf("Unknown comparator: %s", matcher.Comparator)
+	}
+
+	if isFloat(actual) || isFloat(matcher.CompareTo[0]) {
+		var secondOperand float64 = 1e-8
+		if len(matcher.CompareTo) == 2 {
+			secondOperand = toFloat(matcher.CompareTo[1])
+		}
+		success = matcher.matchFloats(toFloat(actual), toFloat(matcher.CompareTo[0]), secondOperand)
+	} else if isInteger(actual) {
+		var secondOperand int64 = 0
+		if len(matcher.CompareTo) == 2 {
+			secondOperand = toInteger(matcher.CompareTo[1])
+		}
+		success = matcher.matchIntegers(toInteger(actual), toInteger(matcher.CompareTo[0]), secondOperand)
+	} else if isUnsignedInteger(actual) {
+		var secondOperand uint64 = 0
+		if len(matcher.CompareTo) == 2 {
+			secondOperand = toUnsignedInteger(matcher.CompareTo[1])
+		}
+		success = matcher.matchUnsignedIntegers(toUnsignedInteger(actual), toUnsignedInteger(matcher.CompareTo[0]), secondOperand)
+	} else {
+		return false, fmt.Errorf("Failed to compare:\n%s\n%s:\n%s", format.Object(actual, 1), matcher.Comparator, format.Object(matcher.CompareTo[0], 1))
+	}
+
+	return success, nil
+}
+
+func (matcher *BeNumericallyMatcher) matchIntegers(actual, compareTo, threshold int64) (success bool) {
+	switch matcher.Comparator {
+	case "==", "~":
+		diff := actual - compareTo
+		return -threshold <= diff && diff <= threshold
+	case ">":
+		return (actual > compareTo)
+	case ">=":
+		return (actual >= compareTo)
+	case "<":
+		return (actual < compareTo)
+	case "<=":
+		return (actual <= compareTo)
+	}
+	return false
+}
+
+func (matcher *BeNumericallyMatcher) matchUnsignedIntegers(actual, compareTo, threshold uint64) (success bool) {
+	switch matcher.Comparator {
+	case "==", "~":
+		if actual < compareTo {
+			actual, compareTo = compareTo, actual
+		}
+		return actual-compareTo <= threshold
+	case ">":
+		return (actual > compareTo)
+	case ">=":
+		return (actual >= compareTo)
+	case "<":
+		return (actual < compareTo)
+	case "<=":
+		return (actual <= compareTo)
+	}
+	return false
+}
+
+func (matcher *BeNumericallyMatcher) matchFloats(actual, compareTo, threshold float64) (success bool) {
+	switch matcher.Comparator {
+	case "~":
+		return math.Abs(actual-compareTo) <= threshold
+	case "==":
+		return (actual == compareTo)
+	case ">":
+		return (actual > compareTo)
+	case ">=":
+		return (actual >= compareTo)
+	case "<":
+		return (actual < compareTo)
+	case "<=":
+		return (actual <= compareTo)
+	}
+	return false
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher_test.go
new file mode 100644
index 000000000..a32d2b8b1
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher_test.go
@@ -0,0 +1,172 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeNumerically", func() {
+	Context("when passed a number", func() {
+		It("should support ==", func() {
+			Expect(uint32(5)).Should(BeNumerically("==", 5))
+			Expect(float64(5.0)).Should(BeNumerically("==", 5))
+			Expect(int8(5)).Should(BeNumerically("==", 5))
+		})
+
+		It("should not have false positives", func() {
+			Expect(5.1).ShouldNot(BeNumerically("==", 5))
+			Expect(5).ShouldNot(BeNumerically("==", 5.1))
+		})
+
+		It("should support >", func() {
+			Expect(uint32(5)).Should(BeNumerically(">", 4))
+			Expect(float64(5.0)).Should(BeNumerically(">", 4.9))
+			Expect(int8(5)).Should(BeNumerically(">", 4))
+
+			Expect(uint32(5)).ShouldNot(BeNumerically(">", 5))
+			Expect(float64(5.0)).ShouldNot(BeNumerically(">", 5.0))
+			Expect(int8(5)).ShouldNot(BeNumerically(">", 5))
+		})
+
+		It("should support <", func() {
+			Expect(uint32(5)).Should(BeNumerically("<", 6))
+			Expect(float64(5.0)).Should(BeNumerically("<", 5.1))
+			Expect(int8(5)).Should(BeNumerically("<", 6))
+
+			Expect(uint32(5)).ShouldNot(BeNumerically("<", 5))
+			Expect(float64(5.0)).ShouldNot(BeNumerically("<", 5.0))
+			Expect(int8(5)).ShouldNot(BeNumerically("<", 5))
+		})
+
+		It("should support >=", func() {
+			Expect(uint32(5)).Should(BeNumerically(">=", 4))
+			Expect(float64(5.0)).Should(BeNumerically(">=", 4.9))
+			Expect(int8(5)).Should(BeNumerically(">=", 4))
+
+			Expect(uint32(5)).Should(BeNumerically(">=", 5))
+			Expect(float64(5.0)).Should(BeNumerically(">=", 5.0))
+			Expect(int8(5)).Should(BeNumerically(">=", 5))
+
+			Expect(uint32(5)).ShouldNot(BeNumerically(">=", 6))
+			Expect(float64(5.0)).ShouldNot(BeNumerically(">=", 5.1))
+			Expect(int8(5)).ShouldNot(BeNumerically(">=", 6))
+		})
+
+		It("should support <=", func() {
+			Expect(uint32(5)).Should(BeNumerically("<=", 6))
+			Expect(float64(5.0)).Should(BeNumerically("<=", 5.1))
+			Expect(int8(5)).Should(BeNumerically("<=", 6))
+
+			Expect(uint32(5)).Should(BeNumerically("<=", 5))
+			Expect(float64(5.0)).Should(BeNumerically("<=", 5.0))
+			Expect(int8(5)).Should(BeNumerically("<=", 5))
+
+			Expect(uint32(5)).ShouldNot(BeNumerically("<=", 4))
+			Expect(float64(5.0)).ShouldNot(BeNumerically("<=", 4.9))
+			Expect(int8(5)).Should(BeNumerically("<=", 5))
+		})
+
+		Context("when passed ~", func() {
+			Context("when passed a float", func() {
+				Context("and there is no precision parameter", func() {
+					It("should default to 1e-8", func() {
+						Expect(5.00000001).Should(BeNumerically("~", 5.00000002))
+						Expect(5.00000001).ShouldNot(BeNumerically("~", 5.0000001))
+					})
+
+					It("should show failure message", func() {
+						actual := BeNumerically("~", 4.98).FailureMessage(123)
+						expected := "Expected\n    <int>: 123\nto be ~\n    <float64>: 4.98"
+						Expect(actual).To(Equal(expected))
+					})
+
+					It("should show negated failure message", func() {
+						actual := BeNumerically("~", 4.98).NegatedFailureMessage(123)
+						expected := "Expected\n    <int>: 123\nnot to be ~\n    <float64>: 4.98"
+						Expect(actual).To(Equal(expected))
+					})
+				})
+
+				Context("and there is a precision parameter", func() {
+					It("should use the precision parameter", func() {
+						Expect(5.1).Should(BeNumerically("~", 5.19, 0.1))
+						Expect(5.1).Should(BeNumerically("~", 5.01, 0.1))
+						Expect(5.1).ShouldNot(BeNumerically("~", 5.22, 0.1))
+						Expect(5.1).ShouldNot(BeNumerically("~", 4.98, 0.1))
+					})
+
+					It("should show precision in failure message", func() {
+						actual := BeNumerically("~", 4.98, 0.1).FailureMessage(123)
+						expected := "Expected\n    <int>: 123\nto be within 0.1 of ~\n    <float64>: 4.98"
+						Expect(actual).To(Equal(expected))
+					})
+
+					It("should show precision in negated failure message", func() {
+						actual := BeNumerically("~", 4.98, 0.1).NegatedFailureMessage(123)
+						expected := "Expected\n    <int>: 123\nnot to be within 0.1 of ~\n    <float64>: 4.98"
+						Expect(actual).To(Equal(expected))
+					})
+				})
+			})
+
+			Context("when passed an int/uint", func() {
+				Context("and there is no precision parameter", func() {
+					It("should just do strict equality", func() {
+						Expect(5).Should(BeNumerically("~", 5))
+						Expect(5).ShouldNot(BeNumerically("~", 6))
+						Expect(uint(5)).ShouldNot(BeNumerically("~", 6))
+					})
+				})
+
+				Context("and there is a precision parameter", func() {
+					It("should use precision paramter", func() {
+						Expect(5).Should(BeNumerically("~", 6, 2))
+						Expect(5).ShouldNot(BeNumerically("~", 8, 2))
+						Expect(uint(5)).Should(BeNumerically("~", 6, 1))
+					})
+				})
+			})
+		})
+	})
+
+	Context("when passed a non-number", func() {
+		It("should error", func() {
+			success, err := (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{5}}).Match("foo")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeNumericallyMatcher{Comparator: "=="}).Match(5)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeNumericallyMatcher{Comparator: "~", CompareTo: []interface{}{3.0, "foo"}}).Match(5.0)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{"bar"}}).Match(5)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{"bar"}}).Match("foo")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{nil}}).Match(0)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{0}}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed an unsupported comparator", func() {
+		It("should error", func() {
+			success, err := (&BeNumericallyMatcher{Comparator: "!=", CompareTo: []interface{}{5}}).Match(4)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_sent_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_sent_matcher.go
new file mode 100644
index 000000000..302dd1a0a
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_sent_matcher.go
@@ -0,0 +1,71 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeSentMatcher struct {
+	Arg           interface{}
+	channelClosed bool
+}
+
+func (matcher *BeSentMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isChan(actual) {
+		return false, fmt.Errorf("BeSent expects a channel.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	channelType := reflect.TypeOf(actual)
+	channelValue := reflect.ValueOf(actual)
+
+	if channelType.ChanDir() == reflect.RecvDir {
+		return false, fmt.Errorf("BeSent matcher cannot be passed a receive-only channel.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	argType := reflect.TypeOf(matcher.Arg)
+	assignable := argType.AssignableTo(channelType.Elem())
+
+	if !assignable {
+		return false, fmt.Errorf("Cannot pass:\n%s to the channel:\n%s\nThe types don't match.", format.Object(matcher.Arg, 1), format.Object(actual, 1))
+	}
+
+	argValue := reflect.ValueOf(matcher.Arg)
+
+	defer func() {
+		if e := recover(); e != nil {
+			success = false
+			err = fmt.Errorf("Cannot send to a closed channel")
+			matcher.channelClosed = true
+		}
+	}()
+
+	winnerIndex, _, _ := reflect.Select([]reflect.SelectCase{
+		{Dir: reflect.SelectSend, Chan: channelValue, Send: argValue},
+		{Dir: reflect.SelectDefault},
+	})
+
+	var didSend bool
+	if winnerIndex == 0 {
+		didSend = true
+	}
+
+	return didSend, nil
+}
+
+func (matcher *BeSentMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to send:", matcher.Arg)
+}
+
+func (matcher *BeSentMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to send:", matcher.Arg)
+}
+
+func (matcher *BeSentMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+	if !isChan(actual) {
+		return false
+	}
+
+	return !matcher.channelClosed
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_sent_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_sent_matcher_test.go
new file mode 100644
index 000000000..68ec72879
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_sent_matcher_test.go
@@ -0,0 +1,107 @@
+package matchers_test
+
+import (
+	"time"
+
+	. "github.com/onsi/gomega/matchers"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("BeSent", func() {
+	Context("when passed a channel and a matching type", func() {
+		Context("when the channel is ready to receive", func() {
+			It("should succeed and send the value down the channel", func() {
+				c := make(chan string)
+				d := make(chan string)
+				go func() {
+					val := <-c
+					d <- val
+				}()
+
+				time.Sleep(10 * time.Millisecond)
+
+				Expect(c).Should(BeSent("foo"))
+				Eventually(d).Should(Receive(Equal("foo")))
+			})
+
+			It("should succeed (with a buffered channel)", func() {
+				c := make(chan string, 1)
+				Expect(c).Should(BeSent("foo"))
+				Expect(<-c).Should(Equal("foo"))
+			})
+		})
+
+		Context("when the channel is not ready to receive", func() {
+			It("should fail and not send down the channel", func() {
+				c := make(chan string)
+				Expect(c).ShouldNot(BeSent("foo"))
+				Consistently(c).ShouldNot(Receive())
+			})
+		})
+
+		Context("when the channel is eventually ready to receive", func() {
+			It("should succeed", func() {
+				c := make(chan string)
+				d := make(chan string)
+				go func() {
+					time.Sleep(30 * time.Millisecond)
+					val := <-c
+					d <- val
+				}()
+
+				Eventually(c).Should(BeSent("foo"))
+				Eventually(d).Should(Receive(Equal("foo")))
+			})
+		})
+
+		Context("when the channel is closed", func() {
+			It("should error", func() {
+				c := make(chan string)
+				close(c)
+				success, err := (&BeSentMatcher{Arg: "foo"}).Match(c)
+				Expect(success).Should(BeFalse())
+				Expect(err).Should(HaveOccurred())
+			})
+
+			It("should short-circuit Eventually", func() {
+				c := make(chan string)
+				close(c)
+
+				t := time.Now()
+				failures := InterceptGomegaFailures(func() {
+					Eventually(c, 10.0).Should(BeSent("foo"))
+				})
+				Expect(failures).Should(HaveLen(1))
+				Expect(time.Since(t)).Should(BeNumerically("<", time.Second))
+			})
+		})
+	})
+
+	Context("when passed a channel and a non-matching type", func() {
+		It("should error", func() {
+			success, err := (&BeSentMatcher{Arg: "foo"}).Match(make(chan int, 1))
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed a receive-only channel", func() {
+		It("should error", func() {
+			var c <-chan string
+			c = make(chan string, 1)
+			success, err := (&BeSentMatcher{Arg: "foo"}).Match(c)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed a nonchannel", func() {
+		It("should error", func() {
+			success, err := (&BeSentMatcher{Arg: "foo"}).Match("bar")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher.go
new file mode 100644
index 000000000..cb7c038ef
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher.go
@@ -0,0 +1,66 @@
+package matchers
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeTemporallyMatcher struct {
+	Comparator string
+	CompareTo  time.Time
+	Threshold  []time.Duration
+}
+
+func (matcher *BeTemporallyMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("to be %s", matcher.Comparator), matcher.CompareTo)
+}
+
+func (matcher *BeTemporallyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("not to be %s", matcher.Comparator), matcher.CompareTo)
+}
+
+func (matcher *BeTemporallyMatcher) Match(actual interface{}) (bool, error) {
+	// predicate to test for time.Time type
+	isTime := func(t interface{}) bool {
+		_, ok := t.(time.Time)
+		return ok
+	}
+
+	if !isTime(actual) {
+		return false, fmt.Errorf("Expected a time.Time.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	switch matcher.Comparator {
+	case "==", "~", ">", ">=", "<", "<=":
+	default:
+		return false, fmt.Errorf("Unknown comparator: %s", matcher.Comparator)
+	}
+
+	var threshold = time.Millisecond
+	if len(matcher.Threshold) == 1 {
+		threshold = matcher.Threshold[0]
+	}
+
+	return matcher.matchTimes(actual.(time.Time), matcher.CompareTo, threshold), nil
+}
+
+func (matcher *BeTemporallyMatcher) matchTimes(actual, compareTo time.Time, threshold time.Duration) (success bool) {
+	switch matcher.Comparator {
+	case "==":
+		return actual.Equal(compareTo)
+	case "~":
+		diff := actual.Sub(compareTo)
+		return -threshold <= diff && diff <= threshold
+	case ">":
+		return actual.After(compareTo)
+	case ">=":
+		return !actual.Before(compareTo)
+	case "<":
+		return actual.Before(compareTo)
+	case "<=":
+		return !actual.After(compareTo)
+	}
+	return false
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher_test.go
new file mode 100644
index 000000000..95a3a103e
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher_test.go
@@ -0,0 +1,99 @@
+package matchers_test
+
+import (
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeTemporally", func() {
+
+	var t0, t1, t2 time.Time
+	BeforeEach(func() {
+		t0 = time.Now()
+		t1 = t0.Add(time.Second)
+		t2 = t0.Add(-time.Second)
+	})
+
+	Context("When comparing times", func() {
+
+		It("should support ==", func() {
+			Expect(t0).Should(BeTemporally("==", t0))
+			Expect(t1).ShouldNot(BeTemporally("==", t0))
+			Expect(t0).ShouldNot(BeTemporally("==", t1))
+			Expect(t0).ShouldNot(BeTemporally("==", time.Time{}))
+		})
+
+		It("should support >", func() {
+			Expect(t0).Should(BeTemporally(">", t2))
+			Expect(t0).ShouldNot(BeTemporally(">", t0))
+			Expect(t2).ShouldNot(BeTemporally(">", t0))
+		})
+
+		It("should support <", func() {
+			Expect(t0).Should(BeTemporally("<", t1))
+			Expect(t0).ShouldNot(BeTemporally("<", t0))
+			Expect(t1).ShouldNot(BeTemporally("<", t0))
+		})
+
+		It("should support >=", func() {
+			Expect(t0).Should(BeTemporally(">=", t2))
+			Expect(t0).Should(BeTemporally(">=", t0))
+			Expect(t0).ShouldNot(BeTemporally(">=", t1))
+		})
+
+		It("should support <=", func() {
+			Expect(t0).Should(BeTemporally("<=", t1))
+			Expect(t0).Should(BeTemporally("<=", t0))
+			Expect(t0).ShouldNot(BeTemporally("<=", t2))
+		})
+
+		Context("when passed ~", func() {
+			Context("and there is no precision parameter", func() {
+				BeforeEach(func() {
+					t1 = t0.Add(time.Millisecond / 2)
+					t2 = t0.Add(-2 * time.Millisecond)
+				})
+				It("should approximate", func() {
+					Expect(t0).Should(BeTemporally("~", t0))
+					Expect(t0).Should(BeTemporally("~", t1))
+					Expect(t0).ShouldNot(BeTemporally("~", t2))
+				})
+			})
+
+			Context("and there is a precision parameter", func() {
+				BeforeEach(func() {
+					t2 = t0.Add(3 * time.Second)
+				})
+				It("should use precision paramter", func() {
+					d := 2 * time.Second
+					Expect(t0).Should(BeTemporally("~", t0, d))
+					Expect(t0).Should(BeTemporally("~", t1, d))
+					Expect(t0).ShouldNot(BeTemporally("~", t2, d))
+				})
+			})
+		})
+	})
+
+	Context("when passed a non-time", func() {
+		It("should error", func() {
+			success, err := (&BeTemporallyMatcher{Comparator: "==", CompareTo: t0}).Match("foo")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&BeTemporallyMatcher{Comparator: "=="}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed an unsupported comparator", func() {
+		It("should error", func() {
+			success, err := (&BeTemporallyMatcher{Comparator: "!=", CompareTo: t0}).Match(t2)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_true_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_true_matcher.go
new file mode 100644
index 000000000..ec57c5db4
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_true_matcher.go
@@ -0,0 +1,26 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeTrueMatcher struct {
+}
+
+func (matcher *BeTrueMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isBool(actual) {
+		return false, fmt.Errorf("Expected a boolean.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	return actual.(bool), nil
+}
+
+func (matcher *BeTrueMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be true")
+}
+
+func (matcher *BeTrueMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to be true")
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_true_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_true_matcher_test.go
new file mode 100644
index 000000000..9eda62c33
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_true_matcher_test.go
@@ -0,0 +1,20 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("BeTrue", func() {
+	It("should handle true and false correctly", func() {
+		Expect(true).Should(BeTrue())
+		Expect(false).ShouldNot(BeTrue())
+	})
+
+	It("should only support booleans", func() {
+		success, err := (&BeTrueMatcher{}).Match("foo")
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(HaveOccurred())
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_zero_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_zero_matcher.go
new file mode 100644
index 000000000..26196f168
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_zero_matcher.go
@@ -0,0 +1,28 @@
+package matchers
+
+import (
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type BeZeroMatcher struct {
+}
+
+func (matcher *BeZeroMatcher) Match(actual interface{}) (success bool, err error) {
+	if actual == nil {
+		return true, nil
+	}
+	zeroValue := reflect.Zero(reflect.TypeOf(actual)).Interface()
+
+	return reflect.DeepEqual(zeroValue, actual), nil
+
+}
+
+func (matcher *BeZeroMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to be zero-valued")
+}
+
+func (matcher *BeZeroMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to be zero-valued")
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/be_zero_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_zero_matcher_test.go
new file mode 100644
index 000000000..c89e10330
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/be_zero_matcher_test.go
@@ -0,0 +1,40 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("BeZero", func() {
+	It("succeeds for zero values for its type", func() {
+		Expect(nil).Should(BeZero())
+
+		Expect("").Should(BeZero())
+		Expect(" ").ShouldNot(BeZero())
+
+		Expect(0).Should(BeZero())
+		Expect(1).ShouldNot(BeZero())
+
+		Expect(0.0).Should(BeZero())
+		Expect(0.1).ShouldNot(BeZero())
+
+		// Expect([]int{}).Should(BeZero())
+		Expect([]int{1}).ShouldNot(BeZero())
+
+		// Expect(map[string]int{}).Should(BeZero())
+		Expect(map[string]int{"a": 1}).ShouldNot(BeZero())
+
+		Expect(myCustomType{}).Should(BeZero())
+		Expect(myCustomType{s: "a"}).ShouldNot(BeZero())
+	})
+
+	It("builds failure message", func() {
+		actual := BeZero().FailureMessage(123)
+		Expect(actual).To(Equal("Expected\n    <int>: 123\nto be zero-valued"))
+	})
+
+	It("builds negated failure message", func() {
+		actual := BeZero().NegatedFailureMessage(123)
+		Expect(actual).To(Equal("Expected\n    <int>: 123\nnot to be zero-valued"))
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/consist_of.go b/vendor/github.com/onsi/gomega/matchers/consist_of.go
new file mode 100644
index 000000000..7b0e08868
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/consist_of.go
@@ -0,0 +1,80 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+	"github.com/onsi/gomega/matchers/support/goraph/bipartitegraph"
+)
+
+type ConsistOfMatcher struct {
+	Elements []interface{}
+}
+
+func (matcher *ConsistOfMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isArrayOrSlice(actual) && !isMap(actual) {
+		return false, fmt.Errorf("ConsistOf matcher expects an array/slice/map.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	elements := matcher.Elements
+	if len(matcher.Elements) == 1 && isArrayOrSlice(matcher.Elements[0]) {
+		elements = []interface{}{}
+		value := reflect.ValueOf(matcher.Elements[0])
+		for i := 0; i < value.Len(); i++ {
+			elements = append(elements, value.Index(i).Interface())
+		}
+	}
+
+	matchers := []interface{}{}
+	for _, element := range elements {
+		matcher, isMatcher := element.(omegaMatcher)
+		if !isMatcher {
+			matcher = &EqualMatcher{Expected: element}
+		}
+		matchers = append(matchers, matcher)
+	}
+
+	values := matcher.valuesOf(actual)
+
+	if len(values) != len(matchers) {
+		return false, nil
+	}
+
+	neighbours := func(v, m interface{}) (bool, error) {
+		match, err := m.(omegaMatcher).Match(v)
+		return match && err == nil, nil
+	}
+
+	bipartiteGraph, err := bipartitegraph.NewBipartiteGraph(values, matchers, neighbours)
+	if err != nil {
+		return false, err
+	}
+
+	return len(bipartiteGraph.LargestMatching()) == len(values), nil
+}
+
+func (matcher *ConsistOfMatcher) valuesOf(actual interface{}) []interface{} {
+	value := reflect.ValueOf(actual)
+	values := []interface{}{}
+	if isMap(actual) {
+		keys := value.MapKeys()
+		for i := 0; i < value.Len(); i++ {
+			values = append(values, value.MapIndex(keys[i]).Interface())
+		}
+	} else {
+		for i := 0; i < value.Len(); i++ {
+			values = append(values, value.Index(i).Interface())
+		}
+	}
+
+	return values
+}
+
+func (matcher *ConsistOfMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to consist of", matcher.Elements)
+}
+
+func (matcher *ConsistOfMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to consist of", matcher.Elements)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/consist_of_test.go b/vendor/github.com/onsi/gomega/matchers/consist_of_test.go
new file mode 100644
index 000000000..f6971c4f5
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/consist_of_test.go
@@ -0,0 +1,75 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ConsistOf", func() {
+	Context("with a slice", func() {
+		It("should do the right thing", func() {
+			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
+			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
+			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("baz", "bar", "foo"))
+			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
+			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "foo"))
+		})
+	})
+
+	Context("with an array", func() {
+		It("should do the right thing", func() {
+			Expect([3]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
+			Expect([3]string{"foo", "bar", "baz"}).Should(ConsistOf("baz", "bar", "foo"))
+			Expect([3]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
+			Expect([3]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "foo"))
+		})
+	})
+
+	Context("with a map", func() {
+		It("should apply to the values", func() {
+			Expect(map[int]string{1: "foo", 2: "bar", 3: "baz"}).Should(ConsistOf("foo", "bar", "baz"))
+			Expect(map[int]string{1: "foo", 2: "bar", 3: "baz"}).Should(ConsistOf("baz", "bar", "foo"))
+			Expect(map[int]string{1: "foo", 2: "bar", 3: "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
+			Expect(map[int]string{1: "foo", 2: "bar", 3: "baz"}).ShouldNot(ConsistOf("baz", "foo"))
+		})
+
+	})
+
+	Context("with anything else", func() {
+		It("should error", func() {
+			failures := InterceptGomegaFailures(func() {
+				Expect("foo").Should(ConsistOf("f", "o", "o"))
+			})
+
+			Expect(failures).Should(HaveLen(1))
+		})
+	})
+
+	Context("when passed matchers", func() {
+		It("should pass if the matchers pass", func() {
+			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", MatchRegexp("^ba"), "baz"))
+			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba")))
+			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("foo")))
+			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("^ba")))
+			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("turducken")))
+		})
+
+		It("should not depend on the order of the matchers", func() {
+			Expect([][]int{{1, 2}, {2}}).Should(ConsistOf(ContainElement(1), ContainElement(2)))
+			Expect([][]int{{1, 2}, {2}}).Should(ConsistOf(ContainElement(2), ContainElement(1)))
+		})
+
+		Context("when a matcher errors", func() {
+			It("should soldier on", func() {
+				Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf(BeFalse(), "foo", "bar"))
+				Expect([]interface{}{"foo", "bar", false}).Should(ConsistOf(BeFalse(), ContainSubstring("foo"), "bar"))
+			})
+		})
+	})
+
+	Context("when passed exactly one argument, and that argument is a slice", func() {
+		It("should match against the elements of that argument", func() {
+			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf([]string{"foo", "bar", "baz"}))
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/contain_element_matcher.go b/vendor/github.com/onsi/gomega/matchers/contain_element_matcher.go
new file mode 100644
index 000000000..4159335d0
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/contain_element_matcher.go
@@ -0,0 +1,56 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type ContainElementMatcher struct {
+	Element interface{}
+}
+
+func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isArrayOrSlice(actual) && !isMap(actual) {
+		return false, fmt.Errorf("ContainElement matcher expects an array/slice/map.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	elemMatcher, elementIsMatcher := matcher.Element.(omegaMatcher)
+	if !elementIsMatcher {
+		elemMatcher = &EqualMatcher{Expected: matcher.Element}
+	}
+
+	value := reflect.ValueOf(actual)
+	var keys []reflect.Value
+	if isMap(actual) {
+		keys = value.MapKeys()
+	}
+	var lastError error
+	for i := 0; i < value.Len(); i++ {
+		var success bool
+		var err error
+		if isMap(actual) {
+			success, err = elemMatcher.Match(value.MapIndex(keys[i]).Interface())
+		} else {
+			success, err = elemMatcher.Match(value.Index(i).Interface())
+		}
+		if err != nil {
+			lastError = err
+			continue
+		}
+		if success {
+			return true, nil
+		}
+	}
+
+	return false, lastError
+}
+
+func (matcher *ContainElementMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to contain element matching", matcher.Element)
+}
+
+func (matcher *ContainElementMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to contain element matching", matcher.Element)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/contain_element_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/contain_element_matcher_test.go
new file mode 100644
index 000000000..60fb55e96
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/contain_element_matcher_test.go
@@ -0,0 +1,76 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("ContainElement", func() {
+	Context("when passed a supported type", func() {
+		Context("and expecting a non-matcher", func() {
+			It("should do the right thing", func() {
+				Expect([2]int{1, 2}).Should(ContainElement(2))
+				Expect([2]int{1, 2}).ShouldNot(ContainElement(3))
+
+				Expect([]int{1, 2}).Should(ContainElement(2))
+				Expect([]int{1, 2}).ShouldNot(ContainElement(3))
+
+				Expect(map[string]int{"foo": 1, "bar": 2}).Should(ContainElement(2))
+				Expect(map[int]int{3: 1, 4: 2}).ShouldNot(ContainElement(3))
+
+				arr := make([]myCustomType, 2)
+				arr[0] = myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}
+				arr[1] = myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "c"}}
+				Expect(arr).Should(ContainElement(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}))
+				Expect(arr).ShouldNot(ContainElement(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"b", "c"}}))
+			})
+		})
+
+		Context("and expecting a matcher", func() {
+			It("should pass each element through the matcher", func() {
+				Expect([]int{1, 2, 3}).Should(ContainElement(BeNumerically(">=", 3)))
+				Expect([]int{1, 2, 3}).ShouldNot(ContainElement(BeNumerically(">", 3)))
+				Expect(map[string]int{"foo": 1, "bar": 2}).Should(ContainElement(BeNumerically(">=", 2)))
+				Expect(map[string]int{"foo": 1, "bar": 2}).ShouldNot(ContainElement(BeNumerically(">", 2)))
+			})
+
+			It("should power through even if the matcher ever fails", func() {
+				Expect([]interface{}{1, 2, "3", 4}).Should(ContainElement(BeNumerically(">=", 3)))
+			})
+
+			It("should fail if the matcher fails", func() {
+				actual := []interface{}{1, 2, "3", "4"}
+				success, err := (&ContainElementMatcher{Element: BeNumerically(">=", 3)}).Match(actual)
+				Expect(success).Should(BeFalse())
+				Expect(err).Should(HaveOccurred())
+			})
+		})
+	})
+
+	Context("when passed a correctly typed nil", func() {
+		It("should operate succesfully on the passed in value", func() {
+			var nilSlice []int
+			Expect(nilSlice).ShouldNot(ContainElement(1))
+
+			var nilMap map[int]string
+			Expect(nilMap).ShouldNot(ContainElement("foo"))
+		})
+	})
+
+	Context("when passed an unsupported type", func() {
+		It("should error", func() {
+			success, err := (&ContainElementMatcher{Element: 0}).Match(0)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&ContainElementMatcher{Element: 0}).Match("abc")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&ContainElementMatcher{Element: 0}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher.go b/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher.go
new file mode 100644
index 000000000..f8dc41e74
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher.go
@@ -0,0 +1,38 @@
+package matchers
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/onsi/gomega/format"
+)
+
+type ContainSubstringMatcher struct {
+	Substr string
+	Args   []interface{}
+}
+
+func (matcher *ContainSubstringMatcher) Match(actual interface{}) (success bool, err error) {
+	actualString, ok := toString(actual)
+	if !ok {
+		return false, fmt.Errorf("ContainSubstring matcher requires a string or stringer.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	return strings.Contains(actualString, matcher.stringToMatch()), nil
+}
+
+func (matcher *ContainSubstringMatcher) stringToMatch() string {
+	stringToMatch := matcher.Substr
+	if len(matcher.Args) > 0 {
+		stringToMatch = fmt.Sprintf(matcher.Substr, matcher.Args...)
+	}
+	return stringToMatch
+}
+
+func (matcher *ContainSubstringMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to contain substring", matcher.stringToMatch())
+}
+
+func (matcher *ContainSubstringMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to contain substring", matcher.stringToMatch())
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher_test.go
new file mode 100644
index 000000000..efffb4732
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher_test.go
@@ -0,0 +1,36 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("ContainSubstringMatcher", func() {
+	Context("when actual is a string", func() {
+		It("should match against the string", func() {
+			Expect("Marvelous").Should(ContainSubstring("rve"))
+			Expect("Marvelous").ShouldNot(ContainSubstring("boo"))
+		})
+	})
+
+	Context("when the matcher is called with multiple arguments", func() {
+		It("should pass the string and arguments to sprintf", func() {
+			Expect("Marvelous3").Should(ContainSubstring("velous%d", 3))
+		})
+	})
+
+	Context("when actual is a stringer", func() {
+		It("should call the stringer and match agains the returned string", func() {
+			Expect(&myStringer{a: "Abc3"}).Should(ContainSubstring("bc3"))
+		})
+	})
+
+	Context("when actual is neither a string nor a stringer", func() {
+		It("should error", func() {
+			success, err := (&ContainSubstringMatcher{Substr: "2"}).Match(2)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/equal_matcher.go b/vendor/github.com/onsi/gomega/matchers/equal_matcher.go
new file mode 100644
index 000000000..befb7bdfd
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/equal_matcher.go
@@ -0,0 +1,42 @@
+package matchers
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type EqualMatcher struct {
+	Expected interface{}
+}
+
+func (matcher *EqualMatcher) Match(actual interface{}) (success bool, err error) {
+	if actual == nil && matcher.Expected == nil {
+		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
+	}
+	// Shortcut for byte slices.
+	// Comparing long byte slices with reflect.DeepEqual is very slow,
+	// so use bytes.Equal if actual and expected are both byte slices.
+	if actualByteSlice, ok := actual.([]byte); ok {
+		if expectedByteSlice, ok := matcher.Expected.([]byte); ok {
+			return bytes.Equal(actualByteSlice, expectedByteSlice), nil
+		}
+	}
+	return reflect.DeepEqual(actual, matcher.Expected), nil
+}
+
+func (matcher *EqualMatcher) FailureMessage(actual interface{}) (message string) {
+	actualString, actualOK := actual.(string)
+	expectedString, expectedOK := matcher.Expected.(string)
+	if actualOK && expectedOK {
+		return format.MessageWithDiff(actualString, "to equal", expectedString)
+	}
+
+	return format.Message(actual, "to equal", matcher.Expected)
+}
+
+func (matcher *EqualMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to equal", matcher.Expected)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/equal_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/equal_matcher_test.go
new file mode 100644
index 000000000..3ab991e4f
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/equal_matcher_test.go
@@ -0,0 +1,80 @@
+package matchers_test
+
+import (
+	"errors"
+	"strings"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("Equal", func() {
+	Context("when asserting that nil equals nil", func() {
+		It("should error", func() {
+			success, err := (&EqualMatcher{Expected: nil}).Match(nil)
+
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("When asserting equality between objects", func() {
+		It("should do the right thing", func() {
+			Expect(5).Should(Equal(5))
+			Expect(5.0).Should(Equal(5.0))
+
+			Expect(5).ShouldNot(Equal("5"))
+			Expect(5).ShouldNot(Equal(5.0))
+			Expect(5).ShouldNot(Equal(3))
+
+			Expect("5").Should(Equal("5"))
+			Expect([]int{1, 2}).Should(Equal([]int{1, 2}))
+			Expect([]int{1, 2}).ShouldNot(Equal([]int{2, 1}))
+			Expect([]byte{'f', 'o', 'o'}).Should(Equal([]byte{'f', 'o', 'o'}))
+			Expect([]byte{'f', 'o', 'o'}).ShouldNot(Equal([]byte{'b', 'a', 'r'}))
+			Expect(map[string]string{"a": "b", "c": "d"}).Should(Equal(map[string]string{"a": "b", "c": "d"}))
+			Expect(map[string]string{"a": "b", "c": "d"}).ShouldNot(Equal(map[string]string{"a": "b", "c": "e"}))
+			Expect(errors.New("foo")).Should(Equal(errors.New("foo")))
+			Expect(errors.New("foo")).ShouldNot(Equal(errors.New("bar")))
+
+			Expect(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).Should(Equal(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}))
+			Expect(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).ShouldNot(Equal(myCustomType{s: "bar", n: 3, f: 2.0, arr: []string{"a", "b"}}))
+			Expect(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).ShouldNot(Equal(myCustomType{s: "foo", n: 2, f: 2.0, arr: []string{"a", "b"}}))
+			Expect(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).ShouldNot(Equal(myCustomType{s: "foo", n: 3, f: 3.0, arr: []string{"a", "b"}}))
+			Expect(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).ShouldNot(Equal(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b", "c"}}))
+		})
+	})
+
+	Describe("failure messages", func() {
+		It("shows the two strings simply when they are short", func() {
+			subject := EqualMatcher{Expected: "eric"}
+
+			failureMessage := subject.FailureMessage("tim")
+			Expect(failureMessage).To(BeEquivalentTo(expectedShortStringFailureMessage))
+		})
+
+		It("shows the exact point where two long strings differ", func() {
+			stringWithB := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+			stringWithZ := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+
+			subject := EqualMatcher{Expected: stringWithZ}
+
+			failureMessage := subject.FailureMessage(stringWithB)
+			Expect(failureMessage).To(BeEquivalentTo(expectedLongStringFailureMessage))
+		})
+	})
+})
+
+var expectedShortStringFailureMessage = strings.TrimSpace(`
+Expected
+    <string>: tim
+to equal
+    <string>: eric
+`)
+var expectedLongStringFailureMessage = strings.TrimSpace(`
+Expected
+    <string>: "...aaaaabaaaaa..."
+to equal               |
+    <string>: "...aaaaazaaaaa..."
+`)
diff --git a/vendor/github.com/onsi/gomega/matchers/have_cap_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_cap_matcher.go
new file mode 100644
index 000000000..7ace93dc3
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_cap_matcher.go
@@ -0,0 +1,28 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HaveCapMatcher struct {
+	Count int
+}
+
+func (matcher *HaveCapMatcher) Match(actual interface{}) (success bool, err error) {
+	length, ok := capOf(actual)
+	if !ok {
+		return false, fmt.Errorf("HaveCap matcher expects a array/channel/slice.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	return length == matcher.Count, nil
+}
+
+func (matcher *HaveCapMatcher) FailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected\n%s\nto have capacity %d", format.Object(actual, 1), matcher.Count)
+}
+
+func (matcher *HaveCapMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected\n%s\nnot to have capacity %d", format.Object(actual, 1), matcher.Count)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_cap_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_cap_matcher_test.go
new file mode 100644
index 000000000..8a61f2e2c
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_cap_matcher_test.go
@@ -0,0 +1,50 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("HaveCap", func() {
+	Context("when passed a supported type", func() {
+		It("should do the right thing", func() {
+			Expect([0]int{}).Should(HaveCap(0))
+			Expect([2]int{1}).Should(HaveCap(2))
+
+			Expect([]int{}).Should(HaveCap(0))
+			Expect([]int{1, 2, 3, 4, 5}[:2]).Should(HaveCap(5))
+			Expect(make([]int, 0, 5)).Should(HaveCap(5))
+
+			c := make(chan bool, 3)
+			Expect(c).Should(HaveCap(3))
+			c <- true
+			c <- true
+			Expect(c).Should(HaveCap(3))
+
+			Expect(make(chan bool)).Should(HaveCap(0))
+		})
+	})
+
+	Context("when passed a correctly typed nil", func() {
+		It("should operate succesfully on the passed in value", func() {
+			var nilSlice []int
+			Expect(nilSlice).Should(HaveCap(0))
+
+			var nilChan chan int
+			Expect(nilChan).Should(HaveCap(0))
+		})
+	})
+
+	Context("when passed an unsupported type", func() {
+		It("should error", func() {
+			success, err := (&HaveCapMatcher{Count: 0}).Match(0)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&HaveCapMatcher{Count: 0}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go
new file mode 100644
index 000000000..ea5b92336
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go
@@ -0,0 +1,54 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HaveKeyMatcher struct {
+	Key interface{}
+}
+
+func (matcher *HaveKeyMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isMap(actual) {
+		return false, fmt.Errorf("HaveKey matcher expects a map.  Got:%s", format.Object(actual, 1))
+	}
+
+	keyMatcher, keyIsMatcher := matcher.Key.(omegaMatcher)
+	if !keyIsMatcher {
+		keyMatcher = &EqualMatcher{Expected: matcher.Key}
+	}
+
+	keys := reflect.ValueOf(actual).MapKeys()
+	for i := 0; i < len(keys); i++ {
+		success, err := keyMatcher.Match(keys[i].Interface())
+		if err != nil {
+			return false, fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error())
+		}
+		if success {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+func (matcher *HaveKeyMatcher) FailureMessage(actual interface{}) (message string) {
+	switch matcher.Key.(type) {
+	case omegaMatcher:
+		return format.Message(actual, "to have key matching", matcher.Key)
+	default:
+		return format.Message(actual, "to have key", matcher.Key)
+	}
+}
+
+func (matcher *HaveKeyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	switch matcher.Key.(type) {
+	case omegaMatcher:
+		return format.Message(actual, "not to have key matching", matcher.Key)
+	default:
+		return format.Message(actual, "not to have key", matcher.Key)
+	}
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_key_matcher_test.go
new file mode 100644
index 000000000..0f1561b7d
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_key_matcher_test.go
@@ -0,0 +1,73 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("HaveKey", func() {
+	var (
+		stringKeys map[string]int
+		intKeys    map[int]string
+		objKeys    map[*myCustomType]string
+
+		customA *myCustomType
+		customB *myCustomType
+	)
+	BeforeEach(func() {
+		stringKeys = map[string]int{"foo": 2, "bar": 3}
+		intKeys = map[int]string{2: "foo", 3: "bar"}
+
+		customA = &myCustomType{s: "a", n: 2, f: 2.3, arr: []string{"ice", "cream"}}
+		customB = &myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}
+		objKeys = map[*myCustomType]string{customA: "aardvark", customB: "kangaroo"}
+	})
+
+	Context("when passed a map", func() {
+		It("should do the right thing", func() {
+			Expect(stringKeys).Should(HaveKey("foo"))
+			Expect(stringKeys).ShouldNot(HaveKey("baz"))
+
+			Expect(intKeys).Should(HaveKey(2))
+			Expect(intKeys).ShouldNot(HaveKey(4))
+
+			Expect(objKeys).Should(HaveKey(customA))
+			Expect(objKeys).Should(HaveKey(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}))
+			Expect(objKeys).ShouldNot(HaveKey(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"apple", "pie"}}))
+		})
+	})
+
+	Context("when passed a correctly typed nil", func() {
+		It("should operate succesfully on the passed in value", func() {
+			var nilMap map[int]string
+			Expect(nilMap).ShouldNot(HaveKey("foo"))
+		})
+	})
+
+	Context("when the passed in key is actually a matcher", func() {
+		It("should pass each element through the matcher", func() {
+			Expect(stringKeys).Should(HaveKey(ContainSubstring("oo")))
+			Expect(stringKeys).ShouldNot(HaveKey(ContainSubstring("foobar")))
+		})
+
+		It("should fail if the matcher ever fails", func() {
+			actual := map[int]string{1: "a", 3: "b", 2: "c"}
+			success, err := (&HaveKeyMatcher{Key: ContainSubstring("ar")}).Match(actual)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed something that is not a map", func() {
+		It("should error", func() {
+			success, err := (&HaveKeyMatcher{Key: "foo"}).Match([]string{"foo"})
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&HaveKeyMatcher{Key: "foo"}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go
new file mode 100644
index 000000000..06355b1e9
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go
@@ -0,0 +1,74 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HaveKeyWithValueMatcher struct {
+	Key   interface{}
+	Value interface{}
+}
+
+func (matcher *HaveKeyWithValueMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isMap(actual) {
+		return false, fmt.Errorf("HaveKeyWithValue matcher expects a map.  Got:%s", format.Object(actual, 1))
+	}
+
+	keyMatcher, keyIsMatcher := matcher.Key.(omegaMatcher)
+	if !keyIsMatcher {
+		keyMatcher = &EqualMatcher{Expected: matcher.Key}
+	}
+
+	valueMatcher, valueIsMatcher := matcher.Value.(omegaMatcher)
+	if !valueIsMatcher {
+		valueMatcher = &EqualMatcher{Expected: matcher.Value}
+	}
+
+	keys := reflect.ValueOf(actual).MapKeys()
+	for i := 0; i < len(keys); i++ {
+		success, err := keyMatcher.Match(keys[i].Interface())
+		if err != nil {
+			return false, fmt.Errorf("HaveKeyWithValue's key matcher failed with:\n%s%s", format.Indent, err.Error())
+		}
+		if success {
+			actualValue := reflect.ValueOf(actual).MapIndex(keys[i])
+			success, err := valueMatcher.Match(actualValue.Interface())
+			if err != nil {
+				return false, fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error())
+			}
+			return success, nil
+		}
+	}
+
+	return false, nil
+}
+
+func (matcher *HaveKeyWithValueMatcher) FailureMessage(actual interface{}) (message string) {
+	str := "to have {key: value}"
+	if _, ok := matcher.Key.(omegaMatcher); ok {
+		str += " matching"
+	} else if _, ok := matcher.Value.(omegaMatcher); ok {
+		str += " matching"
+	}
+
+	expect := make(map[interface{}]interface{}, 1)
+	expect[matcher.Key] = matcher.Value
+	return format.Message(actual, str, expect)
+}
+
+func (matcher *HaveKeyWithValueMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	kStr := "not to have key"
+	if _, ok := matcher.Key.(omegaMatcher); ok {
+		kStr = "not to have key matching"
+	}
+
+	vStr := "or that key's value not be"
+	if _, ok := matcher.Value.(omegaMatcher); ok {
+		vStr = "or to have that key's value not matching"
+	}
+
+	return format.Message(actual, kStr, matcher.Key, vStr, matcher.Value)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher_test.go
new file mode 100644
index 000000000..0a49ec993
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher_test.go
@@ -0,0 +1,82 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("HaveKeyWithValue", func() {
+	var (
+		stringKeys map[string]int
+		intKeys    map[int]string
+		objKeys    map[*myCustomType]*myCustomType
+
+		customA *myCustomType
+		customB *myCustomType
+	)
+	BeforeEach(func() {
+		stringKeys = map[string]int{"foo": 2, "bar": 3}
+		intKeys = map[int]string{2: "foo", 3: "bar"}
+
+		customA = &myCustomType{s: "a", n: 2, f: 2.3, arr: []string{"ice", "cream"}}
+		customB = &myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}
+		objKeys = map[*myCustomType]*myCustomType{customA: customA, customB: customA}
+	})
+
+	Context("when passed a map", func() {
+		It("should do the right thing", func() {
+			Expect(stringKeys).Should(HaveKeyWithValue("foo", 2))
+			Expect(stringKeys).ShouldNot(HaveKeyWithValue("foo", 1))
+			Expect(stringKeys).ShouldNot(HaveKeyWithValue("baz", 2))
+			Expect(stringKeys).ShouldNot(HaveKeyWithValue("baz", 1))
+
+			Expect(intKeys).Should(HaveKeyWithValue(2, "foo"))
+			Expect(intKeys).ShouldNot(HaveKeyWithValue(4, "foo"))
+			Expect(intKeys).ShouldNot(HaveKeyWithValue(2, "baz"))
+
+			Expect(objKeys).Should(HaveKeyWithValue(customA, customA))
+			Expect(objKeys).Should(HaveKeyWithValue(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}, &myCustomType{s: "a", n: 2, f: 2.3, arr: []string{"ice", "cream"}}))
+			Expect(objKeys).ShouldNot(HaveKeyWithValue(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"apple", "pie"}}, customA))
+		})
+	})
+
+	Context("when passed a correctly typed nil", func() {
+		It("should operate succesfully on the passed in value", func() {
+			var nilMap map[int]string
+			Expect(nilMap).ShouldNot(HaveKeyWithValue("foo", "bar"))
+		})
+	})
+
+	Context("when the passed in key or value is actually a matcher", func() {
+		It("should pass each element through the matcher", func() {
+			Expect(stringKeys).Should(HaveKeyWithValue(ContainSubstring("oo"), 2))
+			Expect(intKeys).Should(HaveKeyWithValue(2, ContainSubstring("oo")))
+			Expect(stringKeys).ShouldNot(HaveKeyWithValue(ContainSubstring("foobar"), 2))
+		})
+
+		It("should fail if the matcher ever fails", func() {
+			actual := map[int]string{1: "a", 3: "b", 2: "c"}
+			success, err := (&HaveKeyWithValueMatcher{Key: ContainSubstring("ar"), Value: 2}).Match(actual)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			otherActual := map[string]int{"a": 1, "b": 2, "c": 3}
+			success, err = (&HaveKeyWithValueMatcher{Key: "a", Value: ContainSubstring("1")}).Match(otherActual)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed something that is not a map", func() {
+		It("should error", func() {
+			success, err := (&HaveKeyWithValueMatcher{Key: "foo", Value: "bar"}).Match([]string{"foo"})
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&HaveKeyWithValueMatcher{Key: "foo", Value: "bar"}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_len_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_len_matcher.go
new file mode 100644
index 000000000..ee4276189
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_len_matcher.go
@@ -0,0 +1,28 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HaveLenMatcher struct {
+	Count int
+}
+
+func (matcher *HaveLenMatcher) Match(actual interface{}) (success bool, err error) {
+	length, ok := lengthOf(actual)
+	if !ok {
+		return false, fmt.Errorf("HaveLen matcher expects a string/array/map/channel/slice.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	return length == matcher.Count, nil
+}
+
+func (matcher *HaveLenMatcher) FailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected\n%s\nto have length %d", format.Object(actual, 1), matcher.Count)
+}
+
+func (matcher *HaveLenMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected\n%s\nnot to have length %d", format.Object(actual, 1), matcher.Count)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_len_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_len_matcher_test.go
new file mode 100644
index 000000000..c60f63886
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_len_matcher_test.go
@@ -0,0 +1,53 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("HaveLen", func() {
+	Context("when passed a supported type", func() {
+		It("should do the right thing", func() {
+			Expect("").Should(HaveLen(0))
+			Expect("AA").Should(HaveLen(2))
+
+			Expect([0]int{}).Should(HaveLen(0))
+			Expect([2]int{1, 2}).Should(HaveLen(2))
+
+			Expect([]int{}).Should(HaveLen(0))
+			Expect([]int{1, 2, 3}).Should(HaveLen(3))
+
+			Expect(map[string]int{}).Should(HaveLen(0))
+			Expect(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4}).Should(HaveLen(4))
+
+			c := make(chan bool, 3)
+			Expect(c).Should(HaveLen(0))
+			c <- true
+			c <- true
+			Expect(c).Should(HaveLen(2))
+		})
+	})
+
+	Context("when passed a correctly typed nil", func() {
+		It("should operate succesfully on the passed in value", func() {
+			var nilSlice []int
+			Expect(nilSlice).Should(HaveLen(0))
+
+			var nilMap map[int]string
+			Expect(nilMap).Should(HaveLen(0))
+		})
+	})
+
+	Context("when passed an unsupported type", func() {
+		It("should error", func() {
+			success, err := (&HaveLenMatcher{Count: 0}).Match(0)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&HaveLenMatcher{Count: 0}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go
new file mode 100644
index 000000000..ebdd71786
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher.go
@@ -0,0 +1,33 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HaveOccurredMatcher struct {
+}
+
+func (matcher *HaveOccurredMatcher) Match(actual interface{}) (success bool, err error) {
+	// is purely nil?
+	if actual == nil {
+		return false, nil
+	}
+
+	// must be an 'error' type
+	if !isError(actual) {
+		return false, fmt.Errorf("Expected an error-type.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	// must be non-nil (or a pointer to a non-nil)
+	return !isNil(actual), nil
+}
+
+func (matcher *HaveOccurredMatcher) FailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected an error to have occurred.  Got:\n%s", format.Object(actual, 1))
+}
+
+func (matcher *HaveOccurredMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected error:\n%s\n%s\n%s", format.Object(actual, 1), format.IndentString(actual.(error).Error(), 1), "not to have occurred")
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher_test.go
new file mode 100644
index 000000000..0ad632ec1
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher_test.go
@@ -0,0 +1,59 @@
+package matchers_test
+
+import (
+	"errors"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+type CustomErr struct {
+	msg string
+}
+
+func (e *CustomErr) Error() string {
+	return e.msg
+}
+
+var _ = Describe("HaveOccurred", func() {
+	It("should succeed if matching an error", func() {
+		Expect(errors.New("Foo")).Should(HaveOccurred())
+	})
+
+	It("should not succeed with nil", func() {
+		Expect(nil).ShouldNot(HaveOccurred())
+	})
+
+	It("should only support errors and nil", func() {
+		success, err := (&HaveOccurredMatcher{}).Match("foo")
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(HaveOccurred())
+
+		success, err = (&HaveOccurredMatcher{}).Match("")
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(HaveOccurred())
+	})
+
+	It("doesn't support non-error type", func() {
+		success, err := (&HaveOccurredMatcher{}).Match(AnyType{})
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(MatchError("Expected an error-type.  Got:\n    <matchers_test.AnyType>: {}"))
+	})
+
+	It("doesn't support non-error pointer type", func() {
+		success, err := (&HaveOccurredMatcher{}).Match(&AnyType{})
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(MatchError(MatchRegexp(`Expected an error-type.  Got:\n    <*matchers_test.AnyType | 0x[[:xdigit:]]+>: {}`)))
+	})
+
+	It("should succeed with pointer types that conform to error interface", func() {
+		err := &CustomErr{"ohai"}
+		Expect(err).Should(HaveOccurred())
+	})
+
+	It("should not succeed with nil pointers to types that conform to error interface", func() {
+		var err *CustomErr = nil
+		Expect(err).ShouldNot(HaveOccurred())
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher.go
new file mode 100644
index 000000000..1d8e80270
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher.go
@@ -0,0 +1,36 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HavePrefixMatcher struct {
+	Prefix string
+	Args   []interface{}
+}
+
+func (matcher *HavePrefixMatcher) Match(actual interface{}) (success bool, err error) {
+	actualString, ok := toString(actual)
+	if !ok {
+		return false, fmt.Errorf("HavePrefix matcher requires a string or stringer.  Got:\n%s", format.Object(actual, 1))
+	}
+	prefix := matcher.prefix()
+	return len(actualString) >= len(prefix) && actualString[0:len(prefix)] == prefix, nil
+}
+
+func (matcher *HavePrefixMatcher) prefix() string {
+	if len(matcher.Args) > 0 {
+		return fmt.Sprintf(matcher.Prefix, matcher.Args...)
+	}
+	return matcher.Prefix
+}
+
+func (matcher *HavePrefixMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to have prefix", matcher.prefix())
+}
+
+func (matcher *HavePrefixMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to have prefix", matcher.prefix())
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher_test.go
new file mode 100644
index 000000000..fe29b7b5d
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher_test.go
@@ -0,0 +1,36 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("HavePrefixMatcher", func() {
+	Context("when actual is a string", func() {
+		It("should match a string prefix", func() {
+			Expect("Ab").Should(HavePrefix("A"))
+			Expect("A").ShouldNot(HavePrefix("Ab"))
+		})
+	})
+
+	Context("when the matcher is called with multiple arguments", func() {
+		It("should pass the string and arguments to sprintf", func() {
+			Expect("C3PO").Should(HavePrefix("C%dP", 3))
+		})
+	})
+
+	Context("when actual is a stringer", func() {
+		It("should call the stringer and match against the returned string", func() {
+			Expect(&myStringer{a: "Ab"}).Should(HavePrefix("A"))
+		})
+	})
+
+	Context("when actual is neither a string nor a stringer", func() {
+		It("should error", func() {
+			success, err := (&HavePrefixMatcher{Prefix: "2"}).Match(2)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher.go
new file mode 100644
index 000000000..40a3526eb
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher.go
@@ -0,0 +1,36 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type HaveSuffixMatcher struct {
+	Suffix string
+	Args   []interface{}
+}
+
+func (matcher *HaveSuffixMatcher) Match(actual interface{}) (success bool, err error) {
+	actualString, ok := toString(actual)
+	if !ok {
+		return false, fmt.Errorf("HaveSuffix matcher requires a string or stringer.  Got:\n%s", format.Object(actual, 1))
+	}
+	suffix := matcher.suffix()
+	return len(actualString) >= len(suffix) && actualString[len(actualString)-len(suffix):] == suffix, nil
+}
+
+func (matcher *HaveSuffixMatcher) suffix() string {
+	if len(matcher.Args) > 0 {
+		return fmt.Sprintf(matcher.Suffix, matcher.Args...)
+	}
+	return matcher.Suffix
+}
+
+func (matcher *HaveSuffixMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to have suffix", matcher.suffix())
+}
+
+func (matcher *HaveSuffixMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to have suffix", matcher.suffix())
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher_test.go
new file mode 100644
index 000000000..2ae29821a
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher_test.go
@@ -0,0 +1,36 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("HaveSuffixMatcher", func() {
+	Context("when actual is a string", func() {
+		It("should match a string suffix", func() {
+			Expect("Ab").Should(HaveSuffix("b"))
+			Expect("A").ShouldNot(HaveSuffix("Ab"))
+		})
+	})
+
+	Context("when the matcher is called with multiple arguments", func() {
+		It("should pass the string and arguments to sprintf", func() {
+			Expect("C3PO").Should(HaveSuffix("%dPO", 3))
+		})
+	})
+
+	Context("when actual is a stringer", func() {
+		It("should call the stringer and match against the returned string", func() {
+			Expect(&myStringer{a: "Ab"}).Should(HaveSuffix("b"))
+		})
+	})
+
+	Context("when actual is neither a string nor a stringer", func() {
+		It("should error", func() {
+			success, err := (&HaveSuffixMatcher{Suffix: "2"}).Match(2)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_error_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_error_matcher.go
new file mode 100644
index 000000000..07499ac95
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_error_matcher.go
@@ -0,0 +1,51 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type MatchErrorMatcher struct {
+	Expected interface{}
+}
+
+func (matcher *MatchErrorMatcher) Match(actual interface{}) (success bool, err error) {
+	if isNil(actual) {
+		return false, fmt.Errorf("Expected an error, got nil")
+	}
+
+	if !isError(actual) {
+		return false, fmt.Errorf("Expected an error.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	actualErr := actual.(error)
+
+	if isError(matcher.Expected) {
+		return reflect.DeepEqual(actualErr, matcher.Expected), nil
+	}
+
+	if isString(matcher.Expected) {
+		return actualErr.Error() == matcher.Expected, nil
+	}
+
+	var subMatcher omegaMatcher
+	var hasSubMatcher bool
+	if matcher.Expected != nil {
+		subMatcher, hasSubMatcher = (matcher.Expected).(omegaMatcher)
+		if hasSubMatcher {
+			return subMatcher.Match(actualErr.Error())
+		}
+	}
+
+	return false, fmt.Errorf("MatchError must be passed an error, string, or Matcher that can match on strings.  Got:\n%s", format.Object(matcher.Expected, 1))
+}
+
+func (matcher *MatchErrorMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to match error", matcher.Expected)
+}
+
+func (matcher *MatchErrorMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to match error", matcher.Expected)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/match_error_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_error_matcher_test.go
new file mode 100644
index 000000000..9bf89fc46
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_error_matcher_test.go
@@ -0,0 +1,107 @@
+package matchers_test
+
+import (
+	"errors"
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+type CustomError struct {
+}
+
+func (c CustomError) Error() string {
+	return "an error"
+}
+
+var _ = Describe("MatchErrorMatcher", func() {
+	Context("When asserting against an error", func() {
+		It("should succeed when matching with an error", func() {
+			err := errors.New("an error")
+			fmtErr := fmt.Errorf("an error")
+			customErr := CustomError{}
+
+			Expect(err).Should(MatchError(errors.New("an error")))
+			Expect(err).ShouldNot(MatchError(errors.New("another error")))
+
+			Expect(fmtErr).Should(MatchError(errors.New("an error")))
+			Expect(customErr).Should(MatchError(CustomError{}))
+		})
+
+		It("should succeed when matching with a string", func() {
+			err := errors.New("an error")
+			fmtErr := fmt.Errorf("an error")
+			customErr := CustomError{}
+
+			Expect(err).Should(MatchError("an error"))
+			Expect(err).ShouldNot(MatchError("another error"))
+
+			Expect(fmtErr).Should(MatchError("an error"))
+			Expect(customErr).Should(MatchError("an error"))
+		})
+
+		Context("when passed a matcher", func() {
+			It("should pass if the matcher passes against the error string", func() {
+				err := errors.New("error 123 abc")
+
+				Expect(err).Should(MatchError(MatchRegexp(`\d{3}`)))
+			})
+
+			It("should fail if the matcher fails against the error string", func() {
+				err := errors.New("no digits")
+				Expect(err).ShouldNot(MatchError(MatchRegexp(`\d`)))
+			})
+		})
+
+		It("should fail when passed anything else", func() {
+			actualErr := errors.New("an error")
+			_, err := (&MatchErrorMatcher{
+				Expected: []byte("an error"),
+			}).Match(actualErr)
+			Expect(err).Should(HaveOccurred())
+
+			_, err = (&MatchErrorMatcher{
+				Expected: 3,
+			}).Match(actualErr)
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed nil", func() {
+		It("should fail", func() {
+			_, err := (&MatchErrorMatcher{
+				Expected: "an error",
+			}).Match(nil)
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed a non-error", func() {
+		It("should fail", func() {
+			_, err := (&MatchErrorMatcher{
+				Expected: "an error",
+			}).Match("an error")
+			Expect(err).Should(HaveOccurred())
+
+			_, err = (&MatchErrorMatcher{
+				Expected: "an error",
+			}).Match(3)
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when passed an error that is also a string", func() {
+		It("should use it as an error", func() {
+			var e mockErr = "mockErr"
+
+			// this fails if the matcher casts e to a string before comparison
+			Expect(e).Should(MatchError(e))
+		})
+	})
+})
+
+type mockErr string
+
+func (m mockErr) Error() string { return string(m) }
diff --git a/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go
new file mode 100644
index 000000000..f962f139f
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go
@@ -0,0 +1,65 @@
+package matchers
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type MatchJSONMatcher struct {
+	JSONToMatch      interface{}
+	firstFailurePath []interface{}
+}
+
+func (matcher *MatchJSONMatcher) Match(actual interface{}) (success bool, err error) {
+	actualString, expectedString, err := matcher.prettyPrint(actual)
+	if err != nil {
+		return false, err
+	}
+
+	var aval interface{}
+	var eval interface{}
+
+	// this is guarded by prettyPrint
+	json.Unmarshal([]byte(actualString), &aval)
+	json.Unmarshal([]byte(expectedString), &eval)
+	var equal bool
+	equal, matcher.firstFailurePath = deepEqual(aval, eval)
+	return equal, nil
+}
+
+func (matcher *MatchJSONMatcher) FailureMessage(actual interface{}) (message string) {
+	actualString, expectedString, _ := matcher.prettyPrint(actual)
+	return formattedMessage(format.Message(actualString, "to match JSON of", expectedString), matcher.firstFailurePath)
+}
+
+func (matcher *MatchJSONMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	actualString, expectedString, _ := matcher.prettyPrint(actual)
+	return formattedMessage(format.Message(actualString, "not to match JSON of", expectedString), matcher.firstFailurePath)
+}
+
+func (matcher *MatchJSONMatcher) prettyPrint(actual interface{}) (actualFormatted, expectedFormatted string, err error) {
+	actualString, ok := toString(actual)
+	if !ok {
+		return "", "", fmt.Errorf("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got actual:\n%s", format.Object(actual, 1))
+	}
+	expectedString, ok := toString(matcher.JSONToMatch)
+	if !ok {
+		return "", "", fmt.Errorf("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got expected:\n%s", format.Object(matcher.JSONToMatch, 1))
+	}
+
+	abuf := new(bytes.Buffer)
+	ebuf := new(bytes.Buffer)
+
+	if err := json.Indent(abuf, []byte(actualString), "", "  "); err != nil {
+		return "", "", fmt.Errorf("Actual '%s' should be valid JSON, but it is not.\nUnderlying error:%s", actualString, err)
+	}
+
+	if err := json.Indent(ebuf, []byte(expectedString), "", "  "); err != nil {
+		return "", "", fmt.Errorf("Expected '%s' should be valid JSON, but it is not.\nUnderlying error:%s", expectedString, err)
+	}
+
+	return abuf.String(), ebuf.String(), nil
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/match_json_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_json_matcher_test.go
new file mode 100644
index 000000000..4a1a9db20
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_json_matcher_test.go
@@ -0,0 +1,103 @@
+package matchers_test
+
+import (
+	"encoding/json"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("MatchJSONMatcher", func() {
+	Context("When passed stringifiables", func() {
+		It("should succeed if the JSON matches", func() {
+			Expect("{}").Should(MatchJSON("{}"))
+			Expect(`{"a":1}`).Should(MatchJSON(`{"a":1}`))
+			Expect(`{
+			             "a":1
+			         }`).Should(MatchJSON(`{"a":1}`))
+			Expect(`{"a":1, "b":2}`).Should(MatchJSON(`{"b":2, "a":1}`))
+			Expect(`{"a":1}`).ShouldNot(MatchJSON(`{"b":2, "a":1}`))
+
+			Expect(`{"a":"a", "b":"b"}`).ShouldNot(MatchJSON(`{"a":"a", "b":"b", "c":"c"}`))
+			Expect(`{"a":"a", "b":"b", "c":"c"}`).ShouldNot(MatchJSON(`{"a":"a", "b":"b"}`))
+
+			Expect(`{"a":null, "b":null}`).ShouldNot(MatchJSON(`{"c":"c", "d":"d"}`))
+			Expect(`{"a":null, "b":null, "c":null}`).ShouldNot(MatchJSON(`{"a":null, "b":null, "d":null}`))
+		})
+
+		It("should work with byte arrays", func() {
+			Expect([]byte("{}")).Should(MatchJSON([]byte("{}")))
+			Expect("{}").Should(MatchJSON([]byte("{}")))
+			Expect([]byte("{}")).Should(MatchJSON("{}"))
+		})
+
+		It("should work with json.RawMessage", func() {
+			Expect([]byte(`{"a": 1}`)).Should(MatchJSON(json.RawMessage(`{"a": 1}`)))
+		})
+	})
+
+	Context("when a key mismatch is found", func() {
+		It("reports the first found mismatch", func() {
+			subject := MatchJSONMatcher{JSONToMatch: `5`}
+			actual := `7`
+			subject.Match(actual)
+
+			failureMessage := subject.FailureMessage(`7`)
+			Expect(failureMessage).ToNot(ContainSubstring("first mismatched key"))
+
+			subject = MatchJSONMatcher{JSONToMatch: `{"a": 1, "b.g": {"c": 2, "1": ["hello", "see ya"]}}`}
+			actual = `{"a": 1, "b.g": {"c": 2, "1": ["hello", "goodbye"]}}`
+			subject.Match(actual)
+
+			failureMessage = subject.FailureMessage(actual)
+			Expect(failureMessage).To(ContainSubstring(`first mismatched key: "b.g"."1"[1]`))
+		})
+	})
+
+	Context("when the expected is not valid JSON", func() {
+		It("should error and explain why", func() {
+			success, err := (&MatchJSONMatcher{JSONToMatch: `{}`}).Match(`oops`)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("Actual 'oops' should be valid JSON"))
+		})
+	})
+
+	Context("when the actual is not valid JSON", func() {
+		It("should error and explain why", func() {
+			success, err := (&MatchJSONMatcher{JSONToMatch: `oops`}).Match(`{}`)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("Expected 'oops' should be valid JSON"))
+		})
+	})
+
+	Context("when the expected is neither a string nor a stringer nor a byte array", func() {
+		It("should error", func() {
+			success, err := (&MatchJSONMatcher{JSONToMatch: 2}).Match("{}")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <int>: 2"))
+
+			success, err = (&MatchJSONMatcher{JSONToMatch: nil}).Match("{}")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <nil>: nil"))
+		})
+	})
+
+	Context("when the actual is neither a string nor a stringer nor a byte array", func() {
+		It("should error", func() {
+			success, err := (&MatchJSONMatcher{JSONToMatch: "{}"}).Match(2)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <int>: 2"))
+
+			success, err = (&MatchJSONMatcher{JSONToMatch: "{}"}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <nil>: nil"))
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher.go
new file mode 100644
index 000000000..adac5db6b
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher.go
@@ -0,0 +1,43 @@
+package matchers
+
+import (
+	"fmt"
+	"regexp"
+
+	"github.com/onsi/gomega/format"
+)
+
+type MatchRegexpMatcher struct {
+	Regexp string
+	Args   []interface{}
+}
+
+func (matcher *MatchRegexpMatcher) Match(actual interface{}) (success bool, err error) {
+	actualString, ok := toString(actual)
+	if !ok {
+		return false, fmt.Errorf("RegExp matcher requires a string or stringer.\nGot:%s", format.Object(actual, 1))
+	}
+
+	match, err := regexp.Match(matcher.regexp(), []byte(actualString))
+	if err != nil {
+		return false, fmt.Errorf("RegExp match failed to compile with error:\n\t%s", err.Error())
+	}
+
+	return match, nil
+}
+
+func (matcher *MatchRegexpMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to match regular expression", matcher.regexp())
+}
+
+func (matcher *MatchRegexpMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "not to match regular expression", matcher.regexp())
+}
+
+func (matcher *MatchRegexpMatcher) regexp() string {
+	re := matcher.Regexp
+	if len(matcher.Args) > 0 {
+		re = fmt.Sprintf(matcher.Regexp, matcher.Args...)
+	}
+	return re
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher_test.go
new file mode 100644
index 000000000..ac2538bb4
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher_test.go
@@ -0,0 +1,44 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("MatchRegexp", func() {
+	Context("when actual is a string", func() {
+		It("should match against the string", func() {
+			Expect(" a2!bla").Should(MatchRegexp(`\d!`))
+			Expect(" a2!bla").ShouldNot(MatchRegexp(`[A-Z]`))
+		})
+	})
+
+	Context("when actual is a stringer", func() {
+		It("should call the stringer and match agains the returned string", func() {
+			Expect(&myStringer{a: "Abc3"}).Should(MatchRegexp(`[A-Z][a-z]+\d`))
+		})
+	})
+
+	Context("when the matcher is called with multiple arguments", func() {
+		It("should pass the string and arguments to sprintf", func() {
+			Expect(" a23!bla").Should(MatchRegexp(`\d%d!`, 3))
+		})
+	})
+
+	Context("when actual is neither a string nor a stringer", func() {
+		It("should error", func() {
+			success, err := (&MatchRegexpMatcher{Regexp: `\d`}).Match(2)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when the passed in regexp fails to compile", func() {
+		It("should error", func() {
+			success, err := (&MatchRegexpMatcher{Regexp: "("}).Match("Foo")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
new file mode 100644
index 000000000..3b412ce81
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
@@ -0,0 +1,134 @@
+package matchers
+
+import (
+	"bytes"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/onsi/gomega/format"
+	"golang.org/x/net/html/charset"
+)
+
+type MatchXMLMatcher struct {
+	XMLToMatch interface{}
+}
+
+func (matcher *MatchXMLMatcher) Match(actual interface{}) (success bool, err error) {
+	actualString, expectedString, err := matcher.formattedPrint(actual)
+	if err != nil {
+		return false, err
+	}
+
+	aval, err := parseXmlContent(actualString)
+	if err != nil {
+		return false, fmt.Errorf("Actual '%s' should be valid XML, but it is not.\nUnderlying error:%s", actualString, err)
+	}
+
+	eval, err := parseXmlContent(expectedString)
+	if err != nil {
+		return false, fmt.Errorf("Expected '%s' should be valid XML, but it is not.\nUnderlying error:%s", expectedString, err)
+	}
+
+	return reflect.DeepEqual(aval, eval), nil
+}
+
+func (matcher *MatchXMLMatcher) FailureMessage(actual interface{}) (message string) {
+	actualString, expectedString, _ := matcher.formattedPrint(actual)
+	return fmt.Sprintf("Expected\n%s\nto match XML of\n%s", actualString, expectedString)
+}
+
+func (matcher *MatchXMLMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	actualString, expectedString, _ := matcher.formattedPrint(actual)
+	return fmt.Sprintf("Expected\n%s\nnot to match XML of\n%s", actualString, expectedString)
+}
+
+func (matcher *MatchXMLMatcher) formattedPrint(actual interface{}) (actualString, expectedString string, err error) {
+	var ok bool
+	actualString, ok = toString(actual)
+	if !ok {
+		return "", "", fmt.Errorf("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n%s", format.Object(actual, 1))
+	}
+	expectedString, ok = toString(matcher.XMLToMatch)
+	if !ok {
+		return "", "", fmt.Errorf("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n%s", format.Object(matcher.XMLToMatch, 1))
+	}
+	return actualString, expectedString, nil
+}
+
+func parseXmlContent(content string) (*xmlNode, error) {
+	allNodes := []*xmlNode{}
+
+	dec := newXmlDecoder(strings.NewReader(content))
+	for {
+		tok, err := dec.Token()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, fmt.Errorf("failed to decode next token: %v", err)
+		}
+
+		lastNodeIndex := len(allNodes) - 1
+		var lastNode *xmlNode
+		if len(allNodes) > 0 {
+			lastNode = allNodes[lastNodeIndex]
+		} else {
+			lastNode = &xmlNode{}
+		}
+
+		switch tok := tok.(type) {
+		case xml.StartElement:
+			attrs := attributesSlice(tok.Attr)
+			sort.Sort(attrs)
+			allNodes = append(allNodes, &xmlNode{XMLName: tok.Name, XMLAttr: tok.Attr})
+		case xml.EndElement:
+			if len(allNodes) > 1 {
+				allNodes[lastNodeIndex-1].Nodes = append(allNodes[lastNodeIndex-1].Nodes, lastNode)
+				allNodes = allNodes[:lastNodeIndex]
+			}
+		case xml.CharData:
+			lastNode.Content = append(lastNode.Content, tok.Copy()...)
+		case xml.Comment:
+			lastNode.Comments = append(lastNode.Comments, tok.Copy())
+		case xml.ProcInst:
+			lastNode.ProcInsts = append(lastNode.ProcInsts, tok.Copy())
+		}
+	}
+
+	if len(allNodes) == 0 {
+		return nil, errors.New("found no nodes")
+	}
+	firstNode := allNodes[0]
+	trimParentNodesContentSpaces(firstNode)
+
+	return firstNode, nil
+}
+
+func newXmlDecoder(reader io.Reader) *xml.Decoder {
+	dec := xml.NewDecoder(reader)
+	dec.CharsetReader = charset.NewReaderLabel
+	return dec
+}
+
+func trimParentNodesContentSpaces(node *xmlNode) {
+	if len(node.Nodes) > 0 {
+		node.Content = bytes.TrimSpace(node.Content)
+		for _, childNode := range node.Nodes {
+			trimParentNodesContentSpaces(childNode)
+		}
+	}
+}
+
+type xmlNode struct {
+	XMLName   xml.Name
+	Comments  []xml.Comment
+	ProcInsts []xml.ProcInst
+	XMLAttr   []xml.Attr
+	Content   []byte
+	Nodes     []*xmlNode
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher_test.go
new file mode 100644
index 000000000..0b559b22e
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher_test.go
@@ -0,0 +1,97 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("MatchXMLMatcher", func() {
+
+	var (
+		sample_01 = readFileContents("test_data/xml/sample_01.xml")
+		sample_02 = readFileContents("test_data/xml/sample_02.xml")
+		sample_03 = readFileContents("test_data/xml/sample_03.xml")
+		sample_04 = readFileContents("test_data/xml/sample_04.xml")
+		sample_05 = readFileContents("test_data/xml/sample_05.xml")
+		sample_06 = readFileContents("test_data/xml/sample_06.xml")
+		sample_07 = readFileContents("test_data/xml/sample_07.xml")
+		sample_08 = readFileContents("test_data/xml/sample_08.xml")
+		sample_09 = readFileContents("test_data/xml/sample_09.xml")
+		sample_10 = readFileContents("test_data/xml/sample_10.xml")
+		sample_11 = readFileContents("test_data/xml/sample_11.xml")
+	)
+
+	Context("When passed stringifiables", func() {
+		It("matches documents regardless of the attribute order", func() {
+			a := `<a foo="bar" ka="boom"></a>`
+			b := `<a ka="boom" foo="bar"></a>`
+			Expect(b).Should(MatchXML(a))
+			Expect(a).Should(MatchXML(b))
+		})
+
+		It("should succeed if the XML matches", func() {
+			Expect(sample_01).Should(MatchXML(sample_01))    // same XML
+			Expect(sample_01).Should(MatchXML(sample_02))    // same XML with blank lines
+			Expect(sample_01).Should(MatchXML(sample_03))    // same XML with different formatting
+			Expect(sample_01).ShouldNot(MatchXML(sample_04)) // same structures with different values
+			Expect(sample_01).ShouldNot(MatchXML(sample_05)) // different structures
+			Expect(sample_06).ShouldNot(MatchXML(sample_07)) // same xml names with different namespaces
+			Expect(sample_07).ShouldNot(MatchXML(sample_08)) // same structures with different values
+			Expect(sample_09).ShouldNot(MatchXML(sample_10)) // same structures with different attribute values
+			Expect(sample_11).Should(MatchXML(sample_11))    // with non UTF-8 encoding
+		})
+
+		It("should work with byte arrays", func() {
+			Expect([]byte(sample_01)).Should(MatchXML([]byte(sample_01)))
+			Expect([]byte(sample_01)).Should(MatchXML(sample_01))
+			Expect(sample_01).Should(MatchXML([]byte(sample_01)))
+		})
+	})
+
+	Context("when the expected is not valid XML", func() {
+		It("should error and explain why", func() {
+			success, err := (&MatchXMLMatcher{XMLToMatch: sample_01}).Match(`oops`)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("Actual 'oops' should be valid XML"))
+		})
+	})
+
+	Context("when the actual is not valid XML", func() {
+		It("should error and explain why", func() {
+			success, err := (&MatchXMLMatcher{XMLToMatch: `oops`}).Match(sample_01)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("Expected 'oops' should be valid XML"))
+		})
+	})
+
+	Context("when the expected is neither a string nor a stringer nor a byte array", func() {
+		It("should error", func() {
+			success, err := (&MatchXMLMatcher{XMLToMatch: 2}).Match(sample_01)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <int>: 2"))
+
+			success, err = (&MatchXMLMatcher{XMLToMatch: nil}).Match(sample_01)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <nil>: nil"))
+		})
+	})
+
+	Context("when the actual is neither a string nor a stringer nor a byte array", func() {
+		It("should error", func() {
+			success, err := (&MatchXMLMatcher{XMLToMatch: sample_01}).Match(2)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <int>: 2"))
+
+			success, err = (&MatchXMLMatcher{XMLToMatch: sample_01}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <nil>: nil"))
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
new file mode 100644
index 000000000..0c83c2b63
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
@@ -0,0 +1,76 @@
+package matchers
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/onsi/gomega/format"
+	"gopkg.in/yaml.v2"
+)
+
+type MatchYAMLMatcher struct {
+	YAMLToMatch      interface{}
+	firstFailurePath []interface{}
+}
+
+func (matcher *MatchYAMLMatcher) Match(actual interface{}) (success bool, err error) {
+	actualString, expectedString, err := matcher.toStrings(actual)
+	if err != nil {
+		return false, err
+	}
+
+	var aval interface{}
+	var eval interface{}
+
+	if err := yaml.Unmarshal([]byte(actualString), &aval); err != nil {
+		return false, fmt.Errorf("Actual '%s' should be valid YAML, but it is not.\nUnderlying error:%s", actualString, err)
+	}
+	if err := yaml.Unmarshal([]byte(expectedString), &eval); err != nil {
+		return false, fmt.Errorf("Expected '%s' should be valid YAML, but it is not.\nUnderlying error:%s", expectedString, err)
+	}
+
+	var equal bool
+	equal, matcher.firstFailurePath = deepEqual(aval, eval)
+	return equal, nil
+}
+
+func (matcher *MatchYAMLMatcher) FailureMessage(actual interface{}) (message string) {
+	actualString, expectedString, _ := matcher.toNormalisedStrings(actual)
+	return formattedMessage(format.Message(actualString, "to match YAML of", expectedString), matcher.firstFailurePath)
+}
+
+func (matcher *MatchYAMLMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	actualString, expectedString, _ := matcher.toNormalisedStrings(actual)
+	return formattedMessage(format.Message(actualString, "not to match YAML of", expectedString), matcher.firstFailurePath)
+}
+
+func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual interface{}) (actualFormatted, expectedFormatted string, err error) {
+	actualString, expectedString, err := matcher.toStrings(actual)
+	return normalise(actualString), normalise(expectedString), err
+}
+
+func normalise(input string) string {
+	var val interface{}
+	err := yaml.Unmarshal([]byte(input), &val)
+	if err != nil {
+		panic(err) // unreachable since Match already calls Unmarshal
+	}
+	output, err := yaml.Marshal(val)
+	if err != nil {
+		panic(err) // untested section, unreachable since we Unmarshal above
+	}
+	return strings.TrimSpace(string(output))
+}
+
+func (matcher *MatchYAMLMatcher) toStrings(actual interface{}) (actualFormatted, expectedFormatted string, err error) {
+	actualString, ok := toString(actual)
+	if !ok {
+		return "", "", fmt.Errorf("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n%s", format.Object(actual, 1))
+	}
+	expectedString, ok := toString(matcher.YAMLToMatch)
+	if !ok {
+		return "", "", fmt.Errorf("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n%s", format.Object(matcher.YAMLToMatch, 1))
+	}
+
+	return actualString, expectedString, nil
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher_test.go
new file mode 100644
index 000000000..1b0044fd0
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher_test.go
@@ -0,0 +1,101 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("MatchYAMLMatcher", func() {
+	Context("When passed stringifiables", func() {
+		It("should succeed if the YAML matches", func() {
+			Expect("---").Should(MatchYAML(""))
+			Expect("a: 1").Should(MatchYAML(`{"a":1}`))
+			Expect("a: 1\nb: 2").Should(MatchYAML(`{"b":2, "a":1}`))
+		})
+
+		It("should explain if the YAML does not match when it should", func() {
+			message := (&MatchYAMLMatcher{YAMLToMatch: "a: 1"}).FailureMessage("b: 2")
+			Expect(message).To(MatchRegexp(`Expected\s+<string>: b: 2\s+to match YAML of\s+<string>: a: 1`))
+		})
+
+		It("should normalise the expected and actual when explaining if the YAML does not match when it should", func() {
+			message := (&MatchYAMLMatcher{YAMLToMatch: "a: 'one'"}).FailureMessage("{b: two}")
+			Expect(message).To(MatchRegexp(`Expected\s+<string>: b: two\s+to match YAML of\s+<string>: a: one`))
+		})
+
+		It("should explain if the YAML matches when it should not", func() {
+			message := (&MatchYAMLMatcher{YAMLToMatch: "a: 1"}).NegatedFailureMessage("a: 1")
+			Expect(message).To(MatchRegexp(`Expected\s+<string>: a: 1\s+not to match YAML of\s+<string>: a: 1`))
+		})
+
+		It("should normalise the expected and actual when explaining if the YAML matches when it should not", func() {
+			message := (&MatchYAMLMatcher{YAMLToMatch: "a: 'one'"}).NegatedFailureMessage("{a: one}")
+			Expect(message).To(MatchRegexp(`Expected\s+<string>: a: one\s+not to match YAML of\s+<string>: a: one`))
+		})
+
+		It("should fail if the YAML does not match", func() {
+			Expect("a: 1").ShouldNot(MatchYAML(`{"b":2, "a":1}`))
+		})
+
+		It("should work with byte arrays", func() {
+			Expect([]byte("a: 1")).Should(MatchYAML([]byte("a: 1")))
+			Expect("a: 1").Should(MatchYAML([]byte("a: 1")))
+			Expect([]byte("a: 1")).Should(MatchYAML("a: 1"))
+		})
+	})
+
+	Context("when the expected is not valid YAML", func() {
+		It("should error and explain why", func() {
+			success, err := (&MatchYAMLMatcher{YAMLToMatch: ""}).Match("good:\nbad")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("Actual 'good:\nbad' should be valid YAML"))
+		})
+	})
+
+	Context("when the actual is not valid YAML", func() {
+		It("should error and explain why", func() {
+			success, err := (&MatchYAMLMatcher{YAMLToMatch: "good:\nbad"}).Match("")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("Expected 'good:\nbad' should be valid YAML"))
+		})
+
+		It("errors when passed directly to Message", func() {
+			Expect(func() {
+				matcher := MatchYAMLMatcher{YAMLToMatch: "good"}
+				matcher.FailureMessage("good:\nbad")
+			}).To(Panic())
+		})
+	})
+
+	Context("when the expected is neither a string nor a stringer nor a byte array", func() {
+		It("should error", func() {
+			success, err := (&MatchYAMLMatcher{YAMLToMatch: 2}).Match("")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <int>: 2"))
+
+			success, err = (&MatchYAMLMatcher{YAMLToMatch: nil}).Match("")
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <nil>: nil"))
+		})
+	})
+
+	Context("when the actual is neither a string nor a stringer nor a byte array", func() {
+		It("should error", func() {
+			success, err := (&MatchYAMLMatcher{YAMLToMatch: ""}).Match(2)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <int>: 2"))
+
+			success, err = (&MatchYAMLMatcher{YAMLToMatch: ""}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).Should(ContainSubstring("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <nil>: nil"))
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/matcher_tests_suite_test.go b/vendor/github.com/onsi/gomega/matchers/matcher_tests_suite_test.go
new file mode 100644
index 000000000..b5f76c995
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/matcher_tests_suite_test.go
@@ -0,0 +1,50 @@
+package matchers_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+type myStringer struct {
+	a string
+}
+
+func (s *myStringer) String() string {
+	return s.a
+}
+
+type StringAlias string
+
+type myCustomType struct {
+	s   string
+	n   int
+	f   float32
+	arr []string
+}
+
+func Test(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Gomega Matchers")
+}
+
+func readFileContents(filePath string) []byte {
+	f := openFile(filePath)
+	b, err := ioutil.ReadAll(f)
+	if err != nil {
+		panic(fmt.Errorf("failed to read file contents: %v", err))
+	}
+	return b
+}
+
+func openFile(filePath string) *os.File {
+	f, err := os.Open(filePath)
+	if err != nil {
+		panic(fmt.Errorf("failed to open file: %v", err))
+	}
+	return f
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/not.go b/vendor/github.com/onsi/gomega/matchers/not.go
new file mode 100644
index 000000000..2c91670bd
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/not.go
@@ -0,0 +1,30 @@
+package matchers
+
+import (
+	"github.com/onsi/gomega/internal/oraclematcher"
+	"github.com/onsi/gomega/types"
+)
+
+type NotMatcher struct {
+	Matcher types.GomegaMatcher
+}
+
+func (m *NotMatcher) Match(actual interface{}) (bool, error) {
+	success, err := m.Matcher.Match(actual)
+	if err != nil {
+		return false, err
+	}
+	return !success, nil
+}
+
+func (m *NotMatcher) FailureMessage(actual interface{}) (message string) {
+	return m.Matcher.NegatedFailureMessage(actual) // works beautifully
+}
+
+func (m *NotMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return m.Matcher.FailureMessage(actual) // works beautifully
+}
+
+func (m *NotMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+	return oraclematcher.MatchMayChangeInTheFuture(m.Matcher, actual) // just return m.Matcher's value
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/not_test.go b/vendor/github.com/onsi/gomega/matchers/not_test.go
new file mode 100644
index 000000000..06d3ebd17
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/not_test.go
@@ -0,0 +1,64 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("NotMatcher", func() {
+	Context("basic examples", func() {
+		It("works", func() {
+			Expect(input).To(Not(false1))
+			Expect(input).To(Not(Not(true2)))
+			Expect(input).ToNot(Not(true3))
+			Expect(input).ToNot(Not(Not(false1)))
+			Expect(input).To(Not(Not(Not(false2))))
+		})
+
+		It("fails on error", func() {
+			failuresMessages := InterceptGomegaFailures(func() {
+				Expect(input).To(Not(Panic()))
+			})
+			Expect(failuresMessages).To(Equal([]string{"PanicMatcher expects a function.  Got:\n    <string>: hi"}))
+		})
+	})
+
+	Context("De Morgan's laws", func() {
+		It("~(A && B) == ~A || ~B", func() {
+			Expect(input).To(Not(And(false1, false2)))
+			Expect(input).To(Or(Not(false1), Not(false2)))
+		})
+		It("~(A || B) == ~A && ~B", func() {
+			Expect(input).To(Not(Or(false1, false2)))
+			Expect(input).To(And(Not(false1), Not(false2)))
+		})
+	})
+
+	Context("failure messages are opposite of original matchers' failure messages", func() {
+		Context("when match fails", func() {
+			It("gives a descriptive message", func() {
+				verifyFailureMessage(Not(HaveLen(2)), input, "not to have length 2")
+			})
+		})
+
+		Context("when match succeeds, but expected it to fail", func() {
+			It("gives a descriptive message", func() {
+				verifyFailureMessage(Not(Not(HaveLen(3))), input, "to have length 3")
+			})
+		})
+	})
+
+	Context("MatchMayChangeInTheFuture()", func() {
+		It("Propagates value from wrapped matcher", func() {
+			m := Not(Or()) // an empty Or() always returns false, and indicates it cannot change
+			Expect(m.Match("anything")).To(BeTrue())
+			Expect(m.(*NotMatcher).MatchMayChangeInTheFuture("anything")).To(BeFalse())
+		})
+		It("Defaults to true", func() {
+			m := Not(Equal(1)) // Equal does not have this method
+			Expect(m.Match(2)).To(BeTrue())
+			Expect(m.(*NotMatcher).MatchMayChangeInTheFuture(2)).To(BeTrue()) // defaults to true
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/or.go b/vendor/github.com/onsi/gomega/matchers/or.go
new file mode 100644
index 000000000..3bf799800
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/or.go
@@ -0,0 +1,67 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+	"github.com/onsi/gomega/internal/oraclematcher"
+	"github.com/onsi/gomega/types"
+)
+
+type OrMatcher struct {
+	Matchers []types.GomegaMatcher
+
+	// state
+	firstSuccessfulMatcher types.GomegaMatcher
+}
+
+func (m *OrMatcher) Match(actual interface{}) (success bool, err error) {
+	m.firstSuccessfulMatcher = nil
+	for _, matcher := range m.Matchers {
+		success, err := matcher.Match(actual)
+		if err != nil {
+			return false, err
+		}
+		if success {
+			m.firstSuccessfulMatcher = matcher
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func (m *OrMatcher) FailureMessage(actual interface{}) (message string) {
+	// not the most beautiful list of matchers, but not bad either...
+	return format.Message(actual, fmt.Sprintf("To satisfy at least one of these matchers: %s", m.Matchers))
+}
+
+func (m *OrMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return m.firstSuccessfulMatcher.NegatedFailureMessage(actual)
+}
+
+func (m *OrMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+	/*
+		Example with 3 matchers: A, B, C
+
+		Match evaluates them: F, T, <?>  => T
+		So match is currently T, what should MatchMayChangeInTheFuture() return?
+		Seems like it only depends on B, since currently B MUST change to allow the result to become F
+
+		Match eval: F, F, F  => F
+		So match is currently F, what should MatchMayChangeInTheFuture() return?
+		Seems to depend on ANY of them being able to change to T.
+	*/
+
+	if m.firstSuccessfulMatcher != nil {
+		// one of the matchers succeeded.. it must be able to change in order to affect the result
+		return oraclematcher.MatchMayChangeInTheFuture(m.firstSuccessfulMatcher, actual)
+	} else {
+		// so all matchers failed.. Any one of them changing would change the result.
+		for _, matcher := range m.Matchers {
+			if oraclematcher.MatchMayChangeInTheFuture(matcher, actual) {
+				return true
+			}
+		}
+		return false // none of were going to change
+	}
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/or_test.go b/vendor/github.com/onsi/gomega/matchers/or_test.go
new file mode 100644
index 000000000..1f6dfaf61
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/or_test.go
@@ -0,0 +1,92 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("OrMatcher", func() {
+	It("works with positive cases", func() {
+		Expect(input).To(Or(true1))
+		Expect(input).To(Or(true1, true2))
+		Expect(input).To(Or(true1, false1))
+		Expect(input).To(Or(false1, true2))
+		Expect(input).To(Or(true1, true2, true3))
+		Expect(input).To(Or(true1, true2, false3))
+		Expect(input).To(Or(true1, false2, true3))
+		Expect(input).To(Or(false1, true2, true3))
+		Expect(input).To(Or(true1, false2, false3))
+		Expect(input).To(Or(false1, false2, true3))
+
+		// use alias
+		Expect(input).To(SatisfyAny(false1, false2, true3))
+	})
+
+	It("stops on errors", func() {
+		failuresMessages := InterceptGomegaFailures(func() {
+			Expect(input).To(Or(Panic(), true1))
+		})
+		Expect(failuresMessages).To(Equal([]string{"PanicMatcher expects a function.  Got:\n    <string>: hi"}))
+	})
+
+	It("works with negative cases", func() {
+		Expect(input).ToNot(Or())
+		Expect(input).ToNot(Or(false1))
+		Expect(input).ToNot(Or(false1, false2))
+		Expect(input).ToNot(Or(false1, false2, false3))
+	})
+
+	Context("failure messages", func() {
+		Context("when match fails", func() {
+			It("gives a descriptive message", func() {
+				verifyFailureMessage(Or(false1, false2), input,
+					"To satisfy at least one of these matchers: [%!s(*matchers.HaveLenMatcher=&{1}) %!s(*matchers.EqualMatcher=&{hip})]")
+			})
+		})
+
+		Context("when match succeeds, but expected it to fail", func() {
+			It("gives a descriptive message", func() {
+				verifyFailureMessage(Not(Or(true1, true2)), input, `not to have length 2`)
+			})
+		})
+	})
+
+	Context("MatchMayChangeInTheFuture", func() {
+		Context("Match returned false", func() {
+			It("returns true if any of the matchers could change", func() {
+				// 3 matchers, all return false, and all could change
+				m := Or(BeNil(), Equal("hip"), HaveLen(1))
+				Expect(m.Match("hi")).To(BeFalse())
+				Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // all 3 of these matchers default to 'true'
+			})
+			It("returns false if none of the matchers could change", func() {
+				// empty Or() has the property of never matching, and never can change since there are no sub-matchers that could change
+				m := Or()
+				Expect(m.Match("anything")).To(BeFalse())
+				Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("anything")).To(BeFalse())
+
+				// Or() with 3 sub-matchers that return false, and can't change
+				m = Or(Or(), Or(), Or())
+				Expect(m.Match("hi")).To(BeFalse())
+				Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse()) // the 3 empty Or()'s won't change
+			})
+		})
+		Context("Match returned true", func() {
+			Context("returns value of the successful matcher", func() {
+				It("false if successful matcher not going to change", func() {
+					// 3 matchers: 1st returns false, 2nd returns true and is not going to change, 3rd is never called
+					m := Or(BeNil(), And(), Equal(1))
+					Expect(m.Match("hi")).To(BeTrue())
+					Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse())
+				})
+				It("true if successful matcher indicates it might change", func() {
+					// 3 matchers: 1st returns false, 2nd returns true and "might" change, 3rd is never called
+					m := Or(Not(BeNil()), Equal("hi"), Equal(1))
+					Expect(m.Match("hi")).To(BeTrue())
+					Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // Equal("hi") indicates it might change
+				})
+			})
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/panic_matcher.go b/vendor/github.com/onsi/gomega/matchers/panic_matcher.go
new file mode 100644
index 000000000..640f4db1a
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/panic_matcher.go
@@ -0,0 +1,46 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type PanicMatcher struct {
+	object interface{}
+}
+
+func (matcher *PanicMatcher) Match(actual interface{}) (success bool, err error) {
+	if actual == nil {
+		return false, fmt.Errorf("PanicMatcher expects a non-nil actual.")
+	}
+
+	actualType := reflect.TypeOf(actual)
+	if actualType.Kind() != reflect.Func {
+		return false, fmt.Errorf("PanicMatcher expects a function.  Got:\n%s", format.Object(actual, 1))
+	}
+	if !(actualType.NumIn() == 0 && actualType.NumOut() == 0) {
+		return false, fmt.Errorf("PanicMatcher expects a function with no arguments and no return value.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	success = false
+	defer func() {
+		if e := recover(); e != nil {
+			matcher.object = e
+			success = true
+		}
+	}()
+
+	reflect.ValueOf(actual).Call([]reflect.Value{})
+
+	return
+}
+
+func (matcher *PanicMatcher) FailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, "to panic")
+}
+
+func (matcher *PanicMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return format.Message(actual, fmt.Sprintf("not to panic, but panicked with\n%s", format.Object(matcher.object, 1)))
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/panic_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/panic_matcher_test.go
new file mode 100644
index 000000000..326bb10a4
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/panic_matcher_test.go
@@ -0,0 +1,52 @@
+package matchers_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("Panic", func() {
+	Context("when passed something that's not a function that takes zero arguments and returns nothing", func() {
+		It("should error", func() {
+			success, err := (&PanicMatcher{}).Match("foo")
+			Expect(success).To(BeFalse())
+			Expect(err).To(HaveOccurred())
+
+			success, err = (&PanicMatcher{}).Match(nil)
+			Expect(success).To(BeFalse())
+			Expect(err).To(HaveOccurred())
+
+			success, err = (&PanicMatcher{}).Match(func(foo string) {})
+			Expect(success).To(BeFalse())
+			Expect(err).To(HaveOccurred())
+
+			success, err = (&PanicMatcher{}).Match(func() string { return "bar" })
+			Expect(success).To(BeFalse())
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Context("when passed a function of the correct type", func() {
+		It("should call the function and pass if the function panics", func() {
+			Expect(func() { panic("ack!") }).To(Panic())
+			Expect(func() {}).NotTo(Panic())
+		})
+	})
+
+	Context("when assertion fails", func() {
+		It("prints the object passed to Panic when negative", func() {
+			failuresMessages := InterceptGomegaFailures(func() {
+				Expect(func() { panic("ack!") }).NotTo(Panic())
+			})
+			Expect(failuresMessages).To(ConsistOf(ContainSubstring("not to panic, but panicked with\n    <string>: ack!")))
+		})
+
+		It("prints simple message when positive", func() {
+			failuresMessages := InterceptGomegaFailures(func() {
+				Expect(func() {}).To(Panic())
+			})
+			Expect(failuresMessages).To(ConsistOf(MatchRegexp("Expected\n\\s+<func\\(\\)>: .+\nto panic")))
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/receive_matcher.go b/vendor/github.com/onsi/gomega/matchers/receive_matcher.go
new file mode 100644
index 000000000..2018a6128
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/receive_matcher.go
@@ -0,0 +1,128 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/format"
+)
+
+type ReceiveMatcher struct {
+	Arg           interface{}
+	receivedValue reflect.Value
+	channelClosed bool
+}
+
+func (matcher *ReceiveMatcher) Match(actual interface{}) (success bool, err error) {
+	if !isChan(actual) {
+		return false, fmt.Errorf("ReceiveMatcher expects a channel.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	channelType := reflect.TypeOf(actual)
+	channelValue := reflect.ValueOf(actual)
+
+	if channelType.ChanDir() == reflect.SendDir {
+		return false, fmt.Errorf("ReceiveMatcher matcher cannot be passed a send-only channel.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	var subMatcher omegaMatcher
+	var hasSubMatcher bool
+
+	if matcher.Arg != nil {
+		subMatcher, hasSubMatcher = (matcher.Arg).(omegaMatcher)
+		if !hasSubMatcher {
+			argType := reflect.TypeOf(matcher.Arg)
+			if argType.Kind() != reflect.Ptr {
+				return false, fmt.Errorf("Cannot assign a value from the channel:\n%s\nTo:\n%s\nYou need to pass a pointer!", format.Object(actual, 1), format.Object(matcher.Arg, 1))
+			}
+		}
+	}
+
+	winnerIndex, value, open := reflect.Select([]reflect.SelectCase{
+		{Dir: reflect.SelectRecv, Chan: channelValue},
+		{Dir: reflect.SelectDefault},
+	})
+
+	var closed bool
+	var didReceive bool
+	if winnerIndex == 0 {
+		closed = !open
+		didReceive = open
+	}
+	matcher.channelClosed = closed
+
+	if closed {
+		return false, nil
+	}
+
+	if hasSubMatcher {
+		if didReceive {
+			matcher.receivedValue = value
+			return subMatcher.Match(matcher.receivedValue.Interface())
+		}
+		return false, nil
+	}
+
+	if didReceive {
+		if matcher.Arg != nil {
+			outValue := reflect.ValueOf(matcher.Arg)
+
+			if value.Type().AssignableTo(outValue.Elem().Type()) {
+				outValue.Elem().Set(value)
+				return true, nil
+			}
+			if value.Type().Kind() == reflect.Interface && value.Elem().Type().AssignableTo(outValue.Elem().Type()) {
+				outValue.Elem().Set(value.Elem())
+				return true, nil
+			} else {
+				return false, fmt.Errorf("Cannot assign a value from the channel:\n%s\nType:\n%s\nTo:\n%s", format.Object(actual, 1), format.Object(value.Interface(), 1), format.Object(matcher.Arg, 1))
+			}
+
+		}
+
+		return true, nil
+	}
+	return false, nil
+}
+
+func (matcher *ReceiveMatcher) FailureMessage(actual interface{}) (message string) {
+	subMatcher, hasSubMatcher := (matcher.Arg).(omegaMatcher)
+
+	closedAddendum := ""
+	if matcher.channelClosed {
+		closedAddendum = " The channel is closed."
+	}
+
+	if hasSubMatcher {
+		if matcher.receivedValue.IsValid() {
+			return subMatcher.FailureMessage(matcher.receivedValue.Interface())
+		}
+		return "When passed a matcher, ReceiveMatcher's channel *must* receive something."
+	}
+	return format.Message(actual, "to receive something."+closedAddendum)
+}
+
+func (matcher *ReceiveMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	subMatcher, hasSubMatcher := (matcher.Arg).(omegaMatcher)
+
+	closedAddendum := ""
+	if matcher.channelClosed {
+		closedAddendum = " The channel is closed."
+	}
+
+	if hasSubMatcher {
+		if matcher.receivedValue.IsValid() {
+			return subMatcher.NegatedFailureMessage(matcher.receivedValue.Interface())
+		}
+		return "When passed a matcher, ReceiveMatcher's channel *must* receive something."
+	}
+	return format.Message(actual, "not to receive anything."+closedAddendum)
+}
+
+func (matcher *ReceiveMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
+	if !isChan(actual) {
+		return false
+	}
+
+	return !matcher.channelClosed
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/receive_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/receive_matcher_test.go
new file mode 100644
index 000000000..cf04e85dd
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/receive_matcher_test.go
@@ -0,0 +1,304 @@
+package matchers_test
+
+import (
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+type kungFuActor interface {
+	DrunkenMaster() bool
+}
+
+type jackie struct {
+	name string
+}
+
+func (j *jackie) DrunkenMaster() bool {
+	return true
+}
+
+type someError struct{ s string }
+
+func (e *someError) Error() string { return e.s }
+
+var _ = Describe("ReceiveMatcher", func() {
+	Context("with no argument", func() {
+		Context("for a buffered channel", func() {
+			It("should succeed", func() {
+				channel := make(chan bool, 1)
+
+				Expect(channel).ShouldNot(Receive())
+
+				channel <- true
+
+				Expect(channel).Should(Receive())
+			})
+		})
+
+		Context("for an unbuffered channel", func() {
+			It("should succeed (eventually)", func() {
+				channel := make(chan bool)
+
+				Expect(channel).ShouldNot(Receive())
+
+				go func() {
+					time.Sleep(10 * time.Millisecond)
+					channel <- true
+				}()
+
+				Eventually(channel).Should(Receive())
+			})
+		})
+	})
+
+	Context("with a pointer argument", func() {
+		Context("of the correct type", func() {
+			Context("when the channel has an interface type", func() {
+				It("should write the value received on the channel to the pointer", func() {
+					channel := make(chan error, 1)
+
+					var value *someError
+
+					Ω(channel).ShouldNot(Receive(&value))
+					Ω(value).Should(BeZero())
+
+					channel <- &someError{"boooom!"}
+
+					Ω(channel).Should(Receive(&value))
+					Ω(value).Should(MatchError("boooom!"))
+				})
+			})
+		})
+
+		Context("of the correct type", func() {
+			It("should write the value received on the channel to the pointer", func() {
+				channel := make(chan int, 1)
+
+				var value int
+
+				Expect(channel).ShouldNot(Receive(&value))
+				Expect(value).Should(BeZero())
+
+				channel <- 17
+
+				Expect(channel).Should(Receive(&value))
+				Expect(value).Should(Equal(17))
+			})
+		})
+
+		Context("to various types of objects", func() {
+			It("should work", func() {
+				//channels of strings
+				stringChan := make(chan string, 1)
+				stringChan <- "foo"
+
+				var s string
+				Expect(stringChan).Should(Receive(&s))
+				Expect(s).Should(Equal("foo"))
+
+				//channels of slices
+				sliceChan := make(chan []bool, 1)
+				sliceChan <- []bool{true, true, false}
+
+				var sl []bool
+				Expect(sliceChan).Should(Receive(&sl))
+				Expect(sl).Should(Equal([]bool{true, true, false}))
+
+				//channels of channels
+				chanChan := make(chan chan bool, 1)
+				c := make(chan bool)
+				chanChan <- c
+
+				var receivedC chan bool
+				Expect(chanChan).Should(Receive(&receivedC))
+				Expect(receivedC).Should(Equal(c))
+
+				//channels of interfaces
+				jackieChan := make(chan kungFuActor, 1)
+				aJackie := &jackie{name: "Jackie Chan"}
+				jackieChan <- aJackie
+
+				var theJackie kungFuActor
+				Expect(jackieChan).Should(Receive(&theJackie))
+				Expect(theJackie).Should(Equal(aJackie))
+			})
+		})
+
+		Context("of the wrong type", func() {
+			It("should error", func() {
+				channel := make(chan int, 1)
+				channel <- 10
+
+				var incorrectType bool
+
+				success, err := (&ReceiveMatcher{Arg: &incorrectType}).Match(channel)
+				Expect(success).Should(BeFalse())
+				Expect(err).Should(HaveOccurred())
+
+				var notAPointer int
+				success, err = (&ReceiveMatcher{Arg: notAPointer}).Match(channel)
+				Expect(success).Should(BeFalse())
+				Expect(err).Should(HaveOccurred())
+			})
+		})
+	})
+
+	Context("with a matcher", func() {
+		It("should defer to the underlying matcher", func() {
+			intChannel := make(chan int, 1)
+			intChannel <- 3
+			Expect(intChannel).Should(Receive(Equal(3)))
+
+			intChannel <- 2
+			Expect(intChannel).ShouldNot(Receive(Equal(3)))
+
+			stringChannel := make(chan []string, 1)
+			stringChannel <- []string{"foo", "bar", "baz"}
+			Expect(stringChannel).Should(Receive(ContainElement(ContainSubstring("fo"))))
+
+			stringChannel <- []string{"foo", "bar", "baz"}
+			Expect(stringChannel).ShouldNot(Receive(ContainElement(ContainSubstring("archipelago"))))
+		})
+
+		It("should defer to the underlying matcher for the message", func() {
+			matcher := Receive(Equal(3))
+			channel := make(chan int, 1)
+			channel <- 2
+			matcher.Match(channel)
+			Expect(matcher.FailureMessage(channel)).Should(MatchRegexp(`Expected\s+<int>: 2\s+to equal\s+<int>: 3`))
+
+			channel <- 3
+			matcher.Match(channel)
+			Expect(matcher.NegatedFailureMessage(channel)).Should(MatchRegexp(`Expected\s+<int>: 3\s+not to equal\s+<int>: 3`))
+		})
+
+		It("should work just fine with Eventually", func() {
+			stringChannel := make(chan string)
+
+			go func() {
+				time.Sleep(5 * time.Millisecond)
+				stringChannel <- "A"
+				time.Sleep(5 * time.Millisecond)
+				stringChannel <- "B"
+			}()
+
+			Eventually(stringChannel).Should(Receive(Equal("B")))
+		})
+
+		Context("if the matcher errors", func() {
+			It("should error", func() {
+				channel := make(chan int, 1)
+				channel <- 3
+				success, err := (&ReceiveMatcher{Arg: ContainSubstring("three")}).Match(channel)
+				Expect(success).Should(BeFalse())
+				Expect(err).Should(HaveOccurred())
+			})
+		})
+
+		Context("if nothing is received", func() {
+			It("should fail", func() {
+				channel := make(chan int, 1)
+				success, err := (&ReceiveMatcher{Arg: Equal(1)}).Match(channel)
+				Expect(success).Should(BeFalse())
+				Expect(err).ShouldNot(HaveOccurred())
+			})
+		})
+	})
+
+	Context("When actual is a *closed* channel", func() {
+		Context("for a buffered channel", func() {
+			It("should work until it hits the end of the buffer", func() {
+				channel := make(chan bool, 1)
+				channel <- true
+
+				close(channel)
+
+				Expect(channel).Should(Receive())
+				Expect(channel).ShouldNot(Receive())
+			})
+		})
+
+		Context("for an unbuffered channel", func() {
+			It("should always fail", func() {
+				channel := make(chan bool)
+				close(channel)
+
+				Expect(channel).ShouldNot(Receive())
+			})
+		})
+	})
+
+	Context("When actual is a send-only channel", func() {
+		It("should error", func() {
+			channel := make(chan bool)
+
+			var writerChannel chan<- bool
+			writerChannel = channel
+
+			success, err := (&ReceiveMatcher{}).Match(writerChannel)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Context("when acutal is a non-channel", func() {
+		It("should error", func() {
+			var nilChannel chan bool
+
+			success, err := (&ReceiveMatcher{}).Match(nilChannel)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&ReceiveMatcher{}).Match(nil)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+
+			success, err = (&ReceiveMatcher{}).Match(3)
+			Expect(success).Should(BeFalse())
+			Expect(err).Should(HaveOccurred())
+		})
+	})
+
+	Describe("when used with eventually and a custom matcher", func() {
+		It("should return the matcher's error when a failing value is received on the channel, instead of the must receive something failure", func() {
+			failures := InterceptGomegaFailures(func() {
+				c := make(chan string, 0)
+				Eventually(c, 0.01).Should(Receive(Equal("hello")))
+			})
+			Expect(failures[0]).Should(ContainSubstring("When passed a matcher, ReceiveMatcher's channel *must* receive something."))
+
+			failures = InterceptGomegaFailures(func() {
+				c := make(chan string, 1)
+				c <- "hi"
+				Eventually(c, 0.01).Should(Receive(Equal("hello")))
+			})
+			Expect(failures[0]).Should(ContainSubstring("<string>: hello"))
+		})
+	})
+
+	Describe("Bailing early", func() {
+		It("should bail early when passed a closed channel", func() {
+			c := make(chan bool)
+			close(c)
+
+			t := time.Now()
+			failures := InterceptGomegaFailures(func() {
+				Eventually(c).Should(Receive())
+			})
+			Expect(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
+			Expect(failures).Should(HaveLen(1))
+		})
+
+		It("should bail early when passed a non-channel", func() {
+			t := time.Now()
+			failures := InterceptGomegaFailures(func() {
+				Eventually(3).Should(Receive())
+			})
+			Expect(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
+			Expect(failures).Should(HaveLen(1))
+		})
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/semi_structured_data_support.go b/vendor/github.com/onsi/gomega/matchers/semi_structured_data_support.go
new file mode 100644
index 000000000..639295684
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/semi_structured_data_support.go
@@ -0,0 +1,92 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+func formattedMessage(comparisonMessage string, failurePath []interface{}) string {
+	var diffMessage string
+	if len(failurePath) == 0 {
+		diffMessage = ""
+	} else {
+		diffMessage = fmt.Sprintf("\n\nfirst mismatched key: %s", formattedFailurePath(failurePath))
+	}
+	return fmt.Sprintf("%s%s", comparisonMessage, diffMessage)
+}
+
+func formattedFailurePath(failurePath []interface{}) string {
+	formattedPaths := []string{}
+	for i := len(failurePath) - 1; i >= 0; i-- {
+		switch p := failurePath[i].(type) {
+		case int:
+			formattedPaths = append(formattedPaths, fmt.Sprintf(`[%d]`, p))
+		default:
+			if i != len(failurePath)-1 {
+				formattedPaths = append(formattedPaths, ".")
+			}
+			formattedPaths = append(formattedPaths, fmt.Sprintf(`"%s"`, p))
+		}
+	}
+	return strings.Join(formattedPaths, "")
+}
+
+func deepEqual(a interface{}, b interface{}) (bool, []interface{}) {
+	var errorPath []interface{}
+	if reflect.TypeOf(a) != reflect.TypeOf(b) {
+		return false, errorPath
+	}
+
+	switch a.(type) {
+	case []interface{}:
+		if len(a.([]interface{})) != len(b.([]interface{})) {
+			return false, errorPath
+		}
+
+		for i, v := range a.([]interface{}) {
+			elementEqual, keyPath := deepEqual(v, b.([]interface{})[i])
+			if !elementEqual {
+				return false, append(keyPath, i)
+			}
+		}
+		return true, errorPath
+
+	case map[interface{}]interface{}:
+		if len(a.(map[interface{}]interface{})) != len(b.(map[interface{}]interface{})) {
+			return false, errorPath
+		}
+
+		for k, v1 := range a.(map[interface{}]interface{}) {
+			v2, ok := b.(map[interface{}]interface{})[k]
+			if !ok {
+				return false, errorPath
+			}
+			elementEqual, keyPath := deepEqual(v1, v2)
+			if !elementEqual {
+				return false, append(keyPath, k)
+			}
+		}
+		return true, errorPath
+
+	case map[string]interface{}:
+		if len(a.(map[string]interface{})) != len(b.(map[string]interface{})) {
+			return false, errorPath
+		}
+
+		for k, v1 := range a.(map[string]interface{}) {
+			v2, ok := b.(map[string]interface{})[k]
+			if !ok {
+				return false, errorPath
+			}
+			elementEqual, keyPath := deepEqual(v1, v2)
+			if !elementEqual {
+				return false, append(keyPath, k)
+			}
+		}
+		return true, errorPath
+
+	default:
+		return a == b, errorPath
+	}
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/succeed_matcher.go b/vendor/github.com/onsi/gomega/matchers/succeed_matcher.go
new file mode 100644
index 000000000..721ed5529
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/succeed_matcher.go
@@ -0,0 +1,33 @@
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/onsi/gomega/format"
+)
+
+type SucceedMatcher struct {
+}
+
+func (matcher *SucceedMatcher) Match(actual interface{}) (success bool, err error) {
+	// is purely nil?
+	if actual == nil {
+		return true, nil
+	}
+
+	// must be an 'error' type
+	if !isError(actual) {
+		return false, fmt.Errorf("Expected an error-type.  Got:\n%s", format.Object(actual, 1))
+	}
+
+	// must be nil (or a pointer to a nil)
+	return isNil(actual), nil
+}
+
+func (matcher *SucceedMatcher) FailureMessage(actual interface{}) (message string) {
+	return fmt.Sprintf("Expected success, but got an error:\n%s\n%s", format.Object(actual, 1), format.IndentString(actual.(error).Error(), 1))
+}
+
+func (matcher *SucceedMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	return "Expected failure, but got no error."
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/succeed_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/succeed_matcher_test.go
new file mode 100644
index 000000000..e42dd8a6e
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/succeed_matcher_test.go
@@ -0,0 +1,72 @@
+package matchers_test
+
+import (
+	"errors"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+	"regexp"
+)
+
+func Erroring() error {
+	return errors.New("bam")
+}
+
+func NotErroring() error {
+	return nil
+}
+
+type AnyType struct{}
+
+func Invalid() *AnyType {
+	return nil
+}
+
+var _ = Describe("Succeed", func() {
+	It("should succeed if the function succeeds", func() {
+		Expect(NotErroring()).Should(Succeed())
+	})
+
+	It("should succeed (in the negated) if the function errored", func() {
+		Expect(Erroring()).ShouldNot(Succeed())
+	})
+
+	It("should not if passed a non-error", func() {
+		success, err := (&SucceedMatcher{}).Match(Invalid())
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(MatchError("Expected an error-type.  Got:\n    <*matchers_test.AnyType | 0x0>: nil"))
+	})
+
+	It("doesn't support non-error type", func() {
+		success, err := (&SucceedMatcher{}).Match(AnyType{})
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(MatchError("Expected an error-type.  Got:\n    <matchers_test.AnyType>: {}"))
+	})
+
+	It("doesn't support non-error pointer type", func() {
+		success, err := (&SucceedMatcher{}).Match(&AnyType{})
+		Expect(success).Should(BeFalse())
+		Expect(err).Should(MatchError(MatchRegexp(`Expected an error-type.  Got:\n    <*matchers_test.AnyType | 0x[[:xdigit:]]+>: {}`)))
+	})
+
+	It("should not succeed with pointer types that conform to error interface", func() {
+		err := &CustomErr{"ohai"}
+		Expect(err).ShouldNot(Succeed())
+	})
+
+	It("should succeed with nil pointers to types that conform to error interface", func() {
+		var err *CustomErr = nil
+		Expect(err).Should(Succeed())
+	})
+
+	It("builds failure message", func() {
+		actual := Succeed().FailureMessage(errors.New("oops"))
+		actual = regexp.MustCompile(" 0x.*>").ReplaceAllString(actual, " 0x00000000>")
+		Expect(actual).To(Equal("Expected success, but got an error:\n    <*errors.errorString | 0x00000000>: {s: \"oops\"}\n    oops"))
+	})
+
+	It("builds negated failure message", func() {
+		actual := Succeed().NegatedFailureMessage(123)
+		Expect(actual).To(Equal("Expected failure, but got no error."))
+	})
+})
diff --git a/vendor/github.com/onsi/gomega/matchers/support/goraph/MIT.LICENSE b/vendor/github.com/onsi/gomega/matchers/support/goraph/MIT.LICENSE
new file mode 100644
index 000000000..8edd8175a
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/support/goraph/MIT.LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2014 Amit Kumar Gupta
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraph.go b/vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraph.go
new file mode 100644
index 000000000..8aaf8759d
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraph.go
@@ -0,0 +1,41 @@
+package bipartitegraph
+
+import "errors"
+import "fmt"
+
+import . "github.com/onsi/gomega/matchers/support/goraph/node"
+import . "github.com/onsi/gomega/matchers/support/goraph/edge"
+
+type BipartiteGraph struct {
+	Left  NodeOrderedSet
+	Right NodeOrderedSet
+	Edges EdgeSet
+}
+
+func NewBipartiteGraph(leftValues, rightValues []interface{}, neighbours func(interface{}, interface{}) (bool, error)) (*BipartiteGraph, error) {
+	left := NodeOrderedSet{}
+	for i := range leftValues {
+		left = append(left, Node{Id: i})
+	}
+
+	right := NodeOrderedSet{}
+	for j := range rightValues {
+		right = append(right, Node{Id: j + len(left)})
+	}
+
+	edges := EdgeSet{}
+	for i, leftValue := range leftValues {
+		for j, rightValue := range rightValues {
+			neighbours, err := neighbours(leftValue, rightValue)
+			if err != nil {
+				return nil, errors.New(fmt.Sprintf("error determining adjacency for %v and %v: %s", leftValue, rightValue, err.Error()))
+			}
+
+			if neighbours {
+				edges = append(edges, Edge{Node1: left[i], Node2: right[j]})
+			}
+		}
+	}
+
+	return &BipartiteGraph{left, right, edges}, nil
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraphmatching.go b/vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraphmatching.go
new file mode 100644
index 000000000..8181f43a4
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/support/goraph/bipartitegraph/bipartitegraphmatching.go
@@ -0,0 +1,159 @@
+package bipartitegraph
+
+import . "github.com/onsi/gomega/matchers/support/goraph/node"
+import . "github.com/onsi/gomega/matchers/support/goraph/edge"
+import "github.com/onsi/gomega/matchers/support/goraph/util"
+
+func (bg *BipartiteGraph) LargestMatching() (matching EdgeSet) {
+	paths := bg.maximalDisjointSLAPCollection(matching)
+
+	for len(paths) > 0 {
+		for _, path := range paths {
+			matching = matching.SymmetricDifference(path)
+		}
+		paths = bg.maximalDisjointSLAPCollection(matching)
+	}
+
+	return
+}
+
+func (bg *BipartiteGraph) maximalDisjointSLAPCollection(matching EdgeSet) (result []EdgeSet) {
+	guideLayers := bg.createSLAPGuideLayers(matching)
+	if len(guideLayers) == 0 {
+		return
+	}
+
+	used := make(map[Node]bool)
+
+	for _, u := range guideLayers[len(guideLayers)-1] {
+		slap, found := bg.findDisjointSLAP(u, matching, guideLayers, used)
+		if found {
+			for _, edge := range slap {
+				used[edge.Node1] = true
+				used[edge.Node2] = true
+			}
+			result = append(result, slap)
+		}
+	}
+
+	return
+}
+
+func (bg *BipartiteGraph) findDisjointSLAP(
+	start Node,
+	matching EdgeSet,
+	guideLayers []NodeOrderedSet,
+	used map[Node]bool,
+) ([]Edge, bool) {
+	return bg.findDisjointSLAPHelper(start, EdgeSet{}, len(guideLayers)-1, matching, guideLayers, used)
+}
+
+func (bg *BipartiteGraph) findDisjointSLAPHelper(
+	currentNode Node,
+	currentSLAP EdgeSet,
+	currentLevel int,
+	matching EdgeSet,
+	guideLayers []NodeOrderedSet,
+	used map[Node]bool,
+) (EdgeSet, bool) {
+	used[currentNode] = true
+
+	if currentLevel == 0 {
+		return currentSLAP, true
+	}
+
+	for _, nextNode := range guideLayers[currentLevel-1] {
+		if used[nextNode] {
+			continue
+		}
+
+		edge, found := bg.Edges.FindByNodes(currentNode, nextNode)
+		if !found {
+			continue
+		}
+
+		if matching.Contains(edge) == util.Odd(currentLevel) {
+			continue
+		}
+
+		currentSLAP = append(currentSLAP, edge)
+		slap, found := bg.findDisjointSLAPHelper(nextNode, currentSLAP, currentLevel-1, matching, guideLayers, used)
+		if found {
+			return slap, true
+		}
+		currentSLAP = currentSLAP[:len(currentSLAP)-1]
+	}
+
+	used[currentNode] = false
+	return nil, false
+}
+
+func (bg *BipartiteGraph) createSLAPGuideLayers(matching EdgeSet) (guideLayers []NodeOrderedSet) {
+	used := make(map[Node]bool)
+	currentLayer := NodeOrderedSet{}
+
+	for _, node := range bg.Left {
+		if matching.Free(node) {
+			used[node] = true
+			currentLayer = append(currentLayer, node)
+		}
+	}
+
+	if len(currentLayer) == 0 {
+		return []NodeOrderedSet{}
+	}
+	guideLayers = append(guideLayers, currentLayer)
+
+	done := false
+
+	for !done {
+		lastLayer := currentLayer
+		currentLayer = NodeOrderedSet{}
+
+		if util.Odd(len(guideLayers)) {
+			for _, leftNode := range lastLayer {
+				for _, rightNode := range bg.Right {
+					if used[rightNode] {
+						continue
+					}
+
+					edge, found := bg.Edges.FindByNodes(leftNode, rightNode)
+					if !found || matching.Contains(edge) {
+						continue
+					}
+
+					currentLayer = append(currentLayer, rightNode)
+					used[rightNode] = true
+
+					if matching.Free(rightNode) {
+						done = true
+					}
+				}
+			}
+		} else {
+			for _, rightNode := range lastLayer {
+				for _, leftNode := range bg.Left {
+					if used[leftNode] {
+						continue
+					}
+
+					edge, found := bg.Edges.FindByNodes(leftNode, rightNode)
+					if !found || !matching.Contains(edge) {
+						continue
+					}
+
+					currentLayer = append(currentLayer, leftNode)
+					used[leftNode] = true
+				}
+			}
+
+		}
+
+		if len(currentLayer) == 0 {
+			return []NodeOrderedSet{}
+		}
+		guideLayers = append(guideLayers, currentLayer)
+	}
+
+	return
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/support/goraph/edge/edge.go b/vendor/github.com/onsi/gomega/matchers/support/goraph/edge/edge.go
new file mode 100644
index 000000000..4fd15cc06
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/support/goraph/edge/edge.go
@@ -0,0 +1,61 @@
+package edge
+
+import . "github.com/onsi/gomega/matchers/support/goraph/node"
+
+type Edge struct {
+	Node1 Node
+	Node2 Node
+}
+
+type EdgeSet []Edge
+
+func (ec EdgeSet) Free(node Node) bool {
+	for _, e := range ec {
+		if e.Node1 == node || e.Node2 == node {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (ec EdgeSet) Contains(edge Edge) bool {
+	for _, e := range ec {
+		if e == edge {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (ec EdgeSet) FindByNodes(node1, node2 Node) (Edge, bool) {
+	for _, e := range ec {
+		if (e.Node1 == node1 && e.Node2 == node2) || (e.Node1 == node2 && e.Node2 == node1) {
+			return e, true
+		}
+	}
+
+	return Edge{}, false
+}
+
+func (ec EdgeSet) SymmetricDifference(ec2 EdgeSet) EdgeSet {
+	edgesToInclude := make(map[Edge]bool)
+
+	for _, e := range ec {
+		edgesToInclude[e] = true
+	}
+
+	for _, e := range ec2 {
+		edgesToInclude[e] = !edgesToInclude[e]
+	}
+
+	result := EdgeSet{}
+	for e, include := range edgesToInclude {
+		if include {
+			result = append(result, e)
+		}
+	}
+
+	return result
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/support/goraph/node/node.go b/vendor/github.com/onsi/gomega/matchers/support/goraph/node/node.go
new file mode 100644
index 000000000..800c2ea8c
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/support/goraph/node/node.go
@@ -0,0 +1,7 @@
+package node
+
+type Node struct {
+	Id int
+}
+
+type NodeOrderedSet []Node
diff --git a/vendor/github.com/onsi/gomega/matchers/support/goraph/util/util.go b/vendor/github.com/onsi/gomega/matchers/support/goraph/util/util.go
new file mode 100644
index 000000000..d76a1ee00
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/support/goraph/util/util.go
@@ -0,0 +1,7 @@
+package util
+
+import "math"
+
+func Odd(n int) bool {
+	return math.Mod(float64(n), 2.0) == 1.0
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_01.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_01.xml
new file mode 100644
index 000000000..90f0a1b45
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_01.xml
@@ -0,0 +1,6 @@
+<note>
+    <to>Tove</to>
+    <from>Jani</from>
+    <heading>Reminder</heading>
+    <body>Don't forget me this weekend!</body>
+</note>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_02.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_02.xml
new file mode 100644
index 000000000..3863b83c3
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_02.xml
@@ -0,0 +1,9 @@
+
+
+<note>
+    <to>Tove</to>
+    <from>Jani</from>
+    <heading>Reminder</heading>
+    <body>Don't forget me this weekend!</body>
+</note>
+
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_03.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_03.xml
new file mode 100644
index 000000000..a491c213c
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_03.xml
@@ -0,0 +1 @@
+<note> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note>
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_04.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_04.xml
new file mode 100644
index 000000000..dcfd3db03
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_04.xml
@@ -0,0 +1,6 @@
+<note>
+    <to>Tove</to>
+    <from>John</from>
+    <heading>Doe</heading>
+    <body>Don't forget me this weekend!</body>
+</note>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_05.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_05.xml
new file mode 100644
index 000000000..de15a6a55
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_05.xml
@@ -0,0 +1,211 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<CATALOG>

+  <CD>

+    <TITLE>Empire Burlesque</TITLE>

+    <ARTIST>Bob Dylan</ARTIST>

+    <COUNTRY>USA</COUNTRY>

+    <COMPANY>Columbia</COMPANY>

+    <PRICE>10.90</PRICE>

+    <YEAR>1985</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Hide your heart</TITLE>

+    <ARTIST>Bonnie Tyler</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>CBS Records</COMPANY>

+    <PRICE>9.90</PRICE>

+    <YEAR>1988</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Greatest Hits</TITLE>

+    <ARTIST>Dolly Parton</ARTIST>

+    <COUNTRY>USA</COUNTRY>

+    <COMPANY>RCA</COMPANY>

+    <PRICE>9.90</PRICE>

+    <YEAR>1982</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Still got the blues</TITLE>

+    <ARTIST>Gary Moore</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>Virgin records</COMPANY>

+    <PRICE>10.20</PRICE>

+    <YEAR>1990</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Eros</TITLE>

+    <ARTIST>Eros Ramazzotti</ARTIST>

+    <COUNTRY>EU</COUNTRY>

+    <COMPANY>BMG</COMPANY>

+    <PRICE>9.90</PRICE>

+    <YEAR>1997</YEAR>

+  </CD>

+  <CD>

+    <TITLE>One night only</TITLE>

+    <ARTIST>Bee Gees</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>Polydor</COMPANY>

+    <PRICE>10.90</PRICE>

+    <YEAR>1998</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Sylvias Mother</TITLE>

+    <ARTIST>Dr.Hook</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>CBS</COMPANY>

+    <PRICE>8.10</PRICE>

+    <YEAR>1973</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Maggie May</TITLE>

+    <ARTIST>Rod Stewart</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>Pickwick</COMPANY>

+    <PRICE>8.50</PRICE>

+    <YEAR>1990</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Romanza</TITLE>

+    <ARTIST>Andrea Bocelli</ARTIST>

+    <COUNTRY>EU</COUNTRY>

+    <COMPANY>Polydor</COMPANY>

+    <PRICE>10.80</PRICE>

+    <YEAR>1996</YEAR>

+  </CD>

+  <CD>

+    <TITLE>When a man loves a woman</TITLE>

+    <ARTIST>Percy Sledge</ARTIST>

+    <COUNTRY>USA</COUNTRY>

+    <COMPANY>Atlantic</COMPANY>

+    <PRICE>8.70</PRICE>

+    <YEAR>1987</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Black angel</TITLE>

+    <ARTIST>Savage Rose</ARTIST>

+    <COUNTRY>EU</COUNTRY>

+    <COMPANY>Mega</COMPANY>

+    <PRICE>10.90</PRICE>

+    <YEAR>1995</YEAR>

+  </CD>

+  <CD>

+    <TITLE>1999 Grammy Nominees</TITLE>

+    <ARTIST>Many</ARTIST>

+    <COUNTRY>USA</COUNTRY>

+    <COMPANY>Grammy</COMPANY>

+    <PRICE>10.20</PRICE>

+    <YEAR>1999</YEAR>

+  </CD>

+  <CD>

+    <TITLE>For the good times</TITLE>

+    <ARTIST>Kenny Rogers</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>Mucik Master</COMPANY>

+    <PRICE>8.70</PRICE>

+    <YEAR>1995</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Big Willie style</TITLE>

+    <ARTIST>Will Smith</ARTIST>

+    <COUNTRY>USA</COUNTRY>

+    <COMPANY>Columbia</COMPANY>

+    <PRICE>9.90</PRICE>

+    <YEAR>1997</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Tupelo Honey</TITLE>

+    <ARTIST>Van Morrison</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>Polydor</COMPANY>

+    <PRICE>8.20</PRICE>

+    <YEAR>1971</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Soulsville</TITLE>

+    <ARTIST>Jorn Hoel</ARTIST>

+    <COUNTRY>Norway</COUNTRY>

+    <COMPANY>WEA</COMPANY>

+    <PRICE>7.90</PRICE>

+    <YEAR>1996</YEAR>

+  </CD>

+  <CD>

+    <TITLE>The very best of</TITLE>

+    <ARTIST>Cat Stevens</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>Island</COMPANY>

+    <PRICE>8.90</PRICE>

+    <YEAR>1990</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Stop</TITLE>

+    <ARTIST>Sam Brown</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>A and M</COMPANY>

+    <PRICE>8.90</PRICE>

+    <YEAR>1988</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Bridge of Spies</TITLE>

+    <ARTIST>T'Pau</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>Siren</COMPANY>

+    <PRICE>7.90</PRICE>

+    <YEAR>1987</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Private Dancer</TITLE>

+    <ARTIST>Tina Turner</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>Capitol</COMPANY>

+    <PRICE>8.90</PRICE>

+    <YEAR>1983</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Midt om natten</TITLE>

+    <ARTIST>Kim Larsen</ARTIST>

+    <COUNTRY>EU</COUNTRY>

+    <COMPANY>Medley</COMPANY>

+    <PRICE>7.80</PRICE>

+    <YEAR>1983</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Pavarotti Gala Concert</TITLE>

+    <ARTIST>Luciano Pavarotti</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>DECCA</COMPANY>

+    <PRICE>9.90</PRICE>

+    <YEAR>1991</YEAR>

+  </CD>

+  <CD>

+    <TITLE>The dock of the bay</TITLE>

+    <ARTIST>Otis Redding</ARTIST>

+    <COUNTRY>USA</COUNTRY>

+    <COMPANY>Stax Records</COMPANY>

+    <PRICE>7.90</PRICE>

+    <YEAR>1968</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Picture book</TITLE>

+    <ARTIST>Simply Red</ARTIST>

+    <COUNTRY>EU</COUNTRY>

+    <COMPANY>Elektra</COMPANY>

+    <PRICE>7.20</PRICE>

+    <YEAR>1985</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Red</TITLE>

+    <ARTIST>The Communards</ARTIST>

+    <COUNTRY>UK</COUNTRY>

+    <COMPANY>London</COMPANY>

+    <PRICE>7.80</PRICE>

+    <YEAR>1987</YEAR>

+  </CD>

+  <CD>

+    <TITLE>Unchain my heart</TITLE>

+    <ARTIST>Joe Cocker</ARTIST>

+    <COUNTRY>USA</COUNTRY>

+    <COMPANY>EMI</COMPANY>

+    <PRICE>8.20</PRICE>

+    <YEAR>1987</YEAR>

+  </CD>

+</CATALOG>

diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_06.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_06.xml
new file mode 100644
index 000000000..4ba90fb97
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_06.xml
@@ -0,0 +1,13 @@
+<root>
+    <table>
+        <tr>
+            <td>Apples</td>
+            <td>Bananas</td>
+        </tr>
+    </table>
+    <table>
+        <name>African Coffee Table</name>
+        <width>80</width>
+        <length>120</length>
+    </table>
+</root>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_07.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_07.xml
new file mode 100644
index 000000000..34b9e9775
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_07.xml
@@ -0,0 +1,13 @@
+<root>
+    <h:table xmlns:h="http://www.w3.org/TR/html4/">
+        <h:tr>
+            <h:td>Apples</h:td>
+            <h:td>Bananas</h:td>
+        </h:tr>
+    </h:table>
+    <f:table xmlns:f="https://www.w3schools.com/furniture">
+        <f:name>African Coffee Table</f:name>
+        <f:width>80</f:width>
+        <f:length>120</f:length>
+    </f:table>
+</root>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_08.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_08.xml
new file mode 100644
index 000000000..ccaee4e1a
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_08.xml
@@ -0,0 +1,13 @@
+<root>
+    <h:table xmlns:h="http://www.w3.org/TR/html4/">
+        <h:tr>
+            <h:td>Apples</h:td>
+            <h:td>Oranges</h:td>
+        </h:tr>
+    </h:table>
+    <f:table xmlns:f="https://www.w3schools.com/furniture">
+        <f:name>African Coffee Table</f:name>
+        <f:width>80</f:width>
+        <f:length>120</f:length>
+    </f:table>
+</root>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_09.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_09.xml
new file mode 100644
index 000000000..531f84d3f
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_09.xml
@@ -0,0 +1,4 @@
+<person gender="female">
+    <firstname>Foo</firstname>
+    <lastname>Bar</lastname>
+</person>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_10.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_10.xml
new file mode 100644
index 000000000..b1e1e1fbe
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_10.xml
@@ -0,0 +1,4 @@
+<person gender="male">
+    <firstname>Foo</firstname>
+    <lastname>Bar</lastname>
+</person>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_11.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_11.xml
new file mode 100644
index 000000000..3132b0f90
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_11.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>
+<note>
+    <to>Tove</to>
+    <from>Jani</from>
+    <heading>Reminder</heading>
+    <body>Don't forget me this weekend!</body>
+</note>
diff --git a/vendor/github.com/onsi/gomega/matchers/type_support.go b/vendor/github.com/onsi/gomega/matchers/type_support.go
new file mode 100644
index 000000000..75afcd844
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/type_support.go
@@ -0,0 +1,179 @@
+/*
+Gomega matchers
+
+This package implements the Gomega matchers and does not typically need to be imported.
+See the docs for Gomega for documentation on the matchers
+
+http://onsi.github.io/gomega/
+*/
+package matchers
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+)
+
+type omegaMatcher interface {
+	Match(actual interface{}) (success bool, err error)
+	FailureMessage(actual interface{}) (message string)
+	NegatedFailureMessage(actual interface{}) (message string)
+}
+
+func isBool(a interface{}) bool {
+	return reflect.TypeOf(a).Kind() == reflect.Bool
+}
+
+func isNumber(a interface{}) bool {
+	if a == nil {
+		return false
+	}
+	kind := reflect.TypeOf(a).Kind()
+	return reflect.Int <= kind && kind <= reflect.Float64
+}
+
+func isInteger(a interface{}) bool {
+	kind := reflect.TypeOf(a).Kind()
+	return reflect.Int <= kind && kind <= reflect.Int64
+}
+
+func isUnsignedInteger(a interface{}) bool {
+	kind := reflect.TypeOf(a).Kind()
+	return reflect.Uint <= kind && kind <= reflect.Uint64
+}
+
+func isFloat(a interface{}) bool {
+	kind := reflect.TypeOf(a).Kind()
+	return reflect.Float32 <= kind && kind <= reflect.Float64
+}
+
+func toInteger(a interface{}) int64 {
+	if isInteger(a) {
+		return reflect.ValueOf(a).Int()
+	} else if isUnsignedInteger(a) {
+		return int64(reflect.ValueOf(a).Uint())
+	} else if isFloat(a) {
+		return int64(reflect.ValueOf(a).Float())
+	}
+	panic(fmt.Sprintf("Expected a number!  Got <%T> %#v", a, a))
+}
+
+func toUnsignedInteger(a interface{}) uint64 {
+	if isInteger(a) {
+		return uint64(reflect.ValueOf(a).Int())
+	} else if isUnsignedInteger(a) {
+		return reflect.ValueOf(a).Uint()
+	} else if isFloat(a) {
+		return uint64(reflect.ValueOf(a).Float())
+	}
+	panic(fmt.Sprintf("Expected a number!  Got <%T> %#v", a, a))
+}
+
+func toFloat(a interface{}) float64 {
+	if isInteger(a) {
+		return float64(reflect.ValueOf(a).Int())
+	} else if isUnsignedInteger(a) {
+		return float64(reflect.ValueOf(a).Uint())
+	} else if isFloat(a) {
+		return reflect.ValueOf(a).Float()
+	}
+	panic(fmt.Sprintf("Expected a number!  Got <%T> %#v", a, a))
+}
+
+func isError(a interface{}) bool {
+	_, ok := a.(error)
+	return ok
+}
+
+func isChan(a interface{}) bool {
+	if isNil(a) {
+		return false
+	}
+	return reflect.TypeOf(a).Kind() == reflect.Chan
+}
+
+func isMap(a interface{}) bool {
+	if a == nil {
+		return false
+	}
+	return reflect.TypeOf(a).Kind() == reflect.Map
+}
+
+func isArrayOrSlice(a interface{}) bool {
+	if a == nil {
+		return false
+	}
+	switch reflect.TypeOf(a).Kind() {
+	case reflect.Array, reflect.Slice:
+		return true
+	default:
+		return false
+	}
+}
+
+func isString(a interface{}) bool {
+	if a == nil {
+		return false
+	}
+	return reflect.TypeOf(a).Kind() == reflect.String
+}
+
+func toString(a interface{}) (string, bool) {
+	aString, isString := a.(string)
+	if isString {
+		return aString, true
+	}
+
+	aBytes, isBytes := a.([]byte)
+	if isBytes {
+		return string(aBytes), true
+	}
+
+	aStringer, isStringer := a.(fmt.Stringer)
+	if isStringer {
+		return aStringer.String(), true
+	}
+
+	aJSONRawMessage, isJSONRawMessage := a.(json.RawMessage)
+	if isJSONRawMessage {
+		return string(aJSONRawMessage), true
+	}
+
+	return "", false
+}
+
+func lengthOf(a interface{}) (int, bool) {
+	if a == nil {
+		return 0, false
+	}
+	switch reflect.TypeOf(a).Kind() {
+	case reflect.Map, reflect.Array, reflect.String, reflect.Chan, reflect.Slice:
+		return reflect.ValueOf(a).Len(), true
+	default:
+		return 0, false
+	}
+}
+func capOf(a interface{}) (int, bool) {
+	if a == nil {
+		return 0, false
+	}
+	switch reflect.TypeOf(a).Kind() {
+	case reflect.Array, reflect.Chan, reflect.Slice:
+		return reflect.ValueOf(a).Cap(), true
+	default:
+		return 0, false
+	}
+}
+
+func isNil(a interface{}) bool {
+	if a == nil {
+		return true
+	}
+
+	switch reflect.TypeOf(a).Kind() {
+	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return reflect.ValueOf(a).IsNil()
+	}
+
+	return false
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/with_transform.go b/vendor/github.com/onsi/gomega/matchers/with_transform.go
new file mode 100644
index 000000000..8e58d8a0f
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/with_transform.go
@@ -0,0 +1,72 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/onsi/gomega/internal/oraclematcher"
+	"github.com/onsi/gomega/types"
+)
+
+type WithTransformMatcher struct {
+	// input
+	Transform interface{} // must be a function of one parameter that returns one value
+	Matcher   types.GomegaMatcher
+
+	// cached value
+	transformArgType reflect.Type
+
+	// state
+	transformedValue interface{}
+}
+
+func NewWithTransformMatcher(transform interface{}, matcher types.GomegaMatcher) *WithTransformMatcher {
+	if transform == nil {
+		panic("transform function cannot be nil")
+	}
+	txType := reflect.TypeOf(transform)
+	if txType.NumIn() != 1 {
+		panic("transform function must have 1 argument")
+	}
+	if txType.NumOut() != 1 {
+		panic("transform function must have 1 return value")
+	}
+
+	return &WithTransformMatcher{
+		Transform:        transform,
+		Matcher:          matcher,
+		transformArgType: reflect.TypeOf(transform).In(0),
+	}
+}
+
+func (m *WithTransformMatcher) Match(actual interface{}) (bool, error) {
+	// return error if actual's type is incompatible with Transform function's argument type
+	actualType := reflect.TypeOf(actual)
+	if !actualType.AssignableTo(m.transformArgType) {
+		return false, fmt.Errorf("Transform function expects '%s' but we have '%s'", m.transformArgType, actualType)
+	}
+
+	// call the Transform function with `actual`
+	fn := reflect.ValueOf(m.Transform)
+	result := fn.Call([]reflect.Value{reflect.ValueOf(actual)})
+	m.transformedValue = result[0].Interface() // expect exactly one value
+
+	return m.Matcher.Match(m.transformedValue)
+}
+
+func (m *WithTransformMatcher) FailureMessage(_ interface{}) (message string) {
+	return m.Matcher.FailureMessage(m.transformedValue)
+}
+
+func (m *WithTransformMatcher) NegatedFailureMessage(_ interface{}) (message string) {
+	return m.Matcher.NegatedFailureMessage(m.transformedValue)
+}
+
+func (m *WithTransformMatcher) MatchMayChangeInTheFuture(_ interface{}) bool {
+	// TODO: Maybe this should always just return true? (Only an issue for non-deterministic transformers.)
+	//
+	// Querying the next matcher is fine if the transformer always will return the same value.
+	// But if the transformer is non-deterministic and returns a different value each time, then there
+	// is no point in querying the next matcher, since it can only comment on the last transformed value.
+	return oraclematcher.MatchMayChangeInTheFuture(m.Matcher, m.transformedValue)
+}
diff --git a/vendor/github.com/onsi/gomega/matchers/with_transform_test.go b/vendor/github.com/onsi/gomega/matchers/with_transform_test.go
new file mode 100644
index 000000000..e52bf8e63
--- /dev/null
+++ b/vendor/github.com/onsi/gomega/matchers/with_transform_test.go
@@ -0,0 +1,102 @@
+package matchers_test
+
+import (
+	"errors"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/matchers"
+)
+
+var _ = Describe("WithTransformMatcher", func() {
+
+	var plus1 = func(i int) int { return i + 1 }
+
+	Context("Panic if transform function invalid", func() {
+		panicsWithTransformer := func(transform interface{}) {
+			ExpectWithOffset(1, func() { WithTransform(transform, nil) }).To(Panic())
+		}
+		It("nil", func() {
+			panicsWithTransformer(nil)
+		})
+		Context("Invalid number of args, but correct return value count", func() {
+			It("zero", func() {
+				panicsWithTransformer(func() int { return 5 })
+			})
+			It("two", func() {
+				panicsWithTransformer(func(i, j int) int { return 5 })
+			})
+		})
+		Context("Invalid number of return values, but correct number of arguments", func() {
+			It("zero", func() {
+				panicsWithTransformer(func(i int) {})
+			})
+			It("two", func() {
+				panicsWithTransformer(func(i int) (int, int) { return 5, 6 })
+			})
+		})
+	})
+
+	It("works with positive cases", func() {
+		Expect(1).To(WithTransform(plus1, Equal(2)))
+		Expect(1).To(WithTransform(plus1, WithTransform(plus1, Equal(3))))
+		Expect(1).To(WithTransform(plus1, And(Equal(2), BeNumerically(">", 1))))
+
+		// transform expects custom type
+		type S struct {
+			A int
+			B string
+		}
+		transformer := func(s S) string { return s.B }
+		Expect(S{1, "hi"}).To(WithTransform(transformer, Equal("hi")))
+
+		// transform expects interface
+		errString := func(e error) string { return e.Error() }
+		Expect(errors.New("abc")).To(WithTransform(errString, Equal("abc")))
+	})
+
+	It("works with negative cases", func() {
+		Expect(1).ToNot(WithTransform(plus1, Equal(3)))
+		Expect(1).ToNot(WithTransform(plus1, WithTransform(plus1, Equal(2))))
+	})
+
+	Context("failure messages", func() {
+		Context("when match fails", func() {
+			It("gives a descriptive message", func() {
+				m := WithTransform(plus1, Equal(3))
+				Expect(m.Match(1)).To(BeFalse())
+				Expect(m.FailureMessage(1)).To(Equal("Expected\n    <int>: 2\nto equal\n    <int>: 3"))
+			})
+		})
+
+		Context("when match succeeds, but expected it to fail", func() {
+			It("gives a descriptive message", func() {
+				m := Not(WithTransform(plus1, Equal(3)))
+				Expect(m.Match(2)).To(BeFalse())
+				Expect(m.FailureMessage(2)).To(Equal("Expected\n    <int>: 3\nnot to equal\n    <int>: 3"))
+			})
+		})
+
+		Context("actual value is incompatible with transform function's argument type", func() {
+			It("gracefully fails if transform cannot be performed", func() {
+				m := WithTransform(plus1, Equal(3))
+				result, err := m.Match("hi") // give it a string but transform expects int; doesn't panic
+				Expect(result).To(BeFalse())
+				Expect(err).To(MatchError("Transform function expects 'int' but we have 'string'"))
+			})
+		})
+	})
+
+	Context("MatchMayChangeInTheFuture()", func() {
+		It("Propagates value from wrapped matcher on the transformed value", func() {
+			m := WithTransform(plus1, Or()) // empty Or() always returns false, and indicates it cannot change
+			Expect(m.Match(1)).To(BeFalse())
+			Expect(m.(*WithTransformMatcher).MatchMayChangeInTheFuture(1)).To(BeFalse()) // empty Or() indicates cannot change
+		})
+		It("Defaults to true", func() {
+			m := WithTransform(plus1, Equal(2)) // Equal does not have this method
+			Expect(m.Match(1)).To(BeTrue())
+			Expect(m.(*WithTransformMatcher).MatchMayChangeInTheFuture(1)).To(BeTrue()) // defaults to true
+		})
+	})
+})