rust/tests/ui/float_cmp.stderr

error: strict comparison of `f32` or `f64`
  --> tests/ui/float_cmp.rs:72:5
   |
LL |     ONE as f64 != 2.0;
   |     ^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE as f64 - 2.0).abs() > error_margin`
   |
   = note: `-D clippy::float-cmp` implied by `-D warnings`
   = help: to override `-D warnings` add `#[allow(clippy::float_cmp)]`

error: strict comparison of `f32` or `f64`
  --> tests/ui/float_cmp.rs:78:5
   |
LL |     x == 1.0;
   |     ^^^^^^^^ help: consider comparing them within some margin of error: `(x - 1.0).abs() < error_margin`

error: strict comparison of `f32` or `f64`
  --> tests/ui/float_cmp.rs:82:5
   |
LL |     twice(x) != twice(ONE as f64);
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(twice(x) - twice(ONE as f64)).abs() > error_margin`

error: strict comparison of `f32` or `f64`
  --> tests/ui/float_cmp.rs:103:5
   |
LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error_margin`

error: strict comparison of `f32` or `f64` arrays
  --> tests/ui/float_cmp.rs:109:5
   |
LL |     a1 == a2;
   |     ^^^^^^^^

error: strict comparison of `f32` or `f64`
  --> tests/ui/float_cmp.rs:111:5
   |
LL |     a1[0] == a2[0];
   |     ^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(a1[0] - a2[0]).abs() < error_margin`

error: aborting due to 6 previous errors
Update stderrs 2020-01-06 00:36:33 -06:00			error: strict comparison of `f32` or `f64`
Update float tests to include `f16` and `f128` 2024-06-18 12:34:49 -05:00			`--> tests/ui/float_cmp.rs:72:5`
rustup and compile-fail -> ui test move 2017-02-07 14:05:30 -06:00			`\|`
Update *.stderr files 2018-12-27 09:57:55 -06:00			`LL \| ONE as f64 != 2.0;`
Merge commit 'e636b88aa180e8cab9e28802aac90adbc984234d' into clippyup 2020-09-24 07:49:22 -05:00			\| ^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE as f64 - 2.0).abs() > error_margin`
rustup and compile-fail -> ui test move 2017-02-07 14:05:30 -06:00			`\|`
bless clippy 2022-09-22 11:04:22 -05:00			= note: `-D clippy::float-cmp` implied by `-D warnings`
Adjust clippy tests with new rustc help suggestion for lints 2023-08-01 07:02:21 -05:00			= help: to override `-D warnings` add `#[allow(clippy::float_cmp)]`
rustup and compile-fail -> ui test move 2017-02-07 14:05:30 -06:00
Update stderrs 2020-01-06 00:36:33 -06:00			error: strict comparison of `f32` or `f64`
Replace incorrect suggested fix for `float_cmp` Using `f32::EPSILON` or `f64::EPSILON` as the floating-point equality comparison error margin is incorrect, yet `float_cmp` has until now recommended this be done. This change fixes the given guidance (both in docs and compiler hints) to not reference these unsuitable constants. Instead, the guidance now clarifies that the scenarios in which an absolute error margin is usable, provides a reference implementation of using a user-defined absolute error margin (as an absolute error margin can only be used-defined and may be different for different comparisons) and references the floating point guide for a reference implementation of relative error based equaltiy comparison for when absolute error margin cannot be used. changelog: Fix guidance of [`float_cmp`] and [`float_cmp_const`] to not incorrectly recommend `f64::EPSILON` as the error margin. Fixes #6816 2024-07-09 02:12:09 -05:00			`--> tests/ui/float_cmp.rs:78:5`
rustup and compile-fail -> ui test move 2017-02-07 14:05:30 -06:00			`\|`
Update *.stderr files 2018-12-27 09:57:55 -06:00			`LL \| x == 1.0;`
Merge commit 'e636b88aa180e8cab9e28802aac90adbc984234d' into clippyup 2020-09-24 07:49:22 -05:00			\| ^^^^^^^^ help: consider comparing them within some margin of error: `(x - 1.0).abs() < error_margin`
rustup and compile-fail -> ui test move 2017-02-07 14:05:30 -06:00
Update stderrs 2020-01-06 00:36:33 -06:00			error: strict comparison of `f32` or `f64`
Replace incorrect suggested fix for `float_cmp` Using `f32::EPSILON` or `f64::EPSILON` as the floating-point equality comparison error margin is incorrect, yet `float_cmp` has until now recommended this be done. This change fixes the given guidance (both in docs and compiler hints) to not reference these unsuitable constants. Instead, the guidance now clarifies that the scenarios in which an absolute error margin is usable, provides a reference implementation of using a user-defined absolute error margin (as an absolute error margin can only be used-defined and may be different for different comparisons) and references the floating point guide for a reference implementation of relative error based equaltiy comparison for when absolute error margin cannot be used. changelog: Fix guidance of [`float_cmp`] and [`float_cmp_const`] to not incorrectly recommend `f64::EPSILON` as the error margin. Fixes #6816 2024-07-09 02:12:09 -05:00			`--> tests/ui/float_cmp.rs:82:5`
rustup and compile-fail -> ui test move 2017-02-07 14:05:30 -06:00			`\|`
Update *.stderr files 2018-12-27 09:57:55 -06:00			`LL \| twice(x) != twice(ONE as f64);`
Merge commit 'e636b88aa180e8cab9e28802aac90adbc984234d' into clippyup 2020-09-24 07:49:22 -05:00			\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(twice(x) - twice(ONE as f64)).abs() > error_margin`
rustup and compile-fail -> ui test move 2017-02-07 14:05:30 -06:00
Update stderr of float_cmp test 2020-03-17 04:32:20 -05:00			error: strict comparison of `f32` or `f64`
Replace incorrect suggested fix for `float_cmp` Using `f32::EPSILON` or `f64::EPSILON` as the floating-point equality comparison error margin is incorrect, yet `float_cmp` has until now recommended this be done. This change fixes the given guidance (both in docs and compiler hints) to not reference these unsuitable constants. Instead, the guidance now clarifies that the scenarios in which an absolute error margin is usable, provides a reference implementation of using a user-defined absolute error margin (as an absolute error margin can only be used-defined and may be different for different comparisons) and references the floating point guide for a reference implementation of relative error based equaltiy comparison for when absolute error margin cannot be used. changelog: Fix guidance of [`float_cmp`] and [`float_cmp_const`] to not incorrectly recommend `f64::EPSILON` as the error margin. Fixes #6816 2024-07-09 02:12:09 -05:00			`--> tests/ui/float_cmp.rs:103:5`
Add tests for float in array comparison 2019-09-19 07:57:43 -05:00			`\|`
Add float cmp tests for arrays 2020-03-20 05:42:39 -05:00			`LL \| NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];`
Merge commit 'e636b88aa180e8cab9e28802aac90adbc984234d' into clippyup 2020-09-24 07:49:22 -05:00			\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error_margin`
Add float cmp tests for arrays 2020-03-20 05:42:39 -05:00
Indicate when arrays are compared in error message 2020-04-06 02:06:50 -05:00			error: strict comparison of `f32` or `f64` arrays
Replace incorrect suggested fix for `float_cmp` Using `f32::EPSILON` or `f64::EPSILON` as the floating-point equality comparison error margin is incorrect, yet `float_cmp` has until now recommended this be done. This change fixes the given guidance (both in docs and compiler hints) to not reference these unsuitable constants. Instead, the guidance now clarifies that the scenarios in which an absolute error margin is usable, provides a reference implementation of using a user-defined absolute error margin (as an absolute error margin can only be used-defined and may be different for different comparisons) and references the floating point guide for a reference implementation of relative error based equaltiy comparison for when absolute error margin cannot be used. changelog: Fix guidance of [`float_cmp`] and [`float_cmp_const`] to not incorrectly recommend `f64::EPSILON` as the error margin. Fixes #6816 2024-07-09 02:12:09 -05:00			`--> tests/ui/float_cmp.rs:109:5`
Add float cmp tests for arrays 2020-03-20 05:42:39 -05:00			`\|`
			`LL \| a1 == a2;`
			`\| ^^^^^^^^`
Add tests for float in array comparison 2019-09-19 07:57:43 -05:00
Update stderr of float_cmp test 2020-03-17 04:32:20 -05:00			error: strict comparison of `f32` or `f64`
Replace incorrect suggested fix for `float_cmp` Using `f32::EPSILON` or `f64::EPSILON` as the floating-point equality comparison error margin is incorrect, yet `float_cmp` has until now recommended this be done. This change fixes the given guidance (both in docs and compiler hints) to not reference these unsuitable constants. Instead, the guidance now clarifies that the scenarios in which an absolute error margin is usable, provides a reference implementation of using a user-defined absolute error margin (as an absolute error margin can only be used-defined and may be different for different comparisons) and references the floating point guide for a reference implementation of relative error based equaltiy comparison for when absolute error margin cannot be used. changelog: Fix guidance of [`float_cmp`] and [`float_cmp_const`] to not incorrectly recommend `f64::EPSILON` as the error margin. Fixes #6816 2024-07-09 02:12:09 -05:00			`--> tests/ui/float_cmp.rs:111:5`
Add tests for float in array comparison 2019-09-19 07:57:43 -05:00			`\|`
Add float cmp tests for arrays 2020-03-20 05:42:39 -05:00			`LL \| a1[0] == a2[0];`
Merge commit 'e636b88aa180e8cab9e28802aac90adbc984234d' into clippyup 2020-09-24 07:49:22 -05:00			\| ^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(a1[0] - a2[0]).abs() < error_margin`
Add tests for float in array comparison 2019-09-19 07:57:43 -05:00
Add float cmp tests for arrays 2020-03-20 05:42:39 -05:00			`error: aborting due to 6 previous errors`
Update changed ui tests 2018-01-16 10:06:27 -06:00