elvish/pkg/eval/builtin_fn_num_test.go
Qi Xiao 34b115d7af Bump prog.DeprecationLevel to 19.
Remove use of float64 in tests, except for one that tests that it is deprecated.
2023-02-27 00:00:12 +00:00

366 lines
10 KiB
Go

package eval_test
import (
"math"
"math/big"
"math/rand"
"strings"
"testing"
"time"
"unsafe"
. "src.elv.sh/pkg/eval"
"src.elv.sh/pkg/eval/errs"
"src.elv.sh/pkg/eval/vals"
. "src.elv.sh/pkg/eval/evaltest"
)
const (
zeros = "0000000000000000000"
// Values that exceed the range of int64, used for testing bigint.
z = "1" + zeros + "0"
z1 = "1" + zeros + "1" // z+1
z2 = "1" + zeros + "2" // z+2
z3 = "1" + zeros + "3" // z+3
zz = "2" + zeros + "0" // 2z
zz1 = "2" + zeros + "1" // 2z+1
zz2 = "2" + zeros + "2" // 2z+2
zz3 = "2" + zeros + "3" // 2z+3
)
func TestNum(t *testing.T) {
Test(t,
That("num 1").Puts(1),
That("num "+z).Puts(bigInt(z)),
That("num 1/2").Puts(big.NewRat(1, 2)),
That("num 0.1").Puts(0.1),
That("num (num 1)").Puts(1),
)
}
func TestExactNum(t *testing.T) {
Test(t,
That("exact-num 1").Puts(1),
That("exact-num 0.125").Puts(big.NewRat(1, 8)),
That("exact-num inf").Throws(errs.BadValue{
What: "argument here", Valid: "finite float", Actual: "+Inf"}),
)
}
func TestInexactNum(t *testing.T) {
Test(t,
That("inexact-num 1").Puts(1.0),
That("inexact-num 1.0").Puts(1.0),
That("inexact-num (num 1)").Puts(1.0),
That("inexact-num (num 1.0)").Puts(1.0),
)
}
func TestFloat64(t *testing.T) {
Test(t,
That("float64 1").Puts(1.0).PrintsStderrWith("deprecated"),
)
}
func TestNumCmp(t *testing.T) {
Test(t,
// int
That("< 1 2 3").Puts(true),
That("< 1 3 2").Puts(false),
// bigint
That("< "+args(z1, z2, z3)).Puts(true),
That("< "+args(z1, z3, z2)).Puts(false),
// bigint and int
That("< "+args("1", z1)).Puts(true),
// bigrat
That("< 1/4 1/3 1/2").Puts(true),
That("< 1/4 1/2 1/3").Puts(false),
// bigrat, bigint and int
That("< "+args("1/2", "1", z1)).Puts(true),
That("< "+args("1/2", z1, "1")).Puts(false),
// float64
That("< 1.0 2.0 3.0").Puts(true),
That("< 1.0 3.0 2.0").Puts(false),
// float64, bigrat and int
That("< 1.0 3/2 2").Puts(true),
That("< 1.0 2 3/2").Puts(false),
// Mixing of types not tested for commands below; they share the same
// code path as <.
// int
That("<= 1 1 2").Puts(true),
That("<= 1 2 1").Puts(false),
// bigint
That("<= "+args(z1, z1, z2)).Puts(true),
That("<= "+args(z1, z2, z1)).Puts(false),
// bigrat
That("<= 1/3 1/3 1/2").Puts(true),
That("<= 1/3 1/2 1/1").Puts(true),
// float64
That("<= 1.0 1.0 2.0").Puts(true),
That("<= 1.0 2.0 1.0").Puts(false),
// int
That("== 1 1 1").Puts(true),
That("== 1 2 1").Puts(false),
// bigint
That("== "+args(z1, z1, z1)).Puts(true),
That("== "+args(z1, z2, z1)).Puts(false),
// bigrat
That("== 1/2 1/2 1/2").Puts(true),
That("== 1/2 1/3 1/2").Puts(false),
// float64
That("== 1.0 1.0 1.0").Puts(true),
That("== 1.0 2.0 1.0").Puts(false),
// int
That("!= 1 2 1").Puts(true),
That("!= 1 1 2").Puts(false),
// bigint
That("!= "+args(z1, z2, z1)).Puts(true),
That("!= "+args(z1, z1, z2)).Puts(false),
// bigrat
That("!= 1/2 1/3 1/2").Puts(true),
That("!= 1/2 1/2 1/3").Puts(false),
// float64
That("!= 1.0 2.0 1.0").Puts(true),
That("!= 1.0 1.0 2.0").Puts(false),
// int
That("> 3 2 1").Puts(true),
That("> 3 1 2").Puts(false),
// bigint
That("> "+args(z3, z2, z1)).Puts(true),
That("> "+args(z3, z1, z2)).Puts(false),
// bigrat
That("> 1/2 1/3 1/4").Puts(true),
That("> 1/2 1/4 1/3").Puts(false),
// float64
That("> 3.0 2.0 1.0").Puts(true),
That("> 3.0 1.0 2.0").Puts(false),
// int
That(">= 3 3 2").Puts(true),
That(">= 3 2 3").Puts(false),
// bigint
That(">= "+args(z3, z3, z2)).Puts(true),
That(">= "+args(z3, z2, z3)).Puts(false),
// bigrat
That(">= 1/2 1/2 1/3").Puts(true),
That(">= 1/2 1/3 1/2").Puts(false),
// float64
That(">= 3.0 3.0 2.0").Puts(true),
That(">= 3.0 2.0 3.0").Puts(false),
)
}
func TestArithmeticCommands(t *testing.T) {
Test(t,
// No argument
That("+").Puts(0),
// int
That("+ 233100 233").Puts(233333),
// bigint
That("+ "+args(z, z1)).Puts(bigInt(zz1)),
// bigint and int
That("+ 1 2 "+z).Puts(bigInt(z3)),
// bigrat
That("+ 1/2 1/3 1/4").Puts(big.NewRat(13, 12)),
// bigrat, bigint and int
That("+ 1/2 1/2 1 "+z).Puts(bigInt(z2)),
// float64
That("+ 0.5 0.25 1.0").Puts(1.75),
// float64 and other types
That("+ 0.5 1/4 1").Puts(1.75),
// Mixing of types not tested for commands below; they share the same
// code path as +.
That("-").Throws(ErrorWithType(errs.ArityMismatch{})),
// One argument - negation
That("- 233").Puts(-233),
That("- "+z).Puts(bigInt("-"+z)),
That("- 1/2").Puts(big.NewRat(-1, 2)),
That("- 1.0").Puts(-1.0),
// int
That("- 20 10 2").Puts(8),
// bigint
That("- "+args(zz3, z1)).Puts(bigInt(z2)),
// bigrat
That("- 1/2 1/3").Puts(big.NewRat(1, 6)),
// float64
That("- 2.0 1.0 0.5").Puts(0.5),
// No argument
That("*").Puts(1),
// int
That("* 2 7 4").Puts(56),
// bigint
That("* 2 "+z1).Puts(bigInt(zz2)),
// bigrat
That("* 1/2 1/3").Puts(big.NewRat(1, 6)),
// float64
That("* 2.0 0.5 1.75").Puts(1.75),
// 0 * non-infinity
That("* 0 1/2 1.0").Puts(0),
// 0 * infinity
That("* 0 +Inf").Puts(math.NaN()),
// One argument - inversion
That("/ 2").Puts(big.NewRat(1, 2)),
That("/ "+z).Puts(bigRat("1/"+z)),
That("/ 2.0").Puts(0.5),
// int
That("/ 233333 353").Puts(661),
That("/ 3 4 2").Puts(big.NewRat(3, 8)),
// bigint
That("/ "+args(zz, z)).Puts(2),
That("/ "+args(zz, "2")).Puts(bigInt(z)),
That("/ "+args(z1, z)).Puts(bigRat(z1+"/"+z)),
// float64
That("/ 1.0 2.0 4.0").Puts(0.125),
// 0 / non-zero
That("/ 0 1/2 0.1").Puts(0),
// anything / 0
That("/ 0 0").Throws(ErrDivideByZero, "/ 0 0"),
That("/ 1 0").Throws(ErrDivideByZero, "/ 1 0"),
That("/ 1.0 0").Throws(ErrDivideByZero, "/ 1.0 0"),
That("% 23 7").Puts(2),
That("% 1 0").Throws(ErrDivideByZero, "% 1 0"),
)
}
func TestRandint(t *testing.T) {
Test(t,
That("randint 1 2").Puts(1),
That("randint 1").Puts(0),
That("var i = (randint 10 100); and (<= 10 $i) (< $i 100)").Puts(true),
That("var i = (randint 10); and (<= 0 $i) (< $i 10)").Puts(true),
That("randint 2 1").Throws(
errs.BadValue{What: "high value", Valid: "larger than 2", Actual: "1"},
"randint 2 1"),
That("randint").Throws(ErrorWithType(errs.ArityMismatch{}), "randint"),
That("randint 1 2 3").Throws(ErrorWithType(errs.ArityMismatch{}), "randint 1 2 3"),
)
}
func TestRandSeed(t *testing.T) {
// Reseed to make other RNG-dependent tests non-deterministic
defer rand.Seed(time.Now().UTC().UnixNano())
Test(t,
// Observe that the effect of -randseed is making randint deterministic
That("fn f { -randseed 0; randint 10 }; eq (f) (f)").Puts(true),
)
}
var (
maxInt = 1<<((unsafe.Sizeof(0)*8)-1) - 1
minInt = -maxInt - 1
maxDenseIntInFloat = float64(1 << 53)
)
func TestRange(t *testing.T) {
Test(t,
// Basic argument sanity checks.
That("range").Throws(ErrorWithType(errs.ArityMismatch{})),
That("range 0 1 2").Throws(ErrorWithType(errs.ArityMismatch{})),
// Int count up.
That("range 3").Puts(0, 1, 2),
That("range 1 3").Puts(1, 2),
// Int count down.
That("range -1 10 &step=3").Puts(-1, 2, 5, 8),
That("range 3 -3").Puts(3, 2, 1, 0, -1, -2),
// Near maxInt or minInt.
That("range "+args(maxInt-2, maxInt)).Puts(maxInt-2, maxInt-1),
That("range "+args(maxInt, maxInt-2)).Puts(maxInt, maxInt-1),
That("range "+args(minInt, minInt+2)).Puts(minInt, minInt+1),
That("range "+args(minInt+2, minInt)).Puts(minInt+2, minInt+1),
// Invalid step given the "start" and "end" values of the range.
That("range &step=-1 1").
Throws(errs.BadValue{What: "step", Valid: "positive", Actual: "-1"}),
That("range &step=1 1 0").
Throws(errs.BadValue{What: "step", Valid: "negative", Actual: "1"}),
thatOutputErrorIsBubbled("range 2"),
// Big int count up.
That("range "+z+" "+z3).Puts(bigInt(z), bigInt(z1), bigInt(z2)),
That("range "+z+" "+z3+" &step=2").Puts(bigInt(z), bigInt(z2)),
// Big int count down.
That("range "+z3+" "+z).Puts(bigInt(z3), bigInt(z2), bigInt(z1)),
That("range "+z3+" "+z+" &step=-2").Puts(bigInt(z3), bigInt(z1)),
// Invalid big int step.
That("range &step=-"+z+" 10").
Throws(errs.BadValue{What: "step", Valid: "positive", Actual: "-" + z}),
That("range &step="+z+" 10 0").
Throws(errs.BadValue{What: "step", Valid: "negative", Actual: z}),
thatOutputErrorIsBubbled("range "+z+" "+z1),
// Rational count up.
That("range 23/10").Puts(0, 1, 2),
That("range 1/10 23/10").Puts(
big.NewRat(1, 10), big.NewRat(11, 10), big.NewRat(21, 10)),
That("range 23/10 1/10").Puts(
big.NewRat(23, 10), big.NewRat(13, 10), big.NewRat(3, 10)),
That("range 1/10 9/10 &step=3/10").Puts(
big.NewRat(1, 10), big.NewRat(4, 10), big.NewRat(7, 10)),
// Rational count down.
That("range 9/10 0/10 &step=-3/10").Puts(
big.NewRat(9, 10), big.NewRat(6, 10), big.NewRat(3, 10)),
// Invalid rational step.
That("range &step=-1/2 10").
Throws(errs.BadValue{What: "step", Valid: "positive", Actual: "-1/2"}),
That("range &step=1/2 10 0").
Throws(errs.BadValue{What: "step", Valid: "negative", Actual: "1/2"}),
thatOutputErrorIsBubbled("range 1/2 3/2"),
// Float64 count up.
That("range 1.2").Puts(0.0, 1.0),
That("range &step=0.5 1 3").Puts(1.0, 1.5, 2.0, 2.5),
// Float64 count down.
That("range 1.2 -1.2").Puts(1.2, Approximately{F: 0.2}, Approximately{F: -0.8}),
That("range &step=-0.5 3 1").Puts(3.0, 2.5, 2.0, 1.5),
// Near maxDenseIntInFloat.
That("range "+args(maxDenseIntInFloat-2, "+inf")).
Puts(maxDenseIntInFloat-2, maxDenseIntInFloat-1, maxDenseIntInFloat),
That("range "+args(maxDenseIntInFloat, maxDenseIntInFloat-2)).
Puts(maxDenseIntInFloat, maxDenseIntInFloat-1),
// Invalid float64 step.
That("range &step=-0.5 10").
Throws(errs.BadValue{What: "step", Valid: "positive", Actual: "-0.5"}),
That("range &step=0.5 10 0").
Throws(errs.BadValue{What: "step", Valid: "negative", Actual: "0.5"}),
thatOutputErrorIsBubbled("range 1.2"),
)
}
func bigInt(s string) *big.Int {
z, ok := new(big.Int).SetString(s, 0)
if !ok {
panic("cannot parse as big int: " + s)
}
return z
}
func bigRat(s string) *big.Rat {
z, ok := new(big.Rat).SetString(s)
if !ok {
panic("cannot parse as big rat: " + s)
}
return z
}
func args(vs ...any) string {
s := make([]string, len(vs))
for i, v := range vs {
s[i] = vals.ToString(v)
}
return strings.Join(s, " ")
}