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