324ea0ca92
- baseline/store_test.go: Add tests for CheckResourceAnomalies, formatAnomalyDescription, formatRatio, GetAllAnomalies, floatToStr (67.9% -> 92.2%) - memory/incidents_test.go: Add tests for RecordAlertUnacknowledged, RecordRunbook, ListIncidentsByResource, FormatForAlert, FormatForResource, FormatForPatrol (66.8% -> 81.1%) - intelligence_test.go: Add tests for SetStateProvider, FormatGlobalContext, RecordLearning, severityOrder, CheckBaselinesForResource with baselines (61.4% -> 63.1%)
578 lines
16 KiB
Go
578 lines
16 KiB
Go
package baseline
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestLearn_Basic(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Create 50 data points with mean ~50 and some variance
|
|
points := make([]MetricPoint, 50)
|
|
now := time.Now()
|
|
for i := 0; i < 50; i++ {
|
|
points[i] = MetricPoint{
|
|
Value: 50 + float64(i%10) - 5, // Values from 45-54
|
|
Timestamp: now.Add(-time.Duration(50-i) * time.Minute),
|
|
}
|
|
}
|
|
|
|
err := store.Learn("test-vm", "vm", "cpu", points)
|
|
if err != nil {
|
|
t.Fatalf("Learn failed: %v", err)
|
|
}
|
|
|
|
baseline, ok := store.GetBaseline("test-vm", "cpu")
|
|
if !ok {
|
|
t.Fatal("Baseline not found after learning")
|
|
}
|
|
|
|
// Check mean is around 50
|
|
if math.Abs(baseline.Mean-50) > 1 {
|
|
t.Errorf("Expected mean ~50, got %f", baseline.Mean)
|
|
}
|
|
|
|
// Check stddev is reasonable (should be ~3 for our data)
|
|
if baseline.StdDev < 1 || baseline.StdDev > 5 {
|
|
t.Errorf("Expected stddev ~3, got %f", baseline.StdDev)
|
|
}
|
|
|
|
if baseline.SampleCount != 50 {
|
|
t.Errorf("Expected 50 samples, got %d", baseline.SampleCount)
|
|
}
|
|
}
|
|
|
|
func TestLearn_InsufficientData(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 50})
|
|
|
|
// Only 10 points, not enough
|
|
points := make([]MetricPoint, 10)
|
|
for i := 0; i < 10; i++ {
|
|
points[i] = MetricPoint{Value: float64(i)}
|
|
}
|
|
|
|
err := store.Learn("test-vm", "vm", "cpu", points)
|
|
if err != nil {
|
|
t.Fatalf("Learn should not error on insufficient data: %v", err)
|
|
}
|
|
|
|
_, ok := store.GetBaseline("test-vm", "cpu")
|
|
if ok {
|
|
t.Error("Should not have baseline with insufficient data")
|
|
}
|
|
}
|
|
|
|
func TestIsAnomaly(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Create stable data around 50 with low variance
|
|
points := make([]MetricPoint, 100)
|
|
for i := 0; i < 100; i++ {
|
|
points[i] = MetricPoint{
|
|
Value: 50 + float64(i%3) - 1, // Values 49, 50, 51
|
|
}
|
|
}
|
|
|
|
store.Learn("test-vm", "vm", "cpu", points)
|
|
|
|
// Test normal value
|
|
isAnomaly, zScore := store.IsAnomaly("test-vm", "cpu", 50)
|
|
if isAnomaly {
|
|
t.Errorf("50 should not be anomaly, zScore=%f", zScore)
|
|
}
|
|
|
|
// Test slightly high - with stddev ~0.82, 51 is within 2 std devs
|
|
isAnomaly, zScore = store.IsAnomaly("test-vm", "cpu", 51)
|
|
if isAnomaly {
|
|
t.Errorf("51 should not be anomaly with this variance, zScore=%f", zScore)
|
|
}
|
|
|
|
// Test very high (should be anomaly)
|
|
isAnomaly, zScore = store.IsAnomaly("test-vm", "cpu", 60)
|
|
if !isAnomaly {
|
|
t.Errorf("60 should be anomaly, zScore=%f", zScore)
|
|
}
|
|
|
|
// Test very low (should be anomaly)
|
|
isAnomaly, zScore = store.IsAnomaly("test-vm", "cpu", 40)
|
|
if !isAnomaly {
|
|
t.Errorf("40 should be anomaly, zScore=%f", zScore)
|
|
}
|
|
}
|
|
|
|
func TestCheckAnomaly_Severity(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Create very stable data with known statistics
|
|
// Mean = 50, StdDev = 1
|
|
points := make([]MetricPoint, 100)
|
|
for i := 0; i < 100; i++ {
|
|
// Alternate between 49, 50, 51 for stddev ~1
|
|
points[i] = MetricPoint{Value: 50 + float64(i%3) - 1}
|
|
}
|
|
|
|
store.Learn("test-vm", "vm", "cpu", points)
|
|
baseline, _ := store.GetBaseline("test-vm", "cpu")
|
|
|
|
testCases := []struct {
|
|
value float64
|
|
expectedSeverity AnomalySeverity
|
|
}{
|
|
{50, AnomalyNone}, // Mean
|
|
{50 + baseline.StdDev*1.5, AnomalyNone}, // 1.5 std devs - normal
|
|
{50 + baseline.StdDev*2.2, AnomalyLow}, // 2.2 std devs
|
|
{50 + baseline.StdDev*2.7, AnomalyMedium}, // 2.7 std devs
|
|
{50 + baseline.StdDev*3.5, AnomalyHigh}, // 3.5 std devs
|
|
{50 + baseline.StdDev*4.5, AnomalyCritical}, // 4.5 std devs
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
severity, _, _ := store.CheckAnomaly("test-vm", "cpu", tc.value)
|
|
if severity != tc.expectedSeverity {
|
|
t.Errorf("Value %f: expected severity %s, got %s", tc.value, tc.expectedSeverity, severity)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetResourceBaseline(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Learn multiple metrics
|
|
cpuPoints := make([]MetricPoint, 50)
|
|
memPoints := make([]MetricPoint, 50)
|
|
for i := 0; i < 50; i++ {
|
|
cpuPoints[i] = MetricPoint{Value: 30}
|
|
memPoints[i] = MetricPoint{Value: 70}
|
|
}
|
|
|
|
store.Learn("test-vm", "vm", "cpu", cpuPoints)
|
|
store.Learn("test-vm", "vm", "memory", memPoints)
|
|
|
|
rb, ok := store.GetResourceBaseline("test-vm")
|
|
if !ok {
|
|
t.Fatal("Resource baseline not found")
|
|
}
|
|
|
|
if rb.ResourceType != "vm" {
|
|
t.Errorf("Expected resource type 'vm', got '%s'", rb.ResourceType)
|
|
}
|
|
|
|
if len(rb.Metrics) != 2 {
|
|
t.Errorf("Expected 2 metrics, got %d", len(rb.Metrics))
|
|
}
|
|
|
|
if rb.Metrics["cpu"] == nil {
|
|
t.Error("CPU metric baseline missing")
|
|
}
|
|
|
|
if rb.Metrics["memory"] == nil {
|
|
t.Error("Memory metric baseline missing")
|
|
}
|
|
}
|
|
|
|
func TestPercentiles(t *testing.T) {
|
|
values := []float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
|
|
percentiles := computePercentiles(values)
|
|
|
|
// P50 should be ~5.5 for 1-10
|
|
if percentiles[50] < 5 || percentiles[50] > 6 {
|
|
t.Errorf("P50 should be ~5.5, got %f", percentiles[50])
|
|
}
|
|
|
|
// P5 should be close to 1
|
|
if percentiles[5] < 1 || percentiles[5] > 2 {
|
|
t.Errorf("P5 should be ~1, got %f", percentiles[5])
|
|
}
|
|
|
|
// P95 should be close to 10
|
|
if percentiles[95] < 9 || percentiles[95] > 10 {
|
|
t.Errorf("P95 should be ~10, got %f", percentiles[95])
|
|
}
|
|
}
|
|
|
|
func TestComputeStats(t *testing.T) {
|
|
// Test mean and stddev with known values
|
|
values := []float64{2, 4, 4, 4, 5, 5, 7, 9} // Mean = 5, Stddev = 2 (sample)
|
|
|
|
mean := computeMean(values)
|
|
if mean != 5 {
|
|
t.Errorf("Expected mean 5, got %f", mean)
|
|
}
|
|
|
|
stddev := computeStdDev(values)
|
|
// Sample stddev of [2,4,4,4,5,5,7,9] is approximately 2.14, not exactly 2
|
|
if math.Abs(stddev-2.14) > 0.1 {
|
|
t.Errorf("Expected stddev ~2.14, got %f", stddev)
|
|
}
|
|
}
|
|
|
|
func TestCalculateTrend_InsufficientData(t *testing.T) {
|
|
// Less than 5 samples should return nil
|
|
samples := []float64{10, 20, 30}
|
|
result := CalculateTrend(samples, 30)
|
|
if result != nil {
|
|
t.Error("Expected nil for insufficient data")
|
|
}
|
|
}
|
|
|
|
func TestCalculateTrend_IncreasingTrend(t *testing.T) {
|
|
// Simulate hourly samples increasing by 1% per hour
|
|
// 24 samples = 1 day, so 24% increase per day
|
|
samples := make([]float64, 48) // 2 days of data
|
|
for i := 0; i < 48; i++ {
|
|
samples[i] = 50 + float64(i) // 50, 51, 52, ...
|
|
}
|
|
|
|
result := CalculateTrend(samples, 97) // Currently at 97%
|
|
if result == nil {
|
|
t.Fatal("Expected non-nil result for increasing trend")
|
|
}
|
|
|
|
// Should be trending toward full
|
|
if result.DaysToFull <= 0 {
|
|
t.Errorf("Expected positive DaysToFull for increasing trend, got %d", result.DaysToFull)
|
|
}
|
|
|
|
// With 24% increase per day and 3% remaining, should be full very soon
|
|
if result.Severity != "critical" && result.Severity != "warning" {
|
|
t.Errorf("Expected critical or warning severity, got %s", result.Severity)
|
|
}
|
|
}
|
|
|
|
func TestCalculateTrend_DecreasingTrend(t *testing.T) {
|
|
// Simulate hourly samples decreasing
|
|
samples := make([]float64, 48)
|
|
for i := 0; i < 48; i++ {
|
|
samples[i] = 80 - float64(i)*0.5 // 80, 79.5, 79, ...
|
|
}
|
|
|
|
result := CalculateTrend(samples, 56)
|
|
if result == nil {
|
|
t.Fatal("Expected non-nil result for decreasing trend")
|
|
}
|
|
|
|
// Should indicate decreasing (DaysToFull = -1)
|
|
if result.DaysToFull != -1 {
|
|
t.Errorf("Expected DaysToFull=-1 for decreasing trend, got %d", result.DaysToFull)
|
|
}
|
|
|
|
if result.Severity != "info" {
|
|
t.Errorf("Expected info severity for decreasing trend, got %s", result.Severity)
|
|
}
|
|
}
|
|
|
|
func TestCalculateTrend_StableTrend(t *testing.T) {
|
|
// Simulate stable usage around 50%
|
|
samples := make([]float64, 48)
|
|
for i := 0; i < 48; i++ {
|
|
samples[i] = 50 + float64(i%3-1)*0.01 // Tiny fluctuations
|
|
}
|
|
|
|
result := CalculateTrend(samples, 50)
|
|
if result == nil {
|
|
t.Fatal("Expected non-nil result for stable trend")
|
|
}
|
|
|
|
// Should indicate stable (DaysToFull = -1)
|
|
if result.DaysToFull != -1 {
|
|
t.Errorf("Expected DaysToFull=-1 for stable trend, got %d", result.DaysToFull)
|
|
}
|
|
}
|
|
|
|
func TestFormatDays(t *testing.T) {
|
|
testCases := []struct {
|
|
days int
|
|
expected string
|
|
}{
|
|
{0, "now"},
|
|
{1, "1 day"},
|
|
{5, "5 days"},
|
|
{7, "~1 week"},
|
|
{14, "~2 weeks"},
|
|
{30, "~1 month"},
|
|
{60, "~2 months"},
|
|
{400, ">1 year"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
result := formatDays(tc.days)
|
|
if result != tc.expected {
|
|
t.Errorf("formatDays(%d): expected %q, got %q", tc.days, tc.expected, result)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCheckResourceAnomalies_Disk(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Create stable data with mean ~60% disk usage
|
|
points := make([]MetricPoint, 100)
|
|
for i := 0; i < 100; i++ {
|
|
points[i] = MetricPoint{Value: 60 + float64(i%5) - 2} // 58-62
|
|
}
|
|
store.Learn("test-vm", "vm", "disk", points)
|
|
|
|
// Test: disk above 85% should be reported
|
|
metrics := map[string]float64{"disk": 90}
|
|
anomalies := store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) == 0 {
|
|
t.Error("Expected disk anomaly to be reported for 90% usage")
|
|
}
|
|
|
|
// Test: disk increase >15 points from baseline should be reported
|
|
metrics = map[string]float64{"disk": 80}
|
|
anomalies = store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) == 0 {
|
|
t.Error("Expected disk anomaly to be reported for 20 point increase from baseline")
|
|
}
|
|
|
|
// Test: disk at baseline should not be reported (no significant deviation)
|
|
metrics = map[string]float64{"disk": 60}
|
|
anomalies = store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) != 0 {
|
|
t.Errorf("Expected no anomaly for disk at baseline, got %d", len(anomalies))
|
|
}
|
|
}
|
|
|
|
func TestCheckResourceAnomalies_CPU(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Create stable data with mean ~20% CPU usage
|
|
points := make([]MetricPoint, 100)
|
|
for i := 0; i < 100; i++ {
|
|
points[i] = MetricPoint{Value: 20 + float64(i%3) - 1} // 19-21
|
|
}
|
|
store.Learn("test-vm", "vm", "cpu", points)
|
|
|
|
// Test: CPU at 80% (above 70% and >2x baseline) should be reported
|
|
metrics := map[string]float64{"cpu": 80}
|
|
anomalies := store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) == 0 {
|
|
t.Error("Expected CPU anomaly to be reported for 80% (>70% and 4x baseline)")
|
|
}
|
|
|
|
// Test: CPU at 50% should NOT be reported (below 70% threshold)
|
|
metrics = map[string]float64{"cpu": 50}
|
|
anomalies = store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) != 0 {
|
|
t.Errorf("Expected no anomaly for CPU at 50%%, got %d", len(anomalies))
|
|
}
|
|
|
|
// Test: CPU at 20% (baseline) should not be reported
|
|
metrics = map[string]float64{"cpu": 20}
|
|
anomalies = store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) != 0 {
|
|
t.Errorf("Expected no anomaly for CPU at baseline, got %d", len(anomalies))
|
|
}
|
|
}
|
|
|
|
func TestCheckResourceAnomalies_Memory(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Create stable data with mean ~40% memory usage
|
|
points := make([]MetricPoint, 100)
|
|
for i := 0; i < 100; i++ {
|
|
points[i] = MetricPoint{Value: 40 + float64(i%3) - 1} // 39-41
|
|
}
|
|
store.Learn("test-vm", "vm", "memory", points)
|
|
|
|
// Test: Memory at 85% should be reported (above 80% threshold)
|
|
metrics := map[string]float64{"memory": 85}
|
|
anomalies := store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) == 0 {
|
|
t.Error("Expected memory anomaly to be reported for 85% (above 80%)")
|
|
}
|
|
|
|
// Test: Memory at 70% with 1.75x baseline should be reported (>1.5x and >60%)
|
|
metrics = map[string]float64{"memory": 70}
|
|
anomalies = store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) == 0 {
|
|
t.Error("Expected memory anomaly to be reported for 70% (1.75x baseline, >60%)")
|
|
}
|
|
|
|
// Test: Memory at 50% should NOT be reported (not >1.5x enough or >80%)
|
|
metrics = map[string]float64{"memory": 50}
|
|
anomalies = store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) != 0 {
|
|
t.Errorf("Expected no anomaly for memory at 50%%, got %d", len(anomalies))
|
|
}
|
|
}
|
|
|
|
func TestCheckResourceAnomalies_OtherMetrics(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Create stable network data with mean ~100
|
|
points := make([]MetricPoint, 100)
|
|
for i := 0; i < 100; i++ {
|
|
points[i] = MetricPoint{Value: 100 + float64(i%5) - 2} // 98-102
|
|
}
|
|
store.Learn("test-vm", "vm", "network_in", points)
|
|
|
|
// Test: network_in at 2x baseline should be reported
|
|
metrics := map[string]float64{"network_in": 250}
|
|
anomalies := store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) == 0 {
|
|
t.Error("Expected network anomaly to be reported for 2.5x baseline")
|
|
}
|
|
|
|
// Test: network_in at 0.3x baseline should be reported (below 0.5x)
|
|
metrics = map[string]float64{"network_in": 30}
|
|
anomalies = store.CheckResourceAnomalies("test-vm", metrics)
|
|
if len(anomalies) == 0 {
|
|
t.Error("Expected network anomaly to be reported for 0.3x baseline")
|
|
}
|
|
}
|
|
|
|
func TestCheckResourceAnomalies_NoBaseline(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// No baselines learned - should return empty
|
|
metrics := map[string]float64{"cpu": 90, "memory": 85}
|
|
anomalies := store.CheckResourceAnomalies("unknown-vm", metrics)
|
|
if len(anomalies) != 0 {
|
|
t.Errorf("Expected no anomalies for unknown resource, got %d", len(anomalies))
|
|
}
|
|
}
|
|
|
|
func TestFormatRatio(t *testing.T) {
|
|
testCases := []struct {
|
|
ratio float64
|
|
expected string
|
|
}{
|
|
{0.005, "near zero"},
|
|
{0.5, "significantly below"},
|
|
{0.8, "significantly below"},
|
|
{1.2, "slightly above"},
|
|
{1.4, "slightly above"},
|
|
{1.7, "1.5x"},
|
|
{2.5, "2x"},
|
|
{4.0, "3x"},
|
|
{6.0, "~6x"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
result := formatRatio(tc.ratio)
|
|
if result != tc.expected {
|
|
t.Errorf("formatRatio(%f): expected %q, got %q", tc.ratio, tc.expected, result)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFormatAnomalyDescription(t *testing.T) {
|
|
testCases := []struct {
|
|
metric string
|
|
ratio float64
|
|
direction string
|
|
severity AnomalySeverity
|
|
contains string
|
|
}{
|
|
{"cpu", 2.0, "above", AnomalyCritical, "Critical anomaly: CPU usage"},
|
|
{"memory", 1.5, "above", AnomalyHigh, "High anomaly: Memory usage"},
|
|
{"disk", 1.8, "above", AnomalyMedium, "Moderate anomaly: Disk usage"},
|
|
{"network_in", 2.0, "below", AnomalyLow, "Minor anomaly: Network inbound"},
|
|
{"network_out", 1.5, "above", AnomalyNone, "Network outbound"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
result := formatAnomalyDescription(tc.metric, tc.ratio, tc.direction, tc.severity)
|
|
if !contains(result, tc.contains) {
|
|
t.Errorf("formatAnomalyDescription(%s, %f, %s, %s): expected to contain %q, got %q",
|
|
tc.metric, tc.ratio, tc.direction, tc.severity, tc.contains, result)
|
|
}
|
|
}
|
|
}
|
|
|
|
func contains(s, substr string) bool {
|
|
return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsHelper(s, substr))
|
|
}
|
|
|
|
func containsHelper(s, substr string) bool {
|
|
for i := 0; i <= len(s)-len(substr); i++ {
|
|
if s[i:i+len(substr)] == substr {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func TestGetAllAnomalies(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
// Learn baselines for multiple resources
|
|
points := make([]MetricPoint, 100)
|
|
for i := 0; i < 100; i++ {
|
|
points[i] = MetricPoint{Value: 20 + float64(i%3) - 1}
|
|
}
|
|
store.Learn("vm-1", "vm", "cpu", points)
|
|
store.Learn("vm-2", "vm", "cpu", points)
|
|
|
|
diskPoints := make([]MetricPoint, 100)
|
|
for i := 0; i < 100; i++ {
|
|
diskPoints[i] = MetricPoint{Value: 50 + float64(i%3) - 1}
|
|
}
|
|
store.Learn("vm-1", "vm", "disk", diskPoints)
|
|
|
|
// Create a metrics provider that returns anomalous values
|
|
metricsProvider := func(resourceID string) map[string]float64 {
|
|
switch resourceID {
|
|
case "vm-1":
|
|
return map[string]float64{"cpu": 80, "disk": 90} // CPU 4x baseline, disk high
|
|
case "vm-2":
|
|
return map[string]float64{"cpu": 25} // Normal
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
anomalies := store.GetAllAnomalies(metricsProvider)
|
|
|
|
// Should have anomalies for vm-1 (cpu 4x baseline + disk at 90%)
|
|
if len(anomalies) < 1 {
|
|
t.Errorf("Expected at least 1 anomaly, got %d", len(anomalies))
|
|
}
|
|
|
|
// vm-2 should not have anomalies
|
|
for _, a := range anomalies {
|
|
if a.ResourceID == "vm-2" {
|
|
t.Errorf("Did not expect anomaly for vm-2 with normal metrics")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGetAllAnomalies_EmptyStore(t *testing.T) {
|
|
store := NewStore(StoreConfig{MinSamples: 10})
|
|
|
|
metricsProvider := func(resourceID string) map[string]float64 {
|
|
return map[string]float64{"cpu": 90}
|
|
}
|
|
|
|
anomalies := store.GetAllAnomalies(metricsProvider)
|
|
if len(anomalies) != 0 {
|
|
t.Errorf("Expected no anomalies from empty store, got %d", len(anomalies))
|
|
}
|
|
}
|
|
|
|
func TestFloatToStr(t *testing.T) {
|
|
testCases := []struct {
|
|
value float64
|
|
precision int
|
|
expected string
|
|
}{
|
|
{1.5, 1, "1.5"},
|
|
{2.0, 1, "2"},
|
|
{1.05, 2, "1.05"},
|
|
{3.0, 2, "3"},
|
|
{0.5, 1, "0.5"},
|
|
{0.05, 2, "0.05"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
result := floatToStr(tc.value, tc.precision)
|
|
if result != tc.expected {
|
|
t.Errorf("floatToStr(%f, %d): expected %q, got %q", tc.value, tc.precision, tc.expected, result)
|
|
}
|
|
}
|
|
}
|
|
|