[cvs] / jsr166 / src / test / tck / TimeUnitTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/TimeUnitTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.8, Tue Jan 13 12:59:29 2004 UTC revision 1.9, Thu Dec 30 13:04:50 2004 UTC
# Line 20  Line 20 
20          return new TestSuite(TimeUnitTest.class);          return new TestSuite(TimeUnitTest.class);
21      }      }
22    
23        // (loops to 88888 check increments at all time divisions.)
24    
25      /**      /**
26       * convert correctly converts sample values across the four units       * convert correctly converts sample values across the units
27       */       */
28      public void testConvert() {      public void testConvert() {
29          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
30                assertEquals(t*60*60*24,
31                             TimeUnit.SECONDS.convert(t,
32                                                      TimeUnit.DAYS));
33                assertEquals(t*60*60,
34                             TimeUnit.SECONDS.convert(t,
35                                                      TimeUnit.HOURS));
36                assertEquals(t*60,
37                             TimeUnit.SECONDS.convert(t,
38                                                      TimeUnit.MINUTES));
39              assertEquals(t,              assertEquals(t,
40                           TimeUnit.SECONDS.convert(t,                           TimeUnit.SECONDS.convert(t,
41                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
42              assertEquals(t,              assertEquals(t,
43                           TimeUnit.SECONDS.convert(1000 * t,                           TimeUnit.SECONDS.convert(1000L*t,
44                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
45              assertEquals(t,              assertEquals(t,
46                           TimeUnit.SECONDS.convert(1000000 * t,                           TimeUnit.SECONDS.convert(1000000L*t,
47                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
48              assertEquals(t,              assertEquals(t,
49                           TimeUnit.SECONDS.convert(1000000000 * t,                           TimeUnit.SECONDS.convert(1000000000L*t,
50                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
51              assertEquals(1000 * t,  
52    
53                assertEquals(1000L*t*60*60*24,
54                             TimeUnit.MILLISECONDS.convert(t,
55                                                      TimeUnit.DAYS));
56                assertEquals(1000L*t*60*60,
57                             TimeUnit.MILLISECONDS.convert(t,
58                                                      TimeUnit.HOURS));
59                assertEquals(1000L*t*60,
60                             TimeUnit.MILLISECONDS.convert(t,
61                                                      TimeUnit.MINUTES));
62                assertEquals(1000L*t,
63                           TimeUnit.MILLISECONDS.convert(t,                           TimeUnit.MILLISECONDS.convert(t,
64                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
65              assertEquals(t,              assertEquals(t,
66                           TimeUnit.MILLISECONDS.convert(t,                           TimeUnit.MILLISECONDS.convert(t,
67                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
68              assertEquals(t,              assertEquals(t,
69                           TimeUnit.MILLISECONDS.convert(1000 * t,                           TimeUnit.MILLISECONDS.convert(1000L*t,
70                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
71              assertEquals(t,              assertEquals(t,
72                           TimeUnit.MILLISECONDS.convert(1000000 * t,                           TimeUnit.MILLISECONDS.convert(1000000L*t,
73                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
74              assertEquals(1000000 * t,  
75                assertEquals(1000000L*t*60*60*24,
76                             TimeUnit.MICROSECONDS.convert(t,
77                                                      TimeUnit.DAYS));
78                assertEquals(1000000L*t*60*60,
79                             TimeUnit.MICROSECONDS.convert(t,
80                                                      TimeUnit.HOURS));
81                assertEquals(1000000L*t*60,
82                             TimeUnit.MICROSECONDS.convert(t,
83                                                      TimeUnit.MINUTES));
84                assertEquals(1000000L*t,
85                           TimeUnit.MICROSECONDS.convert(t,                           TimeUnit.MICROSECONDS.convert(t,
86                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
87              assertEquals(1000 * t,              assertEquals(1000L*t,
88                           TimeUnit.MICROSECONDS.convert(t,                           TimeUnit.MICROSECONDS.convert(t,
89                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
90              assertEquals(t,              assertEquals(t,
91                           TimeUnit.MICROSECONDS.convert(t,                           TimeUnit.MICROSECONDS.convert(t,
92                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
93              assertEquals(t,              assertEquals(t,
94                           TimeUnit.MICROSECONDS.convert(1000 * t,                           TimeUnit.MICROSECONDS.convert(1000L*t,
95                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
96              assertEquals(1000000000 * t,  
97                assertEquals(1000000000L*t*60*60*24,
98                             TimeUnit.NANOSECONDS.convert(t,
99                                                      TimeUnit.DAYS));
100                assertEquals(1000000000L*t*60*60,
101                             TimeUnit.NANOSECONDS.convert(t,
102                                                      TimeUnit.HOURS));
103                assertEquals(1000000000L*t*60,
104                             TimeUnit.NANOSECONDS.convert(t,
105                                                      TimeUnit.MINUTES));
106                assertEquals(1000000000L*t,
107                           TimeUnit.NANOSECONDS.convert(t,                           TimeUnit.NANOSECONDS.convert(t,
108                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
109              assertEquals(1000000 * t,              assertEquals(1000000L*t,
110                           TimeUnit.NANOSECONDS.convert(t,                           TimeUnit.NANOSECONDS.convert(t,
111                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
112              assertEquals(1000 * t,              assertEquals(1000L*t,
113                           TimeUnit.NANOSECONDS.convert(t,                           TimeUnit.NANOSECONDS.convert(t,
114                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
115              assertEquals(t,              assertEquals(t,
# Line 81  Line 123 
123       * nanoseconds       * nanoseconds
124       */       */
125      public void testToNanos() {      public void testToNanos() {
126          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
127              assertEquals(1000000000 * t,              assertEquals(t*1000000000L*60*60*24,
128                             TimeUnit.DAYS.toNanos(t));
129                assertEquals(t*1000000000L*60*60,
130                             TimeUnit.HOURS.toNanos(t));
131                assertEquals(t*1000000000L*60,
132                             TimeUnit.MINUTES.toNanos(t));
133                assertEquals(1000000000L*t,
134                           TimeUnit.SECONDS.toNanos(t));                           TimeUnit.SECONDS.toNanos(t));
135                assertEquals(1000000L*t,
             assertEquals(1000000 * t,  
136                           TimeUnit.MILLISECONDS.toNanos(t));                           TimeUnit.MILLISECONDS.toNanos(t));
137              assertEquals(1000 * t,              assertEquals(1000L*t,
138                           TimeUnit.MICROSECONDS.toNanos(t));                           TimeUnit.MICROSECONDS.toNanos(t));
139              assertEquals(t,              assertEquals(t,
140                           TimeUnit.NANOSECONDS.toNanos(t));                           TimeUnit.NANOSECONDS.toNanos(t));
# Line 99  Line 146 
146       * microseconds       * microseconds
147       */       */
148      public void testToMicros() {      public void testToMicros() {
149          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
150              assertEquals(1000000 * t,              assertEquals(t*1000000L*60*60*24,
151                             TimeUnit.DAYS.toMicros(t));
152                assertEquals(t*1000000L*60*60,
153                             TimeUnit.HOURS.toMicros(t));
154                assertEquals(t*1000000L*60,
155                             TimeUnit.MINUTES.toMicros(t));
156                assertEquals(1000000L*t,
157                           TimeUnit.SECONDS.toMicros(t));                           TimeUnit.SECONDS.toMicros(t));
158                assertEquals(1000L*t,
             assertEquals(1000 * t,  
159                           TimeUnit.MILLISECONDS.toMicros(t));                           TimeUnit.MILLISECONDS.toMicros(t));
160              assertEquals(t,              assertEquals(t,
161                           TimeUnit.MICROSECONDS.toMicros(t));                           TimeUnit.MICROSECONDS.toMicros(t));
162              assertEquals(t,              assertEquals(t,
163                           TimeUnit.NANOSECONDS.toMicros(t * 1000));                           TimeUnit.NANOSECONDS.toMicros(t*1000L));
164          }          }
165      }      }
166    
# Line 117  Line 169 
169       * milliseconds       * milliseconds
170       */       */
171      public void testToMillis() {      public void testToMillis() {
172          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
173              assertEquals(1000 * t,              assertEquals(t*1000L*60*60*24,
174                             TimeUnit.DAYS.toMillis(t));
175                assertEquals(t*1000L*60*60,
176                             TimeUnit.HOURS.toMillis(t));
177                assertEquals(t*1000L*60,
178                             TimeUnit.MINUTES.toMillis(t));
179                assertEquals(1000L*t,
180                           TimeUnit.SECONDS.toMillis(t));                           TimeUnit.SECONDS.toMillis(t));
   
181              assertEquals(t,              assertEquals(t,
182                           TimeUnit.MILLISECONDS.toMillis(t));                           TimeUnit.MILLISECONDS.toMillis(t));
183              assertEquals(t,              assertEquals(t,
184                           TimeUnit.MICROSECONDS.toMillis(t * 1000));                           TimeUnit.MICROSECONDS.toMillis(t*1000L));
185              assertEquals(t,              assertEquals(t,
186                           TimeUnit.NANOSECONDS.toMillis(t * 1000000));                           TimeUnit.NANOSECONDS.toMillis(t*1000000L));
187          }          }
188      }      }
189    
# Line 135  Line 192 
192       * seconds       * seconds
193       */       */
194      public void testToSeconds() {      public void testToSeconds() {
195          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
196                assertEquals(t*60*60*24,
197                             TimeUnit.DAYS.toSeconds(t));
198                assertEquals(t*60*60,
199                             TimeUnit.HOURS.toSeconds(t));
200                assertEquals(t*60,
201                             TimeUnit.MINUTES.toSeconds(t));
202              assertEquals(t,              assertEquals(t,
203                           TimeUnit.SECONDS.toSeconds(t));                           TimeUnit.SECONDS.toSeconds(t));
204                assertEquals(t,
205                             TimeUnit.MILLISECONDS.toSeconds(t*1000L));
206                assertEquals(t,
207                             TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
208                assertEquals(t,
209                             TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
210            }
211        }
212    
213        /**
214         * toMinutes correctly converts sample values in different units to
215         * minutes
216         */
217        public void testToMinutes() {
218            for (long t = 0; t < 88888; ++t) {
219                assertEquals(t*60*24,
220                             TimeUnit.DAYS.toMinutes(t));
221                assertEquals(t*60,
222                             TimeUnit.HOURS.toMinutes(t));
223                assertEquals(t,
224                             TimeUnit.MINUTES.toMinutes(t));
225                assertEquals(t,
226                             TimeUnit.SECONDS.toMinutes(t*60));
227              assertEquals(t,              assertEquals(t,
228                           TimeUnit.MILLISECONDS.toSeconds(t * 1000));                           TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));
229              assertEquals(t,              assertEquals(t,
230                           TimeUnit.MICROSECONDS.toSeconds(t * 1000000));                           TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));
231              assertEquals(t,              assertEquals(t,
232                           TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));                           TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));
233            }
234        }
235    
236        /**
237         * toHours correctly converts sample values in different units to
238         * hours
239         */
240        public void testToHours() {
241            for (long t = 0; t < 88888; ++t) {
242                assertEquals(t*24,
243                             TimeUnit.DAYS.toHours(t));
244                assertEquals(t,
245                             TimeUnit.HOURS.toHours(t));
246                assertEquals(t,
247                             TimeUnit.MINUTES.toHours(t*60));
248                assertEquals(t,
249                             TimeUnit.SECONDS.toHours(t*60*60));
250                assertEquals(t,
251                             TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));
252                assertEquals(t,
253                             TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));
254                assertEquals(t,
255                             TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));
256            }
257        }
258    
259        /**
260         * toDays correctly converts sample values in different units to
261         * days
262         */
263        public void testToDays() {
264            for (long t = 0; t < 88888; ++t) {
265                assertEquals(t,
266                             TimeUnit.DAYS.toDays(t));
267                assertEquals(t,
268                             TimeUnit.HOURS.toDays(t*24));
269                assertEquals(t,
270                             TimeUnit.MINUTES.toDays(t*60*24));
271                assertEquals(t,
272                             TimeUnit.SECONDS.toDays(t*60*60*24));
273                assertEquals(t,
274                             TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
275                assertEquals(t,
276                             TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
277                assertEquals(t,
278                             TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
279          }          }
280      }      }
281    
# Line 160  Line 291 
291          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
292                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
293                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
294            assertEquals(Long.MAX_VALUE,
295                         TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
296                                                      TimeUnit.MINUTES));
297            assertEquals(Long.MIN_VALUE,
298                         TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
299                                                      TimeUnit.MINUTES));
300            assertEquals(Long.MAX_VALUE,
301                         TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
302                                                      TimeUnit.HOURS));
303            assertEquals(Long.MIN_VALUE,
304                         TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
305                                                      TimeUnit.HOURS));
306            assertEquals(Long.MAX_VALUE,
307                         TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
308                                                      TimeUnit.DAYS));
309            assertEquals(Long.MIN_VALUE,
310                         TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
311                                                      TimeUnit.DAYS));
312    
313      }      }
314    
315      /**      /**

Legend:
Removed from v.1.8  
changed lines
  Added in v.1.9

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8