1 #[cfg(test)]
2 mod duration {
3     use chrono::Duration;
4     use chrono_humanize::HumanTime;
5 
6     #[test]
zero()7     fn zero() {
8         let ht = HumanTime::from(Duration::zero());
9         let english = format!("{:#}", ht);
10         assert_eq!("0 seconds", english);
11     }
12 
13     #[test]
plus_1s()14     fn plus_1s() {
15         let ht = HumanTime::from(Duration::seconds(1));
16         let english = format!("{:#}", ht);
17         assert_eq!("in 1 second", english);
18     }
19 
20     #[test]
minus_1s()21     fn minus_1s() {
22         let ht = HumanTime::from(Duration::seconds(-1));
23         let english = format!("{:#}", ht);
24         assert_eq!("1 second ago", english);
25     }
26 
27     #[test]
plus_5s()28     fn plus_5s() {
29         let ht = HumanTime::from(Duration::seconds(5));
30         let english = format!("{:#}", ht);
31         assert_eq!("in 5 seconds", english);
32     }
33 
34     #[test]
minus_5s()35     fn minus_5s() {
36         let ht = HumanTime::from(Duration::seconds(-5));
37         let english = format!("{:#}", ht);
38         assert_eq!("5 seconds ago", english);
39     }
40 
41     #[test]
plus_15s()42     fn plus_15s() {
43         let ht = HumanTime::from(Duration::seconds(15));
44         let english = format!("{:#}", ht);
45         assert_eq!("in 15 seconds", english);
46     }
47 
48     #[test]
minus_15s()49     fn minus_15s() {
50         let ht = HumanTime::from(Duration::seconds(-15));
51         let english = format!("{:#}", ht);
52         assert_eq!("15 seconds ago", english);
53     }
54 
55     #[test]
plus_95s()56     fn plus_95s() {
57         let ht = HumanTime::from(Duration::seconds(95));
58         let english = format!("{:#}", ht);
59         assert_eq!("in 1 minute and 35 seconds", english);
60     }
61 
62     #[test]
minus_95s()63     fn minus_95s() {
64         let ht = HumanTime::from(Duration::seconds(-95));
65         let english = format!("{:#}", ht);
66         assert_eq!("1 minute and 35 seconds ago", english);
67     }
68 
69     #[test]
plus_125s()70     fn plus_125s() {
71         let ht = HumanTime::from(Duration::seconds(125));
72         let english = format!("{:#}", ht);
73         assert_eq!("in 2 minutes and 5 seconds", english);
74     }
75 
76     #[test]
minus_125s()77     fn minus_125s() {
78         let ht = HumanTime::from(Duration::seconds(-125));
79         let english = format!("{:#}", ht);
80         assert_eq!("2 minutes and 5 seconds ago", english);
81     }
82 
83     #[test]
plus_31m()84     fn plus_31m() {
85         let ht = HumanTime::from(Duration::minutes(31));
86         let english = format!("{:#}", ht);
87         assert_eq!("in 31 minutes", english);
88     }
89 
90     #[test]
minus_31m()91     fn minus_31m() {
92         let ht = HumanTime::from(Duration::minutes(-31));
93         let english = format!("{:#}", ht);
94         assert_eq!("31 minutes ago", english);
95     }
96 
97     #[test]
plus_45m()98     fn plus_45m() {
99         let ht = HumanTime::from(Duration::minutes(45));
100         let english = format!("{:#}", ht);
101         assert_eq!("in 45 minutes", english);
102     }
103 
104     #[test]
minus_45m()105     fn minus_45m() {
106         let ht = HumanTime::from(Duration::minutes(-45));
107         let english = format!("{:#}", ht);
108         assert_eq!("45 minutes ago", english);
109     }
110 
111     #[test]
plus_46m()112     fn plus_46m() {
113         let ht = HumanTime::from(Duration::minutes(46));
114         let english = format!("{:#}", ht);
115         assert_eq!("in 46 minutes", english);
116     }
117 
118     #[test]
minus_46m()119     fn minus_46m() {
120         let ht = HumanTime::from(Duration::minutes(-46));
121         let english = format!("{:#}", ht);
122         assert_eq!("46 minutes ago", english);
123     }
124 
125     #[test]
plus_1h()126     fn plus_1h() {
127         let ht = HumanTime::from(Duration::hours(1));
128         let english = format!("{:#}", ht);
129         assert_eq!("in 1 hour", english);
130     }
131 
132     #[test]
minus_1h()133     fn minus_1h() {
134         let ht = HumanTime::from(Duration::hours(-1));
135         let english = format!("{:#}", ht);
136         assert_eq!("1 hour ago", english);
137     }
138 
139     #[test]
plus_72m()140     fn plus_72m() {
141         let ht = HumanTime::from(Duration::minutes(72));
142         let english = format!("{:#}", ht);
143         assert_eq!("in 1 hour and 12 minutes", english);
144     }
145 
146     #[test]
minus_72m()147     fn minus_72m() {
148         let ht = HumanTime::from(Duration::minutes(-72));
149         let english = format!("{:#}", ht);
150         assert_eq!("1 hour and 12 minutes ago", english);
151     }
152 
153     #[test]
plus_12h()154     fn plus_12h() {
155         let ht = HumanTime::from(Duration::hours(12));
156         let english = format!("{:#}", ht);
157         assert_eq!("in 12 hours", english);
158     }
159 
160     #[test]
minus_12h()161     fn minus_12h() {
162         let ht = HumanTime::from(Duration::hours(-12));
163         let english = format!("{:#}", ht);
164         assert_eq!("12 hours ago", english);
165     }
166 
167     #[test]
plus_23h()168     fn plus_23h() {
169         let ht = HumanTime::from(Duration::hours(23));
170         let english = format!("{:#}", ht);
171         assert_eq!("in 23 hours", english);
172     }
173 
174     #[test]
minus_23h()175     fn minus_23h() {
176         let ht = HumanTime::from(Duration::hours(-23));
177         let english = format!("{:#}", ht);
178         assert_eq!("23 hours ago", english);
179     }
180 
181     #[test]
plus_26h()182     fn plus_26h() {
183         let ht = HumanTime::from(Duration::hours(26));
184         let english = format!("{:#}", ht);
185         assert_eq!("in 1 day and 2 hours", english);
186     }
187 
188     #[test]
minus_26h()189     fn minus_26h() {
190         let ht = HumanTime::from(Duration::hours(-26));
191         let english = format!("{:#}", ht);
192         assert_eq!("1 day and 2 hours ago", english);
193     }
194 
195     #[test]
plus_1d()196     fn plus_1d() {
197         let ht = HumanTime::from(Duration::days(1));
198         let english = format!("{:#}", ht);
199         assert_eq!("in 1 day", english);
200     }
201 
202     #[test]
minus_1d()203     fn minus_1d() {
204         let ht = HumanTime::from(Duration::days(-1));
205         let english = format!("{:#}", ht);
206         assert_eq!("1 day ago", english);
207     }
208 
209     #[test]
plus_2d()210     fn plus_2d() {
211         let ht = HumanTime::from(Duration::days(2));
212         let english = format!("{:#}", ht);
213         assert_eq!("in 2 days", english);
214     }
215 
216     #[test]
minus_2d()217     fn minus_2d() {
218         let ht = HumanTime::from(Duration::days(-2));
219         let english = format!("{:#}", ht);
220         assert_eq!("2 days ago", english);
221     }
222 
223     #[test]
plus_6d_13h()224     fn plus_6d_13h() {
225         let ht = HumanTime::from(Duration::days(6) + Duration::hours(13));
226         let english = format!("{:#}", ht);
227         assert_eq!("in 6 days and 13 hours", english);
228     }
229 
230     #[test]
minus_6d_13h()231     fn minus_6d_13h() {
232         let ht = HumanTime::from(Duration::days(-6) + Duration::hours(-13));
233         let english = format!("{:#}", ht);
234         assert_eq!("6 days and 13 hours ago", english);
235     }
236 
237     #[test]
plus_7d()238     fn plus_7d() {
239         let ht = HumanTime::from(Duration::days(7));
240         let english = format!("{:#}", ht);
241         assert_eq!("in 1 week", english);
242     }
243 
244     #[test]
minus_7d()245     fn minus_7d() {
246         let ht = HumanTime::from(Duration::days(-7));
247         let english = format!("{:#}", ht);
248         assert_eq!("1 week ago", english);
249     }
250 
251     #[test]
plus_10d()252     fn plus_10d() {
253         let ht = HumanTime::from(Duration::days(10));
254         let english = format!("{:#}", ht);
255         assert_eq!("in 1 week and 3 days", english);
256     }
257 
258     #[test]
minus_10d()259     fn minus_10d() {
260         let ht = HumanTime::from(Duration::days(-10));
261         let english = format!("{:#}", ht);
262         assert_eq!("1 week and 3 days ago", english);
263     }
264 
265     #[test]
plus_11d()266     fn plus_11d() {
267         let ht = HumanTime::from(Duration::days(11));
268         let english = format!("{:#}", ht);
269         assert_eq!("in 1 week and 4 days", english);
270     }
271 
272     #[test]
minus_11d()273     fn minus_11d() {
274         let ht = HumanTime::from(Duration::days(-11));
275         let english = format!("{:#}", ht);
276         assert_eq!("1 week and 4 days ago", english);
277     }
278 
279     #[test]
plus_4w()280     fn plus_4w() {
281         let ht = HumanTime::from(Duration::weeks(4));
282         let english = format!("{:#}", ht);
283         assert_eq!("in 4 weeks", english);
284     }
285 
286     #[test]
minus_4w()287     fn minus_4w() {
288         let ht = HumanTime::from(Duration::weeks(-4));
289         let english = format!("{:#}", ht);
290         assert_eq!("4 weeks ago", english);
291     }
292 
293     #[test]
plus_30d()294     fn plus_30d() {
295         let ht = HumanTime::from(Duration::days(30));
296         let english = format!("{:#}", ht);
297         assert_eq!("in 1 month", english);
298     }
299 
300     #[test]
minus_30d()301     fn minus_30d() {
302         let ht = HumanTime::from(Duration::days(-30));
303         let english = format!("{:#}", ht);
304         assert_eq!("1 month ago", english);
305     }
306 
307     #[test]
plus_45d()308     fn plus_45d() {
309         let ht = HumanTime::from(Duration::days(45));
310         let english = format!("{:#}", ht);
311         assert_eq!("in 1 month, 2 weeks and 1 day", english);
312     }
313 
314     #[test]
minus_45d()315     fn minus_45d() {
316         let ht = HumanTime::from(Duration::days(-45));
317         let english = format!("{:#}", ht);
318         assert_eq!("1 month, 2 weeks and 1 day ago", english);
319     }
320 
321     #[test]
plus_46d()322     fn plus_46d() {
323         let ht = HumanTime::from(Duration::days(46));
324         let english = format!("{:#}", ht);
325         assert_eq!("in 1 month, 2 weeks and 2 days", english);
326     }
327 
328     #[test]
minus_46d()329     fn minus_46d() {
330         let ht = HumanTime::from(Duration::days(-46));
331         let english = format!("{:#}", ht);
332         assert_eq!("1 month, 2 weeks and 2 days ago", english);
333     }
334 
335     #[test]
plus_24w()336     fn plus_24w() {
337         let ht = HumanTime::from(Duration::weeks(24));
338         let english = format!("{:#}", ht);
339         assert_eq!("in 5 months, 2 weeks and 4 days", english);
340     }
341 
342     #[test]
minus_24w()343     fn minus_24w() {
344         let ht = HumanTime::from(Duration::weeks(-24));
345         let english = format!("{:#}", ht);
346         assert_eq!("5 months, 2 weeks and 4 days ago", english);
347     }
348 
349     #[test]
plus_26w()350     fn plus_26w() {
351         let ht = HumanTime::from(Duration::weeks(26));
352         let english = format!("{:#}", ht);
353         assert_eq!("in 6 months and 2 days", english);
354     }
355 
356     #[test]
minus_26w()357     fn minus_26w() {
358         let ht = HumanTime::from(Duration::weeks(-26));
359         let english = format!("{:#}", ht);
360         assert_eq!("6 months and 2 days ago", english);
361     }
362 
363     #[test]
plus_50w()364     fn plus_50w() {
365         let ht = HumanTime::from(Duration::weeks(50));
366         let english = format!("{:#}", ht);
367         assert_eq!("in 11 months, 2 weeks and 6 days", english);
368     }
369 
370     #[test]
minus_50w()371     fn minus_50w() {
372         let ht = HumanTime::from(Duration::weeks(-50));
373         let english = format!("{:#}", ht);
374         assert_eq!("11 months, 2 weeks and 6 days ago", english);
375     }
376 
377     #[test]
plus_100w()378     fn plus_100w() {
379         let ht = HumanTime::from(Duration::weeks(100));
380         let english = format!("{:#}", ht);
381         assert_eq!("in 1 year, 11 months and 5 days", english);
382     }
383 
384     #[test]
minus_100w()385     fn minus_100w() {
386         let ht = HumanTime::from(Duration::weeks(-100));
387         let english = format!("{:#}", ht);
388         assert_eq!("1 year, 11 months and 5 days ago", english);
389     }
390 
391     #[test]
plus_120w()392     fn plus_120w() {
393         let ht = HumanTime::from(Duration::weeks(120));
394         let english = format!("{:#}", ht);
395         assert_eq!("in 2 years, 3 months, 2 weeks and 6 days", english);
396     }
397 
398     #[test]
minus_120w()399     fn minus_120w() {
400         let ht = HumanTime::from(Duration::weeks(-120));
401         let english = format!("{:#}", ht);
402         assert_eq!("2 years, 3 months, 2 weeks and 6 days ago", english);
403     }
404 
405     #[test]
plus_200w()406     fn plus_200w() {
407         let ht = HumanTime::from(Duration::weeks(200));
408         let english = format!("{:#}", ht);
409         assert_eq!("in 3 years, 10 months and 5 days", english);
410     }
411 
412     #[test]
minus_200w()413     fn minus_200w() {
414         let ht = HumanTime::from(Duration::weeks(-200));
415         let english = format!("{:#}", ht);
416         assert_eq!("3 years, 10 months and 5 days ago", english);
417     }
418 }
419 
420 #[cfg(test)]
421 mod utc {
422     use chrono::Utc;
423     use chrono_humanize::HumanTime;
424 
425     #[test]
now()426     fn now() {
427         let ht = HumanTime::from(Utc::now());
428         let english = format!("{:#}", ht);
429         assert_eq!("0 seconds", english);
430     }
431 }
432 
433 #[cfg(test1)]
434 mod local {
435     use chrono::{Duration, Local};
436     use chrono_humanize::HumanTime;
437 
438     #[test]
now()439     fn now() {
440         let ht = HumanTime::from(Local::now());
441         let english = format!("{:#}", ht);
442         assert_eq!("0 seconds", english);
443     }
444 
445     #[test]
minus_35d()446     fn minus_35d() {
447         let past = Local::now() - Duration::days(35);
448         let ht = HumanTime::from(past);
449         let english = format!("{:#}", ht);
450         assert_eq!("1 month ago", english);
451     }
452 
453     #[test]
plus_35d()454     fn plus_35d() {
455         let future = Local::now() + Duration::days(35);
456         let ht = HumanTime::from(future);
457         let english = format!("{:#}", ht);
458         assert_eq!("in 1 month", english);
459     }
460 }
461