Dmitry Sergeev
113 lines
3.0 KiB
Go
113 lines
3.0 KiB
Go
package video
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
"mxl-pattern-generator/internal/generator"
|
|
)
|
|
|
|
type stubFrameGenerator struct{}
|
|
|
|
func (*stubFrameGenerator) GenerateFrame([]byte, int) error { return nil }
|
|
func (*stubFrameGenerator) Close() error { return nil }
|
|
|
|
func TestSelectFrameGenerator(t *testing.T) {
|
|
gpuErr := errors.New("no GPU")
|
|
cpuErr := errors.New("no CPU pattern")
|
|
tests := []struct {
|
|
name string
|
|
backend Backend
|
|
gpuErr error
|
|
cpuErr error
|
|
wantBackend Backend
|
|
wantGPUCalls int
|
|
wantCPUCalls int
|
|
wantErrSubstr []string
|
|
}{
|
|
{name: "explicit GPU", backend: BackendGPU, wantBackend: BackendGPU, wantGPUCalls: 1},
|
|
{name: "explicit CPU", backend: BackendCPU, wantBackend: BackendCPU, wantCPUCalls: 1},
|
|
{name: "auto prefers GPU", backend: BackendAuto, wantBackend: BackendGPU, wantGPUCalls: 1},
|
|
{name: "zero value is auto", wantBackend: BackendGPU, wantGPUCalls: 1},
|
|
{
|
|
name: "auto falls back to CPU",
|
|
backend: BackendAuto,
|
|
gpuErr: gpuErr,
|
|
wantBackend: BackendCPU,
|
|
wantGPUCalls: 1,
|
|
wantCPUCalls: 1,
|
|
},
|
|
{
|
|
name: "auto reports both failures",
|
|
backend: BackendAuto,
|
|
gpuErr: gpuErr,
|
|
cpuErr: cpuErr,
|
|
wantGPUCalls: 1,
|
|
wantCPUCalls: 1,
|
|
wantErrSubstr: []string{"GPU video generator", "CPU video generator"},
|
|
},
|
|
{
|
|
name: "explicit GPU does not fall back",
|
|
backend: BackendGPU,
|
|
gpuErr: gpuErr,
|
|
wantGPUCalls: 1,
|
|
wantErrSubstr: []string{"GPU video generator"},
|
|
},
|
|
{
|
|
name: "explicit CPU does not try GPU",
|
|
backend: BackendCPU,
|
|
cpuErr: cpuErr,
|
|
wantCPUCalls: 1,
|
|
wantErrSubstr: []string{"CPU video generator"},
|
|
},
|
|
{
|
|
name: "invalid backend",
|
|
backend: Backend("invalid"),
|
|
wantErrSubstr: []string{"unsupported video backend"},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
gpuCalls, cpuCalls := 0, 0
|
|
factory := func(calls *int, err error) generatorFactory {
|
|
return func() (generator.FrameGenerator, error) {
|
|
*calls++
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &stubFrameGenerator{}, nil
|
|
}
|
|
}
|
|
|
|
gen, backend, err := selectFrameGenerator(
|
|
tc.backend,
|
|
factory(&gpuCalls, tc.gpuErr),
|
|
factory(&cpuCalls, tc.cpuErr),
|
|
)
|
|
if gpuCalls != tc.wantGPUCalls || cpuCalls != tc.wantCPUCalls {
|
|
t.Fatalf("factory calls GPU/CPU = %d/%d, want %d/%d",
|
|
gpuCalls, cpuCalls, tc.wantGPUCalls, tc.wantCPUCalls)
|
|
}
|
|
if len(tc.wantErrSubstr) == 0 {
|
|
if err != nil {
|
|
t.Fatalf("selectFrameGenerator: %v", err)
|
|
}
|
|
if gen == nil || backend != tc.wantBackend {
|
|
t.Fatalf("generator/backend = %v/%q, want non-nil/%q", gen, backend, tc.wantBackend)
|
|
}
|
|
return
|
|
}
|
|
if err == nil {
|
|
t.Fatal("selectFrameGenerator returned nil error")
|
|
}
|
|
for _, substring := range tc.wantErrSubstr {
|
|
if !strings.Contains(err.Error(), substring) {
|
|
t.Errorf("error = %q, want substring %q", err, substring)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|