Revert "Dependency updates. (#14033)" (#14304)

This reverts commit f14c79f170.

vendor/github.com/mitchellh/go-testing-interface/README.md

@@ -38,14 +38,6 @@ You can also call the test helper at runtime if needed:
         TestHelper(&testing.RuntimeT{})
     }
 
-## Versioning
-
-The tagged version matches the version of Go that the interface is
-compatible with. For example, the version "1.14.0" is for Go 1.14 and
-introduced the `Cleanup` function. The patch version (the ".0" in the
-prior example) is used to fix any bugs found in this library and has no
-correlation to the supported Go version.
-
 ## Why?!
 
 **Why would I call a test helper that takes a *testing.T at runtime?**

vendor/github.com/mitchellh/go-testing-interface/go.mod

@@ -1,3 +1 @@
 module github.com/mitchellh/go-testing-interface
-
-go 1.14

vendor/github.com/mitchellh/go-testing-interface/testing.go

@@ -1,3 +1,5 @@
+// +build !go1.9
+
 package testing
 
 import (
@@ -10,7 +12,6 @@ import (
 // In unit tests you can just pass a *testing.T struct. At runtime, outside
 // of tests, you can pass in a RuntimeT struct from this package.
 type T interface {
-	Cleanup(func())
 	Error(args ...interface{})
 	Errorf(format string, args ...interface{})
 	Fail()
@@ -18,7 +19,6 @@ type T interface {
 	Failed() bool
 	Fatal(args ...interface{})
 	Fatalf(format string, args ...interface{})
-	Helper()
 	Log(args ...interface{})
 	Logf(format string, args ...interface{})
 	Name() string
@@ -31,13 +31,10 @@ type T interface {
 // RuntimeT implements T and can be instantiated and run at runtime to
 // mimic *testing.T behavior. Unlike *testing.T, this will simply panic
 // for calls to Fatal. For calls to Error, you'll have to check the errors
-// list to determine whether to exit yourself.
-//
-// Cleanup does NOT work, so if you're using a helper that uses Cleanup,
-// there may be dangling resources.
+// list to determine whether to exit yourself. Name and Skip methods are
+// unimplemented noops.
 type RuntimeT struct {
-	skipped bool
-	failed  bool
+	failed bool
 }
 
 func (t *RuntimeT) Error(args ...interface{}) {
@@ -46,10 +43,20 @@ func (t *RuntimeT) Error(args ...interface{}) {
 }
 
 func (t *RuntimeT) Errorf(format string, args ...interface{}) {
-	log.Printf(format, args...)
+	log.Println(fmt.Sprintf(format, args...))
 	t.Fail()
 }
 
+func (t *RuntimeT) Fatal(args ...interface{}) {
+	log.Println(fmt.Sprintln(args...))
+	t.FailNow()
+}
+
+func (t *RuntimeT) Fatalf(format string, args ...interface{}) {
+	log.Println(fmt.Sprintf(format, args...))
+	t.FailNow()
+}
+
 func (t *RuntimeT) Fail() {
 	t.failed = true
 }
@@ -62,16 +69,6 @@ func (t *RuntimeT) Failed() bool {
 	return t.failed
 }
 
-func (t *RuntimeT) Fatal(args ...interface{}) {
-	log.Print(args...)
-	t.FailNow()
-}
-
-func (t *RuntimeT) Fatalf(format string, args ...interface{}) {
-	log.Printf(format, args...)
-	t.FailNow()
-}
-
 func (t *RuntimeT) Log(args ...interface{}) {
 	log.Println(fmt.Sprintln(args...))
 }
@@ -80,28 +77,8 @@ func (t *RuntimeT) Logf(format string, args ...interface{}) {
 	log.Println(fmt.Sprintf(format, args...))
 }
 
-func (t *RuntimeT) Name() string {
-	return ""
-}
-
-func (t *RuntimeT) Skip(args ...interface{}) {
-	log.Print(args...)
-	t.SkipNow()
-}
-
-func (t *RuntimeT) SkipNow() {
-	t.skipped = true
-}
-
-func (t *RuntimeT) Skipf(format string, args ...interface{}) {
-	log.Printf(format, args...)
-	t.SkipNow()
-}
-
-func (t *RuntimeT) Skipped() bool {
-	return t.skipped
-}
-
-func (t *RuntimeT) Helper() {}
-
-func (t *RuntimeT) Cleanup(func()) {}
+func (t *RuntimeT) Name() string                             { return "" }
+func (t *RuntimeT) Skip(args ...interface{})                 {}
+func (t *RuntimeT) SkipNow()                                 {}
+func (t *RuntimeT) Skipf(format string, args ...interface{}) {}
+func (t *RuntimeT) Skipped() bool                            { return false }

vendor/github.com/mitchellh/go-testing-interface/testing_go19.go

@@ -0,0 +1,108 @@
+// +build go1.9
+
+// NOTE: This is a temporary copy of testing.go for Go 1.9 with the addition
+// of "Helper" to the T interface. Go 1.9 at the time of typing is in RC
+// and is set for release shortly. We'll support this on master as the default
+// as soon as 1.9 is released.
+
+package testing
+
+import (
+	"fmt"
+	"log"
+)
+
+// T is the interface that mimics the standard library *testing.T.
+//
+// In unit tests you can just pass a *testing.T struct. At runtime, outside
+// of tests, you can pass in a RuntimeT struct from this package.
+type T interface {
+	Error(args ...interface{})
+	Errorf(format string, args ...interface{})
+	Fail()
+	FailNow()
+	Failed() bool
+	Fatal(args ...interface{})
+	Fatalf(format string, args ...interface{})
+	Log(args ...interface{})
+	Logf(format string, args ...interface{})
+	Name() string
+	Skip(args ...interface{})
+	SkipNow()
+	Skipf(format string, args ...interface{})
+	Skipped() bool
+	Helper()
+}
+
+// RuntimeT implements T and can be instantiated and run at runtime to
+// mimic *testing.T behavior. Unlike *testing.T, this will simply panic
+// for calls to Fatal. For calls to Error, you'll have to check the errors
+// list to determine whether to exit yourself.
+type RuntimeT struct {
+	skipped bool
+	failed  bool
+}
+
+func (t *RuntimeT) Error(args ...interface{}) {
+	log.Println(fmt.Sprintln(args...))
+	t.Fail()
+}
+
+func (t *RuntimeT) Errorf(format string, args ...interface{}) {
+	log.Printf(format, args...)
+	t.Fail()
+}
+
+func (t *RuntimeT) Fail() {
+	t.failed = true
+}
+
+func (t *RuntimeT) FailNow() {
+	panic("testing.T failed, see logs for output (if any)")
+}
+
+func (t *RuntimeT) Failed() bool {
+	return t.failed
+}
+
+func (t *RuntimeT) Fatal(args ...interface{}) {
+	log.Print(args...)
+	t.FailNow()
+}
+
+func (t *RuntimeT) Fatalf(format string, args ...interface{}) {
+	log.Printf(format, args...)
+	t.FailNow()
+}
+
+func (t *RuntimeT) Log(args ...interface{}) {
+	log.Println(fmt.Sprintln(args...))
+}
+
+func (t *RuntimeT) Logf(format string, args ...interface{}) {
+	log.Println(fmt.Sprintf(format, args...))
+}
+
+func (t *RuntimeT) Name() string {
+	return ""
+}
+
+func (t *RuntimeT) Skip(args ...interface{}) {
+	log.Print(args...)
+	t.SkipNow()
+}
+
+func (t *RuntimeT) SkipNow() {
+	t.skipped = true
+}
+
+func (t *RuntimeT) Skipf(format string, args ...interface{}) {
+	log.Printf(format, args...)
+	t.SkipNow()
+}
+
+func (t *RuntimeT) Skipped() bool {
+	return t.skipped
+}
+
+func (t *RuntimeT) Helper() {}