Example #1
0
func TestSeriesZeroOrOne(t *testing.T) {
	task := &fakeTask{}
	if tasks.SeriesTasks() != tasks.NilTask() {
		t.Error("Expected zero series tasks to be nil task.")
	}
	if tasks.SeriesTasks(task) != task {
		t.Error("Expected one series task to be that task.")
	}
}
Example #2
0
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)
	})
}
Example #3
0
func TestSeriesError(t *testing.T) {
	// three tasks
	testTasks := make([]tasks.Task, 3)

	// second task throws an error
	for i := range testTasks {
		if i == 1 {
			testTasks[i] = &fakeTask{err: kSomeError}
		} else {
			testTasks[i] = &fakeTask{}
		}
	}
	e := tasks.Start(tasks.SeriesTasks(testTasks...))
	<-e.Done()

	// First 2 tasks should have been but not 3rd task
	for i, atask := range testTasks {
		ft := atask.(*fakeTask)
		if i < 2 {
			if !ft.hasRun() {
				t.Errorf("Expected task %d to be run.", i)
			}
		} else {
			if ft.hasRun() {
				t.Errorf("Expected task %d not to be run.", i)
			}
		}
	}
}
Example #4
0
func TestSeriesEnded(t *testing.T) {
	// two tasks
	testTasks := make([]tasks.Task, 2)

	for i := range testTasks {
		testTasks[i] = &fakeTask{runDuration: time.Hour}
	}
	e := tasks.Start(tasks.SeriesTasks(testTasks...))
	e.End()
	<-e.Done()

	// 2nd task should not be reached.
	for i, atask := range testTasks {
		ft := atask.(*fakeTask)
		if i < 1 {
			if !ft.hasRun() {
				t.Errorf("Expected task %d to be run.", i)
			}
		} else {
			if ft.hasRun() {
				t.Errorf("Expected task %d not to be run.", i)
			}
		}
	}
}
Example #5
0
func TestSeries(t *testing.T) {
	// three tasks
	testTasks := make([]tasks.Task, 3)

	// second task throws an error
	for i := range testTasks {
		testTasks[i] = &fakeTask{}
	}
	e := tasks.Start(tasks.SeriesTasks(testTasks...))
	<-e.Done()
	for i, atask := range testTasks {
		ft := atask.(*fakeTask)
		if !ft.hasRun() {
			t.Errorf("Expected task %d to be run.", i)
		}
	}
}
Example #6
0
func TestPauseSeriesItself(t *testing.T) {
	starting := make(chan bool, 100)
	defer close(starting)
	task := &pauseTask{Starting: starting}
	se := tasks.NewSingleExecutor()
	defer se.Close()
	// Tasks in executor must support equality
	e := se.Start(&taskStruct{tasks.SeriesTasks(task, task)})
	waitForStarts(starting, 1)
	se.Pause()
	select {
	case <-e.Done():
		t.Error("Pause not working")
	case <-time.After(10 * time.Millisecond):
	}
	e.End()
	<-e.Done()
}
Example #7
0
func TestPauseSeries(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.SeriesTasks(ts...)})
	waitForStarts(starting, 1)
	se.Pause()
	expected := 1
	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()
	se.Resume()
	waitForStarts(starting, 1)
	se.Pause()
	expected += 1
	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()
	e.End()
	<-e.Done()
}