func TestParallelZeroOrOne(t *testing.T) { task := &fakeTask{} if tasks.ParallelTasks() != tasks.NilTask() { t.Error("Expected zero parallel tasks to be nil task.") } if tasks.ParallelTasks(task) != task { t.Error("Expected one parallel task to be that task.") } }
func (a *Action) asTask(setter Setter, lights []int) tasks.Task { if len(a.Lights) > 0 { lights = a.Lights } if len(a.Parallel) > 0 { parallelTasks := make([]tasks.Task, len(a.Parallel)) for i := range parallelTasks { parallelTasks[i] = a.Parallel[i].AsTask(setter, lights) } return tasks.ParallelTasks(parallelTasks...) } if len(a.Series) > 0 { seriesTasks := make([]tasks.Task, len(a.Series)) for i := range seriesTasks { seriesTasks[i] = a.Series[i].AsTask(setter, lights) } return tasks.SeriesTasks(seriesTasks...) } if a.G != nil { if len(a.G.Cds) == 0 || a.G.Cds[0].D != 0 { panic("D of first ColorDuration element must be 0.") } return tasks.TaskFunc(func(e *tasks.Execution) { a.doGradient(setter, lights, e) }) } if a.C.Valid || a.Bri.Valid || a.On || a.Off { return tasks.TaskFunc(func(e *tasks.Execution) { a.doOnOff(setter, lights, e) }) } return tasks.TaskFunc(func(e *tasks.Execution) { e.Sleep(a.Sleep) }) }
func TestParallelError(t *testing.T) { testTasks := make([]tasks.Task, 20) for i := range testTasks { if i == 5 { testTasks[i] = &fakeTask{err: kSomeError} } else { testTasks[i] = &fakeTask{} } } e := tasks.Start(tasks.ParallelTasks(testTasks...)) <-e.Done() if e.Error() != kSomeError { t.Error("Expected to get an error.") } }
func TestParallelEnded(t *testing.T) { testTasks := make([]tasks.Task, 20) for i := range testTasks { testTasks[i] = &fakeTask{runDuration: time.Hour} } e := tasks.Start(tasks.ParallelTasks(testTasks...)) e.End() <-e.Done() for _, atask := range testTasks { ft := atask.(*fakeTask) if !ft.hasRun() { t.Error("Expected task to be run.") } } }
func TestParallel(t *testing.T) { testTasks := make([]tasks.Task, 20) for i := range testTasks { testTasks[i] = &fakeTask{} } e := tasks.Start(tasks.ParallelTasks(testTasks...)) <-e.Done() // Blocking here is not necessary in production code. Just testing that // this channel gets closed too. <-e.Ended() for _, atask := range testTasks { ft := atask.(*fakeTask) if !ft.hasRun() { t.Error("Expected task to be run.") } } }
func TestPauseNotSupportedParallelPauseEarly(t *testing.T) { starting := make(chan bool, 100) defer close(starting) task1 := &pauseTask{Starting: starting} ts := make([]tasks.Task, 20) for i := range ts { ts[i] = task1 } se := tasks.NewSingleExecutor() defer se.Close() se.Start(&taskStruct{tasks.ParallelTasks(ts...)}) se.Pause() // Acknowledge the tasks that completed while pausing waitForStarts(starting, task1.Count()) time.Sleep(time.Millisecond) // No new tasks should start assertNoStarting(t, starting) }
func TestPauseNotSupportedParallel(t *testing.T) { starting := make(chan bool, 100) defer close(starting) task1 := &pauseTask{Starting: starting} ts := make([]tasks.Task, 20) for i := range ts { ts[i] = task1 } se := tasks.NewSingleExecutor() defer se.Close() e := se.Start(&taskStruct{tasks.ParallelTasks(ts...)}) waitForStarts(starting, len(ts)) // Since these parallel tasks don't support pause, this Pause() call // won't return until all the tasks have finished. se.Pause() if out := task1.Count(); out != len(ts) { t.Errorf("Expected %d, got %d", len(ts), out) } // A paused task can still end on its own. The only // guarantee is that the paused task won't do any additional work. <-e.Done() }
func TestPauseParallel(t *testing.T) { starting := make(chan bool, 100) defer close(starting) task := &pauseTask{Starting: starting} se := tasks.NewSingleExecutor() defer se.Close() ts := make([]tasks.Task, 20) for i := range ts { ts[i] = tasks.RepeatingTask(task, 2147483647) } // Tasks in executor must support equality e := se.Start(&taskStruct{tasks.ParallelTasks(ts...)}) waitForStarts(starting, len(ts)) se.Pause() expected := len(ts) if out := task.Count(); out != expected { t.Errorf("Expected count of %d, got %d", expected, out) expected = out } time.Sleep(5 * time.Millisecond) assertNoStarting(t, starting) se.Resume() waitForStarts(starting, len(ts)) se.Pause() // no-op se.Pause() expected += len(ts) if out := task.Count(); out != expected { t.Errorf("Expected count of %d, got %d", expected, out) expected = out } time.Sleep(5 * time.Millisecond) assertNoStarting(t, starting) e.End() <-e.Done() }