github-mirror/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell.git synced 2024-12-12 08:33:45 +08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
53961c7759
fish-shell/tests/checks/math.fish

375 lines
7.6 KiB
Fish
Raw Normal View History

Extended & human-friendly keys See the changelog additions for user-visible changes. Since we enable/disable terminal protocols whenever we pass terminal ownership, tests can no longer run in parallel on the same terminal. For the same reason, readline shortcuts in the gdb REPL will not work anymore. As a remedy, use gdbserver, or lobby for CSI u support in libreadline. Add sleep to some tests, otherwise they fall (both in CI and locally). There are two weird failures on FreeBSD remaining, disable them for now https://github.com/fish-shell/fish-shell/pull/10359/checks?check_run_id=23330096362 Design and implementation borrows heavily from Kakoune. In future, we should try to implement more of the kitty progressive enhancements. Closes #10359
2024-03-30 23:10:12 +08:00
#RUN: %fish %s | %filter-ctrlseqs
Skip some tests on OpenBSD sigint2 would hang (probably because of different semantics in signal delivery?) wcstod isn't implemented correctly, so math can't do hex numbers. OpenBSD only passes the filename as argv[0] and doesn't give us another feature I know of, so status fish-path can't work.
2021-06-25 02:07:54 +08:00
# OpenBSD doesn't do hex numbers in str/wcstod (like C99 requires).
# So let's skip this.
#REQUIRES: test "$(uname)" != OpenBSD
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
# Validate basic expressions
math 3 / 2
# CHECK: 1.5
math 10/6
# CHECK: 1.666667
math -s0 10 / 6
# CHECK: 1
math 'floor(10 / 6)'
# CHECK: 1
math -s3 10/6
# CHECK: 1.667
math '10 % 6'
# CHECK: 4
math -s0 '10 % 6'
# CHECK: 4
math '23 % 7'
# CHECK: 2
math --scale=6 '5 / 3 * 0.3'
# CHECK: 0.5
math --scale=max '5 / 3'
# CHECK: 1.666666666666667
math "7^2"
# CHECK: 49
math -1 + 1
# CHECK: 0
math '-2 * -2'
# CHECK: 4
math 5 \* -2
# CHECK: -10
math -- -4 / 2
# CHECK: -2
math -- '-4 * 2'
# CHECK: -8
Add max and min math functions
2021-03-28 23:58:41 +08:00
# Validate max and min
math 'max(1,2)'
math 'min(1,2)'
# CHECK: 2
# CHECK: 1
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
# Validate some rounding functions
Run fish_indent on all our fish scripts It's now good enough to do so. We don't allow grid-alignment: ```fish complete -c foo -s b -l barnanana -a '(something)' complete -c foo -s z -a '(something)' ``` becomes ```fish complete -c foo -s b -l barnanana -a '(something)' complete -c foo -s z -a '(something)' ``` It's just more trouble than it is worth. The one part I'd change: We align and/or'd parts of an if-condition with the in-block code: ```fish if true and false dosomething end ``` becomes ```fish if true and false dosomething end ``` but it's not used terribly much and if we ever fix it we can just reindent.
2020-01-14 03:34:22 +08:00
math 'round(3/2)'
math 'floor(3/2)'
math 'ceil(3/2)'
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
# CHECK: 2
# CHECK: 1
# CHECK: 2
Run fish_indent on all our fish scripts It's now good enough to do so. We don't allow grid-alignment: ```fish complete -c foo -s b -l barnanana -a '(something)' complete -c foo -s z -a '(something)' ``` becomes ```fish complete -c foo -s b -l barnanana -a '(something)' complete -c foo -s z -a '(something)' ``` It's just more trouble than it is worth. The one part I'd change: We align and/or'd parts of an if-condition with the in-block code: ```fish if true and false dosomething end ``` becomes ```fish if true and false dosomething end ``` but it's not used terribly much and if we ever fix it we can just reindent.
2020-01-14 03:34:22 +08:00
math 'round(-3/2)'
math 'floor(-3/2)'
math 'ceil(-3/2)'
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
# CHECK: -2
# CHECK: -2
# CHECK: -1
# Validate some integral computations
math 1
math 10
math 100
math 1000
# CHECK: 1
# CHECK: 10
# CHECK: 100
# CHECK: 1000
math '10^15'
math '-10^14'
math '-10^15'
# CHECK: 1000000000000000
# CHECK: 100000000000000
# CHECK: -1000000000000000
Fixes #6280 : Added right associativity to 'pow' function
2019-11-09 13:54:33 +08:00
math 3^0.5^2
math -2^2
# CHECK: 1.316074
# CHECK: 4
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
math -s0 '1.0 / 2.0'
math -s0 '3.0 / 2.0'
math -s0 '10^15 / 2.0'
# CHECK: 0
# CHECK: 1
# CHECK: 500000000000000
# Validate how variables in an expression are handled
math $x + 1
set x 1
math $x + 1
set x 3
set y 1.5
math "-$x * $y"
math -s0 "-$x * $y"
# CHECK: 1
# CHECK: 2
# CHECK: -4.5
# CHECK: -4
# Validate math error reporting
# NOTE: The leading whitespace for the carets here is ignored
# by littlecheck.
not math '2 - '
# CHECKERR: math: Error: Too few arguments
# CHECKERR: '2 - '
# CHECKERR: ^
not math 'ncr(1)'
# CHECKERR: math: Error: Too few arguments
# CHECKERR: 'ncr(1)'
# CHECKERR: ^
math: Don't override errors with "unexpected token" As always, we want to give the most specific error we can. Fixes #7508
2020-11-26 19:35:56 +08:00
Fix error for vararg functions with zero arguments
2022-09-09 02:45:20 +08:00
math "min()"
# CHECKERR: math: Error: Too few arguments
# CHECKERR: 'min()'
# CHECKERR: ^
Add max and min math functions
2021-03-28 23:58:41 +08:00
# There is no "blah" function.
not math 'blah()'
math: Don't override errors with "unexpected token" As always, we want to give the most specific error we can. Fixes #7508
2020-11-26 19:35:56 +08:00
# CHECKERR: math: Error: Unknown function
Add max and min math functions
2021-03-28 23:58:41 +08:00
# CHECKERR: 'blah()'
math: Add error length Like we now do for syntax errors, this marks the extent of the error. Currently for unknown functions only, would be cool for division too
2022-09-08 23:54:45 +08:00
# CHECKERR: ^~~^
math: Don't override errors with "unexpected token" As always, we want to give the most specific error we can. Fixes #7508
2020-11-26 19:35:56 +08:00
math n + 4
# CHECKERR: math: Error: Unknown function
# CHECKERR: 'n + 4'
# CHECKERR: ^
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
not math 'sin()'
# CHECKERR: math: Error: Too few arguments
# CHECKERR: 'sin()'
# CHECKERR: ^
not math '2 + 2 4'
math: For two adjacent numbers, complain about missing operator Simply a nicer error message.
2021-12-01 23:55:19 +08:00
# CHECKERR: math: Error: Missing operator
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
# CHECKERR: '2 + 2 4'
math: Report missing operators between the tokens This affects the caret position. In an expression like 123 456 we previously reported: 123 456 ^ missing operator Now we do: 123 456 ^ missing operator We do it on the first space, which should be acceptable. (no need for a changelog entry, we have already ignored #8511)
2021-12-30 20:26:44 +08:00
# This regex to check whitespace - the error appears between the second 2 and the 4!
# (right after the 2)
# CHECKERR: {{^}} ^
math: Add length to missing operator error
2022-09-09 00:45:41 +08:00
printf '<%s>\n' (math '2 + 2 4' 2>&1)
# CHECK: <math: Error: Missing operator>
# CHECK: <'2 + 2 4'>
# CHECK: < ^~~~~^>
tinyexpr: report errors for extra args in parens correctly. Usages like `math (1 1)` should report too many arguments, same as `math 1 1`. Check for these cases and add tests. Fixes #8511
2021-12-01 20:38:42 +08:00
not math '(1 2)'
math: For two adjacent numbers, complain about missing operator Simply a nicer error message.
2021-12-01 23:55:19 +08:00
# CHECKERR: math: Error: Missing operator
tinyexpr: report errors for extra args in parens correctly. Usages like `math (1 1)` should report too many arguments, same as `math 1 1`. Check for these cases and add tests. Fixes #8511
2021-12-01 20:38:42 +08:00
# CHECKERR: '(1 2)'
math: For two adjacent numbers, complain about missing operator Simply a nicer error message.
2021-12-01 23:55:19 +08:00
# CHECKERR: ^
tinyexpr: report errors for extra args in parens correctly. Usages like `math (1 1)` should report too many arguments, same as `math 1 1`. Check for these cases and add tests. Fixes #8511
2021-12-01 20:38:42 +08:00
not math '(1 pi)'
math: For two adjacent numbers, complain about missing operator Simply a nicer error message.
2021-12-01 23:55:19 +08:00
# CHECKERR: math: Error: Missing operator
tinyexpr: report errors for extra args in parens correctly. Usages like `math (1 1)` should report too many arguments, same as `math 1 1`. Check for these cases and add tests. Fixes #8511
2021-12-01 20:38:42 +08:00
# CHECKERR: '(1 pi)'
math: For two adjacent numbers, complain about missing operator Simply a nicer error message.
2021-12-01 23:55:19 +08:00
# CHECKERR: ^
tinyexpr: report errors for extra args in parens correctly. Usages like `math (1 1)` should report too many arguments, same as `math 1 1`. Check for these cases and add tests. Fixes #8511
2021-12-01 20:38:42 +08:00
not math '(1 pow 1,2)'
Fix expected outcome in test The reported error is now different, so the test is updated accordingly.
2022-01-13 06:27:17 +08:00
# CHECKERR: math: Error: Missing operator
tinyexpr: report errors for extra args in parens correctly. Usages like `math (1 1)` should report too many arguments, same as `math 1 1`. Check for these cases and add tests. Fixes #8511
2021-12-01 20:38:42 +08:00
# CHECKERR: '(1 pow 1,2)'
Fix expected outcome in test The reported error is now different, so the test is updated accordingly.
2022-01-13 06:27:17 +08:00
# CHECKERR: ^
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
not math
Update tests for changed error output
2021-11-04 13:52:17 +08:00
# CHECKERR: math: expected >= 1 arguments; got 0
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
not math -s 12
Update tests for changed error output
2021-11-04 13:52:17 +08:00
# CHECKERR: math: expected >= 1 arguments; got 0
# XXX FIXME these two should be just "missing argument" errors, the count is not helpful
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
not math 2^999999
# CHECKERR: math: Error: Result is infinite
# CHECKERR: '2^999999'
Add some additional tests for builtin math This fills some gaps in our error message test coverage.
2023-08-06 02:54:39 +08:00
not math 'sqrt(-1)'
# CHECKERR: math: Error: Result is not a number
# CHECKERR: 'sqrt(-1)'
math 'sqrt(-0)'
# CHECK: -0
not math 2^53 + 1
# CHECKERR: math: Error: Result magnitude is too large
# CHECKERR: '2^53 + 1'
not math -2^53 - 1
# CHECKERR: math: Error: Result magnitude is too large
# CHECKERR: '-2^53 - 1'
math: Give a proper error for division by zero This errored out *later* because the result was infinite or NaN, but it didn't actually stop evaluation. I'm not sure if there is a way to get floating point math to turn an infinity back into something that doesn't depend on a literal infinity, but division by zero conceptually isn't a thing we can support. There's entire branches of maths dedicated to figuring out what dividing by "basically zero" means and we don't have to get into it.
2022-09-08 22:50:18 +08:00
printf '<%s>\n' (not math 1 / 0 2>&1)
# CHECK: <math: Error: Division by zero>
# CHECK: <'1 / 0'>
# CHECK: < ^>
printf '<%s>\n' (math 1 % 0 - 5 2>&1)
# CHECK: <math: Error: Division by zero>
# CHECK: <'1 % 0 - 5'>
# CHECK: < ^>
Test division by zero with min This would actually return any finite argument before!
2022-09-09 03:32:09 +08:00
printf '<%s>\n' (math min 1 / 0, 5 2>&1)
# CHECK: <math: Error: Division by zero>
# CHECK: <'min 1 / 0, 5'>
# CHECK: < ^>
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
# Validate "x" as multiplier
math 0x2 # Hex
math 5 x 4
math 2x 4
math 2 x4 # ERROR
math: Complain about unknown *function*, not *variable* We removed variables from tinyexpr, so we shouldn't use that error.
2020-01-31 04:46:22 +08:00
# CHECKERR: math: Error: Unknown function
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
# CHECKERR: '2 x4'
math: Add error length Like we now do for syntax errors, this marks the extent of the error. Currently for unknown functions only, would be cool for division too
2022-09-08 23:54:45 +08:00
# CHECKERR: ^^
Port math test to littlecheck This shows one bit where not trimming whitespace would make sense.
2019-06-27 01:03:04 +08:00
math 0x 3
# CHECK: 2
# CHECK: 20
# CHECK: 8
# CHECK: 0
math: Print special error for logical operators Until now, something like `math '7 = 2'` would complain about a "missing" operator. Now we print an error about logical operators not being supported and point the user towards `test`. Fixes #6096
2019-11-01 15:40:56 +08:00
math "42 >= 1337"
# CHECKERR: math: Error: Logical operations are not supported, use `test` instead
# CHECKERR: '42 >= 1337'
# CHECKERR: ^
math: Add bitwise and/or functions Just as `math "bitand(5,3)"` and `math "bitor(6,2)"`. These cast to long long before doing their thing, so they truncate to an integer, producing weird results with floats. That's to be expected because float representation is *very* different, and performing bitwise operations on floats feels quite useless. Fixes #7281.
2020-08-25 22:45:31 +08:00
math "bitand(0xFE, 1)"
# CHECK: 0
math "bitor(0xFE, 1)"
# CHECK: 255
math "bitxor(5, 1)"
# CHECK: 4
math "bitand(5.5, 2)"
# CHECK: 0
math "bitand(5.5, 1)"
# CHECK: 1
math "bitor(37 ^ 5, 255)"
# CHECK: 69343999
math: Actually report closing paren error This was typically overridden by "too many/few arguments", but it's actually incorrect: sin(55 has the correct number of arguments to `sin`, but it's lacking the closing `)`.
2020-10-26 04:28:49 +08:00
math 'log 16'
math: Make function parentheses optional (#7877) * math: Make function parentheses optional It's a bit annoying to use parentheses here because that requires quoting or escaping. This allows the parens to be omitted, so math sin pi is the same as math 'sin(pi)' Function calls have the lowest precedence, so math sin 2 + 6 is the same as math 'sin(2 + 6)' * Add more tests * Add a note to the docs * even moar docs Moar docca * moar tests Call me Nikola Testla
2021-03-30 23:21:28 +08:00
# CHECK: 1.20412
math: Actually report closing paren error This was typically overridden by "too many/few arguments", but it's actually incorrect: sin(55 has the correct number of arguments to `sin`, but it's lacking the closing `)`.
2020-10-26 04:28:49 +08:00
math 'log(16'
# CHECKERR: math: Error: Missing closing parenthesis
# CHECKERR: 'log(16'
# CHECKERR: ^
math: Add --base option Currently a bit limited, unfortunately printf's `%a` specifier is absolutely unreadable. So we add `hex` and `octal` with `0x` and `0` prefixes respectively, and also take a number but currently only allow 16 and 8. The output is truncated to integer, so scale values other than 0 are invalid and 0 is implied. The docs mention this may change.
2020-10-08 01:03:19 +08:00
tinyexpr: report errors for extra args in parens correctly. Usages like `math (1 1)` should report too many arguments, same as `math 1 1`. Check for these cases and add tests. Fixes #8511
2021-12-01 20:38:42 +08:00
math '(2'
# CHECKERR: math: Error: Missing closing parenthesis
# CHECKERR: '(2'
# CHECKERR: ^
math: Add --base option Currently a bit limited, unfortunately printf's `%a` specifier is absolutely unreadable. So we add `hex` and `octal` with `0x` and `0` prefixes respectively, and also take a number but currently only allow 16 and 8. The output is truncated to integer, so scale values other than 0 are invalid and 0 is implied. The docs mention this may change.
2020-10-08 01:03:19 +08:00
math --base=16 255 / 15
# CHECK: 0x11
math -bhex 16 x 2
# CHECK: 0x20
math --base hex 12 + 0x50
# CHECK: 0x5c
math: Correct printing of negative and large values in octal and hex This fixes printing octal and hex values that are negative or larger than UINT_MAX. Negative values get a leading -, like: > math --base hex -10 -0xa Fixes #8417.
2021-11-08 08:41:47 +08:00
math --base hex 0
# CHECK: 0x0
math --base hex -1
# CHECK: -0x1
math --base hex -15
# CHECK: -0xf
math --base hex 'pow(2,40)'
# CHECK: 0x10000000000
math --base octal 0
# CHECK: 0
math --base octal -1
# CHECK: -01
math --base octal -15
# CHECK: -017
math --base octal 'pow(2,40)'
# CHECK: 020000000000000
math: Add --base option Currently a bit limited, unfortunately printf's `%a` specifier is absolutely unreadable. So we add `hex` and `octal` with `0x` and `0` prefixes respectively, and also take a number but currently only allow 16 and 8. The output is truncated to integer, so scale values other than 0 are invalid and 0 is implied. The docs mention this may change.
2020-10-08 01:03:19 +08:00
math --base octal --scale=0 55
# CHECK: 067
math --base notabase
Update tests for changed error output
2021-11-04 13:52:17 +08:00
# CHECKERR: math: notabase: invalid base value
math: Add --base option Currently a bit limited, unfortunately printf's `%a` specifier is absolutely unreadable. So we add `hex` and `octal` with `0x` and `0` prefixes respectively, and also take a number but currently only allow 16 and 8. The output is truncated to integer, so scale values other than 0 are invalid and 0 is implied. The docs mention this may change.
2020-10-08 01:03:19 +08:00
echo $status
# CHECK: 2
math: Add log2 This was already in the documentation as an example, now it is actually working. Fixes #7734
2021-02-21 15:48:38 +08:00
math 'log2(8)'
# CHECK: 3
math: Make function parentheses optional (#7877) * math: Make function parentheses optional It's a bit annoying to use parentheses here because that requires quoting or escaping. This allows the parens to be omitted, so math sin pi is the same as math 'sin(pi)' Function calls have the lowest precedence, so math sin 2 + 6 is the same as math 'sin(2 + 6)' * Add more tests * Add a note to the docs * even moar docs Moar docca * moar tests Call me Nikola Testla
2021-03-30 23:21:28 +08:00
# same as sin(cos(2 x pi))
math sin cos 2 x pi
# CHECK: 0.841471
# Inner function binds stronger, so this is interpreted as
# pow(sin(3,5))
math pow sin 3, 5
# CHECKERR: math: Error: Too many arguments
# CHECKERR: 'pow sin 3, 5'
# CHECKERR: ^
Add length also for too-many/few-args error
2022-09-09 02:41:02 +08:00
math pow sin 3, 5 + 2
# CHECKERR: math: Error: Too many arguments
# CHECKERR: 'pow sin 3, 5 + 2'
# CHECKERR: ^~~~^
math: Make function parentheses optional (#7877) * math: Make function parentheses optional It's a bit annoying to use parentheses here because that requires quoting or escaping. This allows the parens to be omitted, so math sin pi is the same as math 'sin(pi)' Function calls have the lowest precedence, so math sin 2 + 6 is the same as math 'sin(2 + 6)' * Add more tests * Add a note to the docs * even moar docs Moar docca * moar tests Call me Nikola Testla
2021-03-30 23:21:28 +08:00
math sin pow 3, 5
# CHECK: -0.890009
math pow 2, cos -pi
# CHECK: 0.5
# pow(2*cos(-pi), 2)
# i.e. 2^2
# i.e. 4
math pow 2 x cos'(-pi)', 2
# CHECK: 4
tinyexpr: Check for nan in ncr Turns out this takes ages. Fixes #8170
2021-07-27 00:39:09 +08:00
# This used to take ages, see #8170.
# If this test hangs, that's reintroduced!
math 'ncr(0/0, 1)'
math: Give a proper error for division by zero This errored out *later* because the result was infinite or NaN, but it didn't actually stop evaluation. I'm not sure if there is a way to get floating point math to turn an infinity back into something that doesn't depend on a literal infinity, but division by zero conceptually isn't a thing we can support. There's entire branches of maths dedicated to figuring out what dividing by "basically zero" means and we don't have to get into it.
2022-09-08 22:50:18 +08:00
# CHECKERR: math: Error: Division by zero
tinyexpr: Check for nan in ncr Turns out this takes ages. Fixes #8170
2021-07-27 00:39:09 +08:00
# CHECKERR: 'ncr(0/0, 1)'
math: Give a proper error for division by zero This errored out *later* because the result was infinite or NaN, but it didn't actually stop evaluation. I'm not sure if there is a way to get floating point math to turn an infinity back into something that doesn't depend on a literal infinity, but division by zero conceptually isn't a thing we can support. There's entire branches of maths dedicated to figuring out what dividing by "basically zero" means and we don't have to get into it.
2022-09-08 22:50:18 +08:00
# CHECKERR: ^
Add tests for variadic functions and nested calls
2022-01-20 06:12:30 +08:00
# Variadic functions require at least one argument
math min
# CHECKERR: math: Error: Too few arguments
# CHECKERR: 'min'
# CHECKERR: ^
math min 2
# CHECK: 2
math min 2, 3, 4, 5, -10, 1
# CHECK: -10
# Parentheses are required to disambiguate function call nested in argument list,
# except when the call is the last argument.
math 'min 5, 4, 3, ncr 2, 1, 5'
# CHECKERR: math: Error: Too many arguments
# CHECKERR: 'min 5, 4, 3, ncr 2, 1, 5'
# CHECKERR: {{^}} ^
math 'min 5, 4, 3, ncr(2, 1), 5'
# CHECK: 2
math 'min 5, 4, 3, 5, ncr 2, 1'
# CHECK: 2
# Variadic function consumes all available arguments,
# so it is always the last argument unless parenthesised.
# max(1, 2, min(3, 4, 5))
math 'max 1, 2, min 3, 4, 5'
# CHECK: 3
# max(1, 2, min(3, 4), 5)
math 'max 1, 2, min(3, 4), 5'
# CHECK: 5
Allow underscores as separators in the `math` builtin (#8611) * Implement fish_wcstod_underscores * Add fish_wcstod_underscores unit tests * Switch to using fish_wcstod_underscores in tinyexpr * Add tests for math builtin underscore separator functionality * Add documentation for underscore separators for math builtin * Add a changelog entry for underscore numeric separators
2022-03-13 18:23:35 +08:00
math 0_1
# CHECK: 1
math 0x0_A
# CHECK: 10
math 1_000 + 2_000
# CHECK: 3000
math 1_0_0_0
# CHECK: 1000
math 0_0.5_0 + 0_1.0_0
# CHECK: 1.5
math 2e0_0_2
# CHECK: 200
math -0_0.5_0_0E0_0_3
# CHECK: -500
math 20e-0_1
# CHECK: 2
math 0x0_2.0_0_0P0_2
# CHECK: 8
math -0x8p-0_3
# CHECK: -1
Fix read_blocked This caused math to assert out because it never wrote into the buffer. Now, presumably it wrote somewhere but I don't know where, so fixing this seems like a good idea. Fixes #9735.
2023-04-17 23:27:39 +08:00
echo 5 + 6 | math
# CHECK: 11
math: Add tests for args via stdin and argv This reads stdin and ignores argv, which is certainly a choice. Leaving it this way for now, and possibly discussing later.
2023-08-20 17:19:52 +08:00
# Historical: If we have arguments on stdin and argv,
# the former takes precedence and the latter is ignored entirely.
echo 7 + 6 | math 2 + 2
# CHECK: 13
# It isn't checked at all.
echo 7 + 8 | math not an expression
# CHECK: 15
tinyexpr: Check for wcstod errors This would otherwise unwrap() an Err and crash.
2023-08-25 22:15:52 +08:00
math (string repeat -n 1000 1) 2>| string shorten -m50 --char=""
# CHECK: math: Error: Number is too large
# CHECK: '1111111111111111111111111111111111111111111111111
# CHECK: ^
math 0x0_2.0P-0x3
# CHECKERR: math: Error: Unknown function
# CHECKERR: '0x0_2.0P-0x3'
# CHECKERR: ^^
math 0x0_2.0P-f
# CHECKERR: math: Error: Unexpected token
# CHECKERR: '0x0_2.0P-f'
# CHECKERR: ^
Reference in New Issue Copy Permalink