refactor(test): reorganize tests

src/i256/mod.rs

@@ -195,17 +195,17 @@ mod tests {
  use super::*;
 
  #[test]
- fn it_calculates_min() {
+ fn min() {
  assert_eq!(i128::try_from(I256::I128_MIN).unwrap(), i128::MIN);
  }
 
  #[test]
- fn it_calculates_max() {
+ fn max() {
  assert_eq!(i128::try_from(I256::I128_MAX).unwrap(), i128::MAX);
  }
 
  #[test]
- fn it_compares() {
+ fn cmp() {
  use core::cmp::Ordering::{self, *};
  fn t(a: i128, b: i128, ord: Ordering) {
  let a = I256::from(a);
@@ -219,7 +219,7 @@ mod tests {
  }
 
  #[test]
- fn it_converts_i256_from_i128() {
+ fn from_i128() {
  fn t(x: i128) {
  assert_eq!(i128::try_from(I256::from(x)).unwrap(), x);
  }
@@ -233,7 +233,7 @@ mod tests {
  }
 
  #[test]
- fn it_negates_i128() {
+ fn neg_i128() {
  fn t(x: i128) {
  assert_eq!(i128::try_from(-I256::from(x)).unwrap(), -x);
  assert_eq!(i128::try_from(-I256::from(-x)).unwrap(), x);
@@ -245,7 +245,7 @@ mod tests {
  }
 
  #[test]
- fn it_negates_i256() {
+ fn neg_i256() {
  fn t(value: I256, expected: I256) {
  let actual: I256 = -value;
  assert_eq!(actual, expected);
@@ -270,12 +270,12 @@ mod tests {
 
  #[test]
  #[should_panic]
- fn it_doesnt_negate_i256_min() {
+ fn neg_i256_min() {
  let _x = -I256::MIN;
  }
 
  #[test]
- fn it_adds() {
+ fn add() {
  fn t(a: i128, b: i128, expected: i128) {
  let a = I256::from(a);
  let b = I256::from(b);
@@ -291,7 +291,7 @@ mod tests {
  }
 
  #[test]
- fn it_subtracts() {
+ fn sub() {
  fn t(a: i128, b: i128, expected: i128) {
  let a = I256::from(a);
  let b = I256::from(b);
@@ -307,7 +307,7 @@ mod tests {
  }
 
  #[test]
- fn it_multiplies() {
+ fn mul() {
  fn t(a: i128, b: i128, expected: i128) {
  let a = I256::from(a);
  let b = I256::from(b);
@@ -322,7 +322,7 @@ mod tests {
  }
 
  #[test]
- fn it_divides() {
+ fn div() {
  fn t(a: i128, b: i128, expected: i128) {
  let a = I256::from(a);
  let b = I256::from(b);

src/i256/u256.rs

@@ -853,7 +853,7 @@ mod tests {
  use super::*;
 
  #[test]
- fn it_counts_leading_zeros() {
+ fn leading_zeros() {
  fn t(x: U256, expected: u32) {
  assert_eq!(x.leading_zeros(), expected);
  }

tests/it/const_ctor/mod.rs

@@ -0,0 +1,21 @@
+use fixnum::{fixnum_const, FixedPoint};
+
+#[test]
+fn valid() {
+ type F64p9 = FixedPoint<i64, typenum::U9>;
+
+ const SAMPLE0: F64p9 = fixnum_const!(42.42, 9);
+ assert_eq!(SAMPLE0, F64p9::from_decimal(4242, -2).unwrap());
+
+ const SAMPLE1: F64p9 = fixnum_const!(42, 9);
+ assert_eq!(SAMPLE1, F64p9::from_decimal(42, 0).unwrap());
+
+ const SAMPLE2: F64p9 = fixnum_const!(42., 9);
+ assert_eq!(SAMPLE2, F64p9::from_decimal(42, 0).unwrap());
+}
+
+#[test]
+fn too_long_fractional() {
+ let test_cases = trybuild::TestCases::new();
+ test_cases.compile_fail("tests/it/const_ctor/too_long_fractional.rs");
+}

tests/const_fn/01_fixnum_const_bad_str_with_too_long_fractional_part.stderr → tests/it/const_ctor/too_long_fractional.stderr

@@ -7,15 +7,15 @@ error: constant evaluation is taking a long time
  = note: this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval.
  If your compilation actually takes a long time, you can safely allow the lint.
 help: the constant being evaluated
- --> tests/const_fn/01_fixnum_const_bad_str_with_too_long_fractional_part.rs:7:36
+ --> tests/it/const_ctor/too_long_fractional.rs:7:36
  |
 7 | const VALUE: FixedPoint<i64, U9> = fixnum_const!(0.1234567891, 9);
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  = note: `#[deny(long_running_const_eval)]` on by default
  = note: this error originates in the macro `const_assert` which comes from the expansion of the macro `fixnum_const` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: erroneous constant used
- --> tests/const_fn/01_fixnum_const_bad_str_with_too_long_fractional_part.rs:7:36
+ --> tests/it/const_ctor/too_long_fractional.rs:7:36
  |
 7 | const VALUE: FixedPoint<i64, U9> = fixnum_const!(0.1234567891, 9);
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/test_convert.rs → tests/it/convert.rs

@@ -4,8 +4,6 @@ use proptest::prelude::*;
 
 use fixnum::ops::Bounded;
 
-mod macros;
-
 #[test]
 fn from_decimal() -> Result<()> {
  test_fixed_point! {

tests/test_convert_f64.rs → tests/it/convert_f64.rs

@@ -4,8 +4,6 @@ use proptest::prelude::*;
 
 use fixnum::*;
 
-mod macros;
-
 #[test]
 #[allow(clippy::float_cmp)]
 fn to_f64() -> Result<()> {

tests/test_convert_string.rs → tests/it/convert_str.rs

@@ -7,9 +7,7 @@ use anyhow::Result;
 #[cfg(feature = "i128")]
 use proptest::prelude::*;
 
-use self::macros::TestCaseResult;
-
-mod macros;
+use crate::TestCaseResult;
 
 #[test]
 #[allow(overflowing_literals)]

tests/macros.rs → tests/it/main.rs

@@ -1,7 +1,4 @@
-#![allow(dead_code)]
-
-/// Testing helper macro. Allows to use generalized `FixedPoint` and `Layout` types in the test cases.
-#[macro_export]
+/// Allows to use generalized `FixedPoint` and `Layout` types in the test cases.
 macro_rules! test_fixed_point {
  (
  case ($( $case_pattern:ident: $case_type:ty ),* $( , )?) => $case:block,
@@ -11,7 +8,7 @@ macro_rules! test_fixed_point {
  ) => {{
  macro_rules! impl_test_case {
  () => {
- fn test_case($( $case_pattern: $case_type ),*) -> $crate::macros::TestCaseResult {
+ fn test_case($( $case_pattern: $case_type ),*) -> $crate::TestCaseResult {
  $case
  Ok(())
  }
@@ -90,15 +87,15 @@ macro_rules! test_fixed_point {
  };
  (@suite_passes {$( ($( $args:expr )*) )*}) => {
  $(
- $crate::macros::r#impl::catch_and_augment(stringify!($( $args ),*), || {
+ $crate::r#impl::catch_and_augment(stringify!($( $args ),*), || {
  test_case($( $args ),*)
  })?;
  )*
  };
  (@suite_fails {$( ($( $args:expr )*) )*}) => {
  $(
- $crate::macros::r#impl::catch_and_augment(stringify!($( $args ),*), || {
- $crate::macros::r#impl::assert_fails(|| test_case($( $args ),*));
+ $crate::r#impl::catch_and_augment(stringify!($( $args ),*), || {
+ $crate::r#impl::assert_fails(|| test_case($( $args ),*));
  Ok(())
  })?;
  )*
@@ -108,8 +105,8 @@ macro_rules! test_fixed_point {
 use std::fmt::Display;
 
 // Use a special error based on `Display` in order to support `nostd`.
-pub(crate) type TestCaseResult = Result<(), TestCaseError>;
-pub(crate) struct TestCaseError(Box<dyn Display>);
+type TestCaseResult = Result<(), TestCaseError>;
+struct TestCaseError(Box<dyn Display>);
 
 impl<E: Display + 'static> From<E> for TestCaseError {
  fn from(error: E) -> Self {
@@ -125,7 +122,7 @@ impl From<TestCaseError> for anyhow::Error {
 }
 
 #[cfg(not(feature = "std"))]
-pub(crate) mod r#impl {
+mod r#impl {
  use anyhow::Result;
 
  use super::TestCaseResult;
@@ -141,7 +138,7 @@ pub(crate) mod r#impl {
 }
 
 #[cfg(feature = "std")]
-pub(crate) mod r#impl {
+mod r#impl {
  use std::panic::{catch_unwind, AssertUnwindSafe};
 
  use anyhow::{anyhow, Context, Result};
@@ -180,3 +177,11 @@ pub(crate) mod r#impl {
  }
  }
 }
+
+// Tests
+mod const_ctor;
+mod convert;
+mod convert_f64;
+mod convert_str;
+mod ops;
+mod serde;

tests/test_ops.rs → tests/it/ops.rs

@@ -7,8 +7,6 @@ use fixnum::{
  *,
 };
 
-mod macros;
-
 #[test]
 fn cmul_overflow() -> Result<()> {
  test_fixed_point! {

tests/test_serde.rs → tests/it/serde.rs

@@ -4,8 +4,6 @@ use anyhow::Result;
 use derive_more::{From, Into};
 use serde::{Deserialize, Serialize};
 
-mod macros;
-
 #[test]
 fn display_and_serde() -> Result<()> {
  test_fixed_point! {