@@ -11,7 +11,7 @@ clone git github.com/Microsoft/hcsshim 116e0e9f5ced0cec94ae46d0aa1b3002a325f532

 clone git github.com/Microsoft/go-winio f778f05015353be65d242f3fedc18695756153bb

 clone git github.com/Sirupsen/logrus v0.9.0 # logrus is a common dependency among multiple deps

 clone git github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a

-clone git github.com/go-check/check 11d3bc7aa68e238947792f30573146a3231fc0f1

+clone git github.com/go-check/check a625211d932a2a643d0d17352095f03fb7774663 https://github.com/cpuguy83/check.git

 clone git github.com/gorilla/context 14f550f51a

 clone git github.com/gorilla/mux e444e69cbd

 clone git github.com/kr/pty 5cf931ef8f

new file mode 100644

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

+language: go

+go:

+  - 1.5

+  - tip

+script:

+  - go get -u github.com/golang/lint/golint

+  - # go vet ./...

+  - # test -z "$(golint ./... | tee /dev/stderr)"

+  - # test -z "$(gofmt -s -l . | tee /dev/stderr)"

+  - go test -v ./...

@@ -1,20 +1,10 @@

-Instructions

-============

+Go-check

+========

-Install the package with:

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

-    go get gopkg.in/check.v1

-    

-Import it with:

+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.

-    import "gopkg.in/check.v1"

-

-and use _check_ as the package name inside the code.

-

-For more details, visit the project page:

-

-* http://labix.org/gocheck

-

-and the API documentation:

-

-* https://gopkg.in/check.v1

+The original branch is intact at `orig_v1`

@@ -522,6 +522,7 @@ type suiteRunner struct {

 	reportedProblemLast       bool

 	benchTime                 time.Duration

 	benchMem                  bool

+	checkTimeout              time.Duration

 }

 type RunConf struct {

@@ -533,6 +534,7 @@ type RunConf struct {

 	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.

@@ -553,14 +555,15 @@ func newSuiteRunner(suite interface{}, runConf *RunConf) *suiteRunner {

 	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),

+		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

@@ -670,8 +673,16 @@ func (runner *suiteRunner) forkCall(method *methodType, kind funcKind, testName

 // Same as forkCall(), but wait for call to finish before returning.

 func (runner *suiteRunner) runFunc(method *methodType, kind funcKind, testName string, logb *logger, dispatcher func(c *C)) *C {

+	var timeout <-chan time.Time

+	if runner.checkTimeout != 0 {

+		timeout = time.After(runner.checkTimeout)

+	}

 	c := runner.forkCall(method, kind, testName, logb, dispatcher)

-	<-c.done

+	select {

+	case <-c.done:

+	case <-timeout:

+		panic(fmt.Sprintf("test timed out after %v", runner.checkTimeout))

+	}

 	return c

 }

@@ -806,8 +817,16 @@ func (runner *suiteRunner) forkTest(method *methodType) *C {

 // Same as forkTest(), but wait for the test to finish before returning.

 func (runner *suiteRunner) runTest(method *methodType) *C {

+	var timeout <-chan time.Time

+	if runner.checkTimeout != 0 {

+		timeout = time.After(runner.checkTimeout)

+	}

 	c := runner.forkTest(method)

-	<-c.done

+	select {

+	case <-c.done:

+	case <-timeout:

+		panic(fmt.Sprintf("test timed out after %v", runner.checkTimeout))

+	}

 	return c

 }

@@ -871,84 +890,3 @@ func (runner *suiteRunner) reportCallDone(c *C) {

 		runner.output.WriteCallSuccess("MISS", c)

 	}

 }

-

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

-// Output writer manages atomic output writing according to settings.

-

-type outputWriter struct {

-	m                    sync.Mutex

-	writer               io.Writer

-	wroteCallProblemLast bool

-	Stream               bool

-	Verbose              bool

-}

-

-func newOutputWriter(writer io.Writer, stream, verbose bool) *outputWriter {

-	return &outputWriter{writer: writer, Stream: stream, Verbose: verbose}

-}

-

-func (ow *outputWriter) Write(content []byte) (n int, err error) {

-	ow.m.Lock()

-	n, err = ow.writer.Write(content)

-	ow.m.Unlock()

-	return

-}

-

-func (ow *outputWriter) WriteCallStarted(label string, c *C) {

-	if ow.Stream {

-		header := renderCallHeader(label, c, "", "\n")

-		ow.m.Lock()

-		ow.writer.Write([]byte(header))

-		ow.m.Unlock()

-	}

-}

-

-func (ow *outputWriter) WriteCallProblem(label string, c *C) {

-	var prefix string

-	if !ow.Stream {

-		prefix = "\n-----------------------------------" +

-			"-----------------------------------\n"

-	}

-	header := renderCallHeader(label, c, prefix, "\n\n")

-	ow.m.Lock()

-	ow.wroteCallProblemLast = true

-	ow.writer.Write([]byte(header))

-	if !ow.Stream {

-		c.logb.WriteTo(ow.writer)

-	}

-	ow.m.Unlock()

-}

-

-func (ow *outputWriter) WriteCallSuccess(label string, c *C) {

-	if ow.Stream || (ow.Verbose && c.kind == testKd) {

-		// TODO Use a buffer here.

-		var suffix string

-		if c.reason != "" {

-			suffix = " (" + c.reason + ")"

-		}

-		if c.status() == succeededSt {

-			suffix += "\t" + c.timerString()

-		}

-		suffix += "\n"

-		if ow.Stream {

-			suffix += "\n"

-		}

-		header := renderCallHeader(label, c, "", suffix)

-		ow.m.Lock()

-		// Resist temptation of using line as prefix above due to race.

-		if !ow.Stream && ow.wroteCallProblemLast {

-			header = "\n-----------------------------------" +

-				"-----------------------------------\n" +

-				header

-		}

-		ow.wroteCallProblemLast = false

-		ow.writer.Write([]byte(header))

-		ow.m.Unlock()

-	}

-}

-

-func renderCallHeader(label string, c *C, prefix, suffix string) string {

-	pc := c.method.PC()

-	return fmt.Sprintf("%s%s: %s: %s%s", prefix, label, niceFuncPath(pc),

-		niceFuncName(pc), suffix)

-}

new file mode 100644

@@ -0,0 +1,88 @@

+package check

+

+import (

+	"fmt"

+	"io"

+	"sync"

+)

+

+// -----------------------------------------------------------------------

+// Output writer manages atomic output writing according to settings.

+

+type outputWriter struct {

+	m                    sync.Mutex

+	writer               io.Writer

+	wroteCallProblemLast bool

+	Stream               bool

+	Verbose              bool

+}

+

+func newOutputWriter(writer io.Writer, stream, verbose bool) *outputWriter {

+	return &outputWriter{writer: writer, Stream: stream, Verbose: verbose}

+}

+

+func (ow *outputWriter) Write(content []byte) (n int, err error) {

+	ow.m.Lock()

+	n, err = ow.writer.Write(content)

+	ow.m.Unlock()

+	return

+}

+

+func (ow *outputWriter) WriteCallStarted(label string, c *C) {

+	if ow.Stream {

+		header := renderCallHeader(label, c, "", "\n")

+		ow.m.Lock()

+		ow.writer.Write([]byte(header))

+		ow.m.Unlock()

+	}

+}

+

+func (ow *outputWriter) WriteCallProblem(label string, c *C) {

+	var prefix string

+	if !ow.Stream {

+		prefix = "\n-----------------------------------" +

+			"-----------------------------------\n"

+	}

+	header := renderCallHeader(label, c, prefix, "\n\n")

+	ow.m.Lock()

+	ow.wroteCallProblemLast = true

+	ow.writer.Write([]byte(header))

+	if !ow.Stream {

+		c.logb.WriteTo(ow.writer)

+	}

+	ow.m.Unlock()

+}

+

+func (ow *outputWriter) WriteCallSuccess(label string, c *C) {

+	if ow.Stream || (ow.Verbose && c.kind == testKd) {

+		// TODO Use a buffer here.

+		var suffix string

+		if c.reason != "" {

+			suffix = " (" + c.reason + ")"

+		}

+		if c.status() == succeededSt {

+			suffix += "\t" + c.timerString()

+		}

+		suffix += "\n"

+		if ow.Stream {

+			suffix += "\n"

+		}

+		header := renderCallHeader(label, c, "", suffix)

+		ow.m.Lock()

+		// Resist temptation of using line as prefix above due to race.

+		if !ow.Stream && ow.wroteCallProblemLast {

+			header = "\n-----------------------------------" +

+				"-----------------------------------\n" +

+				header

+		}

+		ow.wroteCallProblemLast = false

+		ow.writer.Write([]byte(header))

+		ow.m.Unlock()

+	}

+}

+

+func renderCallHeader(label string, c *C, prefix, suffix string) string {

+	pc := c.method.PC()

+	return fmt.Sprintf("%s%s: %s: %s%s", prefix, label, niceFuncPath(pc),

+		niceFuncName(pc), suffix)

+}

@@ -42,6 +42,7 @@ var (

 	newBenchMem    = flag.Bool("check.bmem", false, "Report memory benchmarks")

 	newListFlag    = flag.Bool("check.list", false, "List the names of all tests that will be run")

 	newWorkFlag    = flag.Bool("check.work", false, "Display and do not remove the test working directory")

+	checkTimeout   = flag.String("check.timeout", "", "Panic if test runs longer than specified duration")

 )

 // TestingT runs all test suites registered with the Suite function,

@@ -61,6 +62,13 @@ func TestingT(testingT *testing.T) {

 		BenchmarkMem:  *newBenchMem,

 		KeepWorkDir:   *oldWorkFlag || *newWorkFlag,

 	}

+	if *checkTimeout != "" {

+		timeout, err := time.ParseDuration(*checkTimeout)

+		if err != nil {

+			testingT.Fatalf("error parsing specified timeout flag: %v", err)

+		}

+		conf.CheckTimeout = timeout

+	}

 	if *oldListFlag || *newListFlag {

 		w := bufio.NewWriter(os.Stdout)

 		for _, name := range ListAll(conf) {