Mirrors/coreutils
2
0
Fork 0
mirror of https://github.com/uutils/coreutils synced 2024-12-14 23:32:39 +00:00
Code Issues Projects Releases Packages Wiki Activity
coreutils/tests/by-util/test_seq.rs

696 lines
16 KiB
Rust
Raw Normal View History

seq: return UResult from uumain() function (#2784)
2021-12-29 14:20:17 +00:00
// spell-checker:ignore lmnop xlmnop
tests ~ fix 'edition=2018' module import errors - ref: <https://users.rust-lang.org/t/imports-can-only-refer-to-extern-crate-names/24388> @@ <https://archive.is/iCaXp>
2020-05-25 17:05:26 +00:00
use crate::common::util::*;
seq: use stdout.write_all() instead of print!() Change from using `print!()` to using `stdout.write_all()` in order to allow the main function to handle broken pipe errors gracefully.
2021-09-10 02:02:31 +00:00
use std::io::Read;
rewrite tests for cargo compat, decoupled directory, output handling
2015-11-16 05:25:01 +00:00
seq: Adds testing for hexadecimal integer parsing
2021-10-02 15:46:09 +00:00
#[test]
seq: Adds testing for large hex numbers
2021-10-03 16:50:49 +00:00
fn test_hex_rejects_sign_after_identifier() {
seq: Adds testing for hexadecimal integer parsing
2021-10-02 15:46:09 +00:00
new_ucmd!()
.args(&["0x-123ABC"])
.fails()
.no_stdout()
seq: use BigDecimal to represent floats (#2698) * seq: use BigDecimal to represent floats Use `BigDecimal` to represent arbitrary precision floats in order to prevent numerical precision issues when iterating over a sequence of numbers. This commit makes several changes at once to accomplish this goal. First, it creates a new struct, `PreciseNumber`, that is responsible for storing not only the number itself but also the number of digits (both integer and decimal) needed to display it. This information is collected at the time of parsing the number, which lives in the new `numberparse.rs` module. Second, it uses the `BigDecimal` struct to store arbitrary precision floating point numbers instead of the previous `f64` primitive type. This protects against issues of numerical precision when repeatedly accumulating a very small increment. Third, since neither the `BigDecimal` nor `BigInt` types have a representation of infinity, minus infinity, minus zero, or NaN, we add the `ExtendedBigDecimal` and `ExtendedBigInt` enumerations which extend the basic types with these concepts. * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats
2021-11-06 14:44:42 +00:00
.stderr_contains("invalid floating point argument: '0x-123ABC'")
seq: Adds testing for hexadecimal integer parsing
2021-10-02 15:46:09 +00:00
.stderr_contains("for more information.");
new_ucmd!()
.args(&["0x+123ABC"])
.fails()
.no_stdout()
seq: use BigDecimal to represent floats (#2698) * seq: use BigDecimal to represent floats Use `BigDecimal` to represent arbitrary precision floats in order to prevent numerical precision issues when iterating over a sequence of numbers. This commit makes several changes at once to accomplish this goal. First, it creates a new struct, `PreciseNumber`, that is responsible for storing not only the number itself but also the number of digits (both integer and decimal) needed to display it. This information is collected at the time of parsing the number, which lives in the new `numberparse.rs` module. Second, it uses the `BigDecimal` struct to store arbitrary precision floating point numbers instead of the previous `f64` primitive type. This protects against issues of numerical precision when repeatedly accumulating a very small increment. Third, since neither the `BigDecimal` nor `BigInt` types have a representation of infinity, minus infinity, minus zero, or NaN, we add the `ExtendedBigDecimal` and `ExtendedBigInt` enumerations which extend the basic types with these concepts. * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats
2021-11-06 14:44:42 +00:00
.stderr_contains("invalid floating point argument: '0x+123ABC'")
seq: Adds testing for hexadecimal integer parsing
2021-10-02 15:46:09 +00:00
.stderr_contains("for more information.");
new_ucmd!()
.args(&["-0x-123ABC"])
.fails()
.no_stdout()
seq: use BigDecimal to represent floats (#2698) * seq: use BigDecimal to represent floats Use `BigDecimal` to represent arbitrary precision floats in order to prevent numerical precision issues when iterating over a sequence of numbers. This commit makes several changes at once to accomplish this goal. First, it creates a new struct, `PreciseNumber`, that is responsible for storing not only the number itself but also the number of digits (both integer and decimal) needed to display it. This information is collected at the time of parsing the number, which lives in the new `numberparse.rs` module. Second, it uses the `BigDecimal` struct to store arbitrary precision floating point numbers instead of the previous `f64` primitive type. This protects against issues of numerical precision when repeatedly accumulating a very small increment. Third, since neither the `BigDecimal` nor `BigInt` types have a representation of infinity, minus infinity, minus zero, or NaN, we add the `ExtendedBigDecimal` and `ExtendedBigInt` enumerations which extend the basic types with these concepts. * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats
2021-11-06 14:44:42 +00:00
.stderr_contains("invalid floating point argument: '-0x-123ABC'")
seq: Adds testing for hexadecimal integer parsing
2021-10-02 15:46:09 +00:00
.stderr_contains("for more information.");
new_ucmd!()
.args(&["-0x+123ABC"])
.fails()
.no_stdout()
seq: use BigDecimal to represent floats (#2698) * seq: use BigDecimal to represent floats Use `BigDecimal` to represent arbitrary precision floats in order to prevent numerical precision issues when iterating over a sequence of numbers. This commit makes several changes at once to accomplish this goal. First, it creates a new struct, `PreciseNumber`, that is responsible for storing not only the number itself but also the number of digits (both integer and decimal) needed to display it. This information is collected at the time of parsing the number, which lives in the new `numberparse.rs` module. Second, it uses the `BigDecimal` struct to store arbitrary precision floating point numbers instead of the previous `f64` primitive type. This protects against issues of numerical precision when repeatedly accumulating a very small increment. Third, since neither the `BigDecimal` nor `BigInt` types have a representation of infinity, minus infinity, minus zero, or NaN, we add the `ExtendedBigDecimal` and `ExtendedBigInt` enumerations which extend the basic types with these concepts. * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats
2021-11-06 14:44:42 +00:00
.stderr_contains("invalid floating point argument: '-0x+123ABC'")
seq: Adds testing for hexadecimal integer parsing
2021-10-02 15:46:09 +00:00
.stderr_contains("for more information.");
}
#[test]
fn test_hex_lowercase_uppercase() {
new_ucmd!()
.args(&["0xa", "0xA"])
.succeeds()
.stdout_is("10\n");
new_ucmd!()
.args(&["0Xa", "0XA"])
.succeeds()
.stdout_is("10\n");
}
seq: Adds testing for large hex numbers
2021-10-03 16:50:49 +00:00
#[test]
fn test_hex_big_number() {
new_ucmd!()
.args(&[
"0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
"0x100000000000000000000000000000000",
])
.succeeds()
.stdout_is(
"340282366920938463463374607431768211455\n340282366920938463463374607431768211456\n",
);
}
seq: Updates hex parse readability, adds hex test
2021-10-06 01:41:28 +00:00
#[test]
fn test_hex_identifier_in_wrong_place() {
new_ucmd!()
.args(&["1234ABCD0x"])
.fails()
.no_stdout()
seq: use BigDecimal to represent floats (#2698) * seq: use BigDecimal to represent floats Use `BigDecimal` to represent arbitrary precision floats in order to prevent numerical precision issues when iterating over a sequence of numbers. This commit makes several changes at once to accomplish this goal. First, it creates a new struct, `PreciseNumber`, that is responsible for storing not only the number itself but also the number of digits (both integer and decimal) needed to display it. This information is collected at the time of parsing the number, which lives in the new `numberparse.rs` module. Second, it uses the `BigDecimal` struct to store arbitrary precision floating point numbers instead of the previous `f64` primitive type. This protects against issues of numerical precision when repeatedly accumulating a very small increment. Third, since neither the `BigDecimal` nor `BigInt` types have a representation of infinity, minus infinity, minus zero, or NaN, we add the `ExtendedBigDecimal` and `ExtendedBigInt` enumerations which extend the basic types with these concepts. * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats
2021-11-06 14:44:42 +00:00
.stderr_contains("invalid floating point argument: '1234ABCD0x'")
seq: Updates hex parse readability, adds hex test
2021-10-06 01:41:28 +00:00
.stderr_contains("for more information.");
}
seq: reject NaN arguments Move the validation logic to an argument validator.
2021-06-01 16:12:37 +00:00
#[test]
fn test_rejects_nan() {
tests: use CmdResult::usage_error
2021-11-09 20:23:41 +00:00
new_ucmd!()
.arg("NaN")
.fails()
.usage_error("invalid 'not-a-number' argument: 'NaN'");
seq: reject NaN arguments Move the validation logic to an argument validator.
2021-06-01 16:12:37 +00:00
}
#[test]
fn test_rejects_non_floats() {
tests: use CmdResult::usage_error
2021-11-09 20:23:41 +00:00
new_ucmd!()
.arg("foo")
.fails()
.usage_error("invalid floating point argument: 'foo'");
seq: reject NaN arguments Move the validation logic to an argument validator.
2021-06-01 16:12:37 +00:00
}
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
#[test]
fn test_invalid_float() {
new_ucmd!()
.args(&["1e2.3"])
.fails()
.no_stdout()
.stderr_contains("invalid floating point argument: '1e2.3'")
.stderr_contains("for more information.");
new_ucmd!()
.args(&["1e2.3", "2"])
.fails()
.no_stdout()
.stderr_contains("invalid floating point argument: '1e2.3'")
.stderr_contains("for more information.");
new_ucmd!()
.args(&["1", "1e2.3"])
.fails()
.no_stdout()
.stderr_contains("invalid floating point argument: '1e2.3'")
.stderr_contains("for more information.");
new_ucmd!()
.args(&["1e2.3", "2", "3"])
.fails()
.no_stdout()
.stderr_contains("invalid floating point argument: '1e2.3'")
.stderr_contains("for more information.");
new_ucmd!()
.args(&["1", "1e2.3", "3"])
.fails()
.no_stdout()
.stderr_contains("invalid floating point argument: '1e2.3'")
.stderr_contains("for more information.");
new_ucmd!()
.args(&["1", "2", "1e2.3"])
.fails()
.no_stdout()
.stderr_contains("invalid floating point argument: '1e2.3'")
.stderr_contains("for more information.");
}
#[test]
fn test_width_invalid_float() {
new_ucmd!()
.args(&["-w", "1e2.3"])
.fails()
.no_stdout()
.stderr_contains("invalid floating point argument: '1e2.3'")
.stderr_contains("for more information.");
}
seq: implement integer sequences If we notice that we can represent all arguments as BigInts, take a different code path. Just like GNU seq this means we can print an infinite amount of numbers in this case.
2021-05-31 18:49:02 +00:00
// ---- Tests for the big integer based path ----
rewrite tests for cargo compat, decoupled directory, output handling
2015-11-16 05:25:01 +00:00
#[test]
fn test_count_up() {
tests: remove helper function boilerplate via macros
2016-08-23 11:52:43 +00:00
new_ucmd!()
rustfmt the tests
2020-04-13 18:36:03 +00:00
.args(&["10"])
.run()
.stdout_is("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n");
rewrite tests for cargo compat, decoupled directory, output handling
2015-11-16 05:25:01 +00:00
}
#[test]
fn test_count_down() {
tests: remove helper function boilerplate via macros
2016-08-23 11:52:43 +00:00
new_ucmd!()
rustfmt the tests
2020-04-13 18:36:03 +00:00
.args(&["--", "5", "-1", "1"])
.run()
.stdout_is("5\n4\n3\n2\n1\n");
fix formatting fr test_seq
2021-01-02 09:14:18 +00:00
new_ucmd!()
bug(seq) - Allow 'seq 6 -1 0' Was failing with ``` Found argument '-1' which wasn't expected, or isn't valid in this context ``` otherwise
2020-12-19 10:17:41 +00:00
.args(&["5", "-1", "1"])
.run()
.stdout_is("5\n4\n3\n2\n1\n");
rewrite tests for cargo compat, decoupled directory, output handling
2015-11-16 05:25:01 +00:00
}
#[test]
fn test_separator_and_terminator() {
tests: remove helper function boilerplate via macros
2016-08-23 11:52:43 +00:00
new_ucmd!()
rustfmt the tests
2020-04-13 18:36:03 +00:00
.args(&["-s", ",", "-t", "!", "2", "6"])
.run()
.stdout_is("2,3,4,5,6!");
seq: change default value for -t and remove dubious escape sequences GNU seq does not support -t, but always outputs a newline at the end. Therefore, our default for -t should be \n. Also removes support for escape sequences (interpreting a literal "\n" as a newline). This is not what GNU seq is doing, and unexpected.
2021-05-31 19:19:19 +00:00
new_ucmd!()
.args(&["-s", ",", "2", "6"])
.run()
.stdout_is("2,3,4,5,6\n");
new_ucmd!()
.args(&["-s", "\n", "2", "6"])
.run()
.stdout_is("2\n3\n4\n5\n6\n");
new_ucmd!()
.args(&["-s", "\\n", "2", "6"])
.run()
.stdout_is("2\\n3\\n4\\n5\\n6\n");
rewrite tests for cargo compat, decoupled directory, output handling
2015-11-16 05:25:01 +00:00
}
#[test]
fn test_equalize_widths() {
tests: remove helper function boilerplate via macros
2016-08-23 11:52:43 +00:00
new_ucmd!()
rustfmt the tests
2020-04-13 18:36:03 +00:00
.args(&["-w", "5", "10"])
.run()
.stdout_is("05\n06\n07\n08\n09\n10\n");
rewrite tests for cargo compat, decoupled directory, output handling
2015-11-16 05:25:01 +00:00
}
test(seq): add a test to check that we don't accept more than 3 args
2020-10-20 20:35:19 +00:00
#[test]
fn test_seq_wrong_arg() {
new_ucmd!().args(&["-w", "5", "10", "33", "32"]).fails();
}
Do not allow seq to run with an increment of zero
2021-02-18 21:10:53 +00:00
#[test]
fn test_zero_step() {
new_ucmd!().args(&["10", "0", "32"]).fails();
}
seq: implement integer sequences If we notice that we can represent all arguments as BigInts, take a different code path. Just like GNU seq this means we can print an infinite amount of numbers in this case.
2021-05-31 18:49:02 +00:00
#[test]
fn test_big_numbers() {
new_ucmd!()
.args(&[
"1000000000000000000000000000",
"1000000000000000000000000001",
])
.succeeds()
.stdout_only("1000000000000000000000000000\n1000000000000000000000000001\n");
}
// ---- Tests for the floating point based path ----
#[test]
fn test_count_up_floats() {
new_ucmd!()
.args(&["10.0"])
.run()
.stdout_is("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n");
}
#[test]
fn test_count_down_floats() {
new_ucmd!()
.args(&["--", "5", "-1.0", "1"])
.run()
.stdout_is("5.0\n4.0\n3.0\n2.0\n1.0\n");
new_ucmd!()
.args(&["5", "-1", "1.0"])
.run()
.stdout_is("5\n4\n3\n2\n1\n");
}
#[test]
fn test_separator_and_terminator_floats() {
new_ucmd!()
.args(&["-s", ",", "-t", "!", "2.0", "6"])
.run()
.stdout_is("2.0,3.0,4.0,5.0,6.0!");
}
#[test]
fn test_equalize_widths_floats() {
new_ucmd!()
.args(&["-w", "5", "10.0"])
.run()
.stdout_is("05\n06\n07\n08\n09\n10\n");
}
#[test]
fn test_seq_wrong_arg_floats() {
new_ucmd!().args(&["-w", "5", "10.0", "33", "32"]).fails();
}
#[test]
fn test_zero_step_floats() {
new_ucmd!().args(&["10.0", "0", "32"]).fails();
}
seq: print negative zero at start of integer seq.
2021-08-27 22:55:02 +00:00
#[test]
fn test_preserve_negative_zero_start() {
new_ucmd!()
.args(&["-0", "1"])
.succeeds()
.stdout_is("-0\n1\n")
.no_stderr();
seq: use print_seq_integers() regardless of last Ensure that the `print_seq_integers()` function is called when the first number and the increment are integers, regardless of the type of the last value specified.
2021-09-17 03:02:02 +00:00
new_ucmd!()
.args(&["-0", "1", "2"])
.succeeds()
.stdout_is("-0\n1\n2\n")
.no_stderr();
new_ucmd!()
.args(&["-0", "1", "2.0"])
.succeeds()
.stdout_is("-0\n1\n2\n")
.no_stderr();
seq: print negative zero at start of integer seq.
2021-08-27 22:55:02 +00:00
}
#[test]
fn test_drop_negative_zero_end() {
new_ucmd!()
.args(&["1", "-1", "-0"])
.succeeds()
.stdout_is("1\n0\n")
.no_stderr();
}
seq: compute width of numbers after parsing Fix a bug in `seq` where the number of characters needed to print the number was computed incorrectly in some cases. This commit changes the computation of the width to be after parsing the number instead of before, in order to accommodate inputs like `1e3`, which requires four digits when printing the number, not three.
2021-08-28 20:28:38 +00:00
#[test]
fn test_width_scientific_notation() {
new_ucmd!()
.args(&["-w", "999", "1e3"])
.succeeds()
.stdout_is("0999\n1000\n")
.no_stderr();
}
#[test]
fn test_width_negative_zero() {
new_ucmd!()
.args(&["-w", "-0", "1"])
.succeeds()
.stdout_is("-0\n01\n")
.no_stderr();
seq: use print_seq_integers() regardless of last Ensure that the `print_seq_integers()` function is called when the first number and the increment are integers, regardless of the type of the last value specified.
2021-09-17 03:02:02 +00:00
new_ucmd!()
.args(&["-w", "-0", "1", "2"])
.succeeds()
.stdout_is("-0\n01\n02\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0", "1", "2.0"])
.succeeds()
.stdout_is("-0\n01\n02\n")
.no_stderr();
}
#[test]
fn test_width_negative_zero_decimal_notation() {
new_ucmd!()
.args(&["-w", "-0.0", "1"])
.succeeds()
.stdout_is("-0.0\n01.0\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.0", "1.0"])
.succeeds()
.stdout_is("-0.0\n01.0\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.0", "1", "2"])
.succeeds()
.stdout_is("-0.0\n01.0\n02.0\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.0", "1", "2.0"])
.succeeds()
.stdout_is("-0.0\n01.0\n02.0\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.0", "1.0", "2"])
.succeeds()
.stdout_is("-0.0\n01.0\n02.0\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.0", "1.0", "2.0"])
.succeeds()
.stdout_is("-0.0\n01.0\n02.0\n")
.no_stderr();
seq: compute width of numbers after parsing Fix a bug in `seq` where the number of characters needed to print the number was computed incorrectly in some cases. This commit changes the computation of the width to be after parsing the number instead of before, in order to accommodate inputs like `1e3`, which requires four digits when printing the number, not three.
2021-08-28 20:28:38 +00:00
}
seq: use stdout.write_all() instead of print!() Change from using `print!()` to using `stdout.write_all()` in order to allow the main function to handle broken pipe errors gracefully.
2021-09-10 02:02:31 +00:00
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
#[test]
fn test_width_negative_zero_scientific_notation() {
new_ucmd!()
.args(&["-w", "-0e0", "1"])
.succeeds()
.stdout_is("-0\n01\n")
.no_stderr();
seq: use print_seq_integers() regardless of last Ensure that the `print_seq_integers()` function is called when the first number and the increment are integers, regardless of the type of the last value specified.
2021-09-17 03:02:02 +00:00
new_ucmd!()
.args(&["-w", "-0e0", "1", "2"])
.succeeds()
.stdout_is("-0\n01\n02\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0e0", "1", "2.0"])
.succeeds()
.stdout_is("-0\n01\n02\n")
.no_stderr();
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
new_ucmd!()
.args(&["-w", "-0e+1", "1"])
.succeeds()
.stdout_is("-00\n001\n")
.no_stderr();
seq: use print_seq_integers() regardless of last Ensure that the `print_seq_integers()` function is called when the first number and the increment are integers, regardless of the type of the last value specified.
2021-09-17 03:02:02 +00:00
new_ucmd!()
.args(&["-w", "-0e+1", "1", "2"])
.succeeds()
.stdout_is("-00\n001\n002\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0e+1", "1", "2.0"])
.succeeds()
.stdout_is("-00\n001\n002\n")
.no_stderr();
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
new_ucmd!()
.args(&["-w", "-0.000e0", "1"])
.succeeds()
.stdout_is("-0.000\n01.000\n")
.no_stderr();
seq: use print_seq_integers() regardless of last Ensure that the `print_seq_integers()` function is called when the first number and the increment are integers, regardless of the type of the last value specified.
2021-09-17 03:02:02 +00:00
new_ucmd!()
.args(&["-w", "-0.000e0", "1", "2"])
.succeeds()
.stdout_is("-0.000\n01.000\n02.000\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.000e0", "1", "2.0"])
.succeeds()
.stdout_is("-0.000\n01.000\n02.000\n")
.no_stderr();
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
new_ucmd!()
.args(&["-w", "-0.000e-2", "1"])
.succeeds()
.stdout_is("-0.00000\n01.00000\n")
.no_stderr();
seq: use print_seq_integers() regardless of last Ensure that the `print_seq_integers()` function is called when the first number and the increment are integers, regardless of the type of the last value specified.
2021-09-17 03:02:02 +00:00
new_ucmd!()
.args(&["-w", "-0.000e-2", "1", "2"])
.succeeds()
.stdout_is("-0.00000\n01.00000\n02.00000\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.000e-2", "1", "2.0"])
.succeeds()
.stdout_is("-0.00000\n01.00000\n02.00000\n")
.no_stderr();
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
new_ucmd!()
.args(&["-w", "-0.000e5", "1"])
.succeeds()
.stdout_is("-000000\n0000001\n")
.no_stderr();
seq: use print_seq_integers() regardless of last Ensure that the `print_seq_integers()` function is called when the first number and the increment are integers, regardless of the type of the last value specified.
2021-09-17 03:02:02 +00:00
new_ucmd!()
.args(&["-w", "-0.000e5", "1", "2"])
.succeeds()
.stdout_is("-000000\n0000001\n0000002\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.000e5", "1", "2.0"])
.succeeds()
.stdout_is("-000000\n0000001\n0000002\n")
.no_stderr();
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
new_ucmd!()
.args(&["-w", "-0.000e5", "1"])
.succeeds()
.stdout_is("-000000\n0000001\n")
.no_stderr();
seq: use print_seq_integers() regardless of last Ensure that the `print_seq_integers()` function is called when the first number and the increment are integers, regardless of the type of the last value specified.
2021-09-17 03:02:02 +00:00
new_ucmd!()
.args(&["-w", "-0.000e5", "1", "2"])
.succeeds()
.stdout_is("-000000\n0000001\n0000002\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.000e5", "1", "2.0"])
.succeeds()
.stdout_is("-000000\n0000001\n0000002\n")
.no_stderr();
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
}
#[test]
fn test_width_decimal_scientific_notation_increment() {
new_ucmd!()
.args(&["-w", ".1", "1e-2", ".11"])
.succeeds()
.stdout_is("0.10\n0.11\n")
.no_stderr();
new_ucmd!()
.args(&["-w", ".0", "1.500e-1", ".2"])
.succeeds()
.stdout_is("0.0000\n0.1500\n")
.no_stderr();
}
/// Test that trailing zeros in the start argument contribute to precision.
#[test]
fn test_width_decimal_scientific_notation_trailing_zeros_start() {
new_ucmd!()
.args(&["-w", ".1000", "1e-2", ".11"])
.succeeds()
.stdout_is("0.1000\n0.1100\n")
.no_stderr();
}
/// Test that trailing zeros in the increment argument contribute to precision.
#[test]
fn test_width_decimal_scientific_notation_trailing_zeros_increment() {
new_ucmd!()
.args(&["-w", "1e-1", "0.0100", ".11"])
.succeeds()
.stdout_is("0.1000\n0.1100\n")
.no_stderr();
}
seq: correct width for certain negative decimals Fix a bug in which a negative decimal input would not be displayed with the correct width in the output. Before this commit, the output was incorrectly $ seq -w -.1 .1 .11 -0.1 0.0 0.1 After this commit, the output is correctly $ seq -w -.1 .1 .11 -0.1 00.0 00.1 The code was failing to take into account that the input decimal "-.1" needs to be displayed with a leading zero, like "-0.1".
2021-10-24 17:44:19 +00:00
#[test]
fn test_width_negative_decimal_notation() {
new_ucmd!()
.args(&["-w", "-.1", ".1", ".11"])
.succeeds()
.stdout_is("-0.1\n00.0\n00.1\n")
.no_stderr();
}
seq: use BigDecimal to represent floats (#2698) * seq: use BigDecimal to represent floats Use `BigDecimal` to represent arbitrary precision floats in order to prevent numerical precision issues when iterating over a sequence of numbers. This commit makes several changes at once to accomplish this goal. First, it creates a new struct, `PreciseNumber`, that is responsible for storing not only the number itself but also the number of digits (both integer and decimal) needed to display it. This information is collected at the time of parsing the number, which lives in the new `numberparse.rs` module. Second, it uses the `BigDecimal` struct to store arbitrary precision floating point numbers instead of the previous `f64` primitive type. This protects against issues of numerical precision when repeatedly accumulating a very small increment. Third, since neither the `BigDecimal` nor `BigInt` types have a representation of infinity, minus infinity, minus zero, or NaN, we add the `ExtendedBigDecimal` and `ExtendedBigInt` enumerations which extend the basic types with these concepts. * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats
2021-11-06 14:44:42 +00:00
#[test]
fn test_width_negative_scientific_notation() {
new_ucmd!()
.args(&["-w", "-1e-3", "1"])
.succeeds()
.stdout_is("-0.001\n00.999\n")
.no_stderr();
seq: correct width for certain negative decimals Fix a bug in which a negative decimal input would not be displayed with the correct width in the output. Before this commit, the output was incorrectly $ seq -w -.1 .1 .11 -0.1 0.0 0.1 After this commit, the output is correctly $ seq -w -.1 .1 .11 -0.1 00.0 00.1 The code was failing to take into account that the input decimal "-.1" needs to be displayed with a leading zero, like "-0.1".
2021-10-24 17:44:19 +00:00
new_ucmd!()
.args(&["-w", "-1.e-3", "1"])
.succeeds()
.stdout_is("-0.001\n00.999\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-1.0e-4", "1"])
.succeeds()
.stdout_is("-0.00010\n00.99990\n")
.no_stderr();
new_ucmd!()
.args(&["-w", "-.1e2", "10", "100"])
.succeeds()
.stdout_is(
"-010
0000
0010
0020
0030
0040
0050
0060
0070
0080
0090
0100
",
)
.no_stderr();
new_ucmd!()
.args(&["-w", "-0.1e2", "10", "100"])
.succeeds()
.stdout_is(
"-010
0000
0010
0020
0030
0040
0050
0060
0070
0080
0090
0100
",
)
.no_stderr();
seq: use BigDecimal to represent floats (#2698) * seq: use BigDecimal to represent floats Use `BigDecimal` to represent arbitrary precision floats in order to prevent numerical precision issues when iterating over a sequence of numbers. This commit makes several changes at once to accomplish this goal. First, it creates a new struct, `PreciseNumber`, that is responsible for storing not only the number itself but also the number of digits (both integer and decimal) needed to display it. This information is collected at the time of parsing the number, which lives in the new `numberparse.rs` module. Second, it uses the `BigDecimal` struct to store arbitrary precision floating point numbers instead of the previous `f64` primitive type. This protects against issues of numerical precision when repeatedly accumulating a very small increment. Third, since neither the `BigDecimal` nor `BigInt` types have a representation of infinity, minus infinity, minus zero, or NaN, we add the `ExtendedBigDecimal` and `ExtendedBigInt` enumerations which extend the basic types with these concepts. * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats
2021-11-06 14:44:42 +00:00
}
seq: compute correct width for scientific notation Change the way `seq` computes the number of digits needed to print a number so that it works for inputs given in scientific notation. Specifically, this commit parses the input string to determine whether it is an integer, a float in decimal notation, or a float in scientific notation, and then computes the number of integral digits and the number of fractional digits based on that. This also supports floating point negative zero, expressed in both decimal and scientific notation.
2021-09-11 16:49:12 +00:00
/// Test that trailing zeros in the end argument do not contribute to width.
#[test]
fn test_width_decimal_scientific_notation_trailing_zeros_end() {
new_ucmd!()
.args(&["-w", "1e-1", "1e-2", ".1100"])
.succeeds()
.stdout_is("0.10\n0.11\n")
.no_stderr();
}
seq: replace loops with a single format string Replace two loops that print leading and trailing 0s when printing a number in fixed-width mode with a single call to `write!()` with the appropriate formatting parameters.
2021-09-14 01:19:49 +00:00
#[test]
fn test_width_floats() {
new_ucmd!()
.args(&["-w", "9.0", "10.0"])
.succeeds()
.stdout_is("09.0\n10.0\n")
.no_stderr();
}
seq: use stdout.write_all() instead of print!() Change from using `print!()` to using `stdout.write_all()` in order to allow the main function to handle broken pipe errors gracefully.
2021-09-10 02:02:31 +00:00
// TODO This is duplicated from `test_yes.rs`; refactor them.
/// Run `seq`, capture some of the output, close the pipe, and verify it.
fn run(args: &[&str], expected: &[u8]) {
let mut cmd = new_ucmd!();
let mut child = cmd.args(args).run_no_wait();
let mut stdout = child.stdout.take().unwrap();
let mut buf = vec![0; expected.len()];
stdout.read_exact(&mut buf).unwrap();
drop(stdout);
assert!(child.wait().unwrap().success());
assert_eq!(buf.as_slice(), expected);
}
#[test]
fn test_neg_inf() {
run(&["--", "-inf", "0"], b"-inf\n-inf\n-inf\n");
}
#[test]
fn test_inf() {
run(&["inf"], b"1\n2\n3\n");
}
seq: trim leading whitespace from inputs
2021-09-12 03:10:13 +00:00
seq: correct fixed-width spacing for inf sequences Pad infinity and negative infinity values with spaces when using the `-w` option to `seq`. This corrects the behavior of `seq` to match that of the GNU version: $ seq -w 1.000 inf inf | head -n 4 1.000 inf inf inf Previously, it incorrectly padded with 0s instead of spaces.
2021-10-06 00:59:51 +00:00
#[test]
fn test_inf_width() {
run(
&["-w", "1.000", "inf", "inf"],
b"1.000\n inf\n inf\n inf\n",
);
}
#[test]
fn test_neg_inf_width() {
run(
&["-w", "1.000", "-inf", "-inf"],
b"1.000\n -inf\n -inf\n -inf\n",
);
}
seq: trim leading whitespace from inputs
2021-09-12 03:10:13 +00:00
#[test]
fn test_ignore_leading_whitespace() {
new_ucmd!()
.arg(" 1")
.succeeds()
.stdout_is("1\n")
.no_stderr();
}
#[test]
fn test_trailing_whitespace_error() {
// In some locales, the GNU error message has curly quotes (‘)
// instead of straight quotes ('). We just test the straight single
// quotes.
new_ucmd!()
.arg("1 ")
.fails()
tests: use CmdResult::usage_error
2021-11-09 20:23:41 +00:00
.usage_error("invalid floating point argument: '1 '");
seq: trim leading whitespace from inputs
2021-09-12 03:10:13 +00:00
}
seq: use BigDecimal to represent floats (#2698) * seq: use BigDecimal to represent floats Use `BigDecimal` to represent arbitrary precision floats in order to prevent numerical precision issues when iterating over a sequence of numbers. This commit makes several changes at once to accomplish this goal. First, it creates a new struct, `PreciseNumber`, that is responsible for storing not only the number itself but also the number of digits (both integer and decimal) needed to display it. This information is collected at the time of parsing the number, which lives in the new `numberparse.rs` module. Second, it uses the `BigDecimal` struct to store arbitrary precision floating point numbers instead of the previous `f64` primitive type. This protects against issues of numerical precision when repeatedly accumulating a very small increment. Third, since neither the `BigDecimal` nor `BigInt` types have a representation of infinity, minus infinity, minus zero, or NaN, we add the `ExtendedBigDecimal` and `ExtendedBigInt` enumerations which extend the basic types with these concepts. * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats * fixup! seq: use BigDecimal to represent floats
2021-11-06 14:44:42 +00:00
#[test]
fn test_negative_zero_int_start_float_increment() {
new_ucmd!()
.args(&["-0", "0.1", "0.1"])
.succeeds()
.stdout_is("-0.0\n0.1\n")
.no_stderr();
}
#[test]
fn test_float_precision_increment() {
new_ucmd!()
.args(&["999", "0.1", "1000.1"])
.succeeds()
.stdout_is(
"999.0
999.1
999.2
999.3
999.4
999.5
999.6
999.7
999.8
999.9
1000.0
1000.1
",
)
.no_stderr();
}
/// Test for floating point precision issues.
#[test]
fn test_negative_increment_decimal() {
new_ucmd!()
.args(&["0.1", "-0.1", "-0.2"])
.succeeds()
.stdout_is("0.1\n0.0\n-0.1\n-0.2\n")
.no_stderr();
}
#[test]
fn test_zero_not_first() {
new_ucmd!()
.args(&["-w", "-0.1", "0.1", "0.1"])
.succeeds()
.stdout_is("-0.1\n00.0\n00.1\n")
.no_stderr();
}
#[test]
fn test_rounding_end() {
new_ucmd!()
.args(&["1", "-1", "0.1"])
.succeeds()
.stdout_is("1\n")
.no_stderr();
}
seq: return UResult from uumain() function (#2784)
2021-12-29 14:20:17 +00:00
#[test]
fn test_parse_error_float() {
new_ucmd!()
.arg("lmnop")
.fails()
.usage_error("invalid floating point argument: 'lmnop'");
}
#[test]
fn test_parse_error_hex() {
new_ucmd!()
.arg("0xlmnop")
.fails()
.usage_error("invalid hexadecimal argument: '0xlmnop'");
}
Reference in a new issue Copy permalink