wehub-resource-sync
347 lines
10 KiB
Go
347 lines
10 KiB
Go
package ui
|
|
|
|
import (
|
|
"math"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestAnalyzeSupportsArbitraryBandCounts(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
samples := make([]float64, classicPeakFFTSize)
|
|
for i := range samples {
|
|
samples[i] = math.Sin(2 * math.Pi * 440 * float64(i) / v.sr)
|
|
}
|
|
|
|
for _, spec := range []VisAnalysisSpec{
|
|
spectrumAnalysisSpec(DefaultSpectrumBands),
|
|
{BandCount: 17, FFTSize: defaultFFTSize},
|
|
{BandCount: classicPeakSpectrumBands, FFTSize: classicPeakFFTSize},
|
|
} {
|
|
bands := v.Analyze(samples, spec)
|
|
if len(bands) != spec.BandCount {
|
|
t.Fatalf("Analyze(..., %+v) len = %d, want %d", spec, len(bands), spec.BandCount)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBuildSpectrumEdgesPreservesLegacyDefaultLayout(t *testing.T) {
|
|
got := buildSpectrumEdges(DefaultSpectrumBands)
|
|
want := legacySpectrumEdges[:]
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("buildSpectrumEdges(%d) = %v, want %v", DefaultSpectrumBands, got, want)
|
|
}
|
|
}
|
|
|
|
func TestAnalyzeDecayStateIsIndependentPerAnalysisSpec(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
specA := spectrumAnalysisSpec(DefaultSpectrumBands)
|
|
specB := VisAnalysisSpec{BandCount: DefaultSpectrumBands, FFTSize: classicPeakFFTSize}
|
|
v.prevBySpec[specA] = uniformBandsN(specA.BandCount, 0.5)
|
|
v.prevBySpec[specB] = uniformBandsN(specB.BandCount, 0.8)
|
|
|
|
bandsA := v.Analyze(nil, specA)
|
|
bandsB := v.Analyze(nil, specB)
|
|
|
|
if got := bandsA[0]; math.Abs(got-0.4) > classicPeakTestEpsilon {
|
|
t.Fatalf("default-spec decay = %v, want 0.4", got)
|
|
}
|
|
if got := bandsB[0]; math.Abs(got-0.64) > classicPeakTestEpsilon {
|
|
t.Fatalf("classic-peak-spec decay = %v, want 0.64", got)
|
|
}
|
|
}
|
|
|
|
func TestAverageSpectrumRangeLinearDistinguishesSubBinLowBands(t *testing.T) {
|
|
magnitudes := make([]float64, classicPeakFFTSize/2)
|
|
for i := range magnitudes {
|
|
magnitudes[i] = float64(i)
|
|
}
|
|
|
|
spec := VisAnalysisSpec{BandCount: classicPeakSpectrumBands, FFTSize: classicPeakFFTSize}
|
|
edges := buildSpectrumEdges(spec.BandCount)
|
|
binHz := 44100.0 / float64(spec.FFTSize)
|
|
low := make([]float64, 3)
|
|
for i := range low {
|
|
low[i] = averageSpectrumRangeLinear(magnitudes, edges[i]/binHz, edges[i+1]/binHz)
|
|
}
|
|
|
|
if !(low[0] < low[1] && low[1] < low[2]) {
|
|
t.Fatalf("low sub-bin bands collapsed unexpectedly: got %v", low)
|
|
}
|
|
}
|
|
|
|
func TestRenderOnlyDriverUsesDefaultTickInterval(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
// Pulse is a per-frame-animated spectrum mode and stays on the default
|
|
// (TickFast) cadence — VisBars/Bricks/Columns/etc. opt into TickAnim.
|
|
activateMode(t, v, VisPulse)
|
|
|
|
if got := v.TickInterval(VisTickContext{Playing: true}); got != TickFast {
|
|
t.Fatalf("TickInterval(playing) = %v, want %v", got, TickFast)
|
|
}
|
|
if got := v.TickInterval(VisTickContext{OverlayActive: true}); got != TickSlow {
|
|
t.Fatalf("TickInterval(overlay) = %v, want %v", got, TickSlow)
|
|
}
|
|
if got := v.TickInterval(VisTickContext{}); got != TickSlow {
|
|
t.Fatalf("TickInterval(idle) = %v, want %v", got, TickSlow)
|
|
}
|
|
}
|
|
|
|
func TestSmoothBarsDriverUsesAnimTick(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisBars)
|
|
|
|
if got := v.TickInterval(VisTickContext{Playing: true}); got != TickAnim {
|
|
t.Fatalf("Bars TickInterval(playing) = %v, want %v", got, TickAnim)
|
|
}
|
|
}
|
|
|
|
func TestAdvanceSmoothingEasesTowardBands(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
v.bands = []float64{1.0, 0.0}
|
|
v.smoothedBands = []float64{0.0, 1.0}
|
|
|
|
t0 := time.Unix(0, 0)
|
|
v.lastSmoothTick = t0
|
|
v.advanceSmoothing(t0.Add(TickAnim))
|
|
|
|
// Expectations derive from the same easing call the implementation uses,
|
|
// so changes to the rate constants don't silently invalidate the test.
|
|
dt := TickAnim.Seconds()
|
|
wantRise := classicPeakStep(0, 1, dt)
|
|
wantFall := classicPeakStep(1, 0, dt)
|
|
if got := v.smoothedBands[0]; math.Abs(got-wantRise) > 1e-9 {
|
|
t.Fatalf("rise step = %v, want %v", got, wantRise)
|
|
}
|
|
if got := v.smoothedBands[1]; math.Abs(got-wantFall) > 1e-9 {
|
|
t.Fatalf("fall step = %v, want %v", got, wantFall)
|
|
}
|
|
if (1 - wantFall) >= wantRise {
|
|
t.Fatalf("expected decay slower than attack: rise %v, fall %v", wantRise, wantFall)
|
|
}
|
|
}
|
|
|
|
func TestAdvanceSmoothingResizesOnBandCountChange(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
v.smoothedBands = []float64{0.5, 0.5}
|
|
v.bands = []float64{0.1, 0.2, 0.3}
|
|
v.advanceSmoothing(time.Time{})
|
|
|
|
if len(v.smoothedBands) != len(v.bands) {
|
|
t.Fatalf("smoothedBands len = %d, want %d", len(v.smoothedBands), len(v.bands))
|
|
}
|
|
for i, got := range v.smoothedBands {
|
|
if got != v.bands[i] {
|
|
t.Fatalf("smoothedBands[%d] = %v, want %v after resync", i, got, v.bands[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDefaultDriverTickGatesAnalyzeAtAnalyzeCadence(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisBars)
|
|
|
|
calls := 0
|
|
analyze := func(spec VisAnalysisSpec) []float64 {
|
|
calls++
|
|
return uniformBandsN(spec.BandCount, 0.4)
|
|
}
|
|
|
|
t0 := time.Unix(0, 0)
|
|
// First tick analyzes (no prior timestamp).
|
|
v.Tick(VisTickContext{Now: t0, Playing: true, Analyze: analyze})
|
|
// A tick well within TickAnalyze should NOT analyze again.
|
|
v.Tick(VisTickContext{Now: t0.Add(TickAnim), Playing: true, Analyze: analyze})
|
|
if calls != 1 {
|
|
t.Fatalf("Analyze() calls within analyze window = %d, want 1", calls)
|
|
}
|
|
// Past TickAnalyze, it should analyze again.
|
|
v.Tick(VisTickContext{Now: t0.Add(TickAnalyze + time.Millisecond), Playing: true, Analyze: analyze})
|
|
if calls != 2 {
|
|
t.Fatalf("Analyze() calls after analyze window = %d, want 2", calls)
|
|
}
|
|
}
|
|
|
|
func TestRenderOnlyDriverSkipsAnalyzeUnderOverlay(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisBars)
|
|
|
|
calls := 0
|
|
v.Tick(VisTickContext{
|
|
OverlayActive: true,
|
|
Analyze: func(VisAnalysisSpec) []float64 {
|
|
calls++
|
|
return uniformBands(0.6)
|
|
},
|
|
})
|
|
|
|
if calls != 0 {
|
|
t.Fatalf("Analyze() calls = %d, want 0 while overlay is active", calls)
|
|
}
|
|
}
|
|
|
|
func TestRenderOnlyDriverRequestsConfiguredBandCount(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisBars)
|
|
|
|
var requested VisAnalysisSpec
|
|
v.Tick(VisTickContext{
|
|
Analyze: func(spec VisAnalysisSpec) []float64 {
|
|
requested = spec
|
|
return uniformBandsN(spec.BandCount, 0.6)
|
|
},
|
|
})
|
|
|
|
want := spectrumAnalysisSpec(DefaultSpectrumBands)
|
|
if requested != want {
|
|
t.Fatalf("Analyze() requested %+v, want %+v", requested, want)
|
|
}
|
|
if len(v.bands) != DefaultSpectrumBands {
|
|
t.Fatalf("stored bands len = %d, want %d", len(v.bands), DefaultSpectrumBands)
|
|
}
|
|
}
|
|
|
|
func TestClassicPeakRequestsHighResBands(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisClassicPeak)
|
|
|
|
var requested VisAnalysisSpec
|
|
v.Tick(VisTickContext{
|
|
Now: time.Now(),
|
|
Playing: true,
|
|
Analyze: func(spec VisAnalysisSpec) []float64 {
|
|
requested = spec
|
|
return uniformBandsN(spec.BandCount, 0.6)
|
|
},
|
|
})
|
|
|
|
want := VisAnalysisSpec{BandCount: classicPeakSpectrumBands, FFTSize: classicPeakFFTSize}
|
|
if requested != want {
|
|
t.Fatalf("Analyze() requested %+v, want %+v", requested, want)
|
|
}
|
|
if len(v.bands) != classicPeakSpectrumBands {
|
|
t.Fatalf("stored bands len = %d, want %d", len(v.bands), classicPeakSpectrumBands)
|
|
}
|
|
}
|
|
|
|
func TestRawSampleModesRefreshWaveBufAtZeroBandCount(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisWave)
|
|
|
|
samples := []float64{-0.5, -0.1, 0.25, 0.75}
|
|
requested := VisAnalysisSpec{BandCount: -1, FFTSize: -1}
|
|
v.Tick(VisTickContext{
|
|
Playing: true,
|
|
Analyze: func(spec VisAnalysisSpec) []float64 {
|
|
requested = spec
|
|
return v.Analyze(samples, spec)
|
|
},
|
|
})
|
|
|
|
want := spectrumAnalysisSpec(0)
|
|
if requested != want {
|
|
t.Fatalf("Analyze() requested %+v, want %+v for raw-sample modes", requested, want)
|
|
}
|
|
if !reflect.DeepEqual(v.waveBuf, samples) {
|
|
t.Fatalf("waveBuf = %v, want %v after zero-band tick refresh", v.waveBuf, samples)
|
|
}
|
|
}
|
|
|
|
func TestRawSampleModesClearSpectrumHistoryOnModeSwitch(t *testing.T) {
|
|
v := NewVisualizer(44100)
|
|
barsSpec := spectrumAnalysisSpec(DefaultSpectrumBands)
|
|
v.prevBySpec[barsSpec] = uniformBandsN(barsSpec.BandCount, 0.8)
|
|
|
|
activateMode(t, v, VisBars)
|
|
activateMode(t, v, VisWave)
|
|
|
|
if len(v.prevBySpec) != 0 {
|
|
t.Fatalf("prevBySpec len after switch to raw-sample mode = %d, want 0", len(v.prevBySpec))
|
|
}
|
|
|
|
activateMode(t, v, VisBars)
|
|
bands := v.Analyze(nil, barsSpec)
|
|
if got := bands[0]; math.Abs(got) > classicPeakTestEpsilon {
|
|
t.Fatalf("first bar after raw-sample switch = %v, want 0 with cleared spectrum history", got)
|
|
}
|
|
}
|
|
|
|
func TestTerrainPreservesStateAcrossModeSwitch(t *testing.T) {
|
|
withPanelWidth(t, 8)
|
|
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisTerrain)
|
|
driver := terrainDriverFor(t, v)
|
|
bands := uniformBands(0.6)
|
|
v.bands = bands
|
|
|
|
v.Tick(VisTickContext{})
|
|
snapshot := append([]float64(nil), driver.buf...)
|
|
if len(snapshot) != PanelWidth*2 {
|
|
t.Fatalf("terrain buffer len = %d, want %d", len(snapshot), PanelWidth*2)
|
|
}
|
|
|
|
activateMode(t, v, VisBars)
|
|
activateMode(t, v, VisTerrain)
|
|
|
|
if len(driver.buf) != len(snapshot) {
|
|
t.Fatalf("terrain buffer len after switch = %d, want %d", len(driver.buf), len(snapshot))
|
|
}
|
|
for i, got := range driver.buf {
|
|
if got != snapshot[i] {
|
|
t.Fatalf("terrain buffer[%d] = %v after switch, want %v", i, got, snapshot[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTerrainRenderDoesNotAdvanceWithoutTick(t *testing.T) {
|
|
withPanelWidth(t, 8)
|
|
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisTerrain)
|
|
driver := terrainDriverFor(t, v)
|
|
v.bands = uniformBands(0.6)
|
|
|
|
v.Tick(VisTickContext{})
|
|
snapshot := append([]float64(nil), driver.buf...)
|
|
|
|
v.Render()
|
|
v.Render()
|
|
|
|
if !reflect.DeepEqual(driver.buf, snapshot) {
|
|
t.Fatalf("terrain buffer changed across redraws without tick: got %v want %v", driver.buf, snapshot)
|
|
}
|
|
}
|
|
|
|
func TestTerrainTickSkipsAnalyzeUnderOverlay(t *testing.T) {
|
|
withPanelWidth(t, 8)
|
|
|
|
v := NewVisualizer(44100)
|
|
activateMode(t, v, VisTerrain)
|
|
driver := terrainDriverFor(t, v)
|
|
driver.buf = append([]float64(nil), []float64{
|
|
0.1, 0.2, 0.3, 0.4,
|
|
0.5, 0.6, 0.7, 0.8,
|
|
0.2, 0.3, 0.4, 0.5,
|
|
0.6, 0.7, 0.8, 0.9,
|
|
}...)
|
|
snapshot := append([]float64(nil), driver.buf...)
|
|
|
|
calls := 0
|
|
v.Tick(VisTickContext{
|
|
OverlayActive: true,
|
|
Analyze: func(VisAnalysisSpec) []float64 {
|
|
calls++
|
|
return uniformBands(0.6)
|
|
},
|
|
})
|
|
|
|
if calls != 0 {
|
|
t.Fatalf("Analyze() calls = %d, want 0 while overlay is active", calls)
|
|
}
|
|
if !reflect.DeepEqual(driver.buf, snapshot) {
|
|
t.Fatalf("terrain buffer changed under overlay: got %v want %v", driver.buf, snapshot)
|
|
}
|
|
}
|