ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/TimeUnitTest.java

Comparing jsr166/src/test/tck/TimeUnitTest.java (file contents):
Revision 1.36 by jsr166, Thu Sep 5 21:55:17 2019 UTC vs.
Revision 1.37 by jsr166, Sun Sep 8 23:45:54 2019 UTC

#	Line 29 | Line 29 | public class TimeUnitTest extends JSR166
29		return new TestSuite(TimeUnitTest.class);
30		}
31
32	<	// (loops to 88888 check increments at all time divisions.)
33	<
34	<	/**
35	<	* convert correctly converts sample values across the units
36	<	*/
37	<	public void testConvert() {
38	<	for (long t = 0; t < 88888; ++t) {
39	<	assertEquals(t*60*60*24,
40	<	SECONDS.convert(t, DAYS));
41	<	assertEquals(t*60*60,
42	<	SECONDS.convert(t, HOURS));
43	<	assertEquals(t*60,
44	<	SECONDS.convert(t, MINUTES));
45	<	assertEquals(t,
46	<	SECONDS.convert(t, SECONDS));
47	<	assertEquals(t,
48	<	SECONDS.convert(1000L*t, MILLISECONDS));
49	<	assertEquals(t,
50	<	SECONDS.convert(1000000L*t, MICROSECONDS));
51	<	assertEquals(t,
52	<	SECONDS.convert(1000000000L*t, NANOSECONDS));
53	<
54	<	assertEquals(1000L*t*60*60*24,
55	<	MILLISECONDS.convert(t, DAYS));
56	<	assertEquals(1000L*t*60*60,
57	<	MILLISECONDS.convert(t, HOURS));
58	<	assertEquals(1000L*t*60,
59	<	MILLISECONDS.convert(t, MINUTES));
60	<	assertEquals(1000L*t,
61	<	MILLISECONDS.convert(t, SECONDS));
62	<	assertEquals(t,
63	<	MILLISECONDS.convert(t, MILLISECONDS));
64	<	assertEquals(t,
65	<	MILLISECONDS.convert(1000L*t, MICROSECONDS));
66	<	assertEquals(t,
67	<	MILLISECONDS.convert(1000000L*t, NANOSECONDS));
68	<
69	<	assertEquals(1000000L*t*60*60*24,
70	<	MICROSECONDS.convert(t, DAYS));
71	<	assertEquals(1000000L*t*60*60,
72	<	MICROSECONDS.convert(t, HOURS));
73	<	assertEquals(1000000L*t*60,
74	<	MICROSECONDS.convert(t, MINUTES));
75	<	assertEquals(1000000L*t,
76	<	MICROSECONDS.convert(t, SECONDS));
77	<	assertEquals(1000L*t,
78	<	MICROSECONDS.convert(t, MILLISECONDS));
79	<	assertEquals(t,
80	<	MICROSECONDS.convert(t, MICROSECONDS));
81	<	assertEquals(t,
82	<	MICROSECONDS.convert(1000L*t, NANOSECONDS));
83	<
84	<	assertEquals(1000000000L*t*60*60*24,
85	<	NANOSECONDS.convert(t, DAYS));
86	<	assertEquals(1000000000L*t*60*60,
87	<	NANOSECONDS.convert(t, HOURS));
88	<	assertEquals(1000000000L*t*60,
89	<	NANOSECONDS.convert(t, MINUTES));
90	<	assertEquals(1000000000L*t,
91	<	NANOSECONDS.convert(t, SECONDS));
92	<	assertEquals(1000000L*t,
93	<	NANOSECONDS.convert(t, MILLISECONDS));
94	<	assertEquals(1000L*t,
95	<	NANOSECONDS.convert(t, MICROSECONDS));
96	<	assertEquals(t,
97	<	NANOSECONDS.convert(t, NANOSECONDS));
98	<	}
99	<
100	<	for (TimeUnit x : TimeUnit.values()) {
101	<	long[] zs = {
102	<	0, 1, -1,
103	<	Integer.MAX_VALUE, Integer.MIN_VALUE,
104	<	Long.MAX_VALUE, Long.MIN_VALUE,
105	<	};
106	<	for (long z : zs) assertEquals(z, x.convert(z, x));
107	<	}
108	<	}
109	<
110	<	/**
111	<	* toNanos correctly converts sample values in different units to
112	<	* nanoseconds
113	<	*/
114	<	public void testToNanos() {
115	<	for (long t = 0; t < 88888; ++t) {
116	<	assertEquals(t*1000000000L*60*60*24,
117	<	DAYS.toNanos(t));
118	<	assertEquals(t*1000000000L*60*60,
119	<	HOURS.toNanos(t));
120	<	assertEquals(t*1000000000L*60,
121	<	MINUTES.toNanos(t));
122	<	assertEquals(1000000000L*t,
123	<	SECONDS.toNanos(t));
124	<	assertEquals(1000000L*t,
125	<	MILLISECONDS.toNanos(t));
126	<	assertEquals(1000L*t,
127	<	MICROSECONDS.toNanos(t));
128	<	assertEquals(t,
129	<	NANOSECONDS.toNanos(t));
130	<	}
131	<	}
132	<
133	<	/**
134	<	* toMicros correctly converts sample values in different units to
135	<	* microseconds
136	<	*/
137	<	public void testToMicros() {
138	<	for (long t = 0; t < 88888; ++t) {
139	<	assertEquals(t*1000000L*60*60*24,
140	<	DAYS.toMicros(t));
141	<	assertEquals(t*1000000L*60*60,
142	<	HOURS.toMicros(t));
143	<	assertEquals(t*1000000L*60,
144	<	MINUTES.toMicros(t));
145	<	assertEquals(1000000L*t,
146	<	SECONDS.toMicros(t));
147	<	assertEquals(1000L*t,
148	<	MILLISECONDS.toMicros(t));
149	<	assertEquals(t,
150	<	MICROSECONDS.toMicros(t));
151	<	assertEquals(t,
152	<	NANOSECONDS.toMicros(t*1000L));
153	<	}
154	<	}
155	<
156	<	/**
157	<	* toMillis correctly converts sample values in different units to
158	<	* milliseconds
159	<	*/
160	<	public void testToMillis() {
161	<	for (long t = 0; t < 88888; ++t) {
162	<	assertEquals(t*1000L*60*60*24,
163	<	DAYS.toMillis(t));
164	<	assertEquals(t*1000L*60*60,
165	<	HOURS.toMillis(t));
166	<	assertEquals(t*1000L*60,
167	<	MINUTES.toMillis(t));
168	<	assertEquals(1000L*t,
169	<	SECONDS.toMillis(t));
170	<	assertEquals(t,
171	<	MILLISECONDS.toMillis(t));
172	<	assertEquals(t,
173	<	MICROSECONDS.toMillis(t*1000L));
174	<	assertEquals(t,
175	<	NANOSECONDS.toMillis(t*1000000L));
32	>	void testConversion(TimeUnit x, TimeUnit y, long n, long expected) {
33	>	assertEquals(expected, x.convert(n, y));
34	>	switch (x) {
35	>	case NANOSECONDS:  assertEquals(expected, y.toNanos(n));   break;
36	>	case MICROSECONDS: assertEquals(expected, y.toMicros(n));  break;
37	>	case MILLISECONDS: assertEquals(expected, y.toMillis(n));  break;
38	>	case SECONDS:      assertEquals(expected, y.toSeconds(n)); break;
39	>	case MINUTES:      assertEquals(expected, y.toMinutes(n)); break;
40	>	case HOURS:        assertEquals(expected, y.toHours(n));   break;
41	>	case DAYS:         assertEquals(expected, y.toDays(n));    break;
42	>	default: throw new AssertionError();
43	>	}
44	>
45	>	if (n > 0) testConversion(x, y, -n, -expected);
46	>	}
47	>
48	>	void testConversion(TimeUnit x, TimeUnit y) {
49	>	long ratio = x.toNanos(1)/y.toNanos(1);
50	>	assertTrue(ratio > 0);
51	>	long[] ns = { 0, 1, 2, Long.MAX_VALUE/ratio, Long.MIN_VALUE/ratio };
52	>	for (long n : ns) {
53	>	testConversion(y, x, n, n * ratio);
54	>	long[] ks = { n * ratio, n * ratio + 1, n * ratio - 1 };
55	>	for (long k : ks) {
56	>	testConversion(x, y, k, k / ratio);
57	>	}
58		}
59		}
60
61		/**
62	<	* toSeconds correctly converts sample values in different units to
63	<	* seconds
64	<	*/
65	<	public void testToSeconds() {
66	<	for (long t = 0; t < 88888; ++t) {
67	<	assertEquals(t*60*60*24,
68	<	DAYS.toSeconds(t));
69	<	assertEquals(t*60*60,
70	<	HOURS.toSeconds(t));
71	<	assertEquals(t*60,
72	<	MINUTES.toSeconds(t));
191	<	assertEquals(t,
192	<	SECONDS.toSeconds(t));
193	<	assertEquals(t,
194	<	MILLISECONDS.toSeconds(t*1000L));
195	<	assertEquals(t,
196	<	MICROSECONDS.toSeconds(t*1000000L));
197	<	assertEquals(t,
198	<	NANOSECONDS.toSeconds(t*1000000000L));
199	<	}
200	<	}
201	<
202	<	/**
203	<	* toMinutes correctly converts sample values in different units to
204	<	* minutes
205	<	*/
206	<	public void testToMinutes() {
207	<	for (long t = 0; t < 88888; ++t) {
208	<	assertEquals(t*60*24,
209	<	DAYS.toMinutes(t));
210	<	assertEquals(t*60,
211	<	HOURS.toMinutes(t));
212	<	assertEquals(t,
213	<	MINUTES.toMinutes(t));
214	<	assertEquals(t,
215	<	SECONDS.toMinutes(t*60));
216	<	assertEquals(t,
217	<	MILLISECONDS.toMinutes(t*1000L*60));
218	<	assertEquals(t,
219	<	MICROSECONDS.toMinutes(t*1000000L*60));
220	<	assertEquals(t,
221	<	NANOSECONDS.toMinutes(t*1000000000L*60));
222	<	}
223	<	}
62	>	* Conversion methods correctly convert sample values
63	>	*/
64	>	public void testConversions() {
65	>	// Sanity check
66	>	assertEquals(1, NANOSECONDS.toNanos(1));
67	>	assertEquals(1000L * NANOSECONDS.toNanos(1), MICROSECONDS.toNanos(1));
68	>	assertEquals(1000L * MICROSECONDS.toNanos(1), MILLISECONDS.toNanos(1));
69	>	assertEquals(1000L * MILLISECONDS.toNanos(1), SECONDS.toNanos(1));
70	>	assertEquals(60L * SECONDS.toNanos(1), MINUTES.toNanos(1));
71	>	assertEquals(60L * MINUTES.toNanos(1), HOURS.toNanos(1));
72	>	assertEquals(24L * HOURS.toNanos(1), DAYS.toNanos(1));
73
74	<	/**
75	<	* toHours correctly converts sample values in different units to
227	<	* hours
228	<	*/
229	<	public void testToHours() {
230	<	for (long t = 0; t < 88888; ++t) {
231	<	assertEquals(t*24,
232	<	DAYS.toHours(t));
233	<	assertEquals(t,
234	<	HOURS.toHours(t));
235	<	assertEquals(t,
236	<	MINUTES.toHours(t*60));
237	<	assertEquals(t,
238	<	SECONDS.toHours(t*60*60));
239	<	assertEquals(t,
240	<	MILLISECONDS.toHours(t*1000L*60*60));
241	<	assertEquals(t,
242	<	MICROSECONDS.toHours(t*1000000L*60*60));
243	<	assertEquals(t,
244	<	NANOSECONDS.toHours(t*1000000000L*60*60));
74	>	for (TimeUnit x : TimeUnit.values()) {
75	>	assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76		}
246	–	}
77
78	<	/**
79	<	* toDays correctly converts sample values in different units to
80	<	* days
81	<	*/
252	<	public void testToDays() {
253	<	for (long t = 0; t < 88888; ++t) {
254	<	assertEquals(t,
255	<	DAYS.toDays(t));
256	<	assertEquals(t,
257	<	HOURS.toDays(t*24));
258	<	assertEquals(t,
259	<	MINUTES.toDays(t*60*24));
260	<	assertEquals(t,
261	<	SECONDS.toDays(t*60*60*24));
262	<	assertEquals(t,
263	<	MILLISECONDS.toDays(t*1000L*60*60*24));
264	<	assertEquals(t,
265	<	MICROSECONDS.toDays(t*1000000L*60*60*24));
266	<	assertEquals(t,
267	<	NANOSECONDS.toDays(t*1000000000L*60*60*24));
268	<	}
78	>	for (TimeUnit x : TimeUnit.values())
79	>	for (TimeUnit y : TimeUnit.values())
80	>	if (x.toNanos(1) >= y.toNanos(1))
81	>	testConversion(x, y);
82		}
83
84		/**

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines