Skip to content

Commit 22a924d

Browse files
JordanMartinezJordanMartinez
committed
Migrate tests to assert
1 parent 09d53fd commit 22a924d

File tree

1 file changed

+203
-155
lines changed

1 file changed

+203
-155
lines changed

‎test/Main.purs‎

Lines changed: 203 additions & 155 deletions
Original file line numberDiff line numberDiff line change
@@ -11,9 +11,7 @@ import Data.Number.Approximate (Fraction(..), Tolerance(..), eqRelative,
1111

1212
import Effect (Effect)
1313

14-
import Test.Unit (suite, test)
15-
import Test.Unit.Assert (assert, assertFalse, equal)
16-
import Test.Unit.Main (runTest)
14+
import Test.Assert (assertTrue', assertFalse', assertEqual)
1715

1816

1917
-- | Comparison up to 10% relative error.
@@ -28,182 +26,232 @@ eqAbsolute' = eqAbsolute (Tolerance 0.1)
2826

2927
infix 1 eqAbsolute' as =~=
3028

31-
main ∷ Effect Unit
32-
main = runTest do
29+
main :: Effect Unit
30+
main = do
3331

3432

35-
suite "Data.Number.fromString" do
36-
test "valid number string" do
37-
assert "integer strings are coerced" $
38-
fromMaybe false $ map (_ == 123.0) $ fromString "123"
33+
-- suite "Data.Number.fromString" do
34+
-- test "valid number string" do
35+
assertTrue' "integer strings are coerced" $
36+
fromMaybe false $ map (_ == 123.0) $ fromString "123"
3937

40-
assert "decimals are coerced" $
41-
fromMaybe false $ map (_ == 12.34) $ fromString "12.34"
38+
assertTrue' "decimals are coerced" $
39+
fromMaybe false $ map (_ == 12.34) $ fromString "12.34"
4240

43-
assert "exponents are coerced" $
44-
fromMaybe false $ map (_ == 1e4) $ fromString "1e4"
41+
assertTrue' "exponents are coerced" $
42+
fromMaybe false $ map (_ == 1e4) $ fromString "1e4"
4543

46-
assert "decimals exponents are coerced" $
47-
fromMaybe false $ map (_ == 1.2e4) $ fromString "1.2e4"
44+
assertTrue' "decimals exponents are coerced" $
45+
fromMaybe false $ map (_ == 1.2e4) $ fromString "1.2e4"
4846

49-
test "invalid number string" do
50-
assert "invalid strings are not coerced" $
51-
Nothing == fromString "bad string"
47+
-- test "invalid number string" do
48+
assertTrue' "invalid strings are not coerced" $
49+
Nothing == fromString "bad string"
5250

53-
test "too large numbers" do
54-
assert "too large numbers are not coerced" $
55-
Nothing == fromString "1e1000"
51+
-- test "too large numbers" do
52+
assertTrue' "too large numbers are not coerced" $
53+
Nothing == fromString "1e1000"
5654

55+
-- suite "Data.Number.isNaN" do
56+
-- test "Check for NaN" do
57+
assertTrue' "NaN is not a number" $ isNaN nan
58+
assertFalse' "infinity is a number" $ isNaN infinity
59+
assertFalse' "1.0 is a number" $ isNaN 1.0
5760

58-
suite "Data.Number.isNaN" do
59-
test "Check for NaN" do
60-
assert "NaN is not a number" $ isNaN nan
61-
assertFalse "infinity is a number" $ isNaN infinity
62-
assertFalse "1.0 is a number" $ isNaN 1.0
63-
64-
65-
suite "Data.Number.isFinite" do
66-
test "Check for infinity" do
67-
assert "1.0e100 is a finite number" $ isFinite 1.0e100
68-
assertFalse "detect positive infinity" $ isFinite infinity
69-
assertFalse "detect negative infinity" $ isFinite (-infinity)
70-
assertFalse "detect NaN" $ isFinite nan
71-
61+
-- suite "Data.Number.isFinite" do
62+
-- test "Check for infinity" do
63+
assertTrue' "1.0e100 is a finite number" $ isFinite 1.0e100
64+
assertFalse' "detect positive infinity" $ isFinite infinity
65+
assertFalse' "detect negative infinity" $ isFinite (-infinity)
66+
assertFalse' "detect NaN" $ isFinite nan
7267

7368
let pi = 3.14159
74-
suite "Data.Format.toStringWith" do
75-
76-
test "precision" do
77-
equal "3.14" (toStringWith (precision 3) pi)
78-
equal "3.1416" (toStringWith (precision 5) pi)
79-
equal "3" (toStringWith (precision 1) pi)
80-
equal "3" (toStringWith (precision (-3)) pi)
81-
equal "3.14" (toStringWith (precision 3) pi)
82-
equal "1.2e+3" (toStringWith (precision 2) 1234.5)
83-
84-
test "fixed" do
85-
equal "3.14" (toStringWith (fixed 2) pi)
86-
equal "3.1416" (toStringWith (fixed 4) pi)
87-
equal "3" (toStringWith (precision 0) pi)
88-
equal "3" (toStringWith (precision (-3)) pi)
89-
equal "1234.5" (toStringWith (fixed 1) 1234.5)
90-
91-
test "exponential" do
92-
equal "3e+0" (toStringWith (exponential 0) pi)
93-
equal "3.14e+0" (toStringWith (exponential 2) pi)
94-
equal "3.14e+2" (toStringWith (exponential 2) (100.0 * pi))
95-
equal "1.2e+3" (toStringWith (exponential 1) 1234.5)
96-
97-
suite "Data.Format.toString" do
98-
99-
test "toString" do
100-
equal "3.14159" (toString pi)
101-
equal "10" (toString 10.0)
102-
103-
suite "Data.Number.Approximate.eqRelative" do
104-
test "eqRelative" do
105-
assert "should return true for differences smaller 10%" $
106-
10.0 ~= 10.9
107-
108-
assert "should return true for differences smaller 10%" $
109-
10.0 ~= 9.2
110-
111-
assertFalse "should return false for differences larger than 10%" $
112-
10.0 ~= 11.1
113-
114-
assertFalse "should return false for differences larger than 10%" $
115-
10.0 ~= 9.01
116-
117-
test "eqRelative (large numbers)" do
118-
assert "should return true for differences smaller 10%" $
119-
100000000000.0 ~= 109000000000.0
120-
121-
assert "should return true for differences smaller 10%" $
122-
100000000000.0 ~= 92000000000.0
123-
124-
assertFalse "should return false for differences larger than 10%" $
125-
100000000000.0 ~= 111000000000.0
126-
127-
assertFalse "should return false for differences larger than 10%" $
128-
100000000000.0 ~= 90000000000.0
129-
130-
test "eqRelative (small numbers)" do
131-
assert "should return true for differences smaller 10%" $
132-
0.000000000001 ~= 0.00000000000109
133-
134-
assert "should return true for differences smaller 10%" $
135-
0.000000000001 ~= 0.00000000000092
136-
137-
assertFalse "should return false for differences larger than 10%" $
138-
0.000000000001 ~= 0.00000000000111
139-
140-
assertFalse "should return false for differences larger than 10%" $
141-
0.000000000001 ~= 0.0000000000009
142-
143-
test "eqRelative (negative numbers)" do
144-
assert "should return true for differences smaller 10%" $
145-
-10.0 ~= -10.9
146-
147-
assert "should return true for differences smaller 10%" $
148-
-10.0 ~= -9.2
149-
150-
assertFalse "should return false for differences larger than 10%" $
151-
-10.0 ~= -11.1
152-
153-
assertFalse "should return false for differences larger than 10%" $
154-
-10.0 ~= -9.01
155-
156-
test "eqRelative (close or equal to 0.0)" do
157-
assert "should compare against the fraction if left argument is zero" $
158-
0.0 ~= 0.0001
69+
-- suite "Data.Format.toStringWith" do
70+
71+
-- test "precision" do
72+
assertEqual
73+
{ expected: "3.14"
74+
, actual: toStringWith (precision 3) pi
75+
}
76+
assertEqual
77+
{ expected: "3.1416"
78+
, actual: toStringWith (precision 5) pi
79+
}
80+
assertEqual
81+
{ expected: "3"
82+
, actual: toStringWith (precision 1) pi
83+
}
84+
assertEqual
85+
{ expected: "3"
86+
, actual: toStringWith (precision (-3)) pi
87+
}
88+
assertEqual
89+
{ expected: "3.14"
90+
, actual: toStringWith (precision 3) pi
91+
}
92+
assertEqual
93+
{ expected: "1.2e+3"
94+
, actual: toStringWith (precision 2) 1234.5
95+
}
96+
97+
-- test "fixed" do
98+
assertEqual
99+
{ expected: "3.14"
100+
, actual: toStringWith (fixed 2) pi
101+
}
102+
assertEqual
103+
{ expected: "3.1416"
104+
, actual: toStringWith (fixed 4) pi
105+
}
106+
assertEqual
107+
{ expected: "3"
108+
, actual: toStringWith (precision 0) pi
109+
}
110+
assertEqual
111+
{ expected: "3"
112+
, actual: toStringWith (precision (-3)) pi
113+
}
114+
assertEqual
115+
{ expected: "1234.5"
116+
, actual: toStringWith (fixed 1) 1234.5
117+
}
118+
119+
-- test "exponential" do
120+
assertEqual
121+
{ expected: "3e+0"
122+
, actual: toStringWith (exponential 0) pi
123+
}
124+
assertEqual
125+
{ expected: "3.14e+0"
126+
, actual: toStringWith (exponential 2) pi
127+
}
128+
assertEqual
129+
{ expected: "3.14e+2"
130+
, actual: toStringWith (exponential 2) (100.0 * pi)
131+
}
132+
assertEqual
133+
{ expected: "1.2e+3"
134+
, actual: toStringWith (exponential 1) 1234.5
135+
}
136+
137+
-- suite "Data.Format.toString" do
138+
139+
-- test "toString" do
140+
assertEqual
141+
{ expected: "3.14159"
142+
, actual: toString pi
143+
}
144+
145+
assertEqual
146+
{ expected: "10"
147+
, actual: toString 10.0
148+
}
149+
150+
-- suite "Data.Number.Approximate.eqRelative" do
151+
-- test "eqRelative" do
152+
assertTrue' "should return true for differences smaller 10%" $
153+
10.0 ~= 10.9
154+
155+
assertTrue' "should return true for differences smaller 10%" $
156+
10.0 ~= 9.2
157+
158+
assertFalse' "should return false for differences larger than 10%" $
159+
10.0 ~= 11.1
160+
161+
assertFalse' "should return false for differences larger than 10%" $
162+
10.0 ~= 9.01
163+
164+
-- test "eqRelative (large numbers)" do
165+
assertTrue' "should return true for differences smaller 10%" $
166+
100000000000.0 ~= 109000000000.0
167+
168+
assertTrue' "should return true for differences smaller 10%" $
169+
100000000000.0 ~= 92000000000.0
170+
171+
assertFalse' "should return false for differences larger than 10%" $
172+
100000000000.0 ~= 111000000000.0
173+
174+
assertFalse' "should return false for differences larger than 10%" $
175+
100000000000.0 ~= 90000000000.0
176+
177+
-- test "eqRelative (small numbers)" do
178+
assertTrue' "should return true for differences smaller 10%" $
179+
0.000000000001 ~= 0.00000000000109
180+
181+
assertTrue' "should return true for differences smaller 10%" $
182+
0.000000000001 ~= 0.00000000000092
183+
184+
assertFalse' "should return false for differences larger than 10%" $
185+
0.000000000001 ~= 0.00000000000111
186+
187+
-- assertFalse
188+
assertFalse' "should return false for differences larger than 10%" $
189+
0.000000000001 ~= 0.0000000000009
190+
191+
-- test "eqRelative (negative numbers)" do
192+
assertTrue' "should return true for differences smaller 10%" $
193+
-10.0 ~= -10.9
194+
195+
assertTrue' "should return true for differences smaller 10%" $
196+
-10.0 ~= -9.2
197+
198+
assertFalse' "should return false for differences larger than 10%" $
199+
-10.0 ~= -11.1
200+
201+
assertFalse' "should return false for differences larger than 10%" $
202+
-10.0 ~= -9.01
203+
204+
-- test "eqRelative (close or equal to 0.0)" do
205+
assertTrue' "should compare against the fraction if left argument is zero" $
206+
0.0 ~= 0.0001
159207

160-
assert "should compare against the fraction if right argument is zero" $
161-
0.0001 ~= 0.0
208+
assertTrue' "should compare against the fraction if right argument is zero" $
209+
0.0001 ~= 0.0
162210

163-
assert "should succeed if both arguments are zero" $
164-
0.0 ~= 0.0
211+
assertTrue' "should succeed if both arguments are zero" $
212+
0.0 ~= 0.0
165213

166-
assertFalse "should fail if argument is larger than fraction" $
167-
0.0 ~= 0.11
214+
assertFalse' "should fail if argument is larger than fraction" $
215+
0.0 ~= 0.11
168216

169-
assertFalse "should fail if other argument is not exactly zero" $
170-
1.0e-100 ~= 0.1
217+
assertFalse' "should fail if other argument is not exactly zero" $
218+
1.0e-100 ~= 0.1
171219

172-
test "eqRelative (fraction = 0.0)" do
173-
assert "should succeed if numbers are exactly equal" $
174-
eqRelative (Fraction 0.0) 3.14 3.14
220+
-- test "eqRelative (fraction = 0.0)" do
221+
assertTrue' "should succeed if numbers are exactly equal" $
222+
eqRelative (Fraction 0.0) 3.14 3.14
175223

176-
assertFalse "should fail if numbers are not exactly equal" $
177-
eqRelative (Fraction 0.0) 3.14 3.14000000000001
224+
assertFalse' "should fail if numbers are not exactly equal" $
225+
eqRelative (Fraction 0.0) 3.14 3.14000000000001
178226

179-
test "eqRelative (fraction > 1.0)" do
180-
assert "should work for 'fractions' larger than one" $
181-
eqRelative (Fraction 3.0) 10.0 29.5
227+
-- test "eqRelative (fraction > 1.0)" do
228+
assertTrue' "should work for 'fractions' larger than one" $
229+
eqRelative (Fraction 3.0) 10.0 29.5
182230

183231

184-
suite "Data.Number.Approximate.eqApproximate" do
185-
test "0.1 + 0.2 ≅ 0.3" do
186-
assert "0.1 + 0.2 should be approximately equal to 0.3" $
187-
0.1 + 0.2 ≅ 0.3
232+
-- suite "Data.Number.Approximate.eqApproximate" do
233+
-- test "0.1 + 0.2 ≅ 0.3" do
234+
assertTrue' "0.1 + 0.2 should be approximately equal to 0.3" $
235+
0.1 + 0.2 ≅ 0.3
188236

189-
assert "0.1 + 0.200001 should not be approximately equal to 0.3" $
190-
0.1 + 0.200001 ≇ 0.3
237+
assertTrue' "0.1 + 0.200001 should not be approximately equal to 0.3" $
238+
0.1 + 0.200001 ≇ 0.3
191239

192240

193-
suite "Data.Number.Approximate.eqAbsolute" do
194-
test "eqAbsolute" do
195-
assert "should succeed for differences smaller than the tolerance" $
196-
10.0 =~= 10.09
241+
-- suite "Data.Number.Approximate.eqAbsolute" do
242+
-- test "eqAbsolute" do
243+
assertTrue' "should succeed for differences smaller than the tolerance" $
244+
10.0 =~= 10.09
197245

198-
assert "should succeed for differences smaller than the tolerance" $
199-
9.91 ~= 10.00
246+
assertTrue' "should succeed for differences smaller than the tolerance" $
247+
9.91 ~= 10.00
200248

201-
assertFalse "should fail for differences larger than the tolerance" $
202-
10.0 =~= 10.11
249+
assertFalse' "should fail for differences larger than the tolerance" $
250+
10.0 =~= 10.11
203251

204-
assertFalse "should fail for differences larger than the tolerance" $
205-
9.89 =~= 10.0
252+
assertFalse' "should fail for differences larger than the tolerance" $
253+
9.89 =~= 10.0
206254

207-
test "eqAbsolute (compare against 0)" do
208-
assert "should succeed for numbers smaller than the tolerance" $
209-
0.0 ~= -0.09
255+
-- test "eqAbsolute (compare against 0)" do
256+
assertTrue' "should succeed for numbers smaller than the tolerance" $
257+
0.0 ~= -0.09

0 commit comments

Comments
 (0)