Skip to content

Commit 8eefbcc

Browse files
brunocodutrabrunocodutra
committed
replace proptest! by test_strategy::proptest attribute
1 parent e240a3e commit 8eefbcc

File tree

24 files changed

+1940
-1403
lines changed

24 files changed

+1940
-1403
lines changed

‎Cargo.toml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ approx = "0.5.0"
1818

1919
[dev-dependencies]
2020
proptest = { version = "1.0.0", default-features = false, features = ["std"] }
21-
proptest-derive = "0.3.0"
21+
test-strategy = "0.1.2"
2222

2323
[target.'cfg(target_arch = "wasm32")'.dependencies]
2424
wasm-bindgen = "0.2.68"

‎src/phasor.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
#[cfg(test)]
2-
use proptest_derive::Arbitrary;
2+
use test_strategy::Arbitrary;
33

44
mod add;
55
mod angle;

‎src/phasor/add.rs‎

Lines changed: 166 additions & 111 deletions
Original file line numberDiff line numberDiff line change
@@ -39,143 +39,198 @@ mod tests {
3939
use crate::arbitrary::{any, *};
4040
use crate::trig::{cossubatan, tanaddatan};
4141
use approx::{assert_ulps_eq, ulps_eq};
42-
use proptest::prelude::*;
42+
use proptest::prop_assume;
4343
use std::f64::consts::{FRAC_PI_2, SQRT_2};
44+
use test_strategy::proptest;
4445

45-
proptest! {
46-
#[test]
47-
fn is_commutative(a in not_nan(), b in not_nan(), c in not_nan(), d in not_nan()) {
48-
let p = Phasor { mag: a, tan: b };
49-
let q = Phasor { mag: c, tan: d };
46+
#[proptest]
47+
fn is_commutative(
48+
#[strategy(not_nan())] a: f64,
49+
#[strategy(not_nan())] b: f64,
50+
#[strategy(not_nan())] c: f64,
51+
#[strategy(not_nan())] d: f64,
52+
) {
53+
let p = Phasor { mag: a, tan: b };
54+
let q = Phasor { mag: c, tan: d };
5055

51-
prop_assume!(!p.is_infinite() || !q.is_infinite() || !ulps_eq!(p, -q));
56+
prop_assume!(!p.is_infinite() || !q.is_infinite() || !ulps_eq!(p, -q));
5257

53-
assert_ulps_eq!(p + q, q + p);
54-
}
55-
56-
#[test]
57-
fn equals_sum_of_real_and_imaginary_parts(a in normal(), b in not_nan(), c in normal(), d in not_nan()) {
58-
let p = Phasor { mag: a, tan: b };
59-
let q = Phasor { mag: c, tan: d };
60-
let r = Phasor::rect(p.real() + q.real(), p.imag() + q.imag());
61-
62-
assert_ulps_eq!(p + q, r, max_ulps = 800);
63-
assert_ulps_eq!(q + p, r, max_ulps = 800);
64-
}
65-
66-
#[test]
67-
fn has_zero_as_identity(a in nonzero(), b in not_nan(), c in zero(), d in not_nan()) {
68-
let p = Phasor { mag: a, tan: b };
69-
let q = Phasor { mag: c, tan: d };
70-
71-
assert_ulps_eq!(p + q, p);
72-
assert_ulps_eq!(q + p, p);
73-
}
74-
75-
#[test]
76-
fn has_infinity_as_identity(a in finite(), b in not_nan(), c in infinite(), d in not_nan()) {
77-
let p = Phasor { mag: a, tan: b };
78-
let q = Phasor { mag: c, tan: d };
79-
80-
assert_ulps_eq!(p + q, q);
81-
assert_ulps_eq!(q + p, q);
82-
}
83-
84-
#[test]
85-
fn has_bisector_angle_if_magnitudes_are_equal(mag in not_nan(), t in not_nan(), u in not_nan()) {
86-
prop_assume!(cossubatan(t, u) > -0.9f64);
58+
assert_ulps_eq!(p + q, q + p);
59+
}
8760

88-
let p = Phasor { mag, tan: t };
89-
let q = Phasor { mag, tan: u };
61+
#[proptest]
62+
fn equals_sum_of_real_and_imaginary_parts(
63+
#[strategy(normal())] a: f64,
64+
#[strategy(not_nan())] b: f64,
65+
#[strategy(normal())] c: f64,
66+
#[strategy(not_nan())] d: f64,
67+
) {
68+
let p = Phasor { mag: a, tan: b };
69+
let q = Phasor { mag: c, tan: d };
70+
let r = Phasor::rect(p.real() + q.real(), p.imag() + q.imag());
71+
72+
assert_ulps_eq!(p + q, r, max_ulps = 800);
73+
assert_ulps_eq!(q + p, r, max_ulps = 800);
74+
}
9075

91-
let (s, c) = tanaddatan(t, u);
76+
#[proptest]
77+
fn has_zero_as_identity(
78+
#[strategy(nonzero())] a: f64,
79+
#[strategy(not_nan())] b: f64,
80+
#[strategy(zero())] c: f64,
81+
#[strategy(not_nan())] d: f64,
82+
) {
83+
let p = Phasor { mag: a, tan: b };
84+
let q = Phasor { mag: c, tan: d };
85+
86+
assert_ulps_eq!(p + q, p);
87+
assert_ulps_eq!(q + p, p);
88+
}
9289

93-
let r = Phasor::polar(
94-
mag * (1f64 + cossubatan(t, u)).sqrt() * SQRT_2,
95-
s.atan2(c) / 2f64,
96-
);
90+
#[proptest]
91+
fn has_infinity_as_identity(
92+
#[strategy(finite())] a: f64,
93+
#[strategy(not_nan())] b: f64,
94+
#[strategy(infinite())] c: f64,
95+
#[strategy(not_nan())] d: f64,
96+
) {
97+
let p = Phasor { mag: a, tan: b };
98+
let q = Phasor { mag: c, tan: d };
99+
100+
assert_ulps_eq!(p + q, q);
101+
assert_ulps_eq!(q + p, q);
102+
}
97103

98-
assert_ulps_eq!(p + q, r, max_ulps = 80);
99-
assert_ulps_eq!(q + p, r, max_ulps = 80);
100-
}
104+
#[proptest]
105+
fn has_bisector_angle_if_magnitudes_are_equal(
106+
#[strategy(not_nan())] mag: f64,
107+
#[strategy(not_nan())] t: f64,
108+
#[strategy(not_nan())] u: f64,
109+
) {
110+
prop_assume!(cossubatan(t, u) > -0.9f64);
101111

102-
#[test]
103-
fn has_bisector_angle_if_magnitudes_are_opposite(mag in not_nan(), t in not_nan(), u in not_nan()) {
104-
prop_assume!(cossubatan(t, u) < 0.9f64);
112+
let p = Phasor { mag, tan: t };
113+
let q = Phasor { mag, tan: u };
105114

106-
let p = Phasor { mag, tan: t };
107-
let q = Phasor { mag: -mag, tan: u };
115+
let (s, c) = tanaddatan(t, u);
108116

109-
let (s, c) = tanaddatan(t, u);
117+
let r = Phasor::polar(
118+
mag * (1f64 + cossubatan(t, u)).sqrt() * SQRT_2,
119+
s.atan2(c) / 2f64,
120+
);
110121

111-
let r = Phasor::polar(
112-
mag * (1f64 - cossubatan(t, u)).sqrt() * SQRT_2,
113-
s.atan2(c) / 2f64 + if t < u { -FRAC_PI_2 } else { FRAC_PI_2 },
114-
);
122+
assert_ulps_eq!(p + q, r, max_ulps = 80);
123+
assert_ulps_eq!(q + p, r, max_ulps = 80);
124+
}
115125

116-
assert_ulps_eq!(p + q, r, max_ulps = 80);
117-
assert_ulps_eq!(q + p, r, max_ulps = 80);
118-
}
126+
#[proptest]
127+
fn has_bisector_angle_if_magnitudes_are_opposite(
128+
#[strategy(not_nan())] mag: f64,
129+
#[strategy(not_nan())] t: f64,
130+
#[strategy(not_nan())] u: f64,
131+
) {
132+
prop_assume!(cossubatan(t, u) < 0.9f64);
119133

120-
#[test]
121-
fn is_real_if_phasors_are_conjugate(mag in not_nan(), tan in not_nan()) {
122-
let p = Phasor { mag, tan };
123-
let q = p.conj();
134+
let p = Phasor { mag, tan: t };
135+
let q = Phasor { mag: -mag, tan: u };
124136

125-
let r = Phasor {
126-
mag: p.real() + q.real(),
127-
tan: 0f64
128-
};
137+
let (s, c) = tanaddatan(t, u);
129138

130-
prop_assume!(!p.is_infinite() || !p.is_imaginary());
139+
let r = Phasor::polar(
140+
mag * (1f64 - cossubatan(t, u)).sqrt() * SQRT_2,
141+
s.atan2(c) / 2f64 + if t < u { -FRAC_PI_2 } else { FRAC_PI_2 },
142+
);
131143

132-
assert_ulps_eq!(p + q, r, max_ulps = 40);
133-
assert_ulps_eq!(q + p, r, max_ulps = 40);
134-
}
144+
assert_ulps_eq!(p + q, r, max_ulps = 80);
145+
assert_ulps_eq!(q + p, r, max_ulps = 80);
146+
}
135147

136-
#[test]
137-
fn has_double_magnitude_if_phasors_are_equal(mag in not_nan(), tan in not_nan()) {
138-
let p = Phasor { mag, tan };
139-
let r = Phasor { mag: 2f64 * mag, tan };
148+
#[proptest]
149+
fn is_real_if_phasors_are_conjugate(
150+
#[strategy(not_nan())] mag: f64,
151+
#[strategy(not_nan())] tan: f64,
152+
) {
153+
let p = Phasor { mag, tan };
154+
let q = p.conj();
140155

141-
assert_ulps_eq!(p + p, r);
142-
}
156+
let r = Phasor {
157+
mag: p.real() + q.real(),
158+
tan: 0f64,
159+
};
143160

144-
#[test]
145-
fn is_zero_if_phasors_are_finite_and_opposite(mag in finite(), tan in not_nan()) {
146-
let p = Phasor { mag, tan };
147-
let q = -p;
148-
let r = Phasor { mag: 0f64, tan: -tan.recip() };
161+
prop_assume!(!p.is_infinite() || !p.is_imaginary());
149162

150-
assert_ulps_eq!(p + q, r);
151-
assert_ulps_eq!(q + p, r);
152-
}
163+
assert_ulps_eq!(p + q, r, max_ulps = 40);
164+
assert_ulps_eq!(q + p, r, max_ulps = 40);
165+
}
153166

154-
#[test]
155-
fn is_nan_if_phasors_are_opposite_and_infinite(mag in infinite(), tan in not_nan()) {
156-
let p = Phasor { mag, tan };
157-
let q = -p;
167+
#[proptest]
168+
fn has_double_magnitude_if_phasors_are_equal(
169+
#[strategy(not_nan())] mag: f64,
170+
#[strategy(not_nan())] tan: f64,
171+
) {
172+
let p = Phasor { mag, tan };
173+
let r = Phasor {
174+
mag: 2f64 * mag,
175+
tan,
176+
};
177+
178+
assert_ulps_eq!(p + p, r);
179+
}
158180

159-
assert!((p + q).is_nan());
160-
assert!((q + p).is_nan());
161-
}
181+
#[proptest]
182+
fn is_zero_if_phasors_are_finite_and_opposite(
183+
#[strategy(finite())] mag: f64,
184+
#[strategy(not_nan())] tan: f64,
185+
) {
186+
let p = Phasor { mag, tan };
187+
let q = -p;
188+
let r = Phasor {
189+
mag: 0f64,
190+
tan: -tan.recip(),
191+
};
192+
193+
assert_ulps_eq!(p + q, r);
194+
assert_ulps_eq!(q + p, r);
195+
}
162196

163-
#[test]
164-
fn is_nan_if_magnitude_is_nan(a in any(), b in any(), c in nan(), d in any()) {
165-
let p = Phasor { mag: a, tan: b };
166-
let q = Phasor { mag: c, tan: d };
197+
#[proptest]
198+
fn is_nan_if_phasors_are_opposite_and_infinite(
199+
#[strategy(infinite())] mag: f64,
200+
#[strategy(not_nan())] tan: f64,
201+
) {
202+
let p = Phasor { mag, tan };
203+
let q = -p;
167204

168-
assert!((p + q).is_nan());
169-
assert!((q + p).is_nan());
170-
}
205+
assert!((p + q).is_nan());
206+
assert!((q + p).is_nan());
207+
}
171208

172-
#[test]
173-
fn is_nan_if_tangent_is_nan(a in any(), b in any(), c in any(), d in nan()) {
174-
let p = Phasor { mag: a, tan: b };
175-
let q = Phasor { mag: c, tan: d };
209+
#[proptest]
210+
fn is_nan_if_magnitude_is_nan(
211+
#[strategy(any())] a: f64,
212+
#[strategy(any())] b: f64,
213+
#[strategy(nan())] c: f64,
214+
#[strategy(any())] d: f64,
215+
) {
216+
let p = Phasor { mag: a, tan: b };
217+
let q = Phasor { mag: c, tan: d };
218+
219+
assert!((p + q).is_nan());
220+
assert!((q + p).is_nan());
221+
}
176222

177-
assert!((p + q).is_nan());
178-
assert!((q + p).is_nan());
179-
}
223+
#[proptest]
224+
fn is_nan_if_tangent_is_nan(
225+
#[strategy(any())] a: f64,
226+
#[strategy(any())] b: f64,
227+
#[strategy(any())] c: f64,
228+
#[strategy(nan())] d: f64,
229+
) {
230+
let p = Phasor { mag: a, tan: b };
231+
let q = Phasor { mag: c, tan: d };
232+
233+
assert!((p + q).is_nan());
234+
assert!((q + p).is_nan());
180235
}
181236
}

‎src/phasor/angle.rs‎

Lines changed: 26 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -18,31 +18,35 @@ mod tests {
1818
use super::*;
1919
use crate::arbitrary::{any, *};
2020
use approx::assert_ulps_eq;
21-
use proptest::prelude::*;
21+
use test_strategy::proptest;
2222

23-
proptest! {
24-
#[test]
25-
fn has_absolute_value_no_greater_than_pi(mag in not_nan(), tan in not_nan()) {
26-
let p = Phasor { mag, tan };
27-
assert!(p.angle().abs() <= PI);
28-
}
23+
#[proptest]
24+
fn has_absolute_value_no_greater_than_pi(
25+
#[strategy(not_nan())] mag: f64,
26+
#[strategy(not_nan())] tan: f64,
27+
) {
28+
let p = Phasor { mag, tan };
29+
assert!(p.angle().abs() <= PI);
30+
}
2931

30-
#[test]
31-
fn equals_arc_formed_by_imaginary_and_real_parts(mag in regular(), tan in not_nan()) {
32-
let p = Phasor { mag, tan };
33-
assert_ulps_eq!(p.angle(), p.imag().atan2(p.real()), epsilon = 1E-11);
34-
}
32+
#[proptest]
33+
fn equals_arc_formed_by_imaginary_and_real_parts(
34+
#[strategy(regular())] mag: f64,
35+
#[strategy(not_nan())] tan: f64,
36+
) {
37+
let p = Phasor { mag, tan };
38+
assert_ulps_eq!(p.angle(), p.imag().atan2(p.real()), epsilon = 1E-11);
39+
}
3540

36-
#[test]
37-
fn is_nan_if_magnitude_is_nan(mag in nan(), tan in any()) {
38-
let p = Phasor { mag, tan };
39-
assert!(p.angle().is_nan());
40-
}
41+
#[proptest]
42+
fn is_nan_if_magnitude_is_nan(#[strategy(nan())] mag: f64, #[strategy(any())] tan: f64) {
43+
let p = Phasor { mag, tan };
44+
assert!(p.angle().is_nan());
45+
}
4146

42-
#[test]
43-
fn is_nan_if_tangent_is_nan(mag in any(), tan in nan()) {
44-
let p = Phasor { mag, tan };
45-
assert!(p.angle().is_nan());
46-
}
47+
#[proptest]
48+
fn is_nan_if_tangent_is_nan(#[strategy(any())] mag: f64, #[strategy(nan())] tan: f64) {
49+
let p = Phasor { mag, tan };
50+
assert!(p.angle().is_nan());
4751
}
4852
}

0 commit comments

Comments
 (0)