benchclock_test.go

package benchclock

import (
	"testing"
	"time"
)

func TestNew(t *testing.T) {
	fn := func() {
		time.Sleep(1 * time.Microsecond)
	}

	b := New("TestBenchmark", fn)

	if b.Name != "TestBenchmark" {
		t.Errorf("Expected name 'TestBenchmark', got '%s'", b.Name)
	}

	if b.Fn == nil {
		t.Error("Expected non-nil function")
	}

	if b.Config == nil {
		t.Error("Expected default config to be set")
	}
}

func TestDefaultConfig(t *testing.T) {
	cfg := DefaultConfig()

	if cfg.MinIterations <= 0 {
		t.Error("MinIterations should be positive")
	}

	if cfg.MaxIterations <= cfg.MinIterations {
		t.Error("MaxIterations should be greater than MinIterations")
	}

	if cfg.MinDuration <= 0 {
		t.Error("MinDuration should be positive")
	}

	if cfg.WarmupIterations < 0 {
		t.Error("WarmupIterations should be non-negative")
	}
}

func TestBenchmarkRun(t *testing.T) {
	// Simple benchmark that does minimal work
	counter := 0
	fn := func() {
		counter++
		time.Sleep(10 * time.Microsecond)
	}

	cfg := &Config{
		MinIterations:     10,
		MaxIterations:     100,
		MinDuration:       50 * time.Millisecond,
		WarmupIterations:  5,
		CorrectClockDrift: true,
		DetectCPUScaling:  true,
	}

	b := New("TestBenchmark", fn).WithConfig(cfg)
	result, err := b.Run()

	if err != nil {
		t.Fatalf("Benchmark failed: %v", err)
	}

	// Check that warm-up iterations were performed
	if counter < cfg.WarmupIterations {
		t.Errorf("Expected at least %d warm-up iterations", cfg.WarmupIterations)
	}

	// Verify result fields
	if result.Name != "TestBenchmark" {
		t.Errorf("Expected name 'TestBenchmark', got '%s'", result.Name)
	}

	if result.Iterations < cfg.MinIterations {
		t.Errorf("Expected at least %d iterations, got %d", cfg.MinIterations, result.Iterations)
	}

	if result.Mean <= 0 {
		t.Error("Mean should be positive")
	}

	if result.Median <= 0 {
		t.Error("Median should be positive")
	}

	if result.StdDev < 0 {
		t.Error("StdDev should be non-negative")
	}

	if result.Variance < 0 {
		t.Error("Variance should be non-negative")
	}

	if result.Min <= 0 {
		t.Error("Min should be positive")
	}

	if result.Max <= 0 {
		t.Error("Max should be positive")
	}

	if result.Min > result.Max {
		t.Error("Min should be less than or equal to Max")
	}

	if result.ConfidenceInterval95.Lower <= 0 {
		t.Error("95% CI lower bound should be positive")
	}

	if result.ConfidenceInterval95.Upper <= 0 {
		t.Error("95% CI upper bound should be positive")
	}

	if result.ConfidenceInterval95.Lower > result.ConfidenceInterval95.Upper {
		t.Error("95% CI lower bound should be less than upper bound")
	}

	if result.ConfidenceInterval99.Lower <= 0 {
		t.Error("99% CI lower bound should be positive")
	}

	if result.ConfidenceInterval99.Upper <= 0 {
		t.Error("99% CI upper bound should be positive")
	}

	if result.ConfidenceInterval99.Lower > result.ConfidenceInterval99.Upper {
		t.Error("99% CI lower bound should be less than upper bound")
	}

	// 99% CI should be wider than 95% CI
	if result.ConfidenceInterval99.Upper-result.ConfidenceInterval99.Lower <
		result.ConfidenceInterval95.Upper-result.ConfidenceInterval95.Lower {
		t.Error("99% CI should be wider than 95% CI")
	}

	if result.CPUScalingFactor < 1.0 {
		t.Error("CPU scaling factor should be at least 1.0")
	}

	if result.WarmupIterationsDiscarded != cfg.WarmupIterations {
		t.Errorf("Expected %d warmup iterations discarded, got %d",
			cfg.WarmupIterations, result.WarmupIterationsDiscarded)
	}
}

func TestBenchmarkRunNilFunction(t *testing.T) {
	b := &Benchmark{
		Name:   "NilTest",
		Fn:     nil,
		Config: DefaultConfig(),
	}

	_, err := b.Run()
	if err == nil {
		t.Error("Expected error for nil function")
	}
}

func TestMeasureClockDrift(t *testing.T) {
	drift := measureClockDrift()

	// Clock drift should be non-negative and reasonable (< 1ms)
	if drift < 0 {
		t.Error("Clock drift should be non-negative")
	}

	if drift > 1000000 { // 1ms in nanoseconds
		t.Errorf("Clock drift seems unreasonably high: %d ns", drift)
	}
}

func TestDetectCPUScaling(t *testing.T) {
	scaling := detectCPUScaling()

	// CPU scaling factor should be at least 1.0
	if scaling < 1.0 {
		t.Errorf("CPU scaling factor should be at least 1.0, got %.4f", scaling)
	}

	// Should be reasonable (not more than 2.0 for normal systems)
	if scaling > 3.0 {
		t.Logf("Warning: CPU scaling factor is high: %.4f", scaling)
	}
}

func TestResultString(t *testing.T) {
	result := &Result{
		Name:                      "TestBenchmark",
		Iterations:                100,
		Mean:                      1000 * time.Nanosecond,
		Median:                    950 * time.Nanosecond,
		StdDev:                    100 * time.Nanosecond,
		Variance:                  10000,
		Min:                       800 * time.Nanosecond,
		Max:                       1200 * time.Nanosecond,
		ClockDriftCorrection:      50,
		CPUScalingFactor:          1.05,
		WarmupIterationsDiscarded: 10,
	}

	result.ConfidenceInterval95.Lower = 900 * time.Nanosecond
	result.ConfidenceInterval95.Upper = 1100 * time.Nanosecond
	result.ConfidenceInterval99.Lower = 850 * time.Nanosecond
	result.ConfidenceInterval99.Upper = 1150 * time.Nanosecond

	str := result.String()

	if str == "" {
		t.Error("Result string should not be empty")
	}

	// Check that the string contains key information
	if len(str) < 100 {
		t.Error("Result string seems too short")
	}
}

func TestRunMultiple(t *testing.T) {
	benchmarks := []*Benchmark{
		New("Benchmark1", func() { time.Sleep(1 * time.Microsecond) }).WithConfig(&Config{
			MinIterations:     10,
			MaxIterations:     50,
			MinDuration:       20 * time.Millisecond,
			WarmupIterations:  2,
			CorrectClockDrift: true,
			DetectCPUScaling:  false,
		}),
		New("Benchmark2", func() { time.Sleep(2 * time.Microsecond) }).WithConfig(&Config{
			MinIterations:     10,
			MaxIterations:     50,
			MinDuration:       20 * time.Millisecond,
			WarmupIterations:  2,
			CorrectClockDrift: true,
			DetectCPUScaling:  false,
		}),
	}

	results, err := RunMultiple(benchmarks)

	if err != nil {
		t.Fatalf("RunMultiple failed: %v", err)
	}

	if len(results) != 2 {
		t.Errorf("Expected 2 results, got %d", len(results))
	}

	if results[0].Name != "Benchmark1" {
		t.Errorf("Expected first result name 'Benchmark1', got '%s'", results[0].Name)
	}

	if results[1].Name != "Benchmark2" {
		t.Errorf("Expected second result name 'Benchmark2', got '%s'", results[1].Name)
	}
}

func TestCompare(t *testing.T) {
	r1 := &Result{
		Name: "Benchmark1",
		Mean: 1000 * time.Nanosecond,
	}

	r2 := &Result{
		Name: "Benchmark2",
		Mean: 1200 * time.Nanosecond,
	}

	comparison := Compare(r1, r2)

	if comparison == "" {
		t.Error("Comparison string should not be empty")
	}

	// Should indicate that r2 is slower
	if len(comparison) < 10 {
		t.Error("Comparison string seems too short")
	}
}

func TestWithConfig(t *testing.T) {
	fn := func() { time.Sleep(1 * time.Microsecond) }
	customCfg := &Config{
		MinIterations:     50,
		MaxIterations:     500,
		MinDuration:       2 * time.Second,
		WarmupIterations:  20,
		CorrectClockDrift: false,
		DetectCPUScaling:  false,
	}

	b := New("TestBenchmark", fn).WithConfig(customCfg)

	if b.Config != customCfg {
		t.Error("Config was not set correctly")
	}

	if b.Config.MinIterations != 50 {
		t.Errorf("Expected MinIterations 50, got %d", b.Config.MinIterations)
	}
}

// Benchmark using standard Go testing
func BenchmarkBenchclock(b *testing.B) {
	fn := func() {
		// Simple operation
		sum := 0
		for i := 0; i < 100; i++ {
			sum += i
		}
	}

	cfg := &Config{
		MinIterations:     50,
		MaxIterations:     1000,
		MinDuration:       100 * time.Millisecond,
		WarmupIterations:  5,
		CorrectClockDrift: true,
		DetectCPUScaling:  true,
	}

	bench := New("BenchmarkTest", fn).WithConfig(cfg)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := bench.Run()
		if err != nil {
			b.Fatal(err)
		}
	}
}