fix: resolve lint findings in streaming tests and example

Extract the per-plan chunked run in TestStreamingEquivalence_Float64 into a
helper to drop cognitive complexity below 50; replace append([]float64(nil),
x...) with slices.Clone(x) in the streaming and flush-lifecycle tests. In the
streaming example, name the loop count and tone constants, use range-over-int
and max(), and start the FIFO zero-length with capacity so the priming zeros
are appended (satisfies makezero).

Author: tphakala

examples/streaming/main.go

@@ -21,9 +21,12 @@ import (
 
 func main() {
 	const (
-		inRate    = 44100.0
-		outRate   = 48000.0
-		outFrames = 512
+		inRate        = 44100.0
+		outRate       = 48000.0
+		outFrames     = 512
+		callbacks     = 100
+		toneAmplitude = 0.5
+		toneHz        = 997.0
 	)
 
 	rs, err := resampler.NewEngineFloat32(inRate, outRate, resampler.QualityHigh)
@@ -34,12 +37,14 @@ func main() {
 
 	// Prime the FIFO with the startup deficit so the first callbacks are
 	// fed. This trades Latency() samples of leading silence for a steady
-	// pipeline.
-	fifo := make([]float32, rs.Latency())
+	// pipeline. The FIFO starts empty with headroom, then the priming zeros
+	// are appended so later appends grow a zero-length-origin slice.
+	fifo := make([]float32, 0, rs.Latency()+2*outFrames)
+	fifo = append(fifo, make([]float32, rs.Latency())...)
 
 	phase := 0.0
 	firstCall := true
-	for callback := 0; callback < 100; callback++ {
+	for callback := range callbacks {
 		// Size the input chunk from the FIFO's current deficit rather than
 		// a fixed count. A fixed input size drifts against a fixed output
 		// size whenever ratio does not divide outFrames evenly: truncating
@@ -64,10 +69,7 @@ func main() {
 		// below tolerates that warmup.
 		need := outFrames
 		if !firstCall {
-			need = outFrames - len(fifo)
-			if need < 0 {
-				need = 0
-			}
+			need = max(outFrames-len(fifo), 0)
 		}
 		firstCall = false
 		inFrames := int(math.Ceil(float64(need) / ratio))
@@ -76,8 +78,8 @@ func main() {
 		// reuse a single scratch buffer instead of allocating each call.
 		in := make([]float32, inFrames)
 		for i := range in {
-			in[i] = float32(0.5 * math.Sin(phase))
-			phase += 2 * math.Pi * 997 / inRate
+			in[i] = float32(toneAmplitude * math.Sin(phase))
+			phase += 2 * math.Pi * toneHz / inRate
 		}
 		out, err := rs.Process(in)
 		if err != nil {

flush_lifecycle_test.go

@@ -5,6 +5,7 @@ package resampler
 
 import (
 	"math"
+	"slices"
 	"testing"
 )
 
@@ -56,11 +57,11 @@ func TestFlushLifecycle(t *testing.T) {
 			t.Fatal(err)
 		}
 		chunk := sineChunk(4410, c.in)
-		gotAfterFlush, err := r.Process(append([]float64(nil), chunk...))
+		gotAfterFlush, err := r.Process(slices.Clone(chunk))
 		if err != nil {
 			t.Fatal(err)
 		}
-		gotFresh, err := fresh.Process(append([]float64(nil), chunk...))
+		gotFresh, err := fresh.Process(slices.Clone(chunk))
 		if err != nil {
 			t.Fatal(err)
 		}

streaming_equivalence_test.go

@@ -41,7 +41,7 @@ func TestStreamingEquivalence_Float64(t *testing.T) {
 			if err != nil {
 				t.Fatalf("%s: NewEngine: %v", rr.name, err)
 			}
-			ref, err := oneShot.Process(append([]float64(nil), input...))
+			ref, err := oneShot.Process(slices.Clone(input))
 			if err != nil {
 				t.Fatalf("%s: Process: %v", rr.name, err)
 			}
@@ -52,44 +52,52 @@ func TestStreamingEquivalence_Float64(t *testing.T) {
 			ref = append(ref, refTail...)
 
 			for pi, plan := range chunkPlans {
-				chunked, err := NewEngine(rr.in, rr.out, q)
-				if err != nil {
-					t.Fatalf("%s: NewEngine: %v", rr.name, err)
-				}
-				var got []float64
-				rng := rand.New(rand.NewSource(int64(pi) + 1))
-				pos := 0
-				for pos < n {
-					size := plan[rng.Intn(len(plan))]
-					if pos+size > n {
-						size = n - pos
-					}
-					out, err := chunked.Process(append([]float64(nil), input[pos:pos+size]...))
-					if err != nil {
-						t.Fatalf("%s plan %d: Process: %v", rr.name, pi, err)
-					}
-					got = append(got, out...)
-					pos += size
-				}
-				tail, err := chunked.Flush()
-				if err != nil {
-					t.Fatalf("%s plan %d: Flush: %v", rr.name, pi, err)
-				}
-				got = append(got, tail...)
-
-				if len(got) != len(ref) {
-					t.Fatalf("%s q=%v plan %d: length %d != one-shot %d", rr.name, q, pi, len(got), len(ref))
-				}
-				for i := range got {
-					if got[i] != ref[i] {
-						t.Fatalf("%s q=%v plan %d: sample %d differs: %g != %g", rr.name, q, pi, i, got[i], ref[i])
-					}
-				}
+				assertChunkedPlanEqualsFloat64(t, rr.name, rr.in, rr.out, q, pi, plan, input, ref)
 			}
 		}
 	}
 }
 
+// assertChunkedPlanEqualsFloat64 feeds input through a fresh engine in
+// pseudo-random chunk sizes drawn from plan (seeded by pi for reproducibility),
+// Flushes once, and asserts the result is bit-exact with ref.
+func assertChunkedPlanEqualsFloat64(t *testing.T, name string, in, out float64, q QualityPreset, pi int, plan []int, input, ref []float64) {
+	t.Helper()
+
+	chunked, err := NewEngine(in, out, q)
+	if err != nil {
+		t.Fatalf("%s: NewEngine: %v", name, err)
+	}
+	var got []float64
+	rng := rand.New(rand.NewSource(int64(pi) + 1))
+	for pos := 0; pos < len(input); {
+		size := plan[rng.Intn(len(plan))]
+		if pos+size > len(input) {
+			size = len(input) - pos
+		}
+		outChunk, err := chunked.Process(slices.Clone(input[pos : pos+size]))
+		if err != nil {
+			t.Fatalf("%s plan %d: Process: %v", name, pi, err)
+		}
+		got = append(got, outChunk...)
+		pos += size
+	}
+	tail, err := chunked.Flush()
+	if err != nil {
+		t.Fatalf("%s plan %d: Flush: %v", name, pi, err)
+	}
+	got = append(got, tail...)
+
+	if len(got) != len(ref) {
+		t.Fatalf("%s q=%v plan %d: length %d != one-shot %d", name, q, pi, len(got), len(ref))
+	}
+	for i := range got {
+		if got[i] != ref[i] {
+			t.Fatalf("%s q=%v plan %d: sample %d differs: %g != %g", name, q, pi, i, got[i], ref[i])
+		}
+	}
+}
+
 func TestStreamingEquivalence_Float32(t *testing.T) {
 	// Broadened beyond the single issue #51 configuration: an upsample and a
 	// downsample ratio, two qualities, and two fixed chunk sizes. Chunked