Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Written by Doug Lea with assistance from members of JCP JSR-166 |
| 3 | * Expert Group and released to the public domain, as explained at |
| 4 | * http://creativecommons.org/publicdomain/zero/1.0/ |
| 5 | * Other contributors include Andrew Wright, Jeffrey Hayes, |
| 6 | * Pat Fisher, Mike Judd. |
| 7 | */ |
| 8 | |
| 9 | package jsr166; |
| 10 | |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 11 | import static java.util.concurrent.TimeUnit.DAYS; |
| 12 | import static java.util.concurrent.TimeUnit.HOURS; |
| 13 | import static java.util.concurrent.TimeUnit.MICROSECONDS; |
| 14 | import static java.util.concurrent.TimeUnit.MILLISECONDS; |
| 15 | import static java.util.concurrent.TimeUnit.MINUTES; |
| 16 | import static java.util.concurrent.TimeUnit.NANOSECONDS; |
| 17 | import static java.util.concurrent.TimeUnit.SECONDS; |
| 18 | |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 19 | import java.util.concurrent.CountDownLatch; |
| 20 | import java.util.concurrent.TimeUnit; |
| 21 | |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 22 | import junit.framework.Test; |
| 23 | import junit.framework.TestSuite; |
| 24 | |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 25 | public class TimeUnitTest extends JSR166TestCase { |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 26 | // android-note: Removed because the CTS runner does a bad job of |
| 27 | // retrying tests that have suite() declarations. |
| 28 | // |
| 29 | // public static void main(String[] args) { |
| 30 | // main(suite(), args); |
| 31 | // } |
| 32 | // public static Test suite() { |
Przemyslaw Szczepaniak | b8b7511 | 2016-03-11 15:59:10 +0000 | [diff] [blame] | 33 | // return new TestSuite(TimeUnitTest.class); |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 34 | // } |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 35 | |
| 36 | // (loops to 88888 check increments at all time divisions.) |
| 37 | |
| 38 | /** |
| 39 | * convert correctly converts sample values across the units |
| 40 | */ |
| 41 | public void testConvert() { |
| 42 | for (long t = 0; t < 88888; ++t) { |
| 43 | assertEquals(t*60*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 44 | SECONDS.convert(t, DAYS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 45 | assertEquals(t*60*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 46 | SECONDS.convert(t, HOURS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 47 | assertEquals(t*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 48 | SECONDS.convert(t, MINUTES)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 49 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 50 | SECONDS.convert(t, SECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 51 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 52 | SECONDS.convert(1000L*t, MILLISECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 53 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 54 | SECONDS.convert(1000000L*t, MICROSECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 55 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 56 | SECONDS.convert(1000000000L*t, NANOSECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 57 | |
| 58 | assertEquals(1000L*t*60*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 59 | MILLISECONDS.convert(t, DAYS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 60 | assertEquals(1000L*t*60*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 61 | MILLISECONDS.convert(t, HOURS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 62 | assertEquals(1000L*t*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 63 | MILLISECONDS.convert(t, MINUTES)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 64 | assertEquals(1000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 65 | MILLISECONDS.convert(t, SECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 66 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 67 | MILLISECONDS.convert(t, MILLISECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 68 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 69 | MILLISECONDS.convert(1000L*t, MICROSECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 70 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 71 | MILLISECONDS.convert(1000000L*t, NANOSECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 72 | |
| 73 | assertEquals(1000000L*t*60*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 74 | MICROSECONDS.convert(t, DAYS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 75 | assertEquals(1000000L*t*60*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 76 | MICROSECONDS.convert(t, HOURS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 77 | assertEquals(1000000L*t*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 78 | MICROSECONDS.convert(t, MINUTES)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 79 | assertEquals(1000000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 80 | MICROSECONDS.convert(t, SECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 81 | assertEquals(1000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 82 | MICROSECONDS.convert(t, MILLISECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 83 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 84 | MICROSECONDS.convert(t, MICROSECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 85 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 86 | MICROSECONDS.convert(1000L*t, NANOSECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 87 | |
| 88 | assertEquals(1000000000L*t*60*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 89 | NANOSECONDS.convert(t, DAYS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 90 | assertEquals(1000000000L*t*60*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 91 | NANOSECONDS.convert(t, HOURS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 92 | assertEquals(1000000000L*t*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 93 | NANOSECONDS.convert(t, MINUTES)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 94 | assertEquals(1000000000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 95 | NANOSECONDS.convert(t, SECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 96 | assertEquals(1000000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 97 | NANOSECONDS.convert(t, MILLISECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 98 | assertEquals(1000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 99 | NANOSECONDS.convert(t, MICROSECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 100 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 101 | NANOSECONDS.convert(t, NANOSECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 102 | } |
| 103 | } |
| 104 | |
| 105 | /** |
| 106 | * toNanos correctly converts sample values in different units to |
| 107 | * nanoseconds |
| 108 | */ |
| 109 | public void testToNanos() { |
| 110 | for (long t = 0; t < 88888; ++t) { |
| 111 | assertEquals(t*1000000000L*60*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 112 | DAYS.toNanos(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 113 | assertEquals(t*1000000000L*60*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 114 | HOURS.toNanos(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 115 | assertEquals(t*1000000000L*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 116 | MINUTES.toNanos(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 117 | assertEquals(1000000000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 118 | SECONDS.toNanos(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 119 | assertEquals(1000000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 120 | MILLISECONDS.toNanos(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 121 | assertEquals(1000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 122 | MICROSECONDS.toNanos(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 123 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 124 | NANOSECONDS.toNanos(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 125 | } |
| 126 | } |
| 127 | |
| 128 | /** |
| 129 | * toMicros correctly converts sample values in different units to |
| 130 | * microseconds |
| 131 | */ |
| 132 | public void testToMicros() { |
| 133 | for (long t = 0; t < 88888; ++t) { |
| 134 | assertEquals(t*1000000L*60*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 135 | DAYS.toMicros(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 136 | assertEquals(t*1000000L*60*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 137 | HOURS.toMicros(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 138 | assertEquals(t*1000000L*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 139 | MINUTES.toMicros(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 140 | assertEquals(1000000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 141 | SECONDS.toMicros(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 142 | assertEquals(1000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 143 | MILLISECONDS.toMicros(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 144 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 145 | MICROSECONDS.toMicros(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 146 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 147 | NANOSECONDS.toMicros(t*1000L)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 148 | } |
| 149 | } |
| 150 | |
| 151 | /** |
| 152 | * toMillis correctly converts sample values in different units to |
| 153 | * milliseconds |
| 154 | */ |
| 155 | public void testToMillis() { |
| 156 | for (long t = 0; t < 88888; ++t) { |
| 157 | assertEquals(t*1000L*60*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 158 | DAYS.toMillis(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 159 | assertEquals(t*1000L*60*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 160 | HOURS.toMillis(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 161 | assertEquals(t*1000L*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 162 | MINUTES.toMillis(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 163 | assertEquals(1000L*t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 164 | SECONDS.toMillis(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 165 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 166 | MILLISECONDS.toMillis(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 167 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 168 | MICROSECONDS.toMillis(t*1000L)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 169 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 170 | NANOSECONDS.toMillis(t*1000000L)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 171 | } |
| 172 | } |
| 173 | |
| 174 | /** |
| 175 | * toSeconds correctly converts sample values in different units to |
| 176 | * seconds |
| 177 | */ |
| 178 | public void testToSeconds() { |
| 179 | for (long t = 0; t < 88888; ++t) { |
| 180 | assertEquals(t*60*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 181 | DAYS.toSeconds(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 182 | assertEquals(t*60*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 183 | HOURS.toSeconds(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 184 | assertEquals(t*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 185 | MINUTES.toSeconds(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 186 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 187 | SECONDS.toSeconds(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 188 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 189 | MILLISECONDS.toSeconds(t*1000L)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 190 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 191 | MICROSECONDS.toSeconds(t*1000000L)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 192 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 193 | NANOSECONDS.toSeconds(t*1000000000L)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 194 | } |
| 195 | } |
| 196 | |
| 197 | /** |
| 198 | * toMinutes correctly converts sample values in different units to |
| 199 | * minutes |
| 200 | */ |
| 201 | public void testToMinutes() { |
| 202 | for (long t = 0; t < 88888; ++t) { |
| 203 | assertEquals(t*60*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 204 | DAYS.toMinutes(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 205 | assertEquals(t*60, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 206 | HOURS.toMinutes(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 207 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 208 | MINUTES.toMinutes(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 209 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 210 | SECONDS.toMinutes(t*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 211 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 212 | MILLISECONDS.toMinutes(t*1000L*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 213 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 214 | MICROSECONDS.toMinutes(t*1000000L*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 215 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 216 | NANOSECONDS.toMinutes(t*1000000000L*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 217 | } |
| 218 | } |
| 219 | |
| 220 | /** |
| 221 | * toHours correctly converts sample values in different units to |
| 222 | * hours |
| 223 | */ |
| 224 | public void testToHours() { |
| 225 | for (long t = 0; t < 88888; ++t) { |
| 226 | assertEquals(t*24, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 227 | DAYS.toHours(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 228 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 229 | HOURS.toHours(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 230 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 231 | MINUTES.toHours(t*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 232 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 233 | SECONDS.toHours(t*60*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 234 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 235 | MILLISECONDS.toHours(t*1000L*60*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 236 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 237 | MICROSECONDS.toHours(t*1000000L*60*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 238 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 239 | NANOSECONDS.toHours(t*1000000000L*60*60)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 240 | } |
| 241 | } |
| 242 | |
| 243 | /** |
| 244 | * toDays correctly converts sample values in different units to |
| 245 | * days |
| 246 | */ |
| 247 | public void testToDays() { |
| 248 | for (long t = 0; t < 88888; ++t) { |
| 249 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 250 | DAYS.toDays(t)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 251 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 252 | HOURS.toDays(t*24)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 253 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 254 | MINUTES.toDays(t*60*24)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 255 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 256 | SECONDS.toDays(t*60*60*24)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 257 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 258 | MILLISECONDS.toDays(t*1000L*60*60*24)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 259 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 260 | MICROSECONDS.toDays(t*1000000L*60*60*24)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 261 | assertEquals(t, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 262 | NANOSECONDS.toDays(t*1000000000L*60*60*24)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 263 | } |
| 264 | } |
| 265 | |
| 266 | /** |
| 267 | * convert saturates positive too-large values to Long.MAX_VALUE |
| 268 | * and negative to LONG.MIN_VALUE |
| 269 | */ |
| 270 | public void testConvertSaturate() { |
| 271 | assertEquals(Long.MAX_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 272 | NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 273 | assertEquals(Long.MIN_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 274 | NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 275 | assertEquals(Long.MAX_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 276 | NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 277 | assertEquals(Long.MIN_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 278 | NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 279 | assertEquals(Long.MAX_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 280 | NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 281 | assertEquals(Long.MIN_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 282 | NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 283 | assertEquals(Long.MAX_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 284 | NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 285 | assertEquals(Long.MIN_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 286 | NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | /** |
| 290 | * toNanos saturates positive too-large values to Long.MAX_VALUE |
| 291 | * and negative to LONG.MIN_VALUE |
| 292 | */ |
| 293 | public void testToNanosSaturate() { |
| 294 | assertEquals(Long.MAX_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 295 | MILLISECONDS.toNanos(Long.MAX_VALUE / 2)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 296 | assertEquals(Long.MIN_VALUE, |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 297 | MILLISECONDS.toNanos(-Long.MAX_VALUE / 3)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 298 | } |
| 299 | |
| 300 | /** |
| 301 | * toString returns name of unit |
| 302 | */ |
| 303 | public void testToString() { |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 304 | assertEquals("SECONDS", SECONDS.toString()); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 305 | } |
| 306 | |
| 307 | /** |
| 308 | * name returns name of unit |
| 309 | */ |
| 310 | public void testName() { |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 311 | assertEquals("SECONDS", SECONDS.name()); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 312 | } |
| 313 | |
| 314 | /** |
| 315 | * Timed wait without holding lock throws |
| 316 | * IllegalMonitorStateException |
| 317 | */ |
| 318 | public void testTimedWait_IllegalMonitorException() { |
| 319 | Thread t = newStartedThread(new CheckedRunnable() { |
| 320 | public void realRun() throws InterruptedException { |
| 321 | Object o = new Object(); |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 322 | TimeUnit tu = MILLISECONDS; |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 323 | |
| 324 | try { |
| 325 | tu.timedWait(o, LONG_DELAY_MS); |
| 326 | threadShouldThrow(); |
| 327 | } catch (IllegalMonitorStateException success) {} |
| 328 | }}); |
| 329 | |
| 330 | awaitTermination(t); |
| 331 | } |
| 332 | |
| 333 | /** |
| 334 | * timedWait throws InterruptedException when interrupted |
| 335 | */ |
| 336 | public void testTimedWait_Interruptible() { |
| 337 | final CountDownLatch pleaseInterrupt = new CountDownLatch(1); |
| 338 | Thread t = newStartedThread(new CheckedRunnable() { |
| 339 | public void realRun() throws InterruptedException { |
| 340 | Object o = new Object(); |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 341 | TimeUnit tu = MILLISECONDS; |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 342 | |
| 343 | Thread.currentThread().interrupt(); |
| 344 | try { |
| 345 | synchronized (o) { |
| 346 | tu.timedWait(o, LONG_DELAY_MS); |
| 347 | } |
| 348 | shouldThrow(); |
| 349 | } catch (InterruptedException success) {} |
| 350 | assertFalse(Thread.interrupted()); |
| 351 | |
| 352 | pleaseInterrupt.countDown(); |
| 353 | try { |
| 354 | synchronized (o) { |
| 355 | tu.timedWait(o, LONG_DELAY_MS); |
| 356 | } |
| 357 | shouldThrow(); |
| 358 | } catch (InterruptedException success) {} |
| 359 | assertFalse(Thread.interrupted()); |
| 360 | }}); |
| 361 | |
| 362 | await(pleaseInterrupt); |
| 363 | assertThreadStaysAlive(t); |
| 364 | t.interrupt(); |
| 365 | awaitTermination(t); |
| 366 | } |
| 367 | |
| 368 | /** |
| 369 | * timedJoin throws InterruptedException when interrupted |
| 370 | */ |
| 371 | public void testTimedJoin_Interruptible() { |
| 372 | final CountDownLatch pleaseInterrupt = new CountDownLatch(1); |
| 373 | final Thread s = newStartedThread(new CheckedInterruptedRunnable() { |
| 374 | public void realRun() throws InterruptedException { |
| 375 | Thread.sleep(LONG_DELAY_MS); |
| 376 | }}); |
| 377 | final Thread t = newStartedThread(new CheckedRunnable() { |
| 378 | public void realRun() throws InterruptedException { |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 379 | TimeUnit tu = MILLISECONDS; |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 380 | Thread.currentThread().interrupt(); |
| 381 | try { |
| 382 | tu.timedJoin(s, LONG_DELAY_MS); |
| 383 | shouldThrow(); |
| 384 | } catch (InterruptedException success) {} |
| 385 | assertFalse(Thread.interrupted()); |
| 386 | |
| 387 | pleaseInterrupt.countDown(); |
| 388 | try { |
| 389 | tu.timedJoin(s, LONG_DELAY_MS); |
| 390 | shouldThrow(); |
| 391 | } catch (InterruptedException success) {} |
| 392 | assertFalse(Thread.interrupted()); |
| 393 | }}); |
| 394 | |
| 395 | await(pleaseInterrupt); |
| 396 | assertThreadStaysAlive(t); |
| 397 | t.interrupt(); |
| 398 | awaitTermination(t); |
| 399 | s.interrupt(); |
| 400 | awaitTermination(s); |
| 401 | } |
| 402 | |
| 403 | /** |
| 404 | * timedSleep throws InterruptedException when interrupted |
| 405 | */ |
| 406 | public void testTimedSleep_Interruptible() { |
| 407 | final CountDownLatch pleaseInterrupt = new CountDownLatch(1); |
| 408 | Thread t = newStartedThread(new CheckedRunnable() { |
| 409 | public void realRun() throws InterruptedException { |
Narayan Kamath | 8e9a0e9 | 2015-04-28 11:40:00 +0100 | [diff] [blame] | 410 | TimeUnit tu = MILLISECONDS; |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 411 | Thread.currentThread().interrupt(); |
| 412 | try { |
| 413 | tu.sleep(LONG_DELAY_MS); |
| 414 | shouldThrow(); |
| 415 | } catch (InterruptedException success) {} |
| 416 | assertFalse(Thread.interrupted()); |
| 417 | |
| 418 | pleaseInterrupt.countDown(); |
| 419 | try { |
| 420 | tu.sleep(LONG_DELAY_MS); |
| 421 | shouldThrow(); |
| 422 | } catch (InterruptedException success) {} |
| 423 | assertFalse(Thread.interrupted()); |
| 424 | }}); |
| 425 | |
| 426 | await(pleaseInterrupt); |
| 427 | assertThreadStaysAlive(t); |
| 428 | t.interrupt(); |
| 429 | awaitTermination(t); |
| 430 | } |
| 431 | |
| 432 | /** |
| 433 | * a deserialized serialized unit is the same instance |
| 434 | */ |
| 435 | public void testSerialization() throws Exception { |
Przemyslaw Szczepaniak | b8b7511 | 2016-03-11 15:59:10 +0000 | [diff] [blame] | 436 | for (TimeUnit x : TimeUnit.values()) |
| 437 | assertSame(x, serialClone(x)); |
Calin Juravle | 8f0d92b | 2013-08-01 17:26:00 +0100 | [diff] [blame] | 438 | } |
| 439 | |
| 440 | } |