seedlab_test.go

package seedlab

import (
	"encoding/json"
	"testing"
)

// TestLCGDeterminism verifies that LCG produces the same sequence with the same seed
func TestLCGDeterminism(t *testing.T) {
	seed := uint64(12345)
	
	gen1 := NewLCG(seed)
	gen2 := NewLCG(seed)
	
	for i := 0; i < 100; i++ {
		v1 := gen1.Next()
		v2 := gen2.Next()
		if v1 != v2 {
			t.Errorf("LCG not deterministic at iteration %d: %d != %d", i, v1, v2)
		}
	}
}

// TestPCGDeterminism verifies that PCG produces the same sequence with the same seed
func TestPCGDeterminism(t *testing.T) {
	seed := uint64(67890)
	
	gen1 := NewPCG(seed)
	gen2 := NewPCG(seed)
	
	for i := 0; i < 100; i++ {
		v1 := gen1.Next()
		v2 := gen2.Next()
		if v1 != v2 {
			t.Errorf("PCG not deterministic at iteration %d: %d != %d", i, v1, v2)
		}
	}
}

// TestXoshiro256Determinism verifies that Xoshiro256 produces the same sequence with the same seed
func TestXoshiro256Determinism(t *testing.T) {
	seed := uint64(11111)
	
	gen1 := NewXoshiro256(seed)
	gen2 := NewXoshiro256(seed)
	
	for i := 0; i < 100; i++ {
		v1 := gen1.Next()
		v2 := gen2.Next()
		if v1 != v2 {
			t.Errorf("Xoshiro256 not deterministic at iteration %d: %d != %d", i, v1, v2)
		}
	}
}

// TestStateReplay verifies that generators can be restored to previous states
func TestStateReplay(t *testing.T) {
	tests := []struct {
		name string
		gen  Generator
	}{
		{"LCG", NewLCG(12345)},
		{"PCG", NewPCG(67890)},
		{"Xoshiro256", NewXoshiro256(11111)},
	}
	
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Generate some values
			for i := 0; i < 10; i++ {
				tt.gen.Next()
			}
			
			// Save state
			state := tt.gen.GetState()
			
			// Generate more values and record them
			expected := make([]uint64, 10)
			for i := 0; i < 10; i++ {
				expected[i] = tt.gen.Next()
			}
			
			// Restore state
			err := tt.gen.SetState(state)
			if err != nil {
				t.Fatalf("Failed to restore state: %v", err)
			}
			
			// Verify we get the same values
			for i := 0; i < 10; i++ {
				val := tt.gen.Next()
				if val != expected[i] {
					t.Errorf("State replay failed at position %d: got %d, want %d", i, val, expected[i])
				}
			}
		})
	}
}

// TestReseed verifies that reseeding works correctly
func TestReseed(t *testing.T) {
	seed1 := uint64(11111)
	seed2 := uint64(22222)
	
	gen := NewLCG(seed1)
	val1 := gen.Next()
	
	gen.Seed(seed1)
	val2 := gen.Next()
	
	if val1 != val2 {
		t.Errorf("Reseed with same seed failed: %d != %d", val1, val2)
	}
	
	gen.Seed(seed2)
	val3 := gen.Next()
	
	if val3 == val1 {
		t.Errorf("Reseed with different seed produced same value")
	}
}

// TestNextFloat64 verifies that NextFloat64 returns values in [0.0, 1.0)
func TestNextFloat64(t *testing.T) {
	generators := []Generator{
		NewLCG(12345),
		NewPCG(67890),
		NewXoshiro256(11111),
	}
	
	for _, gen := range generators {
		for i := 0; i < 1000; i++ {
			val := gen.NextFloat64()
			if val < 0.0 || val >= 1.0 {
				t.Errorf("%s: NextFloat64 out of range: %f", gen.Algorithm(), val)
			}
		}
	}
}

// TestNextInRange verifies that NextInRange returns values in [min, max)
func TestNextInRange(t *testing.T) {
	generators := []Generator{
		NewLCG(12345),
		NewPCG(67890),
		NewXoshiro256(11111),
	}
	
	min := int64(10)
	max := int64(20)
	
	for _, gen := range generators {
		for i := 0; i < 1000; i++ {
			val := gen.NextInRange(min, max)
			if val < min || val >= max {
				t.Errorf("%s: NextInRange out of range: %d not in [%d, %d)", gen.Algorithm(), val, min, max)
			}
		}
	}
}

// TestExportImportStream verifies stream export and import
func TestExportImportStream(t *testing.T) {
	seed := uint64(12345)
	gen1 := NewLCG(seed)
	
	// Export stream
	stream := ExportStream(gen1, 50)
	
	if stream.Length != 50 {
		t.Errorf("Stream length mismatch: got %d, want 50", stream.Length)
	}
	
	if len(stream.Values) != 50 {
		t.Errorf("Stream values length mismatch: got %d, want 50", len(stream.Values))
	}
	
	if stream.Algorithm != "LCG" {
		t.Errorf("Stream algorithm mismatch: got %s, want LCG", stream.Algorithm)
	}
	
	// Verify values match a fresh generator
	gen2 := NewLCG(seed)
	for i := 0; i < 50; i++ {
		expected := gen2.Next()
		if stream.Values[i] != expected {
			t.Errorf("Stream value mismatch at %d: got %d, want %d", i, stream.Values[i], expected)
		}
	}
}

// TestStreamSerialization verifies JSON serialization of streams
func TestStreamSerialization(t *testing.T) {
	seed := uint64(12345)
	gen := NewPCG(seed)
	
	stream := ExportStream(gen, 10)
	
	// Marshal to JSON
	data, err := MarshalStream(stream)
	if err != nil {
		t.Fatalf("Failed to marshal stream: %v", err)
	}
	
	// Unmarshal from JSON
	stream2, err := UnmarshalStream(data)
	if err != nil {
		t.Fatalf("Failed to unmarshal stream: %v", err)
	}
	
	// Verify fields match
	if stream2.Algorithm != stream.Algorithm {
		t.Errorf("Algorithm mismatch after serialization")
	}
	if stream2.Seed != stream.Seed {
		t.Errorf("Seed mismatch after serialization")
	}
	if stream2.Length != stream.Length {
		t.Errorf("Length mismatch after serialization")
	}
	
	for i := 0; i < len(stream.Values); i++ {
		if stream2.Values[i] != stream.Values[i] {
			t.Errorf("Value mismatch at %d after serialization", i)
		}
	}
}

// TestEntropyAnalysis verifies entropy metrics calculation
func TestEntropyAnalysis(t *testing.T) {
	gen := NewXoshiro256(12345)
	
	values := make([]uint64, 1000)
	for i := 0; i < 1000; i++ {
		values[i] = gen.Next()
	}
	
	metrics := AnalyzeEntropy(values)
	
	// Check that metrics are in reasonable ranges
	if metrics.Mean < 0.0 || metrics.Mean > 1.0 {
		t.Errorf("Mean out of expected range: %f", metrics.Mean)
	}
	
	if metrics.Variance < 0.0 {
		t.Errorf("Variance is negative: %f", metrics.Variance)
	}
	
	if metrics.StandardDeviation < 0.0 {
		t.Errorf("Standard deviation is negative: %f", metrics.StandardDeviation)
	}
	
	// Shannon entropy should be close to 8.0 for good randomness (8 bits per byte)
	if metrics.ShannonEntropy < 7.0 || metrics.ShannonEntropy > 8.0 {
		t.Logf("Warning: Shannon entropy may indicate bias: %f", metrics.ShannonEntropy)
	}
	
	// Chi-square should not be too extreme
	if metrics.ChiSquare < 0.0 {
		t.Errorf("Chi-square is negative: %f", metrics.ChiSquare)
	}
}

// TestBranchSeed verifies seed branching
func TestBranchSeed(t *testing.T) {
	originalSeed := uint64(12345)
	
	branch1 := BranchSeed(originalSeed, 1)
	branch2 := BranchSeed(originalSeed, 2)
	
	if branch1 == branch2 {
		t.Errorf("Different branch IDs produced same seed")
	}
	
	if branch1 == originalSeed {
		t.Errorf("Branch seed same as original seed")
	}
	
	// Verify determinism
	branch1_again := BranchSeed(originalSeed, 1)
	if branch1 != branch1_again {
		t.Errorf("Branch seed not deterministic")
	}
}

// TestStateSerialization verifies state can be serialized and deserialized
func TestStateSerialization(t *testing.T) {
	gen := NewPCG(12345)
	
	// Generate some values
	for i := 0; i < 10; i++ {
		gen.Next()
	}
	
	// Get state
	state := gen.GetState()
	
	// Serialize state
	data, err := json.Marshal(state)
	if err != nil {
		t.Fatalf("Failed to marshal state: %v", err)
	}
	
	// Deserialize state
	var state2 State
	err = json.Unmarshal(data, &state2)
	if err != nil {
		t.Fatalf("Failed to unmarshal state: %v", err)
	}
	
	// Create new generator and restore state
	gen2 := NewPCG(0)
	err = gen2.SetState(state2)
	if err != nil {
		t.Fatalf("Failed to restore state: %v", err)
	}
	
	// Verify they produce the same values
	for i := 0; i < 10; i++ {
		v1 := gen.Next()
		v2 := gen2.Next()
		if v1 != v2 {
			t.Errorf("State serialization failed at iteration %d: %d != %d", i, v1, v2)
		}
	}
}

// TestIncompatibleState verifies error handling for incompatible states
func TestIncompatibleState(t *testing.T) {
	gen := NewLCG(12345)
	state := NewPCG(67890).GetState()
	
	err := gen.SetState(state)
	if err == nil {
		t.Error("Expected error when setting incompatible state, got nil")
	}
}

// TestXoshiroJump verifies the jump function
func TestXoshiroJump(t *testing.T) {
	seed := uint64(12345)
	gen1 := NewXoshiro256(seed)
	gen2 := NewXoshiro256(seed)
	
	// Jump gen1
	gen1.Jump()
	
	// Manually advance gen2 by a large number of steps
	// Just verify they're different after jump
	v1 := gen1.Next()
	v2 := gen2.Next()
	
	if v1 == v2 {
		t.Error("Jump should produce different sequence")
	}
}

// BenchmarkLCG benchmarks the LCG generator
func BenchmarkLCG(b *testing.B) {
	gen := NewLCG(12345)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		gen.Next()
	}
}

// BenchmarkPCG benchmarks the PCG generator
func BenchmarkPCG(b *testing.B) {
	gen := NewPCG(12345)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		gen.Next()
	}
}

// BenchmarkXoshiro256 benchmarks the Xoshiro256** generator
func BenchmarkXoshiro256(b *testing.B) {
	gen := NewXoshiro256(12345)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		gen.Next()
	}
}