1/* GENERATED SOURCE. DO NOT MODIFY. */ 2// © 2016 and later: Unicode, Inc. and others. 3// License & terms of use: http://www.unicode.org/copyright.html#License 4/* 5 ******************************************************************************* 6 * Copyright (C) 2013-2016, International Business Machines Corporation and 7 * others. All Rights Reserved. 8 ******************************************************************************* 9 */ 10package android.icu.dev.test.format; 11 12import java.util.Locale; 13 14import org.junit.Test; 15 16import android.icu.dev.test.TestFmwk; 17import android.icu.math.BigDecimal; 18import android.icu.text.DisplayContext; 19import android.icu.text.NumberFormat; 20import android.icu.text.RelativeDateTimeFormatter; 21import android.icu.text.RelativeDateTimeFormatter.AbsoluteUnit; 22import android.icu.text.RelativeDateTimeFormatter.Direction; 23import android.icu.text.RelativeDateTimeFormatter.RelativeDateTimeUnit; 24import android.icu.text.RelativeDateTimeFormatter.RelativeUnit; 25import android.icu.text.RelativeDateTimeFormatter.Style; 26import android.icu.util.ULocale; 27 28public class RelativeDateTimeFormatterTest extends TestFmwk { 29 @Test 30 public void TestRelativeDateWithQuantity() { 31 Object[][] data = { 32 {0.0, Direction.NEXT, RelativeUnit.SECONDS, "in 0 seconds"}, 33 {0.5, Direction.NEXT, RelativeUnit.SECONDS, "in 0.5 seconds"}, 34 {1.0, Direction.NEXT, RelativeUnit.SECONDS, "in 1 second"}, 35 {2.0, Direction.NEXT, RelativeUnit.SECONDS, "in 2 seconds"}, 36 {0.0, Direction.NEXT, RelativeUnit.MINUTES, "in 0 minutes"}, 37 {0.5, Direction.NEXT, RelativeUnit.MINUTES, "in 0.5 minutes"}, 38 {1.0, Direction.NEXT, RelativeUnit.MINUTES, "in 1 minute"}, 39 {2.0, Direction.NEXT, RelativeUnit.MINUTES, "in 2 minutes"}, 40 {0.0, Direction.NEXT, RelativeUnit.HOURS, "in 0 hours"}, 41 {0.5, Direction.NEXT, RelativeUnit.HOURS, "in 0.5 hours"}, 42 {1.0, Direction.NEXT, RelativeUnit.HOURS, "in 1 hour"}, 43 {2.0, Direction.NEXT, RelativeUnit.HOURS, "in 2 hours"}, 44 {0.0, Direction.NEXT, RelativeUnit.DAYS, "in 0 days"}, 45 {0.5, Direction.NEXT, RelativeUnit.DAYS, "in 0.5 days"}, 46 {1.0, Direction.NEXT, RelativeUnit.DAYS, "in 1 day"}, 47 {2.0, Direction.NEXT, RelativeUnit.DAYS, "in 2 days"}, 48 {0.0, Direction.NEXT, RelativeUnit.WEEKS, "in 0 weeks"}, 49 {0.5, Direction.NEXT, RelativeUnit.WEEKS, "in 0.5 weeks"}, 50 {1.0, Direction.NEXT, RelativeUnit.WEEKS, "in 1 week"}, 51 {2.0, Direction.NEXT, RelativeUnit.WEEKS, "in 2 weeks"}, 52 {0.0, Direction.NEXT, RelativeUnit.MONTHS, "in 0 months"}, 53 {0.5, Direction.NEXT, RelativeUnit.MONTHS, "in 0.5 months"}, 54 {1.0, Direction.NEXT, RelativeUnit.MONTHS, "in 1 month"}, 55 {2.0, Direction.NEXT, RelativeUnit.MONTHS, "in 2 months"}, 56 {0.0, Direction.NEXT, RelativeUnit.YEARS, "in 0 years"}, 57 {0.5, Direction.NEXT, RelativeUnit.YEARS, "in 0.5 years"}, 58 {1.0, Direction.NEXT, RelativeUnit.YEARS, "in 1 year"}, 59 {2.0, Direction.NEXT, RelativeUnit.YEARS, "in 2 years"}, 60 61 {0.0, Direction.LAST, RelativeUnit.SECONDS, "0 seconds ago"}, 62 {0.5, Direction.LAST, RelativeUnit.SECONDS, "0.5 seconds ago"}, 63 {1.0, Direction.LAST, RelativeUnit.SECONDS, "1 second ago"}, 64 {2.0, Direction.LAST, RelativeUnit.SECONDS, "2 seconds ago"}, 65 {0.0, Direction.LAST, RelativeUnit.MINUTES, "0 minutes ago"}, 66 {0.5, Direction.LAST, RelativeUnit.MINUTES, "0.5 minutes ago"}, 67 {1.0, Direction.LAST, RelativeUnit.MINUTES, "1 minute ago"}, 68 {2.0, Direction.LAST, RelativeUnit.MINUTES, "2 minutes ago"}, 69 {0.0, Direction.LAST, RelativeUnit.HOURS, "0 hours ago"}, 70 {0.5, Direction.LAST, RelativeUnit.HOURS, "0.5 hours ago"}, 71 {1.0, Direction.LAST, RelativeUnit.HOURS, "1 hour ago"}, 72 {2.0, Direction.LAST, RelativeUnit.HOURS, "2 hours ago"}, 73 {0.0, Direction.LAST, RelativeUnit.DAYS, "0 days ago"}, 74 {0.5, Direction.LAST, RelativeUnit.DAYS, "0.5 days ago"}, 75 {1.0, Direction.LAST, RelativeUnit.DAYS, "1 day ago"}, 76 {2.0, Direction.LAST, RelativeUnit.DAYS, "2 days ago"}, 77 {0.0, Direction.LAST, RelativeUnit.WEEKS, "0 weeks ago"}, 78 {0.5, Direction.LAST, RelativeUnit.WEEKS, "0.5 weeks ago"}, 79 {1.0, Direction.LAST, RelativeUnit.WEEKS, "1 week ago"}, 80 {2.0, Direction.LAST, RelativeUnit.WEEKS, "2 weeks ago"}, 81 {0.0, Direction.LAST, RelativeUnit.MONTHS, "0 months ago"}, 82 {0.5, Direction.LAST, RelativeUnit.MONTHS, "0.5 months ago"}, 83 {1.0, Direction.LAST, RelativeUnit.MONTHS, "1 month ago"}, 84 {2.0, Direction.LAST, RelativeUnit.MONTHS, "2 months ago"}, 85 {0.0, Direction.LAST, RelativeUnit.YEARS, "0 years ago"}, 86 {0.5, Direction.LAST, RelativeUnit.YEARS, "0.5 years ago"}, 87 {1.0, Direction.LAST, RelativeUnit.YEARS, "1 year ago"}, 88 {2.0, Direction.LAST, RelativeUnit.YEARS, "2 years ago"}, 89 }; 90 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(new ULocale("en_US")); 91 for (Object[] row : data) { 92 String actual = fmt.format( 93 ((Double) row[0]).doubleValue(), (Direction) row[1], (RelativeUnit) row[2]); 94 assertEquals("Relative date with quantity", row[3], actual); 95 } 96 } 97 98 @Test 99 public void TestRelativeDateWithQuantityCaps() { 100 Object[][] data = { 101 {0.0, Direction.NEXT, RelativeUnit.SECONDS, "In 0 seconds"}, 102 {0.5, Direction.NEXT, RelativeUnit.SECONDS, "In 0.5 seconds"}, 103 104 {1.0, Direction.NEXT, RelativeUnit.SECONDS, "In 1 second"}, 105 {2.0, Direction.NEXT, RelativeUnit.SECONDS, "In 2 seconds"}, 106 {0.0, Direction.NEXT, RelativeUnit.MINUTES, "In 0 minutes"}, 107 {0.5, Direction.NEXT, RelativeUnit.MINUTES, "In 0.5 minutes"}, 108 {1.0, Direction.NEXT, RelativeUnit.MINUTES, "In 1 minute"}, 109 {2.0, Direction.NEXT, RelativeUnit.MINUTES, "In 2 minutes"}, 110 {0.0, Direction.NEXT, RelativeUnit.HOURS, "In 0 hours"}, 111 {0.5, Direction.NEXT, RelativeUnit.HOURS, "In 0.5 hours"}, 112 {1.0, Direction.NEXT, RelativeUnit.HOURS, "In 1 hour"}, 113 {2.0, Direction.NEXT, RelativeUnit.HOURS, "In 2 hours"}, 114 {0.0, Direction.NEXT, RelativeUnit.DAYS, "In 0 days"}, 115 {0.5, Direction.NEXT, RelativeUnit.DAYS, "In 0.5 days"}, 116 {1.0, Direction.NEXT, RelativeUnit.DAYS, "In 1 day"}, 117 {2.0, Direction.NEXT, RelativeUnit.DAYS, "In 2 days"}, 118 {0.0, Direction.NEXT, RelativeUnit.WEEKS, "In 0 weeks"}, 119 {0.5, Direction.NEXT, RelativeUnit.WEEKS, "In 0.5 weeks"}, 120 {1.0, Direction.NEXT, RelativeUnit.WEEKS, "In 1 week"}, 121 {2.0, Direction.NEXT, RelativeUnit.WEEKS, "In 2 weeks"}, 122 {0.0, Direction.NEXT, RelativeUnit.MONTHS, "In 0 months"}, 123 {0.5, Direction.NEXT, RelativeUnit.MONTHS, "In 0.5 months"}, 124 {1.0, Direction.NEXT, RelativeUnit.MONTHS, "In 1 month"}, 125 {2.0, Direction.NEXT, RelativeUnit.MONTHS, "In 2 months"}, 126 {0.0, Direction.NEXT, RelativeUnit.YEARS, "In 0 years"}, 127 {0.5, Direction.NEXT, RelativeUnit.YEARS, "In 0.5 years"}, 128 {1.0, Direction.NEXT, RelativeUnit.YEARS, "In 1 year"}, 129 {2.0, Direction.NEXT, RelativeUnit.YEARS, "In 2 years"}, 130 131 {0.0, Direction.LAST, RelativeUnit.SECONDS, "0 seconds ago"}, 132 {0.5, Direction.LAST, RelativeUnit.SECONDS, "0.5 seconds ago"}, 133 {1.0, Direction.LAST, RelativeUnit.SECONDS, "1 second ago"}, 134 {2.0, Direction.LAST, RelativeUnit.SECONDS, "2 seconds ago"}, 135 {0.0, Direction.LAST, RelativeUnit.MINUTES, "0 minutes ago"}, 136 {0.5, Direction.LAST, RelativeUnit.MINUTES, "0.5 minutes ago"}, 137 {1.0, Direction.LAST, RelativeUnit.MINUTES, "1 minute ago"}, 138 {2.0, Direction.LAST, RelativeUnit.MINUTES, "2 minutes ago"}, 139 {0.0, Direction.LAST, RelativeUnit.HOURS, "0 hours ago"}, 140 {0.5, Direction.LAST, RelativeUnit.HOURS, "0.5 hours ago"}, 141 {1.0, Direction.LAST, RelativeUnit.HOURS, "1 hour ago"}, 142 {2.0, Direction.LAST, RelativeUnit.HOURS, "2 hours ago"}, 143 {0.0, Direction.LAST, RelativeUnit.DAYS, "0 days ago"}, 144 {0.5, Direction.LAST, RelativeUnit.DAYS, "0.5 days ago"}, 145 {1.0, Direction.LAST, RelativeUnit.DAYS, "1 day ago"}, 146 {2.0, Direction.LAST, RelativeUnit.DAYS, "2 days ago"}, 147 {0.0, Direction.LAST, RelativeUnit.WEEKS, "0 weeks ago"}, 148 {0.5, Direction.LAST, RelativeUnit.WEEKS, "0.5 weeks ago"}, 149 {1.0, Direction.LAST, RelativeUnit.WEEKS, "1 week ago"}, 150 {2.0, Direction.LAST, RelativeUnit.WEEKS, "2 weeks ago"}, 151 {0.0, Direction.LAST, RelativeUnit.MONTHS, "0 months ago"}, 152 {0.5, Direction.LAST, RelativeUnit.MONTHS, "0.5 months ago"}, 153 {1.0, Direction.LAST, RelativeUnit.MONTHS, "1 month ago"}, 154 {2.0, Direction.LAST, RelativeUnit.MONTHS, "2 months ago"}, 155 {0.0, Direction.LAST, RelativeUnit.YEARS, "0 years ago"}, 156 {0.5, Direction.LAST, RelativeUnit.YEARS, "0.5 years ago"}, 157 {1.0, Direction.LAST, RelativeUnit.YEARS, "1 year ago"}, 158 {2.0, Direction.LAST, RelativeUnit.YEARS, "2 years ago"}, 159 160 }; 161 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 162 new ULocale("en_US"), 163 null, 164 RelativeDateTimeFormatter.Style.LONG, 165 DisplayContext.CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE); 166 for (Object[] row : data) { 167 String actual = fmt.format( 168 ((Double) row[0]).doubleValue(), (Direction) row[1], (RelativeUnit) row[2]); 169 assertEquals("Relative date with quantity", row[3], actual); 170 } 171 } 172 173 @Test 174 public void TestRelativeDateWithQuantityShort() { 175 Object[][] data = { 176 {0.0, Direction.NEXT, RelativeUnit.SECONDS, "in 0 sec."}, 177 {0.5, Direction.NEXT, RelativeUnit.SECONDS, "in 0.5 sec."}, 178 179 {1.0, Direction.NEXT, RelativeUnit.SECONDS, "in 1 sec."}, 180 {2.0, Direction.NEXT, RelativeUnit.SECONDS, "in 2 sec."}, 181 {0.0, Direction.NEXT, RelativeUnit.MINUTES, "in 0 min."}, 182 {0.5, Direction.NEXT, RelativeUnit.MINUTES, "in 0.5 min."}, 183 {1.0, Direction.NEXT, RelativeUnit.MINUTES, "in 1 min."}, 184 {2.0, Direction.NEXT, RelativeUnit.MINUTES, "in 2 min."}, 185 {0.0, Direction.NEXT, RelativeUnit.HOURS, "in 0 hr."}, 186 {0.5, Direction.NEXT, RelativeUnit.HOURS, "in 0.5 hr."}, 187 {1.0, Direction.NEXT, RelativeUnit.HOURS, "in 1 hr."}, 188 {2.0, Direction.NEXT, RelativeUnit.HOURS, "in 2 hr."}, 189 {0.0, Direction.NEXT, RelativeUnit.DAYS, "in 0 days"}, 190 {0.5, Direction.NEXT, RelativeUnit.DAYS, "in 0.5 days"}, 191 {1.0, Direction.NEXT, RelativeUnit.DAYS, "in 1 day"}, 192 {2.0, Direction.NEXT, RelativeUnit.DAYS, "in 2 days"}, 193 {0.0, Direction.NEXT, RelativeUnit.WEEKS, "in 0 wk."}, 194 {0.5, Direction.NEXT, RelativeUnit.WEEKS, "in 0.5 wk."}, 195 {1.0, Direction.NEXT, RelativeUnit.WEEKS, "in 1 wk."}, 196 {2.0, Direction.NEXT, RelativeUnit.WEEKS, "in 2 wk."}, 197 {0.0, Direction.NEXT, RelativeUnit.MONTHS, "in 0 mo."}, 198 {0.5, Direction.NEXT, RelativeUnit.MONTHS, "in 0.5 mo."}, 199 {1.0, Direction.NEXT, RelativeUnit.MONTHS, "in 1 mo."}, 200 {2.0, Direction.NEXT, RelativeUnit.MONTHS, "in 2 mo."}, 201 {0.0, Direction.NEXT, RelativeUnit.YEARS, "in 0 yr."}, 202 {0.5, Direction.NEXT, RelativeUnit.YEARS, "in 0.5 yr."}, 203 {1.0, Direction.NEXT, RelativeUnit.YEARS, "in 1 yr."}, 204 {2.0, Direction.NEXT, RelativeUnit.YEARS, "in 2 yr."}, 205 206 {0.0, Direction.LAST, RelativeUnit.SECONDS, "0 sec. ago"}, 207 {0.5, Direction.LAST, RelativeUnit.SECONDS, "0.5 sec. ago"}, 208 {1.0, Direction.LAST, RelativeUnit.SECONDS, "1 sec. ago"}, 209 {2.0, Direction.LAST, RelativeUnit.SECONDS, "2 sec. ago"}, 210 {0.0, Direction.LAST, RelativeUnit.MINUTES, "0 min. ago"}, 211 {0.5, Direction.LAST, RelativeUnit.MINUTES, "0.5 min. ago"}, 212 {1.0, Direction.LAST, RelativeUnit.MINUTES, "1 min. ago"}, 213 {2.0, Direction.LAST, RelativeUnit.MINUTES, "2 min. ago"}, 214 {0.0, Direction.LAST, RelativeUnit.HOURS, "0 hr. ago"}, 215 {0.5, Direction.LAST, RelativeUnit.HOURS, "0.5 hr. ago"}, 216 {1.0, Direction.LAST, RelativeUnit.HOURS, "1 hr. ago"}, 217 {2.0, Direction.LAST, RelativeUnit.HOURS, "2 hr. ago"}, 218 {0.0, Direction.LAST, RelativeUnit.DAYS, "0 days ago"}, 219 {0.5, Direction.LAST, RelativeUnit.DAYS, "0.5 days ago"}, 220 {1.0, Direction.LAST, RelativeUnit.DAYS, "1 day ago"}, 221 {2.0, Direction.LAST, RelativeUnit.DAYS, "2 days ago"}, 222 {0.0, Direction.LAST, RelativeUnit.WEEKS, "0 wk. ago"}, 223 {0.5, Direction.LAST, RelativeUnit.WEEKS, "0.5 wk. ago"}, 224 {1.0, Direction.LAST, RelativeUnit.WEEKS, "1 wk. ago"}, 225 {2.0, Direction.LAST, RelativeUnit.WEEKS, "2 wk. ago"}, 226 {0.0, Direction.LAST, RelativeUnit.MONTHS, "0 mo. ago"}, 227 {0.5, Direction.LAST, RelativeUnit.MONTHS, "0.5 mo. ago"}, 228 {1.0, Direction.LAST, RelativeUnit.MONTHS, "1 mo. ago"}, 229 {2.0, Direction.LAST, RelativeUnit.MONTHS, "2 mo. ago"}, 230 {0.0, Direction.LAST, RelativeUnit.YEARS, "0 yr. ago"}, 231 {0.5, Direction.LAST, RelativeUnit.YEARS, "0.5 yr. ago"}, 232 {1.0, Direction.LAST, RelativeUnit.YEARS, "1 yr. ago"}, 233 {2.0, Direction.LAST, RelativeUnit.YEARS, "2 yr. ago"}, 234 235 }; 236 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 237 new ULocale("en_US"), 238 null, 239 RelativeDateTimeFormatter.Style.SHORT, 240 DisplayContext.CAPITALIZATION_NONE); 241 for (Object[] row : data) { 242 String actual = fmt.format( 243 ((Double) row[0]).doubleValue(), (Direction) row[1], (RelativeUnit) row[2]); 244 assertEquals("Relative date with quantity", row[3], actual); 245 } 246 } 247 248 @Test 249 public void TestRelativeDateWithQuantityNarrow() { 250 Object[][] data = { 251 {0.0, Direction.NEXT, RelativeUnit.SECONDS, "in 0 sec."}, 252 {0.5, Direction.NEXT, RelativeUnit.SECONDS, "in 0.5 sec."}, 253 254 {1.0, Direction.NEXT, RelativeUnit.SECONDS, "in 1 sec."}, 255 {2.0, Direction.NEXT, RelativeUnit.SECONDS, "in 2 sec."}, 256 {0.0, Direction.NEXT, RelativeUnit.MINUTES, "in 0 min."}, 257 {0.5, Direction.NEXT, RelativeUnit.MINUTES, "in 0.5 min."}, 258 {1.0, Direction.NEXT, RelativeUnit.MINUTES, "in 1 min."}, 259 {2.0, Direction.NEXT, RelativeUnit.MINUTES, "in 2 min."}, 260 {0.0, Direction.NEXT, RelativeUnit.HOURS, "in 0 hr."}, 261 {0.5, Direction.NEXT, RelativeUnit.HOURS, "in 0.5 hr."}, 262 {1.0, Direction.NEXT, RelativeUnit.HOURS, "in 1 hr."}, 263 {2.0, Direction.NEXT, RelativeUnit.HOURS, "in 2 hr."}, 264 {0.0, Direction.NEXT, RelativeUnit.DAYS, "in 0 days"}, 265 {0.5, Direction.NEXT, RelativeUnit.DAYS, "in 0.5 days"}, 266 {1.0, Direction.NEXT, RelativeUnit.DAYS, "in 1 day"}, 267 {2.0, Direction.NEXT, RelativeUnit.DAYS, "in 2 days"}, 268 {0.0, Direction.NEXT, RelativeUnit.WEEKS, "in 0 wk."}, 269 {0.5, Direction.NEXT, RelativeUnit.WEEKS, "in 0.5 wk."}, 270 {1.0, Direction.NEXT, RelativeUnit.WEEKS, "in 1 wk."}, 271 {2.0, Direction.NEXT, RelativeUnit.WEEKS, "in 2 wk."}, 272 {0.0, Direction.NEXT, RelativeUnit.MONTHS, "in 0 mo."}, 273 {0.5, Direction.NEXT, RelativeUnit.MONTHS, "in 0.5 mo."}, 274 {1.0, Direction.NEXT, RelativeUnit.MONTHS, "in 1 mo."}, 275 {2.0, Direction.NEXT, RelativeUnit.MONTHS, "in 2 mo."}, 276 {0.0, Direction.NEXT, RelativeUnit.YEARS, "in 0 yr."}, 277 {0.5, Direction.NEXT, RelativeUnit.YEARS, "in 0.5 yr."}, 278 {1.0, Direction.NEXT, RelativeUnit.YEARS, "in 1 yr."}, 279 {2.0, Direction.NEXT, RelativeUnit.YEARS, "in 2 yr."}, 280 281 {0.0, Direction.LAST, RelativeUnit.SECONDS, "0 sec. ago"}, 282 {0.5, Direction.LAST, RelativeUnit.SECONDS, "0.5 sec. ago"}, 283 {1.0, Direction.LAST, RelativeUnit.SECONDS, "1 sec. ago"}, 284 {2.0, Direction.LAST, RelativeUnit.SECONDS, "2 sec. ago"}, 285 {0.0, Direction.LAST, RelativeUnit.MINUTES, "0 min. ago"}, 286 {0.5, Direction.LAST, RelativeUnit.MINUTES, "0.5 min. ago"}, 287 {1.0, Direction.LAST, RelativeUnit.MINUTES, "1 min. ago"}, 288 {2.0, Direction.LAST, RelativeUnit.MINUTES, "2 min. ago"}, 289 {0.0, Direction.LAST, RelativeUnit.HOURS, "0 hr. ago"}, 290 {0.5, Direction.LAST, RelativeUnit.HOURS, "0.5 hr. ago"}, 291 {1.0, Direction.LAST, RelativeUnit.HOURS, "1 hr. ago"}, 292 {2.0, Direction.LAST, RelativeUnit.HOURS, "2 hr. ago"}, 293 {0.0, Direction.LAST, RelativeUnit.DAYS, "0 days ago"}, 294 {0.5, Direction.LAST, RelativeUnit.DAYS, "0.5 days ago"}, 295 {1.0, Direction.LAST, RelativeUnit.DAYS, "1 day ago"}, 296 {2.0, Direction.LAST, RelativeUnit.DAYS, "2 days ago"}, 297 {0.0, Direction.LAST, RelativeUnit.WEEKS, "0 wk. ago"}, 298 {0.5, Direction.LAST, RelativeUnit.WEEKS, "0.5 wk. ago"}, 299 {1.0, Direction.LAST, RelativeUnit.WEEKS, "1 wk. ago"}, 300 {2.0, Direction.LAST, RelativeUnit.WEEKS, "2 wk. ago"}, 301 {0.0, Direction.LAST, RelativeUnit.MONTHS, "0 mo. ago"}, 302 {0.5, Direction.LAST, RelativeUnit.MONTHS, "0.5 mo. ago"}, 303 {1.0, Direction.LAST, RelativeUnit.MONTHS, "1 mo. ago"}, 304 {2.0, Direction.LAST, RelativeUnit.MONTHS, "2 mo. ago"}, 305 {0.0, Direction.LAST, RelativeUnit.YEARS, "0 yr. ago"}, 306 {0.5, Direction.LAST, RelativeUnit.YEARS, "0.5 yr. ago"}, 307 {1.0, Direction.LAST, RelativeUnit.YEARS, "1 yr. ago"}, 308 {2.0, Direction.LAST, RelativeUnit.YEARS, "2 yr. ago"}, 309 310 }; 311 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 312 new ULocale("en_US"), 313 null, 314 RelativeDateTimeFormatter.Style.NARROW, 315 DisplayContext.CAPITALIZATION_NONE); 316 for (Object[] row : data) { 317 String actual = fmt.format( 318 ((Double) row[0]).doubleValue(), (Direction) row[1], (RelativeUnit) row[2]); 319 assertEquals("Relative date with quantity", row[3], actual); 320 } 321 } 322 323 324 325 @Test 326 public void TestRelativeDateWithQuantitySr() { 327 Object[][] data = { 328 {0.0, Direction.NEXT, RelativeUnit.MONTHS, "\u0437\u0430 0 \u043C\u0435\u0441\u0435\u0446\u0438"}, 329 {1.2, Direction.NEXT, RelativeUnit.MONTHS, "\u0437\u0430 1,2 \u043C\u0435\u0441\u0435\u0446\u0430"}, 330 {21.0, Direction.NEXT, RelativeUnit.MONTHS, "\u0437\u0430 21 \u043C\u0435\u0441\u0435\u0446"}, 331 }; 332 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(new ULocale("sr")); 333 for (Object[] row : data) { 334 String actual = fmt.format( 335 ((Double) row[0]).doubleValue(), (Direction) row[1], (RelativeUnit) row[2]); 336 assertEquals("Relative date with quantity", row[3], actual); 337 } 338 } 339 340 @Test 341 public void TestRelativeDateWithQuantitySrFallback() { 342 Object[][] data = { 343 {0.0, Direction.NEXT, RelativeUnit.MONTHS, "\u0437\u0430 0 \u043C."}, 344 {1.2, Direction.NEXT, RelativeUnit.MONTHS, "\u0437\u0430 1,2 \u043C."}, 345 {21.0, Direction.NEXT, RelativeUnit.MONTHS, "\u0437\u0430 21 \u043C."}, 346 }; 347 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 348 new ULocale("sr"), 349 null, 350 RelativeDateTimeFormatter.Style.NARROW, 351 DisplayContext.CAPITALIZATION_NONE); 352 for (Object[] row : data) { 353 String actual = fmt.format( 354 ((Double) row[0]).doubleValue(), (Direction) row[1], (RelativeUnit) row[2]); 355 assertEquals("Relative date with quantity fallback", row[3], actual); 356 } 357 } 358 359 @Test 360 public void TestRelativeDateWithoutQuantity() { 361 Object[][] data = { 362 {Direction.NEXT_2, AbsoluteUnit.DAY, null}, 363 364 {Direction.NEXT, AbsoluteUnit.DAY, "tomorrow"}, 365 {Direction.NEXT, AbsoluteUnit.WEEK, "next week"}, 366 {Direction.NEXT, AbsoluteUnit.MONTH, "next month"}, 367 {Direction.NEXT, AbsoluteUnit.YEAR, "next year"}, 368 {Direction.NEXT, AbsoluteUnit.MONDAY, "next Monday"}, 369 {Direction.NEXT, AbsoluteUnit.TUESDAY, "next Tuesday"}, 370 {Direction.NEXT, AbsoluteUnit.WEDNESDAY, "next Wednesday"}, 371 {Direction.NEXT, AbsoluteUnit.THURSDAY, "next Thursday"}, 372 {Direction.NEXT, AbsoluteUnit.FRIDAY, "next Friday"}, 373 {Direction.NEXT, AbsoluteUnit.SATURDAY, "next Saturday"}, 374 {Direction.NEXT, AbsoluteUnit.SUNDAY, "next Sunday"}, 375 376 {Direction.LAST_2, AbsoluteUnit.DAY, null}, 377 378 {Direction.LAST, AbsoluteUnit.DAY, "yesterday"}, 379 {Direction.LAST, AbsoluteUnit.WEEK, "last week"}, 380 {Direction.LAST, AbsoluteUnit.MONTH, "last month"}, 381 {Direction.LAST, AbsoluteUnit.YEAR, "last year"}, 382 {Direction.LAST, AbsoluteUnit.MONDAY, "last Monday"}, 383 {Direction.LAST, AbsoluteUnit.TUESDAY, "last Tuesday"}, 384 {Direction.LAST, AbsoluteUnit.WEDNESDAY, "last Wednesday"}, 385 {Direction.LAST, AbsoluteUnit.THURSDAY, "last Thursday"}, 386 {Direction.LAST, AbsoluteUnit.FRIDAY, "last Friday"}, 387 {Direction.LAST, AbsoluteUnit.SATURDAY, "last Saturday"}, 388 {Direction.LAST, AbsoluteUnit.SUNDAY, "last Sunday"}, 389 390 {Direction.THIS, AbsoluteUnit.DAY, "today"}, 391 {Direction.THIS, AbsoluteUnit.WEEK, "this week"}, 392 {Direction.THIS, AbsoluteUnit.MONTH, "this month"}, 393 {Direction.THIS, AbsoluteUnit.YEAR, "this year"}, 394 {Direction.THIS, AbsoluteUnit.MONDAY, "this Monday"}, 395 {Direction.THIS, AbsoluteUnit.TUESDAY, "this Tuesday"}, 396 {Direction.THIS, AbsoluteUnit.WEDNESDAY, "this Wednesday"}, 397 {Direction.THIS, AbsoluteUnit.THURSDAY, "this Thursday"}, 398 {Direction.THIS, AbsoluteUnit.FRIDAY, "this Friday"}, 399 {Direction.THIS, AbsoluteUnit.SATURDAY, "this Saturday"}, 400 {Direction.THIS, AbsoluteUnit.SUNDAY, "this Sunday"}, 401 402 {Direction.PLAIN, AbsoluteUnit.DAY, "day"}, 403 {Direction.PLAIN, AbsoluteUnit.WEEK, "week"}, 404 {Direction.PLAIN, AbsoluteUnit.MONTH, "month"}, 405 {Direction.PLAIN, AbsoluteUnit.YEAR, "year"}, 406 {Direction.PLAIN, AbsoluteUnit.MONDAY, "Monday"}, 407 {Direction.PLAIN, AbsoluteUnit.TUESDAY, "Tuesday"}, 408 {Direction.PLAIN, AbsoluteUnit.WEDNESDAY, "Wednesday"}, 409 {Direction.PLAIN, AbsoluteUnit.THURSDAY, "Thursday"}, 410 {Direction.PLAIN, AbsoluteUnit.FRIDAY, "Friday"}, 411 {Direction.PLAIN, AbsoluteUnit.SATURDAY, "Saturday"}, 412 {Direction.PLAIN, AbsoluteUnit.SUNDAY, "Sunday"}, 413 414 {Direction.PLAIN, AbsoluteUnit.NOW, "now"}, 415 }; 416 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(new ULocale("en_US")); 417 for (Object[] row : data) { 418 String actual = fmt.format((Direction) row[0], (AbsoluteUnit) row[1]); 419 assertEquals("Relative date without quantity", row[2], actual); 420 } 421 } 422 423 @Test 424 public void TestRelativeDateWithoutQuantityCaps() { 425 Object[][] data = { 426 {Direction.NEXT_2, AbsoluteUnit.DAY, null}, 427 428 {Direction.NEXT, AbsoluteUnit.DAY, "Tomorrow"}, 429 {Direction.NEXT, AbsoluteUnit.WEEK, "Next week"}, 430 {Direction.NEXT, AbsoluteUnit.MONTH, "Next month"}, 431 {Direction.NEXT, AbsoluteUnit.YEAR, "Next year"}, 432 433 {Direction.NEXT, AbsoluteUnit.MONDAY, "Next Monday"}, 434 {Direction.NEXT, AbsoluteUnit.TUESDAY, "Next Tuesday"}, 435 {Direction.NEXT, AbsoluteUnit.WEDNESDAY, "Next Wednesday"}, 436 {Direction.NEXT, AbsoluteUnit.THURSDAY, "Next Thursday"}, 437 {Direction.NEXT, AbsoluteUnit.FRIDAY, "Next Friday"}, 438 {Direction.NEXT, AbsoluteUnit.SATURDAY, "Next Saturday"}, 439 {Direction.NEXT, AbsoluteUnit.SUNDAY, "Next Sunday"}, 440 441 {Direction.LAST_2, AbsoluteUnit.DAY, null}, 442 443 {Direction.LAST, AbsoluteUnit.DAY, "Yesterday"}, 444 {Direction.LAST, AbsoluteUnit.WEEK, "Last week"}, 445 {Direction.LAST, AbsoluteUnit.MONTH, "Last month"}, 446 {Direction.LAST, AbsoluteUnit.YEAR, "Last year"}, 447 {Direction.LAST, AbsoluteUnit.MONDAY, "Last Monday"}, 448 {Direction.LAST, AbsoluteUnit.TUESDAY, "Last Tuesday"}, 449 {Direction.LAST, AbsoluteUnit.WEDNESDAY, "Last Wednesday"}, 450 {Direction.LAST, AbsoluteUnit.THURSDAY, "Last Thursday"}, 451 {Direction.LAST, AbsoluteUnit.FRIDAY, "Last Friday"}, 452 {Direction.LAST, AbsoluteUnit.SATURDAY, "Last Saturday"}, 453 {Direction.LAST, AbsoluteUnit.SUNDAY, "Last Sunday"}, 454 455 {Direction.THIS, AbsoluteUnit.DAY, "Today"}, 456 {Direction.THIS, AbsoluteUnit.WEEK, "This week"}, 457 {Direction.THIS, AbsoluteUnit.MONTH, "This month"}, 458 {Direction.THIS, AbsoluteUnit.YEAR, "This year"}, 459 {Direction.THIS, AbsoluteUnit.MONDAY, "This Monday"}, 460 {Direction.THIS, AbsoluteUnit.TUESDAY, "This Tuesday"}, 461 {Direction.THIS, AbsoluteUnit.WEDNESDAY, "This Wednesday"}, 462 {Direction.THIS, AbsoluteUnit.THURSDAY, "This Thursday"}, 463 {Direction.THIS, AbsoluteUnit.FRIDAY, "This Friday"}, 464 {Direction.THIS, AbsoluteUnit.SATURDAY, "This Saturday"}, 465 {Direction.THIS, AbsoluteUnit.SUNDAY, "This Sunday"}, 466 467 {Direction.PLAIN, AbsoluteUnit.DAY, "Day"}, 468 {Direction.PLAIN, AbsoluteUnit.WEEK, "Week"}, 469 {Direction.PLAIN, AbsoluteUnit.MONTH, "Month"}, 470 {Direction.PLAIN, AbsoluteUnit.YEAR, "Year"}, 471 {Direction.PLAIN, AbsoluteUnit.MONDAY, "Monday"}, 472 {Direction.PLAIN, AbsoluteUnit.TUESDAY, "Tuesday"}, 473 {Direction.PLAIN, AbsoluteUnit.WEDNESDAY, "Wednesday"}, 474 {Direction.PLAIN, AbsoluteUnit.THURSDAY, "Thursday"}, 475 {Direction.PLAIN, AbsoluteUnit.FRIDAY, "Friday"}, 476 {Direction.PLAIN, AbsoluteUnit.SATURDAY, "Saturday"}, 477 {Direction.PLAIN, AbsoluteUnit.SUNDAY, "Sunday"}, 478 479 {Direction.PLAIN, AbsoluteUnit.NOW, "Now"}, 480 481 }; 482 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 483 new ULocale("en_US"), 484 null, 485 RelativeDateTimeFormatter.Style.LONG, 486 DisplayContext.CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE); 487 for (Object[] row : data) { 488 String actual = fmt.format((Direction) row[0], (AbsoluteUnit) row[1]); 489 assertEquals("Relative date without quantity caps", row[2], actual); 490 } 491 } 492 493 @Test 494 public void TestRelativeDateWithoutQuantityShort() { 495 Object[][] data = { 496 {Direction.NEXT_2, AbsoluteUnit.DAY, null}, 497 498 {Direction.NEXT, AbsoluteUnit.DAY, "tomorrow"}, 499 {Direction.NEXT, AbsoluteUnit.WEEK, "next wk."}, 500 501 {Direction.NEXT, AbsoluteUnit.MONTH, "next mo."}, 502 {Direction.NEXT, AbsoluteUnit.YEAR, "next yr."}, 503 504 {Direction.NEXT, AbsoluteUnit.MONDAY, "next Mon."}, 505 506 {Direction.NEXT, AbsoluteUnit.TUESDAY, "next Tue."}, 507 {Direction.NEXT, AbsoluteUnit.WEDNESDAY, "next Wed."}, 508 {Direction.NEXT, AbsoluteUnit.THURSDAY, "next Thu."}, 509 {Direction.NEXT, AbsoluteUnit.FRIDAY, "next Fri."}, 510 {Direction.NEXT, AbsoluteUnit.SATURDAY, "next Sat."}, 511 {Direction.NEXT, AbsoluteUnit.SUNDAY, "next Sun."}, 512 513 {Direction.LAST_2, AbsoluteUnit.DAY, null}, 514 515 {Direction.LAST, AbsoluteUnit.DAY, "yesterday"}, 516 {Direction.LAST, AbsoluteUnit.WEEK, "last wk."}, 517 {Direction.LAST, AbsoluteUnit.MONTH, "last mo."}, 518 {Direction.LAST, AbsoluteUnit.YEAR, "last yr."}, 519 {Direction.LAST, AbsoluteUnit.MONDAY, "last Mon."}, 520 {Direction.LAST, AbsoluteUnit.TUESDAY, "last Tue."}, 521 {Direction.LAST, AbsoluteUnit.WEDNESDAY, "last Wed."}, 522 {Direction.LAST, AbsoluteUnit.THURSDAY, "last Thu."}, 523 524 {Direction.LAST, AbsoluteUnit.FRIDAY, "last Fri."}, 525 526 {Direction.LAST, AbsoluteUnit.SATURDAY, "last Sat."}, 527 {Direction.LAST, AbsoluteUnit.SUNDAY, "last Sun."}, 528 529 {Direction.THIS, AbsoluteUnit.DAY, "today"}, 530 {Direction.THIS, AbsoluteUnit.WEEK, "this wk."}, 531 {Direction.THIS, AbsoluteUnit.MONTH, "this mo."}, 532 {Direction.THIS, AbsoluteUnit.YEAR, "this yr."}, 533 {Direction.THIS, AbsoluteUnit.MONDAY, "this Mon."}, 534 {Direction.THIS, AbsoluteUnit.TUESDAY, "this Tue."}, 535 {Direction.THIS, AbsoluteUnit.WEDNESDAY, "this Wed."}, 536 {Direction.THIS, AbsoluteUnit.THURSDAY, "this Thu."}, 537 {Direction.THIS, AbsoluteUnit.FRIDAY, "this Fri."}, 538 {Direction.THIS, AbsoluteUnit.SATURDAY, "this Sat."}, 539 {Direction.THIS, AbsoluteUnit.SUNDAY, "this Sun."}, 540 541 {Direction.PLAIN, AbsoluteUnit.DAY, "day"}, 542 {Direction.PLAIN, AbsoluteUnit.WEEK, "wk."}, 543 {Direction.PLAIN, AbsoluteUnit.MONTH, "mo."}, 544 {Direction.PLAIN, AbsoluteUnit.YEAR, "yr."}, 545 {Direction.PLAIN, AbsoluteUnit.MONDAY, "Mo"}, 546 {Direction.PLAIN, AbsoluteUnit.TUESDAY, "Tu"}, 547 {Direction.PLAIN, AbsoluteUnit.WEDNESDAY, "We"}, 548 {Direction.PLAIN, AbsoluteUnit.THURSDAY, "Th"}, 549 {Direction.PLAIN, AbsoluteUnit.FRIDAY, "Fr"}, 550 {Direction.PLAIN, AbsoluteUnit.SATURDAY, "Sa"}, 551 {Direction.PLAIN, AbsoluteUnit.SUNDAY, "Su"}, 552 553 {Direction.PLAIN, AbsoluteUnit.NOW, "now"}, 554 555 }; 556 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 557 new ULocale("en_US"), 558 null, 559 RelativeDateTimeFormatter.Style.SHORT, 560 DisplayContext.CAPITALIZATION_NONE); 561 for (Object[] row : data) { 562 String actual = fmt.format((Direction) row[0], (AbsoluteUnit) row[1]); 563 assertEquals("Relative date without quantity short", row[2], actual); 564 } 565 } 566 567 @Test 568 public void TestRelativeDateWithoutQuantityNarrow() { 569 Object[][] data = { 570 {Direction.NEXT_2, AbsoluteUnit.DAY, null}, 571 572 {Direction.NEXT, AbsoluteUnit.DAY, "tomorrow"}, 573 {Direction.NEXT, AbsoluteUnit.WEEK, "next wk."}, 574 575 {Direction.NEXT, AbsoluteUnit.MONTH, "next mo."}, 576 {Direction.NEXT, AbsoluteUnit.YEAR, "next yr."}, 577 578 {Direction.NEXT, AbsoluteUnit.MONDAY, "next M"}, 579 580 {Direction.NEXT, AbsoluteUnit.TUESDAY, "next Tu"}, 581 {Direction.NEXT, AbsoluteUnit.WEDNESDAY, "next W"}, 582 {Direction.NEXT, AbsoluteUnit.THURSDAY, "next Th"}, 583 {Direction.NEXT, AbsoluteUnit.FRIDAY, "next F"}, 584 {Direction.NEXT, AbsoluteUnit.SATURDAY, "next Sa"}, 585 {Direction.NEXT, AbsoluteUnit.SUNDAY, "next Su"}, 586 587 {Direction.LAST_2, AbsoluteUnit.DAY, null}, 588 589 {Direction.LAST, AbsoluteUnit.DAY, "yesterday"}, 590 {Direction.LAST, AbsoluteUnit.WEEK, "last wk."}, 591 {Direction.LAST, AbsoluteUnit.MONTH, "last mo."}, 592 {Direction.LAST, AbsoluteUnit.YEAR, "last yr."}, 593 {Direction.LAST, AbsoluteUnit.MONDAY, "last M"}, 594 {Direction.LAST, AbsoluteUnit.TUESDAY, "last Tu"}, 595 {Direction.LAST, AbsoluteUnit.WEDNESDAY, "last W"}, 596 {Direction.LAST, AbsoluteUnit.THURSDAY, "last Th"}, 597 {Direction.LAST, AbsoluteUnit.FRIDAY, "last F"}, 598 {Direction.LAST, AbsoluteUnit.SATURDAY, "last Sa"}, 599 {Direction.LAST, AbsoluteUnit.SUNDAY, "last Su"}, 600 601 {Direction.THIS, AbsoluteUnit.DAY, "today"}, 602 {Direction.THIS, AbsoluteUnit.WEEK, "this wk."}, 603 {Direction.THIS, AbsoluteUnit.MONTH, "this mo."}, 604 {Direction.THIS, AbsoluteUnit.YEAR, "this yr."}, 605 {Direction.THIS, AbsoluteUnit.MONDAY, "this M"}, 606 {Direction.THIS, AbsoluteUnit.TUESDAY, "this Tu"}, 607 {Direction.THIS, AbsoluteUnit.WEDNESDAY, "this W"}, 608 {Direction.THIS, AbsoluteUnit.THURSDAY, "this Th"}, 609 610 {Direction.THIS, AbsoluteUnit.FRIDAY, "this F"}, 611 612 {Direction.THIS, AbsoluteUnit.SATURDAY, "this Sa"}, 613 {Direction.THIS, AbsoluteUnit.SUNDAY, "this Su"}, 614 615 {Direction.PLAIN, AbsoluteUnit.DAY, "day"}, 616 {Direction.PLAIN, AbsoluteUnit.WEEK, "wk."}, 617 {Direction.PLAIN, AbsoluteUnit.MONTH, "mo."}, 618 {Direction.PLAIN, AbsoluteUnit.YEAR, "yr."}, 619 {Direction.PLAIN, AbsoluteUnit.MONDAY, "M"}, 620 {Direction.PLAIN, AbsoluteUnit.TUESDAY, "T"}, 621 {Direction.PLAIN, AbsoluteUnit.WEDNESDAY, "W"}, 622 {Direction.PLAIN, AbsoluteUnit.THURSDAY, "T"}, 623 {Direction.PLAIN, AbsoluteUnit.FRIDAY, "F"}, 624 {Direction.PLAIN, AbsoluteUnit.SATURDAY, "S"}, 625 {Direction.PLAIN, AbsoluteUnit.SUNDAY, "S"}, 626 627 {Direction.PLAIN, AbsoluteUnit.NOW, "now"}, 628 629 }; 630 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 631 new ULocale("en_US"), 632 null, 633 RelativeDateTimeFormatter.Style.NARROW, 634 DisplayContext.CAPITALIZATION_NONE); 635 for (Object[] row : data) { 636 String actual = fmt.format((Direction) row[0], (AbsoluteUnit) row[1]); 637 assertEquals("Relative date without quantity narrow", row[2], actual); 638 } 639 } 640 641 @Test 642 public void TestRelativeDateTimeUnitFormatters() { 643 double[] offsets = { -5.0, -2.2, -2.0, -1.0, -0.7, 0.0, 0.7, 1.0, 2.0, 5.0 }; 644 645 String[] en_decDef_long_midSent_week = { 646 /* text numeric */ 647 "5 weeks ago", "5 weeks ago", /* -5 */ 648 "2.2 weeks ago", "2.2 weeks ago", /* -2.2 */ 649 "2 weeks ago", "2 weeks ago", /* -2 */ 650 "last week", "1 week ago", /* -1 */ 651 "0.7 weeks ago", "0.7 weeks ago", /* -0.7 */ 652 "this week", "in 0 weeks", /* 0 */ 653 "in 0.7 weeks", "in 0.7 weeks", /* 0.7 */ 654 "next week", "in 1 week", /* 1 */ 655 "in 2 weeks", "in 2 weeks", /* 2 */ 656 "in 5 weeks", "in 5 weeks" /* 5 */ 657 }; 658 659 String[] en_dec0_long_midSent_week = { 660 /* text numeric */ 661 "5 weeks ago", "5 weeks ago", /* -5 */ 662 "2 weeks ago", "2 weeks ago", /* -2.2 */ 663 "2 weeks ago", "2 weeks ago", /* -2 */ 664 "last week", "1 week ago", /* -1 */ 665 "0 weeks ago", "0 weeks ago", /* -0.7 */ 666 "this week", "in 0 weeks", /* 0 */ 667 "in 0 weeks", "in 0 weeks", /* 0.7 */ 668 "next week", "in 1 week", /* 1 */ 669 "in 2 weeks", "in 2 weeks", /* 2 */ 670 "in 5 weeks", "in 5 weeks" /* 5 */ 671 }; 672 673 String[] en_decDef_short_midSent_week = { 674 /* text numeric */ 675 "5 wk. ago", "5 wk. ago", /* -5 */ 676 "2.2 wk. ago", "2.2 wk. ago", /* -2.2 */ 677 "2 wk. ago", "2 wk. ago", /* -2 */ 678 "last wk.", "1 wk. ago", /* -1 */ 679 "0.7 wk. ago", "0.7 wk. ago", /* -0.7 */ 680 "this wk.", "in 0 wk.", /* 0 */ 681 "in 0.7 wk.", "in 0.7 wk.", /* 0.7 */ 682 "next wk.", "in 1 wk.", /* 1 */ 683 "in 2 wk.", "in 2 wk.", /* 2 */ 684 "in 5 wk.", "in 5 wk." /* 5 */ 685 }; 686 687 String[] en_decDef_long_midSent_min = { 688 /* text numeric */ 689 "5 minutes ago", "5 minutes ago", /* -5 */ 690 "2.2 minutes ago", "2.2 minutes ago", /* -2.2 */ 691 "2 minutes ago", "2 minutes ago", /* -2 */ 692 "1 minute ago", "1 minute ago", /* -1 */ 693 "0.7 minutes ago", "0.7 minutes ago", /* -0.7 */ 694 "in 0 minutes", "in 0 minutes", /* 0 */ 695 "in 0.7 minutes", "in 0.7 minutes", /* 0.7 */ 696 "in 1 minute", "in 1 minute", /* 1 */ 697 "in 2 minutes", "in 2 minutes", /* 2 */ 698 "in 5 minutes", "in 5 minutes" /* 5 */ 699 }; 700 701 String[] en_dec0_long_midSent_tues = { 702 /* text numeric */ 703 ""/*no data */, ""/*no data */, /* -5 */ 704 ""/*no data */, ""/*no data */, /* -2.2 */ 705 ""/*no data */, ""/*no data */, /* -2 */ 706 "last Tuesday", ""/*no data */, /* -1 */ 707 ""/*no data */, ""/*no data */, /* -0.7 */ 708 "this Tuesday", ""/*no data */, /* 0 */ 709 ""/*no data */, ""/*no data */, /* 0.7 */ 710 "next Tuesday", ""/*no data */, /* 1 */ 711 ""/*no data */, ""/*no data */, /* 2 */ 712 ""/*no data */, ""/*no data */, /* 5 */ 713 }; 714 715 String[] fr_decDef_long_midSent_day = { 716 /* text numeric */ 717 "il y a 5 jours", "il y a 5 jours", /* -5 */ 718 "il y a 2,2 jours", "il y a 2,2 jours", /* -2.2 */ 719 "avant-hier", "il y a 2 jours", /* -2 */ 720 "hier", "il y a 1 jour", /* -1 */ 721 "il y a 0,7 jour", "il y a 0,7 jour", /* -0.7 */ 722 "aujourd’hui", "dans 0 jour", /* 0 */ 723 "dans 0,7 jour", "dans 0,7 jour", /* 0.7 */ 724 "demain", "dans 1 jour", /* 1 */ 725 "après-demain", "dans 2 jours", /* 2 */ 726 "dans 5 jours", "dans 5 jours" /* 5 */ 727 }; 728 729 class TestRelativeDateTimeUnitItem { 730 public String localeID; 731 public int decPlaces; /* fixed decimal places; -1 to use default num formatter */ 732 public Style width; 733 public DisplayContext capContext; 734 public RelativeDateTimeUnit unit; 735 public String[] expectedResults; /* for the various offsets */ 736 public TestRelativeDateTimeUnitItem(String locID, int decP, RelativeDateTimeFormatter.Style wid, 737 DisplayContext capC, RelativeDateTimeUnit ut, String[] expR) { 738 localeID = locID; 739 decPlaces = decP; 740 width = wid; 741 capContext = capC; 742 unit = ut; 743 expectedResults = expR; 744 } 745 }; 746 final TestRelativeDateTimeUnitItem[] items = { 747 new TestRelativeDateTimeUnitItem("en", -1, Style.LONG, DisplayContext.CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, 748 RelativeDateTimeUnit.WEEK, en_decDef_long_midSent_week), 749 new TestRelativeDateTimeUnitItem("en", 0, Style.LONG, DisplayContext.CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, 750 RelativeDateTimeUnit.WEEK, en_dec0_long_midSent_week), 751 new TestRelativeDateTimeUnitItem("en", -1, Style.SHORT, DisplayContext.CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, 752 RelativeDateTimeUnit.WEEK, en_decDef_short_midSent_week), 753 new TestRelativeDateTimeUnitItem("en", -1, Style.LONG, DisplayContext.CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, 754 RelativeDateTimeUnit.MINUTE, en_decDef_long_midSent_min), 755 new TestRelativeDateTimeUnitItem("en", -1, Style.LONG, DisplayContext.CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, 756 RelativeDateTimeUnit.TUESDAY, en_dec0_long_midSent_tues), 757 new TestRelativeDateTimeUnitItem("fr", -1, Style.LONG, DisplayContext.CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, 758 RelativeDateTimeUnit.DAY, fr_decDef_long_midSent_day), 759 }; 760 for (TestRelativeDateTimeUnitItem item: items) { 761 ULocale uloc = new ULocale(item.localeID); 762 NumberFormat nf = null; 763 if (item.decPlaces >= 0) { 764 nf = NumberFormat.getInstance(uloc, NumberFormat.NUMBERSTYLE); 765 nf.setMinimumFractionDigits(item.decPlaces); 766 nf.setMaximumFractionDigits(item.decPlaces); 767 nf.setRoundingMode(BigDecimal.ROUND_DOWN); 768 } 769 RelativeDateTimeFormatter reldatefmt = RelativeDateTimeFormatter.getInstance(uloc, nf, item.width, item.capContext); 770 for (int iOffset = 0; iOffset < offsets.length; iOffset++) { 771 double offset = offsets[iOffset]; 772 if (item.unit == RelativeDateTimeUnit.TUESDAY && offset != -1.0 && offset != 0.0 && offset != 1.0) { 773 continue; /* we do not currently have data for this */ 774 } 775 String result = reldatefmt.format(offset, item.unit); 776 assertEquals("RelativeDateTimeUnit format locale "+item.localeID +", dec "+item.decPlaces +", width "+item.width + ", unit "+item.unit, 777 item.expectedResults[iOffset*2], result); 778 779 if (item.unit == RelativeDateTimeUnit.TUESDAY) { 780 continue; /* we do not currently have numeric-style data for this */ 781 } 782 result = reldatefmt.formatNumeric(offset, item.unit); 783 assertEquals("RelativeDateTimeUnit formatNum locale "+item.localeID +", dec "+item.decPlaces +", width "+item.width + ", unit "+item.unit, 784 item.expectedResults[iOffset*2 + 1], result); 785 } 786 } 787 } 788 789 @Test 790 public void TestTwoBeforeTwoAfter() { 791 Object[][] data = { 792 {Direction.NEXT_2, AbsoluteUnit.DAY, "pasado ma\u00F1ana"}, 793 {Direction.LAST_2, AbsoluteUnit.DAY, "anteayer"}, 794 }; 795 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(new ULocale("es")); 796 for (Object[] row : data) { 797 String actual = fmt.format((Direction) row[0], (AbsoluteUnit) row[1]); 798 assertEquals("Two before two after", row[2], actual); 799 } 800 } 801 802 @Test 803 public void TestFormatWithQuantityIllegalArgument() { 804 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(new ULocale("en_US")); 805 try { 806 fmt.format(1.0, Direction.PLAIN, RelativeUnit.DAYS); 807 fail("Expected IllegalArgumentException."); 808 } catch (IllegalArgumentException e) { 809 // Expected 810 } 811 try { 812 fmt.format(1.0, Direction.THIS, RelativeUnit.DAYS); 813 fail("Expected IllegalArgumentException."); 814 } catch (IllegalArgumentException e) { 815 // Expected 816 } 817 } 818 819 @Test 820 public void TestFormatWithoutQuantityIllegalArgument() { 821 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(new ULocale("en_US")); 822 try { 823 fmt.format(Direction.LAST, AbsoluteUnit.NOW); 824 fail("Expected IllegalArgumentException."); 825 } catch (IllegalArgumentException e) { 826 // Expected 827 } 828 try { 829 fmt.format(Direction.NEXT, AbsoluteUnit.NOW); 830 fail("Expected IllegalArgumentException."); 831 } catch (IllegalArgumentException e) { 832 // Expected 833 } 834 try { 835 fmt.format(Direction.THIS, AbsoluteUnit.NOW); 836 fail("Expected IllegalArgumentException."); 837 } catch (IllegalArgumentException e) { 838 // Expected 839 } 840 } 841 842 @Test 843 public void TestCustomNumberFormat() { 844 ULocale loc = new ULocale("en_US"); 845 NumberFormat nf = NumberFormat.getInstance(loc); 846 nf.setMinimumFractionDigits(1); 847 nf.setMaximumFractionDigits(1); 848 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(loc, nf); 849 850 // Change nf after the fact to prove that we made a defensive copy 851 nf.setMinimumFractionDigits(3); 852 nf.setMaximumFractionDigits(3); 853 854 // Change getNumberFormat to prove we made defensive copy going out. 855 fmt.getNumberFormat().setMinimumFractionDigits(5); 856 assertEquals( 857 "TestCustomNumberformat", 1, fmt.getNumberFormat().getMinimumFractionDigits()); 858 859 Object[][] data = { 860 {0.0, Direction.NEXT, RelativeUnit.SECONDS, "in 0.0 seconds"}, 861 {0.5, Direction.NEXT, RelativeUnit.SECONDS, "in 0.5 seconds"}, 862 {1.0, Direction.NEXT, RelativeUnit.SECONDS, "in 1.0 seconds"}, 863 {2.0, Direction.NEXT, RelativeUnit.SECONDS, "in 2.0 seconds"}, 864 }; 865 for (Object[] row : data) { 866 String actual = fmt.format( 867 ((Double) row[0]).doubleValue(), (Direction) row[1], (RelativeUnit) row[2]); 868 assertEquals("Relative date with quantity special NumberFormat", row[3], actual); 869 } 870 } 871 872 @Test 873 public void TestCombineDateAndTime() { 874 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(new ULocale("en_US")); 875 assertEquals("TestcombineDateAndTime", "yesterday, 3:50", fmt.combineDateAndTime("yesterday", "3:50")); 876 } 877 878 @Test 879 public void TestJavaLocale() { 880 Locale loc = Locale.US; 881 double amount = 12.3456d; 882 883 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(loc); 884 String s = fmt.format(amount, Direction.LAST, RelativeUnit.SECONDS); 885 assertEquals("Java Locale.US", "12.346 seconds ago", s); 886 887 // Modified instance 888 NumberFormat nf = fmt.getNumberFormat(); 889 nf.setMaximumFractionDigits(1); 890 fmt = RelativeDateTimeFormatter.getInstance(loc, nf); 891 892 s = fmt.format(amount, Direction.LAST, RelativeUnit.SECONDS); 893 assertEquals("Java Locale.US", "12.3 seconds ago", s); 894 } 895 896 @Test 897 public void TestGetters() { 898 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 899 new ULocale("en_US"), 900 null, 901 RelativeDateTimeFormatter.Style.SHORT, 902 DisplayContext.CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE); 903 assertEquals("", RelativeDateTimeFormatter.Style.SHORT, fmt.getFormatStyle()); 904 assertEquals( 905 "", 906 DisplayContext.CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, 907 fmt.getCapitalizationContext()); 908 909 // test the no-arguments getInstance(); 910 RelativeDateTimeFormatter fmt_default = RelativeDateTimeFormatter.getInstance(); 911 assertEquals("", RelativeDateTimeFormatter.Style.LONG, fmt_default.getFormatStyle()); 912 assertEquals( 913 "", 914 DisplayContext.CAPITALIZATION_NONE, 915 fmt_default.getCapitalizationContext()); 916 } 917 918 @Test 919 public void TestBadDisplayContext() { 920 try { 921 RelativeDateTimeFormatter.getInstance( 922 new ULocale("en_US"), 923 null, 924 RelativeDateTimeFormatter.Style.LONG, 925 DisplayContext.STANDARD_NAMES); 926 fail("Expected IllegalArgumentException"); 927 } catch (IllegalArgumentException expected) { 928 } 929 } 930 931 @Test 932 public void TestSidewaysDataLoading() { 933 RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance( 934 new ULocale("en_GB"), 935 null, 936 RelativeDateTimeFormatter.Style.NARROW, 937 DisplayContext.CAPITALIZATION_NONE); 938 String s = fmt.format(3.0, Direction.NEXT, RelativeUnit.MONTHS); 939 assertEquals("narrow: in 3 months", "in 3 mo", s); 940 String t = fmt.format(1.0, Direction.LAST, RelativeUnit.QUARTERS); 941 assertEquals("narrow: 1 qtr ago", "1 qtr ago", t); 942 // Check for fallback to SHORT 943 String u = fmt.format(3.0, Direction.LAST, RelativeUnit.QUARTERS); 944 assertEquals("narrow: 3 qtr ago", "3 qtr ago", u); 945 // Do not expect fall back to SHORT 946 String v = fmt.format(1.0, Direction.LAST, RelativeUnit.QUARTERS); 947 assertEquals("narrow: 1 qtr ago", "1 qtr ago", v); 948 String w = fmt.format(6.0, Direction.NEXT, RelativeUnit.QUARTERS); 949 assertEquals("narrow: in 6 qtr", "in 6 qtr", w); 950 } 951} 952