@@ -2,7 +2,6 @@ github.com/Azure/go-ansiterm                        d6e3b3328b783f23731bc4d05887

 github.com/Microsoft/hcsshim                        672e52e9209d1e53718c1b6a7d68cc9272654ab5

 github.com/Microsoft/go-winio                       6c72808b55902eae4c5943626030429ff20f3b63 # v0.4.14

 github.com/docker/libtrust                          9cbd2a1374f46905c68a4eb3694a130610adc62a

-github.com/go-check/check                           4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git

 github.com/golang/gddo                              9b12a26f3fbd7397dee4e20939ddca719d840d2a

 github.com/google/uuid                              0cd6bf5da1e1c83f8b45653022c74f71af0538a4 # v1.1.1

 github.com/gorilla/mux                              ed099d42384823742bba0bf9a72b53b55c9e2e38 # v1.7.2

@@ -13,7 +12,6 @@ github.com/konsorten/go-windows-terminal-sequences  f55edac94c9bbba5d6182a4be46d

 github.com/mattn/go-shellwords                      a72fbe27a1b0ed0df2f02754945044ce1456608b # v1.0.5

 github.com/sirupsen/logrus                          8bdbc7bcc01dcbb8ec23dc8a28e332258d25251f # v1.4.1

 github.com/tchap/go-patricia                        a7f0089c6f496e8e70402f61733606daa326cac5 # v2.3.0

-github.com/vdemeester/shakers                       24d7f1d6a71aa5d9cbe7390e4afb66b7eef9e1b3 # v0.1.0

 golang.org/x/net                                    f3200d17e092c607f615320ecaad13d87ad9a2b3

 golang.org/x/sys                                    4c4f7f33c9ed00de01c4c741d2177abfcfe19307

 github.com/docker/go-units                          519db1ee28dcc9fd2474ae59fca29a810482bfb1 # v0.4.0

deleted file mode 100644

@@ -1,25 +0,0 @@

-Gocheck - A rich testing framework for Go

- 

-Copyright (c) 2010-2013 Gustavo Niemeyer <gustavo@niemeyer.net>

-

-All rights reserved.

-

-Redistribution and use in source and binary forms, with or without

-modification, are permitted provided that the following conditions are met: 

-

-1. Redistributions of source code must retain the above copyright notice, this

-   list of conditions and the following disclaimer. 

-2. Redistributions in binary form must reproduce the above copyright notice,

-   this list of conditions and the following disclaimer in the documentation

-   and/or other materials provided with the distribution. 

-

-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR

-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

deleted file mode 100644

@@ -1,10 +0,0 @@

-Go-check

-========

-

-This is a fork of https://github.com/go-check/check

-

-The intention of this fork is not to change any of the original behavior, but add

-some specific behaviors needed for some of my projects already using this test suite.

-For documentation on the main behavior of go-check see the aforementioned repo.

-

-The original branch is intact at `orig_v1`

deleted file mode 100644

@@ -1,187 +0,0 @@

-// Copyright (c) 2012 The Go Authors. All rights reserved.

-// 

-// Redistribution and use in source and binary forms, with or without

-// modification, are permitted provided that the following conditions are

-// met:

-// 

-//    * Redistributions of source code must retain the above copyright

-// notice, this list of conditions and the following disclaimer.

-//    * Redistributions in binary form must reproduce the above

-// copyright notice, this list of conditions and the following disclaimer

-// in the documentation and/or other materials provided with the

-// distribution.

-//    * Neither the name of Google Inc. nor the names of its

-// contributors may be used to endorse or promote products derived from

-// this software without specific prior written permission.

-// 

-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-

-package check

-

-import (

-	"fmt"

-	"runtime"

-	"time"

-)

-

-var memStats runtime.MemStats

-

-// testingB is a type passed to Benchmark functions to manage benchmark

-// timing and to specify the number of iterations to run.

-type timer struct {

-	start     time.Time // Time test or benchmark started

-	duration  time.Duration

-	N         int

-	bytes     int64

-	timerOn   bool

-	benchTime time.Duration

-	// The initial states of memStats.Mallocs and memStats.TotalAlloc.

-	startAllocs uint64

-	startBytes  uint64

-	// The net total of this test after being run.

-	netAllocs uint64

-	netBytes  uint64

-}

-

-// StartTimer starts timing a test. This function is called automatically

-// before a benchmark starts, but it can also used to resume timing after

-// a call to StopTimer.

-func (c *C) StartTimer() {

-	if !c.timerOn {

-		c.start = time.Now()

-		c.timerOn = true

-

-		runtime.ReadMemStats(&memStats)

-		c.startAllocs = memStats.Mallocs

-		c.startBytes = memStats.TotalAlloc

-	}

-}

-

-// StopTimer stops timing a test. This can be used to pause the timer

-// while performing complex initialization that you don't

-// want to measure.

-func (c *C) StopTimer() {

-	if c.timerOn {

-		c.duration += time.Now().Sub(c.start)

-		c.timerOn = false

-		runtime.ReadMemStats(&memStats)

-		c.netAllocs += memStats.Mallocs - c.startAllocs

-		c.netBytes += memStats.TotalAlloc - c.startBytes

-	}

-}

-

-// ResetTimer sets the elapsed benchmark time to zero.

-// It does not affect whether the timer is running.

-func (c *C) ResetTimer() {

-	if c.timerOn {

-		c.start = time.Now()

-		runtime.ReadMemStats(&memStats)

-		c.startAllocs = memStats.Mallocs

-		c.startBytes = memStats.TotalAlloc

-	}

-	c.duration = 0

-	c.netAllocs = 0

-	c.netBytes = 0

-}

-

-// SetBytes informs the number of bytes that the benchmark processes

-// on each iteration. If this is called in a benchmark it will also

-// report MB/s.

-func (c *C) SetBytes(n int64) {

-	c.bytes = n

-}

-

-func (c *C) nsPerOp() int64 {

-	if c.N <= 0 {

-		return 0

-	}

-	return c.duration.Nanoseconds() / int64(c.N)

-}

-

-func (c *C) mbPerSec() float64 {

-	if c.bytes <= 0 || c.duration <= 0 || c.N <= 0 {

-		return 0

-	}

-	return (float64(c.bytes) * float64(c.N) / 1e6) / c.duration.Seconds()

-}

-

-func (c *C) timerString() string {

-	if c.N <= 0 {

-		return fmt.Sprintf("%3.3fs", float64(c.duration.Nanoseconds())/1e9)

-	}

-	mbs := c.mbPerSec()

-	mb := ""

-	if mbs != 0 {

-		mb = fmt.Sprintf("\t%7.2f MB/s", mbs)

-	}

-	nsop := c.nsPerOp()

-	ns := fmt.Sprintf("%10d ns/op", nsop)

-	if c.N > 0 && nsop < 100 {

-		// The format specifiers here make sure that

-		// the ones digits line up for all three possible formats.

-		if nsop < 10 {

-			ns = fmt.Sprintf("%13.2f ns/op", float64(c.duration.Nanoseconds())/float64(c.N))

-		} else {

-			ns = fmt.Sprintf("%12.1f ns/op", float64(c.duration.Nanoseconds())/float64(c.N))

-		}

-	}

-	memStats := ""

-	if c.benchMem {

-		allocedBytes := fmt.Sprintf("%8d B/op", int64(c.netBytes)/int64(c.N))

-		allocs := fmt.Sprintf("%8d allocs/op", int64(c.netAllocs)/int64(c.N))

-		memStats = fmt.Sprintf("\t%s\t%s", allocedBytes, allocs)

-	}

-	return fmt.Sprintf("%8d\t%s%s%s", c.N, ns, mb, memStats)

-}

-

-func min(x, y int) int {

-	if x > y {

-		return y

-	}

-	return x

-}

-

-func max(x, y int) int {

-	if x < y {

-		return y

-	}

-	return x

-}

-

-// roundDown10 rounds a number down to the nearest power of 10.

-func roundDown10(n int) int {

-	var tens = 0

-	// tens = floor(log_10(n))

-	for n > 10 {

-		n = n / 10

-		tens++

-	}

-	// result = 10^tens

-	result := 1

-	for i := 0; i < tens; i++ {

-		result *= 10

-	}

-	return result

-}

-

-// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX].

-func roundUp(n int) int {

-	base := roundDown10(n)

-	if n < (2 * base) {

-		return 2 * base

-	}

-	if n < (5 * base) {

-		return 5 * base

-	}

-	return 10 * base

-}

deleted file mode 100644

@@ -1,939 +0,0 @@

-// Package check is a rich testing extension for Go's testing package.

-//

-// For details about the project, see:

-//

-//     http://labix.org/gocheck

-//

-package check

-

-import (

-	"bytes"

-	"errors"

-	"fmt"

-	"io"

-	"math/rand"

-	"os"

-	"path"

-	"path/filepath"

-	"reflect"

-	"regexp"

-	"runtime"

-	"strconv"

-	"strings"

-	"sync"

-	"sync/atomic"

-	"time"

-)

-

-// -----------------------------------------------------------------------

-// Internal type which deals with suite method calling.

-

-const (

-	fixtureKd = iota

-	testKd

-)

-

-type funcKind int

-

-const (

-	succeededSt = iota

-	failedSt

-	skippedSt

-	panickedSt

-	fixturePanickedSt

-	missedSt

-)

-

-type funcStatus uint32

-

-// A method value can't reach its own Method structure.

-type methodType struct {

-	reflect.Value

-	Info reflect.Method

-}

-

-func newMethod(receiver reflect.Value, i int) *methodType {

-	return &methodType{receiver.Method(i), receiver.Type().Method(i)}

-}

-

-func (method *methodType) PC() uintptr {

-	return method.Info.Func.Pointer()

-}

-

-func (method *methodType) suiteName() string {

-	t := method.Info.Type.In(0)

-	if t.Kind() == reflect.Ptr {

-		t = t.Elem()

-	}

-	return t.Name()

-}

-

-func (method *methodType) String() string {

-	return method.suiteName() + "." + method.Info.Name

-}

-

-func (method *methodType) matches(re *regexp.Regexp) bool {

-	return (re.MatchString(method.Info.Name) ||

-		re.MatchString(method.suiteName()) ||

-		re.MatchString(method.String()))

-}

-

-type C struct {

-	method    *methodType

-	kind      funcKind

-	testName  string

-	_status   funcStatus

-	logb      *logger

-	logw      io.Writer

-	done      chan *C

-	reason    string

-	mustFail  bool

-	tempDir   *tempDir

-	benchMem  bool

-	startTime time.Time

-	timer

-}

-

-func (c *C) status() funcStatus {

-	return funcStatus(atomic.LoadUint32((*uint32)(&c._status)))

-}

-

-func (c *C) setStatus(s funcStatus) {

-	atomic.StoreUint32((*uint32)(&c._status), uint32(s))

-}

-

-func (c *C) stopNow() {

-	runtime.Goexit()

-}

-

-// logger is a concurrency safe byte.Buffer

-type logger struct {

-	sync.Mutex

-	writer bytes.Buffer

-}

-

-func (l *logger) Write(buf []byte) (int, error) {

-	l.Lock()

-	defer l.Unlock()

-	return l.writer.Write(buf)

-}

-

-func (l *logger) WriteTo(w io.Writer) (int64, error) {

-	l.Lock()

-	defer l.Unlock()

-	return l.writer.WriteTo(w)

-}

-

-func (l *logger) String() string {

-	l.Lock()

-	defer l.Unlock()

-	return l.writer.String()

-}

-

-// -----------------------------------------------------------------------

-// Handling of temporary files and directories.

-

-type tempDir struct {

-	sync.Mutex

-	path    string

-	counter int

-}

-

-func (td *tempDir) newPath() string {

-	td.Lock()

-	defer td.Unlock()

-	if td.path == "" {

-		var err error

-		for i := 0; i != 100; i++ {

-			path := fmt.Sprintf("%s%ccheck-%d", os.TempDir(), os.PathSeparator, rand.Int())

-			if err = os.Mkdir(path, 0700); err == nil {

-				td.path = path

-				break

-			}

-		}

-		if td.path == "" {

-			panic("Couldn't create temporary directory: " + err.Error())

-		}

-	}

-	result := filepath.Join(td.path, strconv.Itoa(td.counter))

-	td.counter += 1

-	return result

-}

-

-func (td *tempDir) removeAll() {

-	td.Lock()

-	defer td.Unlock()

-	if td.path != "" {

-		err := os.RemoveAll(td.path)

-		if err != nil {

-			fmt.Fprintf(os.Stderr, "WARNING: Error cleaning up temporaries: "+err.Error())

-		}

-	}

-}

-

-// Create a new temporary directory which is automatically removed after

-// the suite finishes running.

-func (c *C) MkDir() string {

-	path := c.tempDir.newPath()

-	if err := os.Mkdir(path, 0700); err != nil {

-		panic(fmt.Sprintf("Couldn't create temporary directory %s: %s", path, err.Error()))

-	}

-	return path

-}

-

-// -----------------------------------------------------------------------

-// Low-level logging functions.

-

-func (c *C) log(args ...interface{}) {

-	c.writeLog([]byte(fmt.Sprint(args...) + "\n"))

-}

-

-func (c *C) logf(format string, args ...interface{}) {

-	c.writeLog([]byte(fmt.Sprintf(format+"\n", args...)))

-}

-

-func (c *C) logNewLine() {

-	c.writeLog([]byte{'\n'})

-}

-

-func (c *C) writeLog(buf []byte) {

-	c.logb.Write(buf)

-	if c.logw != nil {

-		c.logw.Write(buf)

-	}

-}

-

-func hasStringOrError(x interface{}) (ok bool) {

-	_, ok = x.(fmt.Stringer)

-	if ok {

-		return

-	}

-	_, ok = x.(error)

-	return

-}

-

-func (c *C) logValue(label string, value interface{}) {

-	if label == "" {

-		if hasStringOrError(value) {

-			c.logf("... %#v (%q)", value, value)

-		} else {

-			c.logf("... %#v", value)

-		}

-	} else if value == nil {

-		c.logf("... %s = nil", label)

-	} else {

-		if hasStringOrError(value) {

-			fv := fmt.Sprintf("%#v", value)

-			qv := fmt.Sprintf("%q", value)

-			if fv != qv {

-				c.logf("... %s %s = %s (%s)", label, reflect.TypeOf(value), fv, qv)

-				return

-			}

-		}

-		if s, ok := value.(string); ok && isMultiLine(s) {

-			c.logf(`... %s %s = "" +`, label, reflect.TypeOf(value))

-			c.logMultiLine(s)

-		} else {

-			c.logf("... %s %s = %#v", label, reflect.TypeOf(value), value)

-		}

-	}

-}

-

-func (c *C) logMultiLine(s string) {

-	b := make([]byte, 0, len(s)*2)

-	i := 0

-	n := len(s)

-	for i < n {

-		j := i + 1

-		for j < n && s[j-1] != '\n' {

-			j++

-		}

-		b = append(b, "...     "...)

-		b = strconv.AppendQuote(b, s[i:j])

-		if j < n {

-			b = append(b, " +"...)

-		}

-		b = append(b, '\n')

-		i = j

-	}

-	c.writeLog(b)

-}

-

-func isMultiLine(s string) bool {

-	for i := 0; i+1 < len(s); i++ {

-		if s[i] == '\n' {

-			return true

-		}

-	}

-	return false

-}

-

-func (c *C) logString(issue string) {

-	c.log("... ", issue)

-}

-

-func (c *C) logCaller(skip int) {

-	// This is a bit heavier than it ought to be.

-	skip += 1 // Our own frame.

-	pc, callerFile, callerLine, ok := runtime.Caller(skip)

-	if !ok {

-		return

-	}

-	var testFile string

-	var testLine int

-	testFunc := runtime.FuncForPC(c.method.PC())

-	if runtime.FuncForPC(pc) != testFunc {

-		for {

-			skip += 1

-			if pc, file, line, ok := runtime.Caller(skip); ok {

-				// Note that the test line may be different on

-				// distinct calls for the same test.  Showing

-				// the "internal" line is helpful when debugging.

-				if runtime.FuncForPC(pc) == testFunc {

-					testFile, testLine = file, line

-					break

-				}

-			} else {

-				break

-			}

-		}

-	}

-	if testFile != "" && (testFile != callerFile || testLine != callerLine) {

-		c.logCode(testFile, testLine)

-	}

-	c.logCode(callerFile, callerLine)

-}

-

-func (c *C) logCode(path string, line int) {

-	c.logf("%s:%d:", nicePath(path), line)

-	code, err := printLine(path, line)

-	if code == "" {

-		code = "..." // XXX Open the file and take the raw line.

-		if err != nil {

-			code += err.Error()

-		}

-	}

-	c.log(indent(code, "    "))

-}

-

-var valueGo = filepath.Join("reflect", "value.go")

-var asmGo = filepath.Join("runtime", "asm_")

-

-func (c *C) logPanic(skip int, value interface{}) {

-	skip++ // Our own frame.

-	initialSkip := skip

-	for ; ; skip++ {

-		if pc, file, line, ok := runtime.Caller(skip); ok {

-			if skip == initialSkip {

-				c.logf("... Panic: %s (PC=0x%X)\n", value, pc)

-			}

-			name := niceFuncName(pc)

-			path := nicePath(file)

-			if strings.Contains(path, "/gopkg.in/check.v") {

-				continue

-			}

-			if name == "Value.call" && strings.HasSuffix(path, valueGo) {

-				continue

-			}

-			if (name == "call16" || name == "call32") && strings.Contains(path, asmGo) {

-				continue

-			}

-			c.logf("%s:%d\n  in %s", nicePath(file), line, name)

-		} else {

-			break

-		}

-	}

-}

-

-func (c *C) logSoftPanic(issue string) {

-	c.log("... Panic: ", issue)

-}

-

-func (c *C) logArgPanic(method *methodType, expectedType string) {

-	c.logf("... Panic: %s argument should be %s",

-		niceFuncName(method.PC()), expectedType)

-}

-

-// -----------------------------------------------------------------------

-// Some simple formatting helpers.

-

-var initWD, initWDErr = os.Getwd()

-

-func init() {

-	if initWDErr == nil {

-		initWD = strings.Replace(initWD, "\\", "/", -1) + "/"

-	}

-}

-

-func nicePath(path string) string {

-	if initWDErr == nil {

-		if strings.HasPrefix(path, initWD) {

-			return path[len(initWD):]

-		}

-	}

-	return path

-}

-

-func niceFuncPath(pc uintptr) string {

-	function := runtime.FuncForPC(pc)

-	if function != nil {

-		filename, line := function.FileLine(pc)

-		return fmt.Sprintf("%s:%d", nicePath(filename), line)

-	}

-	return "<unknown path>"

-}

-

-func niceFuncName(pc uintptr) string {

-	function := runtime.FuncForPC(pc)

-	if function != nil {

-		name := path.Base(function.Name())

-		if i := strings.Index(name, "."); i > 0 {

-			name = name[i+1:]

-		}

-		if strings.HasPrefix(name, "(*") {

-			if i := strings.Index(name, ")"); i > 0 {

-				name = name[2:i] + name[i+1:]

-			}

-		}

-		if i := strings.LastIndex(name, ".*"); i != -1 {

-			name = name[:i] + "." + name[i+2:]

-		}

-		if i := strings.LastIndex(name, "·"); i != -1 {

-			name = name[:i] + "." + name[i+2:]

-		}

-		return name

-	}

-	return "<unknown function>"

-}

-

-// -----------------------------------------------------------------------

-// Result tracker to aggregate call results.

-

-type Result struct {

-	Succeeded        int

-	Failed           int

-	Skipped          int

-	Panicked         int

-	FixturePanicked  int

-	ExpectedFailures int

-	Missed           int    // Not even tried to run, related to a panic in the fixture.

-	RunError         error  // Houston, we've got a problem.

-	WorkDir          string // If KeepWorkDir is true

-}

-

-type resultTracker struct {

-	result          Result

-	_lastWasProblem bool

-	_waiting        int

-	_missed         int

-	_expectChan     chan *C

-	_doneChan       chan *C

-	_stopChan       chan bool

-}

-

-func newResultTracker() *resultTracker {

-	return &resultTracker{_expectChan: make(chan *C), // Synchronous

-		_doneChan: make(chan *C, 32), // Asynchronous

-		_stopChan: make(chan bool)}   // Synchronous

-}

-

-func (tracker *resultTracker) start() {

-	go tracker._loopRoutine()

-}

-

-func (tracker *resultTracker) waitAndStop() {

-	<-tracker._stopChan

-}

-

-func (tracker *resultTracker) expectCall(c *C) {

-	tracker._expectChan <- c

-}

-

-func (tracker *resultTracker) callDone(c *C) {

-	tracker._doneChan <- c

-}

-

-func (tracker *resultTracker) _loopRoutine() {

-	for {

-		var c *C

-		if tracker._waiting > 0 {

-			// Calls still running. Can't stop.

-			select {

-			// XXX Reindent this (not now to make diff clear)

-			case c = <-tracker._expectChan:

-				tracker._waiting += 1

-			case c = <-tracker._doneChan:

-				tracker._waiting -= 1

-				switch c.status() {

-				case succeededSt:

-					if c.kind == testKd {

-						if c.mustFail {

-							tracker.result.ExpectedFailures++

-						} else {

-							tracker.result.Succeeded++

-						}

-					}

-				case failedSt:

-					tracker.result.Failed++

-				case panickedSt:

-					if c.kind == fixtureKd {

-						tracker.result.FixturePanicked++

-					} else {

-						tracker.result.Panicked++

-					}

-				case fixturePanickedSt:

-					// Track it as missed, since the panic

-					// was on the fixture, not on the test.

-					tracker.result.Missed++

-				case missedSt:

-					tracker.result.Missed++

-				case skippedSt:

-					if c.kind == testKd {

-						tracker.result.Skipped++

-					}

-				}

-			}

-		} else {

-			// No calls.  Can stop, but no done calls here.

-			select {

-			case tracker._stopChan <- true:

-				return

-			case c = <-tracker._expectChan:

-				tracker._waiting += 1

-			case c = <-tracker._doneChan:

-				panic("Tracker got an unexpected done call.")

-			}

-		}

-	}

-}

-

-// -----------------------------------------------------------------------

-// The underlying suite runner.

-

-type suiteRunner struct {

-	suite                     interface{}

-	setUpSuite, tearDownSuite *methodType

-	setUpTest, tearDownTest   *methodType

-	onTimeout                 *methodType

-	tests                     []*methodType

-	tracker                   *resultTracker

-	tempDir                   *tempDir

-	keepDir                   bool

-	output                    *outputWriter

-	reportedProblemLast       bool

-	benchTime                 time.Duration

-	benchMem                  bool

-	checkTimeout              time.Duration

-}

-

-type RunConf struct {

-	Output        io.Writer

-	Stream        bool

-	Verbose       bool

-	Filter        string

-	Benchmark     bool

-	BenchmarkTime time.Duration // Defaults to 1 second

-	BenchmarkMem  bool

-	KeepWorkDir   bool

-	CheckTimeout  time.Duration

-}

-

-// Create a new suiteRunner able to run all methods in the given suite.

-func newSuiteRunner(suite interface{}, runConf *RunConf) *suiteRunner {

-	var conf RunConf

-	if runConf != nil {

-		conf = *runConf

-	}

-	if conf.Output == nil {

-		conf.Output = os.Stdout

-	}

-	if conf.Benchmark {

-		conf.Verbose = true

-	}

-

-	suiteType := reflect.TypeOf(suite)

-	suiteNumMethods := suiteType.NumMethod()

-	suiteValue := reflect.ValueOf(suite)

-

-	runner := &suiteRunner{

-		suite:        suite,

-		output:       newOutputWriter(conf.Output, conf.Stream, conf.Verbose),

-		tracker:      newResultTracker(),

-		benchTime:    conf.BenchmarkTime,

-		benchMem:     conf.BenchmarkMem,

-		tempDir:      &tempDir{},

-		keepDir:      conf.KeepWorkDir,

-		tests:        make([]*methodType, 0, suiteNumMethods),

-		checkTimeout: conf.CheckTimeout,

-	}

-	if runner.benchTime == 0 {

-		runner.benchTime = 1 * time.Second

-	}

-

-	var filterRegexp *regexp.Regexp

-	if conf.Filter != "" {

-		if regexp, err := regexp.Compile(conf.Filter); err != nil {

-			msg := "Bad filter expression: " + err.Error()

-			runner.tracker.result.RunError = errors.New(msg)

-			return runner

-		} else {

-			filterRegexp = regexp

-		}

-	}

-

-	for i := 0; i != suiteNumMethods; i++ {

-		method := newMethod(suiteValue, i)

-		switch method.Info.Name {

-		case "SetUpSuite":

-			runner.setUpSuite = method

-		case "TearDownSuite":

-			runner.tearDownSuite = method

-		case "SetUpTest":

-			runner.setUpTest = method

-		case "TearDownTest":

-			runner.tearDownTest = method

-		case "OnTimeout":

-			runner.onTimeout = method

-		default:

-			prefix := "Test"

-			if conf.Benchmark {

-				prefix = "Benchmark"

-			}

-			if !strings.HasPrefix(method.Info.Name, prefix) {

-				continue

-			}

-			if filterRegexp == nil || method.matches(filterRegexp) {

-				runner.tests = append(runner.tests, method)

-			}

-		}

-	}

-	return runner

-}

-

-// Run all methods in the given suite.

-func (runner *suiteRunner) run() *Result {

-	if runner.tracker.result.RunError == nil && len(runner.tests) > 0 {

-		runner.tracker.start()

-		if runner.checkFixtureArgs() {

-			c := runner.runFixture(runner.setUpSuite, "", nil)

-			if c == nil || c.status() == succeededSt {

-				for i := 0; i != len(runner.tests); i++ {

-					c := runner.runTest(runner.tests[i])

-					if c.status() == fixturePanickedSt {

-						runner.skipTests(missedSt, runner.tests[i+1:])

-						break

-					}

-				}