216 lines
3.9 KiB
Go
216 lines
3.9 KiB
Go
package protocol
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
)
|
|
|
|
func TestCompareFloats(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
a, b float64
|
|
expected int
|
|
}{
|
|
// Basic comparisons
|
|
{
|
|
name: "a less than b",
|
|
a: 1.0,
|
|
b: 2.0,
|
|
expected: -1,
|
|
},
|
|
{
|
|
name: "a greater than b",
|
|
a: 2.0,
|
|
b: 1.0,
|
|
expected: 1,
|
|
},
|
|
{
|
|
name: "a equals b exact",
|
|
a: 1.0,
|
|
b: 1.0,
|
|
expected: 0,
|
|
},
|
|
|
|
// Floating-point precision cases
|
|
{
|
|
name: "famous 0.1 + 0.2 equals 0.3 within tolerance",
|
|
a: 0.1 + 0.2,
|
|
b: 0.3,
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "very close numbers within tolerance",
|
|
a: 1.0000000001,
|
|
b: 1.0000000002,
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "numbers outside tolerance a < b",
|
|
a: 1.0,
|
|
b: 1.0001,
|
|
expected: -1,
|
|
},
|
|
{
|
|
name: "numbers outside tolerance a > b",
|
|
a: 1.0001,
|
|
b: 1.0,
|
|
expected: 1,
|
|
},
|
|
|
|
// Edge cases with very small numbers
|
|
{
|
|
name: "very small numbers equal",
|
|
a: 1e-20,
|
|
b: 1e-20,
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "very small numbers a < b",
|
|
a: 1e-9,
|
|
b: 2e-9,
|
|
expected: -1,
|
|
},
|
|
|
|
// Zero and negative zero
|
|
{
|
|
name: "zero equals zero",
|
|
a: 0.0,
|
|
b: 0.0,
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "zero equals negative zero",
|
|
a: 0.0,
|
|
b: -0.000000000000000000001,
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "zero less than small positive",
|
|
a: 0.0,
|
|
b: 1e-9,
|
|
expected: -1,
|
|
},
|
|
{
|
|
name: "zero greater than small negative",
|
|
a: 0.0,
|
|
b: -1e-9,
|
|
expected: 1,
|
|
},
|
|
|
|
// Negative numbers
|
|
{
|
|
name: "negative numbers a > b",
|
|
a: -1.0,
|
|
b: -2.0,
|
|
expected: 1,
|
|
},
|
|
{
|
|
name: "negative numbers a < b",
|
|
a: -2.0,
|
|
b: -1.0,
|
|
expected: -1,
|
|
},
|
|
{
|
|
name: "negative numbers equal",
|
|
a: -1.0,
|
|
b: -1.0,
|
|
expected: 0,
|
|
},
|
|
|
|
// Mixed signs
|
|
{
|
|
name: "negative less than positive",
|
|
a: -1.0,
|
|
b: 1.0,
|
|
expected: -1,
|
|
},
|
|
{
|
|
name: "positive greater than negative",
|
|
a: 1.0,
|
|
b: -1.0,
|
|
expected: 1,
|
|
},
|
|
|
|
// Special values: NaN
|
|
{
|
|
name: "NaN equals NaN",
|
|
a: math.NaN(),
|
|
b: math.NaN(),
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "NaN less than number",
|
|
a: math.NaN(),
|
|
b: 1.0,
|
|
expected: -1,
|
|
},
|
|
{
|
|
name: "number greater than NaN",
|
|
a: 1.0,
|
|
b: math.NaN(),
|
|
expected: 1,
|
|
},
|
|
|
|
// Special values: Infinity
|
|
{
|
|
name: "positive infinity equals positive infinity",
|
|
a: math.Inf(1),
|
|
b: math.Inf(1),
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "negative infinity equals negative infinity",
|
|
a: math.Inf(-1),
|
|
b: math.Inf(-1),
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "positive infinity greater than negative infinity",
|
|
a: math.Inf(1),
|
|
b: math.Inf(-1),
|
|
expected: 1,
|
|
},
|
|
{
|
|
name: "negative infinity less than positive infinity",
|
|
a: math.Inf(-1),
|
|
b: math.Inf(1),
|
|
expected: -1,
|
|
},
|
|
{
|
|
name: "positive infinity greater than large number",
|
|
a: math.Inf(1),
|
|
b: 1e308,
|
|
expected: 1,
|
|
},
|
|
{
|
|
name: "negative infinity less than small number",
|
|
a: math.Inf(-1),
|
|
b: -1e308,
|
|
expected: -1,
|
|
},
|
|
|
|
// Large numbers
|
|
{
|
|
name: "large numbers equal",
|
|
a: 1e15,
|
|
b: 1e15,
|
|
expected: 0,
|
|
},
|
|
{
|
|
name: "large numbers a < b",
|
|
a: 1e15,
|
|
b: 2e15,
|
|
expected: -1,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result := compareFloats(test.a, test.b)
|
|
if result != test.expected {
|
|
t.Errorf("compareFloats(%g, %g) = %d, want %d", test.a, test.b, result, test.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|