go-mxl-pattern-generator/internal/generator/cpu_patterns_test.go

package generator

import (
	"strings"
	"testing"
)

func TestCPUEBU75Static(t *testing.T) {
	const width, height = 1920, 1080
	g, err := NewCPUPatternGenerator(width, height, "ebu75")
	if err != nil {
		t.Fatalf("NewCPUPatternGenerator: %v", err)
	}
	frame := make([]byte, width*height*8/3)
	if err := g.GenerateFrame(frame, 99); err != nil {
		t.Fatalf("GenerateFrame: %v", err)
	}

	for _, tc := range []struct {
		x                     int
		wantY, wantCb, wantCr uint32
	}{
		{x: 0, wantY: 721, wantCb: 512, wantCr: 512},
		{x: 300, wantY: 674, wantCb: 176, wantCr: 543},
		{x: 960, wantY: 251, wantCb: 771, wantCr: 817},
		{x: 1800, wantY: 64, wantCb: 512, wantCr: 512},
	} {
		y, cb, cr := sampleV210(frame, width, tc.x, 100)
		if y != tc.wantY || cb != tc.wantCb || cr != tc.wantCr {
			t.Fatalf("x=%d: got %d/%d/%d, want %d/%d/%d",
				tc.x, y, cb, cr, tc.wantY, tc.wantCb, tc.wantCr)
		}
	}
}

func TestCPUEBU75MovingSquare(t *testing.T) {
	const width, height = 1920, 1080
	g, err := NewCPUPatternGenerator(width, height, "ebu75-move")
	if err != nil {
		t.Fatalf("NewCPUPatternGenerator: %v", err)
	}
	frame := make([]byte, width*height*8/3)

	if err := g.GenerateFrame(frame, 0); err != nil {
		t.Fatalf("GenerateFrame(0): %v", err)
	}
	if y, cb, cr := sampleV210(frame, width, 960, 540); y != 753 || cb != 253 || cr != 207 {
		t.Fatalf("tick 0 center = %d/%d/%d, want inverted magenta 753/253/207", y, cb, cr)
	}

	if err := g.GenerateFrame(frame, 79); err != nil {
		t.Fatalf("GenerateFrame(79): %v", err)
	}
	if y, cb, cr := sampleV210(frame, width, 960, 540); y != 251 || cb != 771 || cr != 817 {
		t.Fatalf("old square position = %d/%d/%d, want restored magenta 251/771/817", y, cb, cr)
	}
	if y, cb, cr := sampleV210(frame, width, 1840, 540); y != 940 || cb != 512 || cr != 512 {
		t.Fatalf("shifted square = %d/%d/%d, want inverted black 940/512/512", y, cb, cr)
	}
}

func TestCPUStaticPatterns(t *testing.T) {
	const width, height = 1920, 1080
	tests := []struct {
		name                  string
		x                     int
		wantY, wantCb, wantCr uint32
	}{
		{name: "ebu100", x: 0, wantY: 940, wantCb: 512, wantCr: 512},
		{name: "ebu100", x: 300, wantY: 877, wantCb: 64, wantCr: 553},
		{name: "ebu100", x: 960, wantY: 313, wantCb: 857, wantCr: 919},
		{name: "gray-bars", x: 0, wantY: 64, wantCb: 512, wantCr: 512},
		{name: "gray-bars", x: 960, wantY: 502, wantCb: 512, wantCr: 512},
		{name: "gray-bars", x: 1800, wantY: 940, wantCb: 512, wantCr: 512},
		{name: "gray-ramp", x: 0, wantY: 64, wantCb: 512, wantCr: 512},
		{name: "gray-ramp", x: 6, wantY: 66, wantCb: 512, wantCr: 512},
		{name: "gray-ramp", x: 960, wantY: 502, wantCb: 512, wantCr: 512},
		{name: "gray-ramp", x: 1918, wantY: 939, wantCb: 512, wantCr: 512},
	}

	frames := make(map[string][]byte)
	for _, tc := range tests {
		frame, ok := frames[tc.name]
		if !ok {
			g, err := NewCPUPatternGenerator(width, height, tc.name)
			if err != nil {
				t.Fatalf("NewCPUPatternGenerator(%q): %v", tc.name, err)
			}
			frame = make([]byte, width*height*8/3)
			if err := g.GenerateFrame(frame, 0); err != nil {
				t.Fatalf("GenerateFrame(%q): %v", tc.name, err)
			}
			frames[tc.name] = frame
		}

		y, cb, cr := sampleV210(frame, width, tc.x, 100)
		if y != tc.wantY || cb != tc.wantCb || cr != tc.wantCr {
			t.Errorf("%s x=%d: got %d/%d/%d, want %d/%d/%d",
				tc.name, tc.x, y, cb, cr, tc.wantY, tc.wantCb, tc.wantCr)
		}
	}
}

func TestCPUMovingPatternUsesOwnBaseColor(t *testing.T) {
	const width, height = 1920, 1080
	g, err := NewCPUPatternGenerator(width, height, "ebu100-move")
	if err != nil {
		t.Fatalf("NewCPUPatternGenerator: %v", err)
	}
	frame := make([]byte, width*height*8/3)
	if err := g.GenerateFrame(frame, 0); err != nil {
		t.Fatalf("GenerateFrame: %v", err)
	}
	if y, cb, cr := sampleV210(frame, width, 960, 540); y != 691 || cb != 167 || cr != 105 {
		t.Fatalf("center = %d/%d/%d, want inverted EBU100 magenta 691/167/105", y, cb, cr)
	}
}

func TestCPUSMPTEIsNotFakedByAnotherPattern(t *testing.T) {
	_, err := NewCPUPatternGenerator(1920, 1080, "smpte")
	if err == nil || !strings.Contains(err.Error(), "not implemented") {
		t.Fatalf("error = %v, want not implemented error", err)
	}
}

func TestNewCPUPatternGeneratorRejectsUnknownPattern(t *testing.T) {
	_, err := NewCPUPatternGenerator(1920, 1080, "unknown")
	if err == nil || !strings.Contains(err.Error(), "not implemented") {
		t.Fatalf("error = %v, want unsupported pattern error", err)
	}
}