qmk-rgb/internal/rgb/effects_test.go

package rgb

import (
	"testing"
)

func TestImpact80EffectName(t *testing.T) {
	cases := []struct {
		value uint8
		want  string
	}{
		{0, "none"},
		{1, "wave"},
		{2, "fixed_wave"},
		{3, "spectrum"},
		{4, "breathing"},
		{5, "light"},
		{6, "shutdown"},
		{7, "unknown"},
	}

	for _, tc := range cases {
		if got := Impact80EffectName(tc.value); got != tc.want {
			t.Errorf("Impact80EffectName(%d) = %q, want %q", tc.value, got, tc.want)
		}
	}
}

func TestParseImpact80Effect(t *testing.T) {
	cases := []struct {
		input string
		want  uint8
	}{
		{"none", 0},
		{"wave", 1},
		{"fixed_wave", 2},
		{"spectrum", 3},
		{"breathing", 4},
		{"light", 5},
		{"shutdown", 6},
		{"rainbow", 3},
		{"static", 5},
	}

	for _, tc := range cases {
		got, err := ParseImpact80Effect(tc.input)
		if err != nil {
			t.Errorf("ParseImpact80Effect(%q) unexpected error: %v", tc.input, err)
			continue
		}
		if got != tc.want {
			t.Errorf("ParseImpact80Effect(%q) = %d, want %d", tc.input, got, tc.want)
		}
	}
}

func TestQMKValueIDs(t *testing.T) {
	if Brightness != 1 {
		t.Errorf("Brightness = %d, want 1", Brightness)
	}
	if EffectID != 2 {
		t.Errorf("EffectID = %d, want 2", EffectID)
	}
	if Speed != 3 {
		t.Errorf("Speed = %d, want 3", Speed)
	}
	if ColorValue != 4 {
		t.Errorf("ColorValue = %d, want 4", ColorValue)
	}
}

func TestParseEffect(t *testing.T) {
	cases := []struct {
		name  string
		input string
		want  Effect
		err   bool
	}{
		{"static", "static", Static, false},
		{"breathing", "breathing", Breathing, false},
		{"rainbow", "rainbow", Rainbow, false},
		{"rainbow_wave", "rainbow_wave", RainbowWave, false},
		{"snake", "snake", Snake, false},
		{"gradient", "gradient", Gradient, false},
		{"tail", "tail", Tail, false},
		{"unknown", "flubber", 0, true},
		{"empty", "", 0, true},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got, err := ParseEffect(tc.input)
			if tc.err {
				if err == nil {
					t.Errorf("ParseEffect(%q) expected error, got nil", tc.input)
				}
				return
			}
			if err != nil {
				t.Errorf("ParseEffect(%q) unexpected error: %v", tc.input, err)
				return
			}
			if got != tc.want {
				t.Errorf("ParseEffect(%q) = %d, want %d", tc.input, got, tc.want)
			}
		})
	}
}

func TestEffectString(t *testing.T) {
	cases := []struct {
		effect Effect
		want   string
	}{
		{Static, "static"},
		{Breathing, "breathing"},
		{Rainbow, "rainbow"},
		{RainbowWave, "rainbow_wave"},
		{Effect(99), "unknown"},
	}

	for _, tc := range cases {
		t.Run(tc.want, func(t *testing.T) {
			got := tc.effect.String()
			if got != tc.want {
				t.Errorf("Effect(%d).String() = %q, want %q", tc.effect, got, tc.want)
			}
		})
	}
}

func TestParseHexColor(t *testing.T) {
	cases := []struct {
		name  string
		input string
		want  Color
		err   bool
	}{
		{"red", "ff0000", Color{R: 255, G: 0, B: 0}, false},
		{"green", "00ff00", Color{R: 0, G: 255, B: 0}, false},
		{"blue", "0000ff", Color{R: 0, G: 0, B: 255}, false},
		{"white", "ffffff", Color{R: 255, G: 255, B: 255}, false},
		{"black", "000000", Color{R: 0, G: 0, B: 0}, false},
		{"lowercase", "aabbcc", Color{R: 0xaa, G: 0xbb, B: 0xcc}, false},
		{"uppercase", "AABBCC", Color{R: 0xaa, G: 0xbb, B: 0xcc}, false},
		{"short", "ff000", Color{0, 0, 0}, true},
		{"long", "ff00000", Color{0, 0, 0}, true},
		{"empty", "", Color{0, 0, 0}, true},
		{"invalid", "gggggg", Color{}, true},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got, err := ParseHexColor(tc.input)
			if tc.err {
				if err == nil {
					t.Errorf("ParseHexColor(%q) expected error, got nil", tc.input)
				}
				return
			}
			if err != nil {
				t.Errorf("ParseHexColor(%q) unexpected error: %v", tc.input, err)
				return
			}
			if got != tc.want {
				t.Errorf("ParseHexColor(%q) = %+v, want %+v", tc.input, got, tc.want)
			}
		})
	}
}

func TestColorToHSV(t *testing.T) {
	cases := []struct {
		name  string
		color Color
		wantH uint8
		wantS uint8
		wantV uint8
	}{
		{"red", Color{R: 255, G: 0, B: 0}, 0, 255, 255},
		{"green", Color{R: 0, G: 255, B: 0}, 85, 255, 255},
		{"blue", Color{R: 0, G: 0, B: 255}, 170, 255, 255},
		{"white", Color{R: 255, G: 255, B: 255}, 0, 0, 255},
		{"black", Color{R: 0, G: 0, B: 0}, 0, 0, 0},
		{"yellow", Color{R: 255, G: 255, B: 0}, 42, 255, 255},
		{"cyan", Color{R: 0, G: 255, B: 255}, 127, 255, 255},
		{"magenta", Color{R: 255, G: 0, B: 255}, 212, 255, 255},
		{"gray", Color{R: 128, G: 128, B: 128}, 0, 0, 128},
		{"dark red", Color{R: 128, G: 0, B: 0}, 0, 255, 128},
		{"light red", Color{R: 255, G: 128, B: 128}, 0, 127, 255},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			h, s, v := tc.color.HSV()
			if h != tc.wantH {
				t.Errorf("HSV(%q).H = %d, want %d", tc.name, h, tc.wantH)
			}
			if s != tc.wantS {
				t.Errorf("HSV(%q).S = %d, want %d", tc.name, s, tc.wantS)
			}
			if v != tc.wantV {
				t.Errorf("HSV(%q).V = %d, want %d", tc.name, v, tc.wantV)
			}
		})
	}
}