func (r *SuiteRunner) RunSuites(runners []*testrunner.TestRunner, numCompilers int, keepGoing bool, willCompile func(suite testsuite.TestSuite)) (testrunner.RunResult, int) {
runResult := testrunner.PassingRunResult()
compilationOutputs := r.compileInParallel(runners, numCompilers, willCompile)
numSuitesThatRan := 0
suitesThatFailed := []testsuite.TestSuite{}
for compilationOutput := range compilationOutputs {
if compilationOutput.err != nil {
fmt.Print(compilationOutput.err.Error())
}
numSuitesThatRan++
suiteRunResult := testrunner.FailingRunResult()
if compilationOutput.err == nil {
suiteRunResult = compilationOutput.runner.Run()
}
r.notifier.SendSuiteCompletionNotification(compilationOutput.runner.Suite, suiteRunResult.Passed)
runResult = runResult.Merge(suiteRunResult)
if !suiteRunResult.Passed {
suitesThatFailed = append(suitesThatFailed, compilationOutput.runner.Suite)
if !keepGoing {
break
}
}
if numSuitesThatRan < len(runners) && !config.DefaultReporterConfig.Succinct {
fmt.Println("")
}
}
if keepGoing && !runResult.Passed {
r.listFailedSuites(suitesThatFailed)
}
return runResult, numSuitesThatRan
}
func (w *SpecWatcher) RunSuite(suite *testsuite.TestSuite, additionalArgs []string) {
w.UpdateSeed()
runner := testrunner.New(suite, w.commandFlags.NumCPU, w.commandFlags.ParallelStream, w.commandFlags.Race, w.commandFlags.Cover, w.commandFlags.Tags, additionalArgs)
err := runner.Compile()
if err != nil {
fmt.Print(err.Error())
}
runResult := testrunner.FailingRunResult()
if err == nil {
runResult = runner.Run()
}
w.notifier.SendSuiteCompletionNotification(suite, runResult.Passed)
runner.CleanUp()
}
func (r *SuiteRunner) RunSuites(runners []*testrunner.TestRunner, numCompilers int, keepGoing bool, willCompile func(suite testsuite.TestSuite)) (testrunner.RunResult, int) {
runResult := testrunner.PassingRunResult()
compilers := make([]*compiler, len(runners))
for i, runner := range runners {
compilers[i] = &compiler{
runner: runner,
compilationError: make(chan error, 1),
}
}
compilerChannel := make(chan *compiler)
if numCompilers == 0 {
numCompilers = runtime.NumCPU()
}
for i := 0; i < numCompilers; i++ {
go func() {
for compiler := range compilerChannel {
if willCompile != nil {
willCompile(compiler.runner.Suite)
}
compiler.compile()
}
}()
}
go func() {
for _, compiler := range compilers {
compilerChannel <- compiler
}
close(compilerChannel)
}()
numSuitesThatRan := 0
suitesThatFailed := []testsuite.TestSuite{}
for i, runner := range runners {
if r.interruptHandler.WasInterrupted() {
break
}
compilationError := <-compilers[i].compilationError
if compilationError != nil {
fmt.Print(compilationError.Error())
}
numSuitesThatRan++
suiteRunResult := testrunner.FailingRunResult()
if compilationError == nil {
suiteRunResult = compilers[i].runner.Run()
}
r.notifier.SendSuiteCompletionNotification(runner.Suite, suiteRunResult.Passed)
runResult = runResult.Merge(suiteRunResult)
if !suiteRunResult.Passed {
suitesThatFailed = append(suitesThatFailed, runner.Suite)
if !keepGoing {
break
}
}
if i < len(runners)-1 && !config.DefaultReporterConfig.Succinct {
fmt.Println("")
}
}
if keepGoing && !runResult.Passed {
r.listFailedSuites(suitesThatFailed)
}
return runResult, numSuitesThatRan
}
func (r *SpecRunner) RunSuites(suites []*testsuite.TestSuite, additionalArgs []string) (testrunner.RunResult, int) {
runResult := testrunner.PassingRunResult()
suiteCompilers := make([]*compiler, len(suites))
for i, suite := range suites {
runner := testrunner.New(suite, r.commandFlags.NumCPU, r.commandFlags.ParallelStream, r.commandFlags.Race, r.commandFlags.Cover, r.commandFlags.Tags, additionalArgs)
suiteCompilers[i] = &compiler{
runner: runner,
compilationError: make(chan error, 1),
}
}
compilerChannel := make(chan *compiler)
numCompilers := runtime.NumCPU()
for i := 0; i < numCompilers; i++ {
go func() {
for compiler := range compilerChannel {
compiler.compile()
}
}()
}
go func() {
for _, compiler := range suiteCompilers {
compilerChannel <- compiler
}
close(compilerChannel)
}()
numSuitesThatRan := 0
suitesThatFailed := []*testsuite.TestSuite{}
for i, suite := range suites {
if r.interruptHandler.WasInterrupted() {
break
}
compilationError := <-suiteCompilers[i].compilationError
if compilationError != nil {
fmt.Print(compilationError.Error())
}
numSuitesThatRan++
suiteRunResult := testrunner.FailingRunResult()
if compilationError == nil {
suiteRunResult = suiteCompilers[i].runner.Run()
}
r.notifier.SendSuiteCompletionNotification(suite, suiteRunResult.Passed)
runResult = runResult.Merge(suiteRunResult)
if !suiteRunResult.Passed {
suitesThatFailed = append(suitesThatFailed, suite)
if !r.commandFlags.KeepGoing {
break
}
}
if i < len(suites)-1 && !config.DefaultReporterConfig.Succinct {
fmt.Println("")
}
}
for i := range suites {
suiteCompilers[i].runner.CleanUp()
}
if r.commandFlags.KeepGoing && !runResult.Passed {
r.listFailedSuites(suitesThatFailed)
}
return runResult, numSuitesThatRan
}