1 // © 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ******************************************************************************* 5 * Copyright (C) 2013-2016, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ******************************************************************************* 8 */ 9 package com.ibm.icu.dev.test.format; 10 11 import java.io.ByteArrayInputStream; 12 import java.io.ByteArrayOutputStream; 13 import java.io.IOException; 14 import java.io.ObjectInputStream; 15 import java.io.ObjectOutputStream; 16 import java.io.Serializable; 17 import java.lang.reflect.Field; 18 import java.text.FieldPosition; 19 import java.text.ParseException; 20 import java.util.ArrayList; 21 import java.util.Arrays; 22 import java.util.Collection; 23 import java.util.Collections; 24 import java.util.Comparator; 25 import java.util.HashMap; 26 import java.util.HashSet; 27 import java.util.List; 28 import java.util.Locale; 29 import java.util.Map; 30 import java.util.Set; 31 import java.util.TreeMap; 32 33 import org.junit.Assert; 34 import org.junit.Test; 35 import org.junit.runner.RunWith; 36 import org.junit.runners.JUnit4; 37 38 import com.ibm.icu.dev.test.TestFmwk; 39 import com.ibm.icu.dev.test.serializable.FormatHandler; 40 import com.ibm.icu.dev.test.serializable.SerializableTestUtility; 41 import com.ibm.icu.impl.Pair; 42 import com.ibm.icu.impl.Utility; 43 import com.ibm.icu.impl.units.MeasureUnitImpl; 44 import com.ibm.icu.math.BigDecimal; 45 import com.ibm.icu.text.MeasureFormat; 46 import com.ibm.icu.text.MeasureFormat.FormatWidth; 47 import com.ibm.icu.text.NumberFormat; 48 import com.ibm.icu.util.Currency; 49 import com.ibm.icu.util.CurrencyAmount; 50 import com.ibm.icu.util.Measure; 51 import com.ibm.icu.util.MeasureUnit; 52 import com.ibm.icu.util.NoUnit; 53 import com.ibm.icu.util.TimeUnit; 54 import com.ibm.icu.util.TimeUnitAmount; 55 import com.ibm.icu.util.ULocale; 56 57 /** 58 * See https://sites.google.com/site/icusite/processes/release/tasks/standards?pli=1 59 * for information on how to update with each new release. 60 * @author markdavis 61 */ 62 @RunWith(JUnit4.class) 63 public class MeasureUnitTest extends TestFmwk { 64 65 static class OrderedPair<F extends Comparable, S extends Comparable> extends Pair<F, S> implements Comparable<OrderedPair<F, S>> { 66 OrderedPair(F first, S second)67 OrderedPair(F first, S second) { 68 super(first, second); 69 } 70 of(F first, S second)71 public static <F extends Comparable, S extends Comparable> OrderedPair<F, S> of(F first, S second) { 72 if (first == null || second == null) { 73 throw new IllegalArgumentException("OrderedPair.of requires non null values."); 74 } 75 return new OrderedPair<>(first, second); 76 } 77 78 @Override compareTo(OrderedPair<F, S> other)79 public int compareTo(OrderedPair<F, S> other) { 80 int result = first.compareTo(other.first); 81 if (result != 0) { 82 return result; 83 } 84 return second.compareTo(other.second); 85 } 86 } 87 88 private static final String[] DRAFT_VERSIONS = {"71", "72"}; 89 90 private static final HashSet<String> DRAFT_VERSION_SET = new HashSet<>(); 91 92 private static final HashSet<String> TIME_CODES = new HashSet<>(); 93 94 private static final String[][] JAVA_VERSIONS = { 95 {"G_FORCE", "53"}, 96 {"DEGREE", "53"}, 97 {"ARC_MINUTE", "53"}, 98 {"ARC_SECOND", "53"}, 99 {"ACRE", "53"}, 100 {"HECTARE", "53"}, 101 {"SQUARE_FOOT", "53"}, 102 {"SQUARE_KILOMETER", "53"}, 103 {"SQUARE_METER", "53"}, 104 {"SQUARE_MILE", "53"}, 105 {"MILLISECOND", "53"}, 106 {"CENTIMETER", "53"}, 107 {"FOOT", "53"}, 108 {"INCH", "53"}, 109 {"KILOMETER", "53"}, 110 {"LIGHT_YEAR", "53"}, 111 {"METER", "53"}, 112 {"MILE", "53"}, 113 {"MILLIMETER", "53"}, 114 {"PICOMETER", "53"}, 115 {"YARD", "53"}, 116 {"GRAM", "53"}, 117 {"KILOGRAM", "53"}, 118 {"OUNCE", "53"}, 119 {"POUND", "53"}, 120 {"HORSEPOWER", "53"}, 121 {"KILOWATT", "53"}, 122 {"WATT", "53"}, 123 {"HECTOPASCAL", "53"}, 124 {"INCH_HG", "53"}, 125 {"MILLIBAR", "53"}, 126 {"KILOMETER_PER_HOUR", "53"}, 127 {"METER_PER_SECOND", "53"}, 128 {"MILE_PER_HOUR", "53"}, 129 {"CELSIUS", "53"}, 130 {"FAHRENHEIT", "53"}, 131 {"CUBIC_KILOMETER", "53"}, 132 {"CUBIC_MILE", "53"}, 133 {"LITER", "53"}, 134 {"YEAR", "53"}, 135 {"MONTH", "53"}, 136 {"WEEK", "53"}, 137 {"DAY", "53"}, 138 {"HOUR", "53"}, 139 {"MINUTE", "53"}, 140 {"SECOND", "53"}, 141 {"METER_PER_SECOND_SQUARED", "54"}, 142 {"RADIAN", "54"}, 143 {"SQUARE_CENTIMETER", "54"}, 144 {"SQUARE_INCH", "54"}, 145 {"SQUARE_YARD", "54"}, 146 {"LITER_PER_KILOMETER", "54"}, 147 {"MILE_PER_GALLON", "54"}, 148 {"BIT", "54"}, 149 {"BYTE", "54"}, 150 {"GIGABIT", "54"}, 151 {"GIGABYTE", "54"}, 152 {"KILOBIT", "54"}, 153 {"KILOBYTE", "54"}, 154 {"MEGABIT", "54"}, 155 {"MEGABYTE", "54"}, 156 {"TERABIT", "54"}, 157 {"TERABYTE", "54"}, 158 {"MICROSECOND", "54"}, 159 {"NANOSECOND", "54"}, 160 {"AMPERE", "54"}, 161 {"MILLIAMPERE", "54"}, 162 {"OHM", "54"}, 163 {"VOLT", "54"}, 164 {"CALORIE", "54"}, 165 {"FOODCALORIE", "54"}, 166 {"JOULE", "54"}, 167 {"KILOCALORIE", "54"}, 168 {"KILOJOULE", "54"}, 169 {"KILOWATT_HOUR", "54"}, 170 {"GIGAHERTZ", "54"}, 171 {"HERTZ", "54"}, 172 {"KILOHERTZ", "54"}, 173 {"MEGAHERTZ", "54"}, 174 {"ASTRONOMICAL_UNIT", "54"}, 175 {"DECIMETER", "54"}, 176 {"FATHOM", "54"}, 177 {"FURLONG", "54"}, 178 {"MICROMETER", "54"}, 179 {"NANOMETER", "54"}, 180 {"NAUTICAL_MILE", "54"}, 181 {"PARSEC", "54"}, 182 {"LUX", "54"}, 183 {"CARAT", "54"}, 184 {"METRIC_TON", "54"}, 185 {"MICROGRAM", "54"}, 186 {"MILLIGRAM", "54"}, 187 {"OUNCE_TROY", "54"}, 188 {"STONE", "54"}, 189 {"TON", "54"}, 190 {"GIGAWATT", "54"}, 191 {"MEGAWATT", "54"}, 192 {"MILLIWATT", "54"}, 193 {"MILLIMETER_OF_MERCURY", "54"}, 194 {"POUND_PER_SQUARE_INCH", "54"}, 195 {"KARAT", "54"}, 196 {"KELVIN", "54"}, 197 {"ACRE_FOOT", "54"}, 198 {"BUSHEL", "54"}, 199 {"CENTILITER", "54"}, 200 {"CUBIC_CENTIMETER", "54"}, 201 {"CUBIC_FOOT", "54"}, 202 {"CUBIC_INCH", "54"}, 203 {"CUBIC_METER", "54"}, 204 {"CUBIC_YARD", "54"}, 205 {"CUP", "54"}, 206 {"DECILITER", "54"}, 207 {"FLUID_OUNCE", "54"}, 208 {"GALLON", "54"}, 209 {"HECTOLITER", "54"}, 210 {"MEGALITER", "54"}, 211 {"MILLILITER", "54"}, 212 {"PINT", "54"}, 213 {"QUART", "54"}, 214 {"TABLESPOON", "54"}, 215 {"TEASPOON", "54"}, 216 {"GENERIC_TEMPERATURE", "56"}, 217 {"REVOLUTION_ANGLE", "56"}, 218 {"LITER_PER_100KILOMETERS", "56"}, 219 {"CENTURY", "56"}, 220 {"MILE_SCANDINAVIAN", "56"}, 221 {"KNOT", "56"}, 222 {"CUP_METRIC", "56"}, 223 {"PINT_METRIC", "56"}, 224 {"MILLIGRAM_PER_DECILITER", "57"}, 225 {"MILLIMOLE_PER_LITER", "57"}, 226 {"PART_PER_MILLION", "57"}, 227 {"MILE_PER_GALLON_IMPERIAL", "57"}, 228 {"GALLON_IMPERIAL", "57"}, 229 {"POINT", "59"}, 230 {"PERCENT", "63"}, 231 {"PERMILLE", "63"}, 232 {"PETABYTE", "63"}, 233 {"ATMOSPHERE", "63"}, 234 {"DUNAM", "64"}, 235 {"MOLE", "64"}, 236 {"PERMYRIAD", "64"}, 237 {"DAY_PERSON", "64"}, 238 {"MONTH_PERSON", "64"}, 239 {"WEEK_PERSON", "64"}, 240 {"YEAR_PERSON", "64"}, 241 {"BRITISH_THERMAL_UNIT", "64"}, 242 {"ELECTRONVOLT", "64"}, 243 {"NEWTON", "64"}, 244 {"POUND_FORCE", "64"}, 245 {"SOLAR_RADIUS", "64"}, 246 {"SOLAR_LUMINOSITY", "64"}, 247 {"DALTON", "64"}, 248 {"EARTH_MASS", "64"}, 249 {"SOLAR_MASS", "64"}, 250 {"KILOPASCAL", "64"}, 251 {"MEGAPASCAL", "64"}, 252 {"NEWTON_METER", "64"}, 253 {"POUND_FOOT", "64"}, 254 {"BARREL", "64"}, 255 {"FLUID_OUNCE_IMPERIAL", "64"}, 256 {"DECADE", "65"}, 257 {"THERM_US", "65"}, 258 {"DOT_PER_CENTIMETER", "65"}, 259 {"DOT_PER_INCH", "65"}, 260 {"EM", "65"}, 261 {"MEGAPIXEL", "65"}, 262 {"PIXEL", "65"}, 263 {"PIXEL_PER_CENTIMETER", "65"}, 264 {"PIXEL_PER_INCH", "65"}, 265 {"BAR", "65"}, 266 {"PASCAL", "65"}, 267 {"DOT", "68"}, 268 {"EARTH_RADIUS", "68"}, 269 {"CANDELA", "68"}, 270 {"LUMEN", "68"}, 271 {"GRAIN", "68"}, 272 {"DESSERT_SPOON", "68"}, 273 {"DESSERT_SPOON_IMPERIAL", "68"}, 274 {"DRAM", "68"}, 275 {"DROP", "68"}, 276 {"JIGGER", "68"}, 277 {"PINCH", "68"}, 278 {"QUART_IMPERIAL", "68"}, 279 {"MILLIGRAM_OFGLUCOSE_PER_DECILITER", "69"}, 280 {"ITEM", "70"}, 281 {"KILOWATT_HOUR_PER_100_KILOMETER", "70"}, 282 {"QUARTER", "72"}, 283 {"TONNE", "72"}, 284 }; 285 286 private static final HashMap<String, String> JAVA_VERSION_MAP = new HashMap<>(); 287 288 // modify certain CLDR unit names before generating functions 289 // that create/get the corresponding MeasureUnit objects 290 private static final Map<String,String> CLDR_NAME_REMAP = new HashMap(); 291 292 static { 293 TIME_CODES.add("year"); 294 TIME_CODES.add("month"); 295 TIME_CODES.add("week"); 296 TIME_CODES.add("day"); 297 TIME_CODES.add("hour"); 298 TIME_CODES.add("minute"); 299 TIME_CODES.add("second"); 300 for (String verNum : DRAFT_VERSIONS) { 301 DRAFT_VERSION_SET.add(verNum); 302 } 303 for (String[] funcNameAndVersion : JAVA_VERSIONS) { JAVA_VERSION_MAP.put(funcNameAndVersion[0], funcNameAndVersion[1])304 JAVA_VERSION_MAP.put(funcNameAndVersion[0], funcNameAndVersion[1]); 305 } 306 307 // CLDR_NAME_REMAP entries 308 // The first two fix overly-generic CLDR unit names 309 CLDR_NAME_REMAP.put("revolution", "revolution-angle"); 310 CLDR_NAME_REMAP.put("generic", "generic-temperature"); 311 // The next seven map updated CLDR 37 names back to their 312 // old form in order to preserve the old function names 313 CLDR_NAME_REMAP.put("meter-per-square-second", "meter-per-second-squared"); 314 CLDR_NAME_REMAP.put("permillion", "part-per-million"); 315 CLDR_NAME_REMAP.put("liter-per-100-kilometer", "liter-per-100kilometers"); 316 CLDR_NAME_REMAP.put("inch-ofhg", "inch-hg"); 317 CLDR_NAME_REMAP.put("millimeter-ofhg", "millimeter-of-mercury"); 318 CLDR_NAME_REMAP.put("pound-force-per-square-inch", "pound-per-square-inch"); 319 CLDR_NAME_REMAP.put("pound-force-foot", "pound-foot"); 320 } 321 322 @Test testZZZ()323 public void testZZZ() { 324 // various generateXXX calls go here, see 325 // docs/processes/release/tasks/updating-measure-unit.md 326 // use this test to run each of the ollowing in succession 327 //generateConstants("72"); // for MeasureUnit.java, update generated MeasureUnit constants 328 //generateBackwardCompatibilityTest("72"); // for MeasureUnitTest.java, create TestCompatible72 329 //generateCXXHConstants("72"); // for measunit.h, update generated createXXX methods 330 //generateCXXConstants(); // for measunit.cpp, update generated code 331 //generateCXXBackwardCompatibilityTest("72"); // for measfmttest.cpp, create TestCompatible72 332 //updateJAVAVersions("72"); // for MeasureUnitTest.java, JAVA_VERSIONS 333 } 334 335 @Test TestCompatible53()336 public void TestCompatible53() { 337 MeasureUnit[] units = { 338 MeasureUnit.G_FORCE, 339 MeasureUnit.DEGREE, 340 MeasureUnit.ARC_MINUTE, 341 MeasureUnit.ARC_SECOND, 342 MeasureUnit.ACRE, 343 MeasureUnit.HECTARE, 344 MeasureUnit.SQUARE_FOOT, 345 MeasureUnit.SQUARE_KILOMETER, 346 MeasureUnit.SQUARE_METER, 347 MeasureUnit.SQUARE_MILE, 348 MeasureUnit.MILLISECOND, 349 MeasureUnit.CENTIMETER, 350 MeasureUnit.FOOT, 351 MeasureUnit.INCH, 352 MeasureUnit.KILOMETER, 353 MeasureUnit.LIGHT_YEAR, 354 MeasureUnit.METER, 355 MeasureUnit.MILE, 356 MeasureUnit.MILLIMETER, 357 MeasureUnit.PICOMETER, 358 MeasureUnit.YARD, 359 MeasureUnit.GRAM, 360 MeasureUnit.KILOGRAM, 361 MeasureUnit.OUNCE, 362 MeasureUnit.POUND, 363 MeasureUnit.HORSEPOWER, 364 MeasureUnit.KILOWATT, 365 MeasureUnit.WATT, 366 MeasureUnit.HECTOPASCAL, 367 MeasureUnit.INCH_HG, 368 MeasureUnit.MILLIBAR, 369 MeasureUnit.KILOMETER_PER_HOUR, 370 MeasureUnit.METER_PER_SECOND, 371 MeasureUnit.MILE_PER_HOUR, 372 MeasureUnit.CELSIUS, 373 MeasureUnit.FAHRENHEIT, 374 MeasureUnit.CUBIC_KILOMETER, 375 MeasureUnit.CUBIC_MILE, 376 MeasureUnit.LITER, 377 MeasureUnit.YEAR, 378 MeasureUnit.MONTH, 379 MeasureUnit.WEEK, 380 MeasureUnit.DAY, 381 MeasureUnit.HOUR, 382 MeasureUnit.MINUTE, 383 MeasureUnit.SECOND, 384 }; 385 assertEquals("", 46, units.length); 386 } 387 388 @Test TestCompatible54()389 public void TestCompatible54() { 390 MeasureUnit[] units = { 391 MeasureUnit.G_FORCE, 392 MeasureUnit.METER_PER_SECOND_SQUARED, 393 MeasureUnit.ARC_MINUTE, 394 MeasureUnit.ARC_SECOND, 395 MeasureUnit.DEGREE, 396 MeasureUnit.RADIAN, 397 MeasureUnit.ACRE, 398 MeasureUnit.HECTARE, 399 MeasureUnit.SQUARE_CENTIMETER, 400 MeasureUnit.SQUARE_FOOT, 401 MeasureUnit.SQUARE_INCH, 402 MeasureUnit.SQUARE_KILOMETER, 403 MeasureUnit.SQUARE_METER, 404 MeasureUnit.SQUARE_MILE, 405 MeasureUnit.SQUARE_YARD, 406 MeasureUnit.LITER_PER_KILOMETER, 407 MeasureUnit.MILE_PER_GALLON, 408 MeasureUnit.BIT, 409 MeasureUnit.BYTE, 410 MeasureUnit.GIGABIT, 411 MeasureUnit.GIGABYTE, 412 MeasureUnit.KILOBIT, 413 MeasureUnit.KILOBYTE, 414 MeasureUnit.MEGABIT, 415 MeasureUnit.MEGABYTE, 416 MeasureUnit.TERABIT, 417 MeasureUnit.TERABYTE, 418 MeasureUnit.DAY, 419 MeasureUnit.HOUR, 420 MeasureUnit.MICROSECOND, 421 MeasureUnit.MILLISECOND, 422 MeasureUnit.MINUTE, 423 MeasureUnit.MONTH, 424 MeasureUnit.NANOSECOND, 425 MeasureUnit.SECOND, 426 MeasureUnit.WEEK, 427 MeasureUnit.YEAR, 428 MeasureUnit.AMPERE, 429 MeasureUnit.MILLIAMPERE, 430 MeasureUnit.OHM, 431 MeasureUnit.VOLT, 432 MeasureUnit.CALORIE, 433 MeasureUnit.FOODCALORIE, 434 MeasureUnit.JOULE, 435 MeasureUnit.KILOCALORIE, 436 MeasureUnit.KILOJOULE, 437 MeasureUnit.KILOWATT_HOUR, 438 MeasureUnit.GIGAHERTZ, 439 MeasureUnit.HERTZ, 440 MeasureUnit.KILOHERTZ, 441 MeasureUnit.MEGAHERTZ, 442 MeasureUnit.ASTRONOMICAL_UNIT, 443 MeasureUnit.CENTIMETER, 444 MeasureUnit.DECIMETER, 445 MeasureUnit.FATHOM, 446 MeasureUnit.FOOT, 447 MeasureUnit.FURLONG, 448 MeasureUnit.INCH, 449 MeasureUnit.KILOMETER, 450 MeasureUnit.LIGHT_YEAR, 451 MeasureUnit.METER, 452 MeasureUnit.MICROMETER, 453 MeasureUnit.MILE, 454 MeasureUnit.MILLIMETER, 455 MeasureUnit.NANOMETER, 456 MeasureUnit.NAUTICAL_MILE, 457 MeasureUnit.PARSEC, 458 MeasureUnit.PICOMETER, 459 MeasureUnit.YARD, 460 MeasureUnit.LUX, 461 MeasureUnit.CARAT, 462 MeasureUnit.GRAM, 463 MeasureUnit.KILOGRAM, 464 MeasureUnit.METRIC_TON, 465 MeasureUnit.MICROGRAM, 466 MeasureUnit.MILLIGRAM, 467 MeasureUnit.OUNCE, 468 MeasureUnit.OUNCE_TROY, 469 MeasureUnit.POUND, 470 MeasureUnit.STONE, 471 MeasureUnit.TON, 472 MeasureUnit.GIGAWATT, 473 MeasureUnit.HORSEPOWER, 474 MeasureUnit.KILOWATT, 475 MeasureUnit.MEGAWATT, 476 MeasureUnit.MILLIWATT, 477 MeasureUnit.WATT, 478 MeasureUnit.HECTOPASCAL, 479 MeasureUnit.INCH_HG, 480 MeasureUnit.MILLIBAR, 481 MeasureUnit.MILLIMETER_OF_MERCURY, 482 MeasureUnit.POUND_PER_SQUARE_INCH, 483 MeasureUnit.KARAT, 484 MeasureUnit.KILOMETER_PER_HOUR, 485 MeasureUnit.METER_PER_SECOND, 486 MeasureUnit.MILE_PER_HOUR, 487 MeasureUnit.CELSIUS, 488 MeasureUnit.FAHRENHEIT, 489 MeasureUnit.KELVIN, 490 MeasureUnit.ACRE_FOOT, 491 MeasureUnit.BUSHEL, 492 MeasureUnit.CENTILITER, 493 MeasureUnit.CUBIC_CENTIMETER, 494 MeasureUnit.CUBIC_FOOT, 495 MeasureUnit.CUBIC_INCH, 496 MeasureUnit.CUBIC_KILOMETER, 497 MeasureUnit.CUBIC_METER, 498 MeasureUnit.CUBIC_MILE, 499 MeasureUnit.CUBIC_YARD, 500 MeasureUnit.CUP, 501 MeasureUnit.DECILITER, 502 MeasureUnit.FLUID_OUNCE, 503 MeasureUnit.GALLON, 504 MeasureUnit.HECTOLITER, 505 MeasureUnit.LITER, 506 MeasureUnit.MEGALITER, 507 MeasureUnit.MILLILITER, 508 MeasureUnit.PINT, 509 MeasureUnit.QUART, 510 MeasureUnit.TABLESPOON, 511 MeasureUnit.TEASPOON, 512 }; 513 assertEquals("", 121, units.length); 514 } 515 516 @Test TestCompatible55()517 public void TestCompatible55() { 518 MeasureUnit[] units = { 519 MeasureUnit.G_FORCE, 520 MeasureUnit.METER_PER_SECOND_SQUARED, 521 MeasureUnit.ARC_MINUTE, 522 MeasureUnit.ARC_SECOND, 523 MeasureUnit.DEGREE, 524 MeasureUnit.RADIAN, 525 MeasureUnit.ACRE, 526 MeasureUnit.HECTARE, 527 MeasureUnit.SQUARE_CENTIMETER, 528 MeasureUnit.SQUARE_FOOT, 529 MeasureUnit.SQUARE_INCH, 530 MeasureUnit.SQUARE_KILOMETER, 531 MeasureUnit.SQUARE_METER, 532 MeasureUnit.SQUARE_MILE, 533 MeasureUnit.SQUARE_YARD, 534 MeasureUnit.LITER_PER_KILOMETER, 535 MeasureUnit.MILE_PER_GALLON, 536 MeasureUnit.BIT, 537 MeasureUnit.BYTE, 538 MeasureUnit.GIGABIT, 539 MeasureUnit.GIGABYTE, 540 MeasureUnit.KILOBIT, 541 MeasureUnit.KILOBYTE, 542 MeasureUnit.MEGABIT, 543 MeasureUnit.MEGABYTE, 544 MeasureUnit.TERABIT, 545 MeasureUnit.TERABYTE, 546 MeasureUnit.DAY, 547 MeasureUnit.HOUR, 548 MeasureUnit.MICROSECOND, 549 MeasureUnit.MILLISECOND, 550 MeasureUnit.MINUTE, 551 MeasureUnit.MONTH, 552 MeasureUnit.NANOSECOND, 553 MeasureUnit.SECOND, 554 MeasureUnit.WEEK, 555 MeasureUnit.YEAR, 556 MeasureUnit.AMPERE, 557 MeasureUnit.MILLIAMPERE, 558 MeasureUnit.OHM, 559 MeasureUnit.VOLT, 560 MeasureUnit.CALORIE, 561 MeasureUnit.FOODCALORIE, 562 MeasureUnit.JOULE, 563 MeasureUnit.KILOCALORIE, 564 MeasureUnit.KILOJOULE, 565 MeasureUnit.KILOWATT_HOUR, 566 MeasureUnit.GIGAHERTZ, 567 MeasureUnit.HERTZ, 568 MeasureUnit.KILOHERTZ, 569 MeasureUnit.MEGAHERTZ, 570 MeasureUnit.ASTRONOMICAL_UNIT, 571 MeasureUnit.CENTIMETER, 572 MeasureUnit.DECIMETER, 573 MeasureUnit.FATHOM, 574 MeasureUnit.FOOT, 575 MeasureUnit.FURLONG, 576 MeasureUnit.INCH, 577 MeasureUnit.KILOMETER, 578 MeasureUnit.LIGHT_YEAR, 579 MeasureUnit.METER, 580 MeasureUnit.MICROMETER, 581 MeasureUnit.MILE, 582 MeasureUnit.MILLIMETER, 583 MeasureUnit.NANOMETER, 584 MeasureUnit.NAUTICAL_MILE, 585 MeasureUnit.PARSEC, 586 MeasureUnit.PICOMETER, 587 MeasureUnit.YARD, 588 MeasureUnit.LUX, 589 MeasureUnit.CARAT, 590 MeasureUnit.GRAM, 591 MeasureUnit.KILOGRAM, 592 MeasureUnit.METRIC_TON, 593 MeasureUnit.MICROGRAM, 594 MeasureUnit.MILLIGRAM, 595 MeasureUnit.OUNCE, 596 MeasureUnit.OUNCE_TROY, 597 MeasureUnit.POUND, 598 MeasureUnit.STONE, 599 MeasureUnit.TON, 600 MeasureUnit.GIGAWATT, 601 MeasureUnit.HORSEPOWER, 602 MeasureUnit.KILOWATT, 603 MeasureUnit.MEGAWATT, 604 MeasureUnit.MILLIWATT, 605 MeasureUnit.WATT, 606 MeasureUnit.HECTOPASCAL, 607 MeasureUnit.INCH_HG, 608 MeasureUnit.MILLIBAR, 609 MeasureUnit.MILLIMETER_OF_MERCURY, 610 MeasureUnit.POUND_PER_SQUARE_INCH, 611 MeasureUnit.KARAT, 612 MeasureUnit.KILOMETER_PER_HOUR, 613 MeasureUnit.METER_PER_SECOND, 614 MeasureUnit.MILE_PER_HOUR, 615 MeasureUnit.CELSIUS, 616 MeasureUnit.FAHRENHEIT, 617 MeasureUnit.GENERIC_TEMPERATURE, 618 MeasureUnit.KELVIN, 619 MeasureUnit.ACRE_FOOT, 620 MeasureUnit.BUSHEL, 621 MeasureUnit.CENTILITER, 622 MeasureUnit.CUBIC_CENTIMETER, 623 MeasureUnit.CUBIC_FOOT, 624 MeasureUnit.CUBIC_INCH, 625 MeasureUnit.CUBIC_KILOMETER, 626 MeasureUnit.CUBIC_METER, 627 MeasureUnit.CUBIC_MILE, 628 MeasureUnit.CUBIC_YARD, 629 MeasureUnit.CUP, 630 MeasureUnit.DECILITER, 631 MeasureUnit.FLUID_OUNCE, 632 MeasureUnit.GALLON, 633 MeasureUnit.HECTOLITER, 634 MeasureUnit.LITER, 635 MeasureUnit.MEGALITER, 636 MeasureUnit.MILLILITER, 637 MeasureUnit.PINT, 638 MeasureUnit.QUART, 639 MeasureUnit.TABLESPOON, 640 MeasureUnit.TEASPOON, 641 }; 642 assertEquals("", 122, units.length); 643 } 644 645 @Test TestCompatible56()646 public void TestCompatible56() { 647 MeasureUnit[] units = { 648 MeasureUnit.G_FORCE, 649 MeasureUnit.METER_PER_SECOND_SQUARED, 650 MeasureUnit.ARC_MINUTE, 651 MeasureUnit.ARC_SECOND, 652 MeasureUnit.DEGREE, 653 MeasureUnit.RADIAN, 654 MeasureUnit.REVOLUTION_ANGLE, 655 MeasureUnit.ACRE, 656 MeasureUnit.HECTARE, 657 MeasureUnit.SQUARE_CENTIMETER, 658 MeasureUnit.SQUARE_FOOT, 659 MeasureUnit.SQUARE_INCH, 660 MeasureUnit.SQUARE_KILOMETER, 661 MeasureUnit.SQUARE_METER, 662 MeasureUnit.SQUARE_MILE, 663 MeasureUnit.SQUARE_YARD, 664 MeasureUnit.LITER_PER_100KILOMETERS, 665 MeasureUnit.LITER_PER_KILOMETER, 666 MeasureUnit.MILE_PER_GALLON, 667 MeasureUnit.BIT, 668 MeasureUnit.BYTE, 669 MeasureUnit.GIGABIT, 670 MeasureUnit.GIGABYTE, 671 MeasureUnit.KILOBIT, 672 MeasureUnit.KILOBYTE, 673 MeasureUnit.MEGABIT, 674 MeasureUnit.MEGABYTE, 675 MeasureUnit.TERABIT, 676 MeasureUnit.TERABYTE, 677 MeasureUnit.CENTURY, 678 MeasureUnit.DAY, 679 MeasureUnit.HOUR, 680 MeasureUnit.MICROSECOND, 681 MeasureUnit.MILLISECOND, 682 MeasureUnit.MINUTE, 683 MeasureUnit.MONTH, 684 MeasureUnit.NANOSECOND, 685 MeasureUnit.SECOND, 686 MeasureUnit.WEEK, 687 MeasureUnit.YEAR, 688 MeasureUnit.AMPERE, 689 MeasureUnit.MILLIAMPERE, 690 MeasureUnit.OHM, 691 MeasureUnit.VOLT, 692 MeasureUnit.CALORIE, 693 MeasureUnit.FOODCALORIE, 694 MeasureUnit.JOULE, 695 MeasureUnit.KILOCALORIE, 696 MeasureUnit.KILOJOULE, 697 MeasureUnit.KILOWATT_HOUR, 698 MeasureUnit.GIGAHERTZ, 699 MeasureUnit.HERTZ, 700 MeasureUnit.KILOHERTZ, 701 MeasureUnit.MEGAHERTZ, 702 MeasureUnit.ASTRONOMICAL_UNIT, 703 MeasureUnit.CENTIMETER, 704 MeasureUnit.DECIMETER, 705 MeasureUnit.FATHOM, 706 MeasureUnit.FOOT, 707 MeasureUnit.FURLONG, 708 MeasureUnit.INCH, 709 MeasureUnit.KILOMETER, 710 MeasureUnit.LIGHT_YEAR, 711 MeasureUnit.METER, 712 MeasureUnit.MICROMETER, 713 MeasureUnit.MILE, 714 MeasureUnit.MILE_SCANDINAVIAN, 715 MeasureUnit.MILLIMETER, 716 MeasureUnit.NANOMETER, 717 MeasureUnit.NAUTICAL_MILE, 718 MeasureUnit.PARSEC, 719 MeasureUnit.PICOMETER, 720 MeasureUnit.YARD, 721 MeasureUnit.LUX, 722 MeasureUnit.CARAT, 723 MeasureUnit.GRAM, 724 MeasureUnit.KILOGRAM, 725 MeasureUnit.METRIC_TON, 726 MeasureUnit.MICROGRAM, 727 MeasureUnit.MILLIGRAM, 728 MeasureUnit.OUNCE, 729 MeasureUnit.OUNCE_TROY, 730 MeasureUnit.POUND, 731 MeasureUnit.STONE, 732 MeasureUnit.TON, 733 MeasureUnit.GIGAWATT, 734 MeasureUnit.HORSEPOWER, 735 MeasureUnit.KILOWATT, 736 MeasureUnit.MEGAWATT, 737 MeasureUnit.MILLIWATT, 738 MeasureUnit.WATT, 739 MeasureUnit.HECTOPASCAL, 740 MeasureUnit.INCH_HG, 741 MeasureUnit.MILLIBAR, 742 MeasureUnit.MILLIMETER_OF_MERCURY, 743 MeasureUnit.POUND_PER_SQUARE_INCH, 744 MeasureUnit.KARAT, 745 MeasureUnit.KILOMETER_PER_HOUR, 746 MeasureUnit.KNOT, 747 MeasureUnit.METER_PER_SECOND, 748 MeasureUnit.MILE_PER_HOUR, 749 MeasureUnit.CELSIUS, 750 MeasureUnit.FAHRENHEIT, 751 MeasureUnit.GENERIC_TEMPERATURE, 752 MeasureUnit.KELVIN, 753 MeasureUnit.ACRE_FOOT, 754 MeasureUnit.BUSHEL, 755 MeasureUnit.CENTILITER, 756 MeasureUnit.CUBIC_CENTIMETER, 757 MeasureUnit.CUBIC_FOOT, 758 MeasureUnit.CUBIC_INCH, 759 MeasureUnit.CUBIC_KILOMETER, 760 MeasureUnit.CUBIC_METER, 761 MeasureUnit.CUBIC_MILE, 762 MeasureUnit.CUBIC_YARD, 763 MeasureUnit.CUP, 764 MeasureUnit.CUP_METRIC, 765 MeasureUnit.DECILITER, 766 MeasureUnit.FLUID_OUNCE, 767 MeasureUnit.GALLON, 768 MeasureUnit.HECTOLITER, 769 MeasureUnit.LITER, 770 MeasureUnit.MEGALITER, 771 MeasureUnit.MILLILITER, 772 MeasureUnit.PINT, 773 MeasureUnit.PINT_METRIC, 774 MeasureUnit.QUART, 775 MeasureUnit.TABLESPOON, 776 MeasureUnit.TEASPOON, 777 }; 778 assertEquals("", 129, units.length); 779 } 780 781 @Test TestCompatible57()782 public void TestCompatible57() { 783 MeasureUnit[] units = { 784 MeasureUnit.G_FORCE, 785 MeasureUnit.METER_PER_SECOND_SQUARED, 786 MeasureUnit.ARC_MINUTE, 787 MeasureUnit.ARC_SECOND, 788 MeasureUnit.DEGREE, 789 MeasureUnit.RADIAN, 790 MeasureUnit.REVOLUTION_ANGLE, 791 MeasureUnit.ACRE, 792 MeasureUnit.HECTARE, 793 MeasureUnit.SQUARE_CENTIMETER, 794 MeasureUnit.SQUARE_FOOT, 795 MeasureUnit.SQUARE_INCH, 796 MeasureUnit.SQUARE_KILOMETER, 797 MeasureUnit.SQUARE_METER, 798 MeasureUnit.SQUARE_MILE, 799 MeasureUnit.SQUARE_YARD, 800 MeasureUnit.KARAT, 801 MeasureUnit.MILLIGRAM_PER_DECILITER, 802 MeasureUnit.MILLIMOLE_PER_LITER, 803 MeasureUnit.PART_PER_MILLION, 804 MeasureUnit.LITER_PER_100KILOMETERS, 805 MeasureUnit.LITER_PER_KILOMETER, 806 MeasureUnit.MILE_PER_GALLON, 807 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 808 MeasureUnit.BIT, 809 MeasureUnit.BYTE, 810 MeasureUnit.GIGABIT, 811 MeasureUnit.GIGABYTE, 812 MeasureUnit.KILOBIT, 813 MeasureUnit.KILOBYTE, 814 MeasureUnit.MEGABIT, 815 MeasureUnit.MEGABYTE, 816 MeasureUnit.TERABIT, 817 MeasureUnit.TERABYTE, 818 MeasureUnit.CENTURY, 819 MeasureUnit.DAY, 820 MeasureUnit.HOUR, 821 MeasureUnit.MICROSECOND, 822 MeasureUnit.MILLISECOND, 823 MeasureUnit.MINUTE, 824 MeasureUnit.MONTH, 825 MeasureUnit.NANOSECOND, 826 MeasureUnit.SECOND, 827 MeasureUnit.WEEK, 828 MeasureUnit.YEAR, 829 MeasureUnit.AMPERE, 830 MeasureUnit.MILLIAMPERE, 831 MeasureUnit.OHM, 832 MeasureUnit.VOLT, 833 MeasureUnit.CALORIE, 834 MeasureUnit.FOODCALORIE, 835 MeasureUnit.JOULE, 836 MeasureUnit.KILOCALORIE, 837 MeasureUnit.KILOJOULE, 838 MeasureUnit.KILOWATT_HOUR, 839 MeasureUnit.GIGAHERTZ, 840 MeasureUnit.HERTZ, 841 MeasureUnit.KILOHERTZ, 842 MeasureUnit.MEGAHERTZ, 843 MeasureUnit.ASTRONOMICAL_UNIT, 844 MeasureUnit.CENTIMETER, 845 MeasureUnit.DECIMETER, 846 MeasureUnit.FATHOM, 847 MeasureUnit.FOOT, 848 MeasureUnit.FURLONG, 849 MeasureUnit.INCH, 850 MeasureUnit.KILOMETER, 851 MeasureUnit.LIGHT_YEAR, 852 MeasureUnit.METER, 853 MeasureUnit.MICROMETER, 854 MeasureUnit.MILE, 855 MeasureUnit.MILE_SCANDINAVIAN, 856 MeasureUnit.MILLIMETER, 857 MeasureUnit.NANOMETER, 858 MeasureUnit.NAUTICAL_MILE, 859 MeasureUnit.PARSEC, 860 MeasureUnit.PICOMETER, 861 MeasureUnit.YARD, 862 MeasureUnit.LUX, 863 MeasureUnit.CARAT, 864 MeasureUnit.GRAM, 865 MeasureUnit.KILOGRAM, 866 MeasureUnit.METRIC_TON, 867 MeasureUnit.MICROGRAM, 868 MeasureUnit.MILLIGRAM, 869 MeasureUnit.OUNCE, 870 MeasureUnit.OUNCE_TROY, 871 MeasureUnit.POUND, 872 MeasureUnit.STONE, 873 MeasureUnit.TON, 874 MeasureUnit.GIGAWATT, 875 MeasureUnit.HORSEPOWER, 876 MeasureUnit.KILOWATT, 877 MeasureUnit.MEGAWATT, 878 MeasureUnit.MILLIWATT, 879 MeasureUnit.WATT, 880 MeasureUnit.HECTOPASCAL, 881 MeasureUnit.INCH_HG, 882 MeasureUnit.MILLIBAR, 883 MeasureUnit.MILLIMETER_OF_MERCURY, 884 MeasureUnit.POUND_PER_SQUARE_INCH, 885 MeasureUnit.KILOMETER_PER_HOUR, 886 MeasureUnit.KNOT, 887 MeasureUnit.METER_PER_SECOND, 888 MeasureUnit.MILE_PER_HOUR, 889 MeasureUnit.CELSIUS, 890 MeasureUnit.FAHRENHEIT, 891 MeasureUnit.GENERIC_TEMPERATURE, 892 MeasureUnit.KELVIN, 893 MeasureUnit.ACRE_FOOT, 894 MeasureUnit.BUSHEL, 895 MeasureUnit.CENTILITER, 896 MeasureUnit.CUBIC_CENTIMETER, 897 MeasureUnit.CUBIC_FOOT, 898 MeasureUnit.CUBIC_INCH, 899 MeasureUnit.CUBIC_KILOMETER, 900 MeasureUnit.CUBIC_METER, 901 MeasureUnit.CUBIC_MILE, 902 MeasureUnit.CUBIC_YARD, 903 MeasureUnit.CUP, 904 MeasureUnit.CUP_METRIC, 905 MeasureUnit.DECILITER, 906 MeasureUnit.FLUID_OUNCE, 907 MeasureUnit.GALLON, 908 MeasureUnit.GALLON_IMPERIAL, 909 MeasureUnit.HECTOLITER, 910 MeasureUnit.LITER, 911 MeasureUnit.MEGALITER, 912 MeasureUnit.MILLILITER, 913 MeasureUnit.PINT, 914 MeasureUnit.PINT_METRIC, 915 MeasureUnit.QUART, 916 MeasureUnit.TABLESPOON, 917 MeasureUnit.TEASPOON, 918 }; 919 assertEquals("", 134, units.length); 920 } 921 922 @Test TestCompatible58()923 public void TestCompatible58() { 924 MeasureUnit[] units = { 925 MeasureUnit.G_FORCE, 926 MeasureUnit.METER_PER_SECOND_SQUARED, 927 MeasureUnit.ARC_MINUTE, 928 MeasureUnit.ARC_SECOND, 929 MeasureUnit.DEGREE, 930 MeasureUnit.RADIAN, 931 MeasureUnit.REVOLUTION_ANGLE, 932 MeasureUnit.ACRE, 933 MeasureUnit.HECTARE, 934 MeasureUnit.SQUARE_CENTIMETER, 935 MeasureUnit.SQUARE_FOOT, 936 MeasureUnit.SQUARE_INCH, 937 MeasureUnit.SQUARE_KILOMETER, 938 MeasureUnit.SQUARE_METER, 939 MeasureUnit.SQUARE_MILE, 940 MeasureUnit.SQUARE_YARD, 941 MeasureUnit.KARAT, 942 MeasureUnit.MILLIGRAM_PER_DECILITER, 943 MeasureUnit.MILLIMOLE_PER_LITER, 944 MeasureUnit.PART_PER_MILLION, 945 MeasureUnit.LITER_PER_100KILOMETERS, 946 MeasureUnit.LITER_PER_KILOMETER, 947 MeasureUnit.MILE_PER_GALLON, 948 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 949 // MeasureUnit.EAST, 950 // MeasureUnit.NORTH, 951 // MeasureUnit.SOUTH, 952 // MeasureUnit.WEST, 953 MeasureUnit.BIT, 954 MeasureUnit.BYTE, 955 MeasureUnit.GIGABIT, 956 MeasureUnit.GIGABYTE, 957 MeasureUnit.KILOBIT, 958 MeasureUnit.KILOBYTE, 959 MeasureUnit.MEGABIT, 960 MeasureUnit.MEGABYTE, 961 MeasureUnit.TERABIT, 962 MeasureUnit.TERABYTE, 963 MeasureUnit.CENTURY, 964 MeasureUnit.DAY, 965 MeasureUnit.HOUR, 966 MeasureUnit.MICROSECOND, 967 MeasureUnit.MILLISECOND, 968 MeasureUnit.MINUTE, 969 MeasureUnit.MONTH, 970 MeasureUnit.NANOSECOND, 971 MeasureUnit.SECOND, 972 MeasureUnit.WEEK, 973 MeasureUnit.YEAR, 974 MeasureUnit.AMPERE, 975 MeasureUnit.MILLIAMPERE, 976 MeasureUnit.OHM, 977 MeasureUnit.VOLT, 978 MeasureUnit.CALORIE, 979 MeasureUnit.FOODCALORIE, 980 MeasureUnit.JOULE, 981 MeasureUnit.KILOCALORIE, 982 MeasureUnit.KILOJOULE, 983 MeasureUnit.KILOWATT_HOUR, 984 MeasureUnit.GIGAHERTZ, 985 MeasureUnit.HERTZ, 986 MeasureUnit.KILOHERTZ, 987 MeasureUnit.MEGAHERTZ, 988 MeasureUnit.ASTRONOMICAL_UNIT, 989 MeasureUnit.CENTIMETER, 990 MeasureUnit.DECIMETER, 991 MeasureUnit.FATHOM, 992 MeasureUnit.FOOT, 993 MeasureUnit.FURLONG, 994 MeasureUnit.INCH, 995 MeasureUnit.KILOMETER, 996 MeasureUnit.LIGHT_YEAR, 997 MeasureUnit.METER, 998 MeasureUnit.MICROMETER, 999 MeasureUnit.MILE, 1000 MeasureUnit.MILE_SCANDINAVIAN, 1001 MeasureUnit.MILLIMETER, 1002 MeasureUnit.NANOMETER, 1003 MeasureUnit.NAUTICAL_MILE, 1004 MeasureUnit.PARSEC, 1005 MeasureUnit.PICOMETER, 1006 MeasureUnit.YARD, 1007 MeasureUnit.LUX, 1008 MeasureUnit.CARAT, 1009 MeasureUnit.GRAM, 1010 MeasureUnit.KILOGRAM, 1011 MeasureUnit.METRIC_TON, 1012 MeasureUnit.MICROGRAM, 1013 MeasureUnit.MILLIGRAM, 1014 MeasureUnit.OUNCE, 1015 MeasureUnit.OUNCE_TROY, 1016 MeasureUnit.POUND, 1017 MeasureUnit.STONE, 1018 MeasureUnit.TON, 1019 MeasureUnit.GIGAWATT, 1020 MeasureUnit.HORSEPOWER, 1021 MeasureUnit.KILOWATT, 1022 MeasureUnit.MEGAWATT, 1023 MeasureUnit.MILLIWATT, 1024 MeasureUnit.WATT, 1025 MeasureUnit.HECTOPASCAL, 1026 MeasureUnit.INCH_HG, 1027 MeasureUnit.MILLIBAR, 1028 MeasureUnit.MILLIMETER_OF_MERCURY, 1029 MeasureUnit.POUND_PER_SQUARE_INCH, 1030 MeasureUnit.KILOMETER_PER_HOUR, 1031 MeasureUnit.KNOT, 1032 MeasureUnit.METER_PER_SECOND, 1033 MeasureUnit.MILE_PER_HOUR, 1034 MeasureUnit.CELSIUS, 1035 MeasureUnit.FAHRENHEIT, 1036 MeasureUnit.GENERIC_TEMPERATURE, 1037 MeasureUnit.KELVIN, 1038 MeasureUnit.ACRE_FOOT, 1039 MeasureUnit.BUSHEL, 1040 MeasureUnit.CENTILITER, 1041 MeasureUnit.CUBIC_CENTIMETER, 1042 MeasureUnit.CUBIC_FOOT, 1043 MeasureUnit.CUBIC_INCH, 1044 MeasureUnit.CUBIC_KILOMETER, 1045 MeasureUnit.CUBIC_METER, 1046 MeasureUnit.CUBIC_MILE, 1047 MeasureUnit.CUBIC_YARD, 1048 MeasureUnit.CUP, 1049 MeasureUnit.CUP_METRIC, 1050 MeasureUnit.DECILITER, 1051 MeasureUnit.FLUID_OUNCE, 1052 MeasureUnit.GALLON, 1053 MeasureUnit.GALLON_IMPERIAL, 1054 MeasureUnit.HECTOLITER, 1055 MeasureUnit.LITER, 1056 MeasureUnit.MEGALITER, 1057 MeasureUnit.MILLILITER, 1058 MeasureUnit.PINT, 1059 MeasureUnit.PINT_METRIC, 1060 MeasureUnit.QUART, 1061 MeasureUnit.TABLESPOON, 1062 MeasureUnit.TEASPOON, 1063 }; 1064 assertEquals("", 134, units.length); 1065 } 1066 1067 @Test TestCompatible59()1068 public void TestCompatible59() { 1069 MeasureUnit[] units = { 1070 MeasureUnit.G_FORCE, 1071 MeasureUnit.METER_PER_SECOND_SQUARED, 1072 MeasureUnit.ARC_MINUTE, 1073 MeasureUnit.ARC_SECOND, 1074 MeasureUnit.DEGREE, 1075 MeasureUnit.RADIAN, 1076 MeasureUnit.REVOLUTION_ANGLE, 1077 MeasureUnit.ACRE, 1078 MeasureUnit.HECTARE, 1079 MeasureUnit.SQUARE_CENTIMETER, 1080 MeasureUnit.SQUARE_FOOT, 1081 MeasureUnit.SQUARE_INCH, 1082 MeasureUnit.SQUARE_KILOMETER, 1083 MeasureUnit.SQUARE_METER, 1084 MeasureUnit.SQUARE_MILE, 1085 MeasureUnit.SQUARE_YARD, 1086 MeasureUnit.KARAT, 1087 MeasureUnit.MILLIGRAM_PER_DECILITER, 1088 MeasureUnit.MILLIMOLE_PER_LITER, 1089 MeasureUnit.PART_PER_MILLION, 1090 MeasureUnit.LITER_PER_100KILOMETERS, 1091 MeasureUnit.LITER_PER_KILOMETER, 1092 MeasureUnit.MILE_PER_GALLON, 1093 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 1094 MeasureUnit.BIT, 1095 MeasureUnit.BYTE, 1096 MeasureUnit.GIGABIT, 1097 MeasureUnit.GIGABYTE, 1098 MeasureUnit.KILOBIT, 1099 MeasureUnit.KILOBYTE, 1100 MeasureUnit.MEGABIT, 1101 MeasureUnit.MEGABYTE, 1102 MeasureUnit.TERABIT, 1103 MeasureUnit.TERABYTE, 1104 MeasureUnit.CENTURY, 1105 MeasureUnit.DAY, 1106 MeasureUnit.HOUR, 1107 MeasureUnit.MICROSECOND, 1108 MeasureUnit.MILLISECOND, 1109 MeasureUnit.MINUTE, 1110 MeasureUnit.MONTH, 1111 MeasureUnit.NANOSECOND, 1112 MeasureUnit.SECOND, 1113 MeasureUnit.WEEK, 1114 MeasureUnit.YEAR, 1115 MeasureUnit.AMPERE, 1116 MeasureUnit.MILLIAMPERE, 1117 MeasureUnit.OHM, 1118 MeasureUnit.VOLT, 1119 MeasureUnit.CALORIE, 1120 MeasureUnit.FOODCALORIE, 1121 MeasureUnit.JOULE, 1122 MeasureUnit.KILOCALORIE, 1123 MeasureUnit.KILOJOULE, 1124 MeasureUnit.KILOWATT_HOUR, 1125 MeasureUnit.GIGAHERTZ, 1126 MeasureUnit.HERTZ, 1127 MeasureUnit.KILOHERTZ, 1128 MeasureUnit.MEGAHERTZ, 1129 MeasureUnit.ASTRONOMICAL_UNIT, 1130 MeasureUnit.CENTIMETER, 1131 MeasureUnit.DECIMETER, 1132 MeasureUnit.FATHOM, 1133 MeasureUnit.FOOT, 1134 MeasureUnit.FURLONG, 1135 MeasureUnit.INCH, 1136 MeasureUnit.KILOMETER, 1137 MeasureUnit.LIGHT_YEAR, 1138 MeasureUnit.METER, 1139 MeasureUnit.MICROMETER, 1140 MeasureUnit.MILE, 1141 MeasureUnit.MILE_SCANDINAVIAN, 1142 MeasureUnit.MILLIMETER, 1143 MeasureUnit.NANOMETER, 1144 MeasureUnit.NAUTICAL_MILE, 1145 MeasureUnit.PARSEC, 1146 MeasureUnit.PICOMETER, 1147 MeasureUnit.POINT, 1148 MeasureUnit.YARD, 1149 MeasureUnit.LUX, 1150 MeasureUnit.CARAT, 1151 MeasureUnit.GRAM, 1152 MeasureUnit.KILOGRAM, 1153 MeasureUnit.METRIC_TON, 1154 MeasureUnit.MICROGRAM, 1155 MeasureUnit.MILLIGRAM, 1156 MeasureUnit.OUNCE, 1157 MeasureUnit.OUNCE_TROY, 1158 MeasureUnit.POUND, 1159 MeasureUnit.STONE, 1160 MeasureUnit.TON, 1161 MeasureUnit.GIGAWATT, 1162 MeasureUnit.HORSEPOWER, 1163 MeasureUnit.KILOWATT, 1164 MeasureUnit.MEGAWATT, 1165 MeasureUnit.MILLIWATT, 1166 MeasureUnit.WATT, 1167 MeasureUnit.HECTOPASCAL, 1168 MeasureUnit.INCH_HG, 1169 MeasureUnit.MILLIBAR, 1170 MeasureUnit.MILLIMETER_OF_MERCURY, 1171 MeasureUnit.POUND_PER_SQUARE_INCH, 1172 MeasureUnit.KILOMETER_PER_HOUR, 1173 MeasureUnit.KNOT, 1174 MeasureUnit.METER_PER_SECOND, 1175 MeasureUnit.MILE_PER_HOUR, 1176 MeasureUnit.CELSIUS, 1177 MeasureUnit.FAHRENHEIT, 1178 MeasureUnit.GENERIC_TEMPERATURE, 1179 MeasureUnit.KELVIN, 1180 MeasureUnit.ACRE_FOOT, 1181 MeasureUnit.BUSHEL, 1182 MeasureUnit.CENTILITER, 1183 MeasureUnit.CUBIC_CENTIMETER, 1184 MeasureUnit.CUBIC_FOOT, 1185 MeasureUnit.CUBIC_INCH, 1186 MeasureUnit.CUBIC_KILOMETER, 1187 MeasureUnit.CUBIC_METER, 1188 MeasureUnit.CUBIC_MILE, 1189 MeasureUnit.CUBIC_YARD, 1190 MeasureUnit.CUP, 1191 MeasureUnit.CUP_METRIC, 1192 MeasureUnit.DECILITER, 1193 MeasureUnit.FLUID_OUNCE, 1194 MeasureUnit.GALLON, 1195 MeasureUnit.GALLON_IMPERIAL, 1196 MeasureUnit.HECTOLITER, 1197 MeasureUnit.LITER, 1198 MeasureUnit.MEGALITER, 1199 MeasureUnit.MILLILITER, 1200 MeasureUnit.PINT, 1201 MeasureUnit.PINT_METRIC, 1202 MeasureUnit.QUART, 1203 MeasureUnit.TABLESPOON, 1204 MeasureUnit.TEASPOON, 1205 }; 1206 assertEquals("", 135, units.length); 1207 } 1208 1209 // Note that TestCompatible60(), TestCompatible61(), TestCompatible62() 1210 // would be the same as TestCompatible59(), no need to add them. 1211 1212 @Test TestCompatible63()1213 public void TestCompatible63() { 1214 MeasureUnit[] units = { 1215 MeasureUnit.G_FORCE, 1216 MeasureUnit.METER_PER_SECOND_SQUARED, 1217 MeasureUnit.ARC_MINUTE, 1218 MeasureUnit.ARC_SECOND, 1219 MeasureUnit.DEGREE, 1220 MeasureUnit.RADIAN, 1221 MeasureUnit.REVOLUTION_ANGLE, 1222 MeasureUnit.ACRE, 1223 MeasureUnit.HECTARE, 1224 MeasureUnit.SQUARE_CENTIMETER, 1225 MeasureUnit.SQUARE_FOOT, 1226 MeasureUnit.SQUARE_INCH, 1227 MeasureUnit.SQUARE_KILOMETER, 1228 MeasureUnit.SQUARE_METER, 1229 MeasureUnit.SQUARE_MILE, 1230 MeasureUnit.SQUARE_YARD, 1231 MeasureUnit.KARAT, 1232 MeasureUnit.MILLIGRAM_PER_DECILITER, 1233 MeasureUnit.MILLIMOLE_PER_LITER, 1234 MeasureUnit.PART_PER_MILLION, 1235 MeasureUnit.PERCENT, 1236 MeasureUnit.PERMILLE, 1237 MeasureUnit.LITER_PER_100KILOMETERS, 1238 MeasureUnit.LITER_PER_KILOMETER, 1239 MeasureUnit.MILE_PER_GALLON, 1240 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 1241 MeasureUnit.BIT, 1242 MeasureUnit.BYTE, 1243 MeasureUnit.GIGABIT, 1244 MeasureUnit.GIGABYTE, 1245 MeasureUnit.KILOBIT, 1246 MeasureUnit.KILOBYTE, 1247 MeasureUnit.MEGABIT, 1248 MeasureUnit.MEGABYTE, 1249 MeasureUnit.PETABYTE, 1250 MeasureUnit.TERABIT, 1251 MeasureUnit.TERABYTE, 1252 MeasureUnit.CENTURY, 1253 MeasureUnit.DAY, 1254 MeasureUnit.HOUR, 1255 MeasureUnit.MICROSECOND, 1256 MeasureUnit.MILLISECOND, 1257 MeasureUnit.MINUTE, 1258 MeasureUnit.MONTH, 1259 MeasureUnit.NANOSECOND, 1260 MeasureUnit.SECOND, 1261 MeasureUnit.WEEK, 1262 MeasureUnit.YEAR, 1263 MeasureUnit.AMPERE, 1264 MeasureUnit.MILLIAMPERE, 1265 MeasureUnit.OHM, 1266 MeasureUnit.VOLT, 1267 MeasureUnit.CALORIE, 1268 MeasureUnit.FOODCALORIE, 1269 MeasureUnit.JOULE, 1270 MeasureUnit.KILOCALORIE, 1271 MeasureUnit.KILOJOULE, 1272 MeasureUnit.KILOWATT_HOUR, 1273 MeasureUnit.GIGAHERTZ, 1274 MeasureUnit.HERTZ, 1275 MeasureUnit.KILOHERTZ, 1276 MeasureUnit.MEGAHERTZ, 1277 MeasureUnit.ASTRONOMICAL_UNIT, 1278 MeasureUnit.CENTIMETER, 1279 MeasureUnit.DECIMETER, 1280 MeasureUnit.FATHOM, 1281 MeasureUnit.FOOT, 1282 MeasureUnit.FURLONG, 1283 MeasureUnit.INCH, 1284 MeasureUnit.KILOMETER, 1285 MeasureUnit.LIGHT_YEAR, 1286 MeasureUnit.METER, 1287 MeasureUnit.MICROMETER, 1288 MeasureUnit.MILE, 1289 MeasureUnit.MILE_SCANDINAVIAN, 1290 MeasureUnit.MILLIMETER, 1291 MeasureUnit.NANOMETER, 1292 MeasureUnit.NAUTICAL_MILE, 1293 MeasureUnit.PARSEC, 1294 MeasureUnit.PICOMETER, 1295 MeasureUnit.POINT, 1296 MeasureUnit.YARD, 1297 MeasureUnit.LUX, 1298 MeasureUnit.CARAT, 1299 MeasureUnit.GRAM, 1300 MeasureUnit.KILOGRAM, 1301 MeasureUnit.METRIC_TON, 1302 MeasureUnit.MICROGRAM, 1303 MeasureUnit.MILLIGRAM, 1304 MeasureUnit.OUNCE, 1305 MeasureUnit.OUNCE_TROY, 1306 MeasureUnit.POUND, 1307 MeasureUnit.STONE, 1308 MeasureUnit.TON, 1309 MeasureUnit.GIGAWATT, 1310 MeasureUnit.HORSEPOWER, 1311 MeasureUnit.KILOWATT, 1312 MeasureUnit.MEGAWATT, 1313 MeasureUnit.MILLIWATT, 1314 MeasureUnit.WATT, 1315 MeasureUnit.ATMOSPHERE, 1316 MeasureUnit.HECTOPASCAL, 1317 MeasureUnit.INCH_HG, 1318 MeasureUnit.MILLIBAR, 1319 MeasureUnit.MILLIMETER_OF_MERCURY, 1320 MeasureUnit.POUND_PER_SQUARE_INCH, 1321 MeasureUnit.KILOMETER_PER_HOUR, 1322 MeasureUnit.KNOT, 1323 MeasureUnit.METER_PER_SECOND, 1324 MeasureUnit.MILE_PER_HOUR, 1325 MeasureUnit.CELSIUS, 1326 MeasureUnit.FAHRENHEIT, 1327 MeasureUnit.GENERIC_TEMPERATURE, 1328 MeasureUnit.KELVIN, 1329 MeasureUnit.ACRE_FOOT, 1330 MeasureUnit.BUSHEL, 1331 MeasureUnit.CENTILITER, 1332 MeasureUnit.CUBIC_CENTIMETER, 1333 MeasureUnit.CUBIC_FOOT, 1334 MeasureUnit.CUBIC_INCH, 1335 MeasureUnit.CUBIC_KILOMETER, 1336 MeasureUnit.CUBIC_METER, 1337 MeasureUnit.CUBIC_MILE, 1338 MeasureUnit.CUBIC_YARD, 1339 MeasureUnit.CUP, 1340 MeasureUnit.CUP_METRIC, 1341 MeasureUnit.DECILITER, 1342 MeasureUnit.FLUID_OUNCE, 1343 MeasureUnit.GALLON, 1344 MeasureUnit.GALLON_IMPERIAL, 1345 MeasureUnit.HECTOLITER, 1346 MeasureUnit.LITER, 1347 MeasureUnit.MEGALITER, 1348 MeasureUnit.MILLILITER, 1349 MeasureUnit.PINT, 1350 MeasureUnit.PINT_METRIC, 1351 MeasureUnit.QUART, 1352 MeasureUnit.TABLESPOON, 1353 MeasureUnit.TEASPOON, 1354 }; 1355 assertEquals("", 139, units.length); 1356 } 1357 1358 @Test TestCompatible64()1359 public void TestCompatible64() { 1360 MeasureUnit[] units = { 1361 MeasureUnit.G_FORCE, 1362 MeasureUnit.METER_PER_SECOND_SQUARED, 1363 MeasureUnit.ARC_MINUTE, 1364 MeasureUnit.ARC_SECOND, 1365 MeasureUnit.DEGREE, 1366 MeasureUnit.RADIAN, 1367 MeasureUnit.REVOLUTION_ANGLE, 1368 MeasureUnit.ACRE, 1369 MeasureUnit.DUNAM, 1370 MeasureUnit.HECTARE, 1371 MeasureUnit.SQUARE_CENTIMETER, 1372 MeasureUnit.SQUARE_FOOT, 1373 MeasureUnit.SQUARE_INCH, 1374 MeasureUnit.SQUARE_KILOMETER, 1375 MeasureUnit.SQUARE_METER, 1376 MeasureUnit.SQUARE_MILE, 1377 MeasureUnit.SQUARE_YARD, 1378 MeasureUnit.KARAT, 1379 MeasureUnit.MILLIGRAM_PER_DECILITER, 1380 MeasureUnit.MILLIMOLE_PER_LITER, 1381 MeasureUnit.MOLE, 1382 MeasureUnit.PART_PER_MILLION, 1383 MeasureUnit.PERCENT, 1384 MeasureUnit.PERMILLE, 1385 MeasureUnit.PERMYRIAD, 1386 MeasureUnit.LITER_PER_100KILOMETERS, 1387 MeasureUnit.LITER_PER_KILOMETER, 1388 MeasureUnit.MILE_PER_GALLON, 1389 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 1390 MeasureUnit.BIT, 1391 MeasureUnit.BYTE, 1392 MeasureUnit.GIGABIT, 1393 MeasureUnit.GIGABYTE, 1394 MeasureUnit.KILOBIT, 1395 MeasureUnit.KILOBYTE, 1396 MeasureUnit.MEGABIT, 1397 MeasureUnit.MEGABYTE, 1398 MeasureUnit.PETABYTE, 1399 MeasureUnit.TERABIT, 1400 MeasureUnit.TERABYTE, 1401 MeasureUnit.CENTURY, 1402 MeasureUnit.DAY, 1403 MeasureUnit.DAY_PERSON, 1404 MeasureUnit.HOUR, 1405 MeasureUnit.MICROSECOND, 1406 MeasureUnit.MILLISECOND, 1407 MeasureUnit.MINUTE, 1408 MeasureUnit.MONTH, 1409 MeasureUnit.MONTH_PERSON, 1410 MeasureUnit.NANOSECOND, 1411 MeasureUnit.SECOND, 1412 MeasureUnit.WEEK, 1413 MeasureUnit.WEEK_PERSON, 1414 MeasureUnit.YEAR, 1415 MeasureUnit.YEAR_PERSON, 1416 MeasureUnit.AMPERE, 1417 MeasureUnit.MILLIAMPERE, 1418 MeasureUnit.OHM, 1419 MeasureUnit.VOLT, 1420 MeasureUnit.BRITISH_THERMAL_UNIT, 1421 MeasureUnit.CALORIE, 1422 MeasureUnit.ELECTRONVOLT, 1423 MeasureUnit.FOODCALORIE, 1424 MeasureUnit.JOULE, 1425 MeasureUnit.KILOCALORIE, 1426 MeasureUnit.KILOJOULE, 1427 MeasureUnit.KILOWATT_HOUR, 1428 MeasureUnit.NEWTON, 1429 MeasureUnit.POUND_FORCE, 1430 MeasureUnit.GIGAHERTZ, 1431 MeasureUnit.HERTZ, 1432 MeasureUnit.KILOHERTZ, 1433 MeasureUnit.MEGAHERTZ, 1434 MeasureUnit.ASTRONOMICAL_UNIT, 1435 MeasureUnit.CENTIMETER, 1436 MeasureUnit.DECIMETER, 1437 MeasureUnit.FATHOM, 1438 MeasureUnit.FOOT, 1439 MeasureUnit.FURLONG, 1440 MeasureUnit.INCH, 1441 MeasureUnit.KILOMETER, 1442 MeasureUnit.LIGHT_YEAR, 1443 MeasureUnit.METER, 1444 MeasureUnit.MICROMETER, 1445 MeasureUnit.MILE, 1446 MeasureUnit.MILE_SCANDINAVIAN, 1447 MeasureUnit.MILLIMETER, 1448 MeasureUnit.NANOMETER, 1449 MeasureUnit.NAUTICAL_MILE, 1450 MeasureUnit.PARSEC, 1451 MeasureUnit.PICOMETER, 1452 MeasureUnit.POINT, 1453 MeasureUnit.SOLAR_RADIUS, 1454 MeasureUnit.YARD, 1455 MeasureUnit.LUX, 1456 MeasureUnit.SOLAR_LUMINOSITY, 1457 MeasureUnit.CARAT, 1458 MeasureUnit.DALTON, 1459 MeasureUnit.EARTH_MASS, 1460 MeasureUnit.GRAM, 1461 MeasureUnit.KILOGRAM, 1462 MeasureUnit.METRIC_TON, 1463 MeasureUnit.MICROGRAM, 1464 MeasureUnit.MILLIGRAM, 1465 MeasureUnit.OUNCE, 1466 MeasureUnit.OUNCE_TROY, 1467 MeasureUnit.POUND, 1468 MeasureUnit.SOLAR_MASS, 1469 MeasureUnit.STONE, 1470 MeasureUnit.TON, 1471 MeasureUnit.GIGAWATT, 1472 MeasureUnit.HORSEPOWER, 1473 MeasureUnit.KILOWATT, 1474 MeasureUnit.MEGAWATT, 1475 MeasureUnit.MILLIWATT, 1476 MeasureUnit.WATT, 1477 MeasureUnit.ATMOSPHERE, 1478 MeasureUnit.HECTOPASCAL, 1479 MeasureUnit.INCH_HG, 1480 MeasureUnit.KILOPASCAL, 1481 MeasureUnit.MEGAPASCAL, 1482 MeasureUnit.MILLIBAR, 1483 MeasureUnit.MILLIMETER_OF_MERCURY, 1484 MeasureUnit.POUND_PER_SQUARE_INCH, 1485 MeasureUnit.KILOMETER_PER_HOUR, 1486 MeasureUnit.KNOT, 1487 MeasureUnit.METER_PER_SECOND, 1488 MeasureUnit.MILE_PER_HOUR, 1489 MeasureUnit.CELSIUS, 1490 MeasureUnit.FAHRENHEIT, 1491 MeasureUnit.GENERIC_TEMPERATURE, 1492 MeasureUnit.KELVIN, 1493 MeasureUnit.NEWTON_METER, 1494 MeasureUnit.POUND_FOOT, 1495 MeasureUnit.ACRE_FOOT, 1496 MeasureUnit.BARREL, 1497 MeasureUnit.BUSHEL, 1498 MeasureUnit.CENTILITER, 1499 MeasureUnit.CUBIC_CENTIMETER, 1500 MeasureUnit.CUBIC_FOOT, 1501 MeasureUnit.CUBIC_INCH, 1502 MeasureUnit.CUBIC_KILOMETER, 1503 MeasureUnit.CUBIC_METER, 1504 MeasureUnit.CUBIC_MILE, 1505 MeasureUnit.CUBIC_YARD, 1506 MeasureUnit.CUP, 1507 MeasureUnit.CUP_METRIC, 1508 MeasureUnit.DECILITER, 1509 MeasureUnit.FLUID_OUNCE, 1510 MeasureUnit.FLUID_OUNCE_IMPERIAL, 1511 MeasureUnit.GALLON, 1512 MeasureUnit.GALLON_IMPERIAL, 1513 MeasureUnit.HECTOLITER, 1514 MeasureUnit.LITER, 1515 MeasureUnit.MEGALITER, 1516 MeasureUnit.MILLILITER, 1517 MeasureUnit.PINT, 1518 MeasureUnit.PINT_METRIC, 1519 MeasureUnit.QUART, 1520 MeasureUnit.TABLESPOON, 1521 MeasureUnit.TEASPOON, 1522 }; 1523 assertEquals("", 161, units.length); 1524 } 1525 1526 @Test TestCompatible65()1527 public void TestCompatible65() { 1528 MeasureUnit[] units = { 1529 MeasureUnit.G_FORCE, 1530 MeasureUnit.METER_PER_SECOND_SQUARED, 1531 MeasureUnit.ARC_MINUTE, 1532 MeasureUnit.ARC_SECOND, 1533 MeasureUnit.DEGREE, 1534 MeasureUnit.RADIAN, 1535 MeasureUnit.REVOLUTION_ANGLE, 1536 MeasureUnit.ACRE, 1537 MeasureUnit.DUNAM, 1538 MeasureUnit.HECTARE, 1539 MeasureUnit.SQUARE_CENTIMETER, 1540 MeasureUnit.SQUARE_FOOT, 1541 MeasureUnit.SQUARE_INCH, 1542 MeasureUnit.SQUARE_KILOMETER, 1543 MeasureUnit.SQUARE_METER, 1544 MeasureUnit.SQUARE_MILE, 1545 MeasureUnit.SQUARE_YARD, 1546 MeasureUnit.KARAT, 1547 MeasureUnit.MILLIGRAM_PER_DECILITER, 1548 MeasureUnit.MILLIMOLE_PER_LITER, 1549 MeasureUnit.MOLE, 1550 MeasureUnit.PART_PER_MILLION, 1551 MeasureUnit.PERCENT, 1552 MeasureUnit.PERMILLE, 1553 MeasureUnit.PERMYRIAD, 1554 MeasureUnit.LITER_PER_100KILOMETERS, 1555 MeasureUnit.LITER_PER_KILOMETER, 1556 MeasureUnit.MILE_PER_GALLON, 1557 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 1558 MeasureUnit.BIT, 1559 MeasureUnit.BYTE, 1560 MeasureUnit.GIGABIT, 1561 MeasureUnit.GIGABYTE, 1562 MeasureUnit.KILOBIT, 1563 MeasureUnit.KILOBYTE, 1564 MeasureUnit.MEGABIT, 1565 MeasureUnit.MEGABYTE, 1566 MeasureUnit.PETABYTE, 1567 MeasureUnit.TERABIT, 1568 MeasureUnit.TERABYTE, 1569 MeasureUnit.CENTURY, 1570 MeasureUnit.DAY, 1571 MeasureUnit.DAY_PERSON, 1572 MeasureUnit.DECADE, 1573 MeasureUnit.HOUR, 1574 MeasureUnit.MICROSECOND, 1575 MeasureUnit.MILLISECOND, 1576 MeasureUnit.MINUTE, 1577 MeasureUnit.MONTH, 1578 MeasureUnit.MONTH_PERSON, 1579 MeasureUnit.NANOSECOND, 1580 MeasureUnit.SECOND, 1581 MeasureUnit.WEEK, 1582 MeasureUnit.WEEK_PERSON, 1583 MeasureUnit.YEAR, 1584 MeasureUnit.YEAR_PERSON, 1585 MeasureUnit.AMPERE, 1586 MeasureUnit.MILLIAMPERE, 1587 MeasureUnit.OHM, 1588 MeasureUnit.VOLT, 1589 MeasureUnit.BRITISH_THERMAL_UNIT, 1590 MeasureUnit.CALORIE, 1591 MeasureUnit.ELECTRONVOLT, 1592 MeasureUnit.FOODCALORIE, 1593 MeasureUnit.JOULE, 1594 MeasureUnit.KILOCALORIE, 1595 MeasureUnit.KILOJOULE, 1596 MeasureUnit.KILOWATT_HOUR, 1597 MeasureUnit.THERM_US, 1598 MeasureUnit.NEWTON, 1599 MeasureUnit.POUND_FORCE, 1600 MeasureUnit.GIGAHERTZ, 1601 MeasureUnit.HERTZ, 1602 MeasureUnit.KILOHERTZ, 1603 MeasureUnit.MEGAHERTZ, 1604 MeasureUnit.DOT_PER_CENTIMETER, 1605 MeasureUnit.DOT_PER_INCH, 1606 MeasureUnit.EM, 1607 MeasureUnit.MEGAPIXEL, 1608 MeasureUnit.PIXEL, 1609 MeasureUnit.PIXEL_PER_CENTIMETER, 1610 MeasureUnit.PIXEL_PER_INCH, 1611 MeasureUnit.ASTRONOMICAL_UNIT, 1612 MeasureUnit.CENTIMETER, 1613 MeasureUnit.DECIMETER, 1614 MeasureUnit.FATHOM, 1615 MeasureUnit.FOOT, 1616 MeasureUnit.FURLONG, 1617 MeasureUnit.INCH, 1618 MeasureUnit.KILOMETER, 1619 MeasureUnit.LIGHT_YEAR, 1620 MeasureUnit.METER, 1621 MeasureUnit.MICROMETER, 1622 MeasureUnit.MILE, 1623 MeasureUnit.MILE_SCANDINAVIAN, 1624 MeasureUnit.MILLIMETER, 1625 MeasureUnit.NANOMETER, 1626 MeasureUnit.NAUTICAL_MILE, 1627 MeasureUnit.PARSEC, 1628 MeasureUnit.PICOMETER, 1629 MeasureUnit.POINT, 1630 MeasureUnit.SOLAR_RADIUS, 1631 MeasureUnit.YARD, 1632 MeasureUnit.LUX, 1633 MeasureUnit.SOLAR_LUMINOSITY, 1634 MeasureUnit.CARAT, 1635 MeasureUnit.DALTON, 1636 MeasureUnit.EARTH_MASS, 1637 MeasureUnit.GRAM, 1638 MeasureUnit.KILOGRAM, 1639 MeasureUnit.METRIC_TON, 1640 MeasureUnit.MICROGRAM, 1641 MeasureUnit.MILLIGRAM, 1642 MeasureUnit.OUNCE, 1643 MeasureUnit.OUNCE_TROY, 1644 MeasureUnit.POUND, 1645 MeasureUnit.SOLAR_MASS, 1646 MeasureUnit.STONE, 1647 MeasureUnit.TON, 1648 MeasureUnit.GIGAWATT, 1649 MeasureUnit.HORSEPOWER, 1650 MeasureUnit.KILOWATT, 1651 MeasureUnit.MEGAWATT, 1652 MeasureUnit.MILLIWATT, 1653 MeasureUnit.WATT, 1654 MeasureUnit.ATMOSPHERE, 1655 MeasureUnit.BAR, 1656 MeasureUnit.HECTOPASCAL, 1657 MeasureUnit.INCH_HG, 1658 MeasureUnit.KILOPASCAL, 1659 MeasureUnit.MEGAPASCAL, 1660 MeasureUnit.MILLIBAR, 1661 MeasureUnit.MILLIMETER_OF_MERCURY, 1662 MeasureUnit.PASCAL, 1663 MeasureUnit.POUND_PER_SQUARE_INCH, 1664 MeasureUnit.KILOMETER_PER_HOUR, 1665 MeasureUnit.KNOT, 1666 MeasureUnit.METER_PER_SECOND, 1667 MeasureUnit.MILE_PER_HOUR, 1668 MeasureUnit.CELSIUS, 1669 MeasureUnit.FAHRENHEIT, 1670 MeasureUnit.GENERIC_TEMPERATURE, 1671 MeasureUnit.KELVIN, 1672 MeasureUnit.NEWTON_METER, 1673 MeasureUnit.POUND_FOOT, 1674 MeasureUnit.ACRE_FOOT, 1675 MeasureUnit.BARREL, 1676 MeasureUnit.BUSHEL, 1677 MeasureUnit.CENTILITER, 1678 MeasureUnit.CUBIC_CENTIMETER, 1679 MeasureUnit.CUBIC_FOOT, 1680 MeasureUnit.CUBIC_INCH, 1681 MeasureUnit.CUBIC_KILOMETER, 1682 MeasureUnit.CUBIC_METER, 1683 MeasureUnit.CUBIC_MILE, 1684 MeasureUnit.CUBIC_YARD, 1685 MeasureUnit.CUP, 1686 MeasureUnit.CUP_METRIC, 1687 MeasureUnit.DECILITER, 1688 MeasureUnit.FLUID_OUNCE, 1689 MeasureUnit.FLUID_OUNCE_IMPERIAL, 1690 MeasureUnit.GALLON, 1691 MeasureUnit.GALLON_IMPERIAL, 1692 MeasureUnit.HECTOLITER, 1693 MeasureUnit.LITER, 1694 MeasureUnit.MEGALITER, 1695 MeasureUnit.MILLILITER, 1696 MeasureUnit.PINT, 1697 MeasureUnit.PINT_METRIC, 1698 MeasureUnit.QUART, 1699 MeasureUnit.TABLESPOON, 1700 MeasureUnit.TEASPOON, 1701 }; 1702 assertEquals("", 172, units.length); 1703 } 1704 1705 @Test TestCompatible68()1706 public void TestCompatible68() { 1707 MeasureUnit[] units = { 1708 MeasureUnit.G_FORCE, 1709 MeasureUnit.METER_PER_SECOND_SQUARED, 1710 MeasureUnit.ARC_MINUTE, 1711 MeasureUnit.ARC_SECOND, 1712 MeasureUnit.DEGREE, 1713 MeasureUnit.RADIAN, 1714 MeasureUnit.REVOLUTION_ANGLE, 1715 MeasureUnit.ACRE, 1716 MeasureUnit.DUNAM, 1717 MeasureUnit.HECTARE, 1718 MeasureUnit.SQUARE_CENTIMETER, 1719 MeasureUnit.SQUARE_FOOT, 1720 MeasureUnit.SQUARE_INCH, 1721 MeasureUnit.SQUARE_KILOMETER, 1722 MeasureUnit.SQUARE_METER, 1723 MeasureUnit.SQUARE_MILE, 1724 MeasureUnit.SQUARE_YARD, 1725 MeasureUnit.KARAT, 1726 MeasureUnit.MILLIGRAM_PER_DECILITER, 1727 MeasureUnit.MILLIMOLE_PER_LITER, 1728 MeasureUnit.MOLE, 1729 MeasureUnit.PERCENT, 1730 MeasureUnit.PERMILLE, 1731 MeasureUnit.PART_PER_MILLION, 1732 MeasureUnit.PERMYRIAD, 1733 MeasureUnit.LITER_PER_100KILOMETERS, 1734 MeasureUnit.LITER_PER_KILOMETER, 1735 MeasureUnit.MILE_PER_GALLON, 1736 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 1737 MeasureUnit.BIT, 1738 MeasureUnit.BYTE, 1739 MeasureUnit.GIGABIT, 1740 MeasureUnit.GIGABYTE, 1741 MeasureUnit.KILOBIT, 1742 MeasureUnit.KILOBYTE, 1743 MeasureUnit.MEGABIT, 1744 MeasureUnit.MEGABYTE, 1745 MeasureUnit.PETABYTE, 1746 MeasureUnit.TERABIT, 1747 MeasureUnit.TERABYTE, 1748 MeasureUnit.CENTURY, 1749 MeasureUnit.DAY, 1750 MeasureUnit.DAY_PERSON, 1751 MeasureUnit.DECADE, 1752 MeasureUnit.HOUR, 1753 MeasureUnit.MICROSECOND, 1754 MeasureUnit.MILLISECOND, 1755 MeasureUnit.MINUTE, 1756 MeasureUnit.MONTH, 1757 MeasureUnit.MONTH_PERSON, 1758 MeasureUnit.NANOSECOND, 1759 MeasureUnit.SECOND, 1760 MeasureUnit.WEEK, 1761 MeasureUnit.WEEK_PERSON, 1762 MeasureUnit.YEAR, 1763 MeasureUnit.YEAR_PERSON, 1764 MeasureUnit.AMPERE, 1765 MeasureUnit.MILLIAMPERE, 1766 MeasureUnit.OHM, 1767 MeasureUnit.VOLT, 1768 MeasureUnit.BRITISH_THERMAL_UNIT, 1769 MeasureUnit.CALORIE, 1770 MeasureUnit.ELECTRONVOLT, 1771 MeasureUnit.FOODCALORIE, 1772 MeasureUnit.JOULE, 1773 MeasureUnit.KILOCALORIE, 1774 MeasureUnit.KILOJOULE, 1775 MeasureUnit.KILOWATT_HOUR, 1776 MeasureUnit.THERM_US, 1777 MeasureUnit.NEWTON, 1778 MeasureUnit.POUND_FORCE, 1779 MeasureUnit.GIGAHERTZ, 1780 MeasureUnit.HERTZ, 1781 MeasureUnit.KILOHERTZ, 1782 MeasureUnit.MEGAHERTZ, 1783 MeasureUnit.DOT, 1784 MeasureUnit.DOT_PER_CENTIMETER, 1785 MeasureUnit.DOT_PER_INCH, 1786 MeasureUnit.EM, 1787 MeasureUnit.MEGAPIXEL, 1788 MeasureUnit.PIXEL, 1789 MeasureUnit.PIXEL_PER_CENTIMETER, 1790 MeasureUnit.PIXEL_PER_INCH, 1791 MeasureUnit.ASTRONOMICAL_UNIT, 1792 MeasureUnit.CENTIMETER, 1793 MeasureUnit.DECIMETER, 1794 MeasureUnit.EARTH_RADIUS, 1795 MeasureUnit.FATHOM, 1796 MeasureUnit.FOOT, 1797 MeasureUnit.FURLONG, 1798 MeasureUnit.INCH, 1799 MeasureUnit.KILOMETER, 1800 MeasureUnit.LIGHT_YEAR, 1801 MeasureUnit.METER, 1802 MeasureUnit.MICROMETER, 1803 MeasureUnit.MILE, 1804 MeasureUnit.MILE_SCANDINAVIAN, 1805 MeasureUnit.MILLIMETER, 1806 MeasureUnit.NANOMETER, 1807 MeasureUnit.NAUTICAL_MILE, 1808 MeasureUnit.PARSEC, 1809 MeasureUnit.PICOMETER, 1810 MeasureUnit.POINT, 1811 MeasureUnit.SOLAR_RADIUS, 1812 MeasureUnit.YARD, 1813 MeasureUnit.CANDELA, 1814 MeasureUnit.LUMEN, 1815 MeasureUnit.LUX, 1816 MeasureUnit.SOLAR_LUMINOSITY, 1817 MeasureUnit.CARAT, 1818 MeasureUnit.DALTON, 1819 MeasureUnit.EARTH_MASS, 1820 MeasureUnit.GRAIN, 1821 MeasureUnit.GRAM, 1822 MeasureUnit.KILOGRAM, 1823 MeasureUnit.METRIC_TON, 1824 MeasureUnit.MICROGRAM, 1825 MeasureUnit.MILLIGRAM, 1826 MeasureUnit.OUNCE, 1827 MeasureUnit.OUNCE_TROY, 1828 MeasureUnit.POUND, 1829 MeasureUnit.SOLAR_MASS, 1830 MeasureUnit.STONE, 1831 MeasureUnit.TON, 1832 MeasureUnit.GIGAWATT, 1833 MeasureUnit.HORSEPOWER, 1834 MeasureUnit.KILOWATT, 1835 MeasureUnit.MEGAWATT, 1836 MeasureUnit.MILLIWATT, 1837 MeasureUnit.WATT, 1838 MeasureUnit.ATMOSPHERE, 1839 MeasureUnit.BAR, 1840 MeasureUnit.HECTOPASCAL, 1841 MeasureUnit.INCH_HG, 1842 MeasureUnit.KILOPASCAL, 1843 MeasureUnit.MEGAPASCAL, 1844 MeasureUnit.MILLIBAR, 1845 MeasureUnit.MILLIMETER_OF_MERCURY, 1846 MeasureUnit.PASCAL, 1847 MeasureUnit.POUND_PER_SQUARE_INCH, 1848 MeasureUnit.KILOMETER_PER_HOUR, 1849 MeasureUnit.KNOT, 1850 MeasureUnit.METER_PER_SECOND, 1851 MeasureUnit.MILE_PER_HOUR, 1852 MeasureUnit.CELSIUS, 1853 MeasureUnit.FAHRENHEIT, 1854 MeasureUnit.GENERIC_TEMPERATURE, 1855 MeasureUnit.KELVIN, 1856 MeasureUnit.NEWTON_METER, 1857 MeasureUnit.POUND_FOOT, 1858 MeasureUnit.ACRE_FOOT, 1859 MeasureUnit.BARREL, 1860 MeasureUnit.BUSHEL, 1861 MeasureUnit.CENTILITER, 1862 MeasureUnit.CUBIC_CENTIMETER, 1863 MeasureUnit.CUBIC_FOOT, 1864 MeasureUnit.CUBIC_INCH, 1865 MeasureUnit.CUBIC_KILOMETER, 1866 MeasureUnit.CUBIC_METER, 1867 MeasureUnit.CUBIC_MILE, 1868 MeasureUnit.CUBIC_YARD, 1869 MeasureUnit.CUP, 1870 MeasureUnit.CUP_METRIC, 1871 MeasureUnit.DECILITER, 1872 MeasureUnit.DESSERT_SPOON, 1873 MeasureUnit.DESSERT_SPOON_IMPERIAL, 1874 MeasureUnit.DRAM, 1875 MeasureUnit.DROP, 1876 MeasureUnit.FLUID_OUNCE, 1877 MeasureUnit.FLUID_OUNCE_IMPERIAL, 1878 MeasureUnit.GALLON, 1879 MeasureUnit.GALLON_IMPERIAL, 1880 MeasureUnit.HECTOLITER, 1881 MeasureUnit.JIGGER, 1882 MeasureUnit.LITER, 1883 MeasureUnit.MEGALITER, 1884 MeasureUnit.MILLILITER, 1885 MeasureUnit.PINCH, 1886 MeasureUnit.PINT, 1887 MeasureUnit.PINT_METRIC, 1888 MeasureUnit.QUART, 1889 MeasureUnit.QUART_IMPERIAL, 1890 MeasureUnit.TABLESPOON, 1891 MeasureUnit.TEASPOON, 1892 }; 1893 assertEquals("", 184, units.length); 1894 } 1895 1896 @Test TestCompatible69()1897 public void TestCompatible69() { 1898 MeasureUnit[] units = { 1899 MeasureUnit.G_FORCE, 1900 MeasureUnit.METER_PER_SECOND_SQUARED, 1901 MeasureUnit.ARC_MINUTE, 1902 MeasureUnit.ARC_SECOND, 1903 MeasureUnit.DEGREE, 1904 MeasureUnit.RADIAN, 1905 MeasureUnit.REVOLUTION_ANGLE, 1906 MeasureUnit.ACRE, 1907 MeasureUnit.DUNAM, 1908 MeasureUnit.HECTARE, 1909 MeasureUnit.SQUARE_CENTIMETER, 1910 MeasureUnit.SQUARE_FOOT, 1911 MeasureUnit.SQUARE_INCH, 1912 MeasureUnit.SQUARE_KILOMETER, 1913 MeasureUnit.SQUARE_METER, 1914 MeasureUnit.SQUARE_MILE, 1915 MeasureUnit.SQUARE_YARD, 1916 MeasureUnit.KARAT, 1917 MeasureUnit.MILLIGRAM_OFGLUCOSE_PER_DECILITER, 1918 MeasureUnit.MILLIGRAM_PER_DECILITER, 1919 MeasureUnit.MILLIMOLE_PER_LITER, 1920 MeasureUnit.MOLE, 1921 MeasureUnit.PERCENT, 1922 MeasureUnit.PERMILLE, 1923 MeasureUnit.PART_PER_MILLION, 1924 MeasureUnit.PERMYRIAD, 1925 MeasureUnit.LITER_PER_100KILOMETERS, 1926 MeasureUnit.LITER_PER_KILOMETER, 1927 MeasureUnit.MILE_PER_GALLON, 1928 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 1929 MeasureUnit.BIT, 1930 MeasureUnit.BYTE, 1931 MeasureUnit.GIGABIT, 1932 MeasureUnit.GIGABYTE, 1933 MeasureUnit.KILOBIT, 1934 MeasureUnit.KILOBYTE, 1935 MeasureUnit.MEGABIT, 1936 MeasureUnit.MEGABYTE, 1937 MeasureUnit.PETABYTE, 1938 MeasureUnit.TERABIT, 1939 MeasureUnit.TERABYTE, 1940 MeasureUnit.CENTURY, 1941 MeasureUnit.DAY, 1942 MeasureUnit.DAY_PERSON, 1943 MeasureUnit.DECADE, 1944 MeasureUnit.HOUR, 1945 MeasureUnit.MICROSECOND, 1946 MeasureUnit.MILLISECOND, 1947 MeasureUnit.MINUTE, 1948 MeasureUnit.MONTH, 1949 MeasureUnit.MONTH_PERSON, 1950 MeasureUnit.NANOSECOND, 1951 MeasureUnit.SECOND, 1952 MeasureUnit.WEEK, 1953 MeasureUnit.WEEK_PERSON, 1954 MeasureUnit.YEAR, 1955 MeasureUnit.YEAR_PERSON, 1956 MeasureUnit.AMPERE, 1957 MeasureUnit.MILLIAMPERE, 1958 MeasureUnit.OHM, 1959 MeasureUnit.VOLT, 1960 MeasureUnit.BRITISH_THERMAL_UNIT, 1961 MeasureUnit.CALORIE, 1962 MeasureUnit.ELECTRONVOLT, 1963 MeasureUnit.FOODCALORIE, 1964 MeasureUnit.JOULE, 1965 MeasureUnit.KILOCALORIE, 1966 MeasureUnit.KILOJOULE, 1967 MeasureUnit.KILOWATT_HOUR, 1968 MeasureUnit.THERM_US, 1969 MeasureUnit.NEWTON, 1970 MeasureUnit.POUND_FORCE, 1971 MeasureUnit.GIGAHERTZ, 1972 MeasureUnit.HERTZ, 1973 MeasureUnit.KILOHERTZ, 1974 MeasureUnit.MEGAHERTZ, 1975 MeasureUnit.DOT, 1976 MeasureUnit.DOT_PER_CENTIMETER, 1977 MeasureUnit.DOT_PER_INCH, 1978 MeasureUnit.EM, 1979 MeasureUnit.MEGAPIXEL, 1980 MeasureUnit.PIXEL, 1981 MeasureUnit.PIXEL_PER_CENTIMETER, 1982 MeasureUnit.PIXEL_PER_INCH, 1983 MeasureUnit.ASTRONOMICAL_UNIT, 1984 MeasureUnit.CENTIMETER, 1985 MeasureUnit.DECIMETER, 1986 MeasureUnit.EARTH_RADIUS, 1987 MeasureUnit.FATHOM, 1988 MeasureUnit.FOOT, 1989 MeasureUnit.FURLONG, 1990 MeasureUnit.INCH, 1991 MeasureUnit.KILOMETER, 1992 MeasureUnit.LIGHT_YEAR, 1993 MeasureUnit.METER, 1994 MeasureUnit.MICROMETER, 1995 MeasureUnit.MILE, 1996 MeasureUnit.MILE_SCANDINAVIAN, 1997 MeasureUnit.MILLIMETER, 1998 MeasureUnit.NANOMETER, 1999 MeasureUnit.NAUTICAL_MILE, 2000 MeasureUnit.PARSEC, 2001 MeasureUnit.PICOMETER, 2002 MeasureUnit.POINT, 2003 MeasureUnit.SOLAR_RADIUS, 2004 MeasureUnit.YARD, 2005 MeasureUnit.CANDELA, 2006 MeasureUnit.LUMEN, 2007 MeasureUnit.LUX, 2008 MeasureUnit.SOLAR_LUMINOSITY, 2009 MeasureUnit.CARAT, 2010 MeasureUnit.DALTON, 2011 MeasureUnit.EARTH_MASS, 2012 MeasureUnit.GRAIN, 2013 MeasureUnit.GRAM, 2014 MeasureUnit.KILOGRAM, 2015 MeasureUnit.METRIC_TON, 2016 MeasureUnit.MICROGRAM, 2017 MeasureUnit.MILLIGRAM, 2018 MeasureUnit.OUNCE, 2019 MeasureUnit.OUNCE_TROY, 2020 MeasureUnit.POUND, 2021 MeasureUnit.SOLAR_MASS, 2022 MeasureUnit.STONE, 2023 MeasureUnit.TON, 2024 MeasureUnit.GIGAWATT, 2025 MeasureUnit.HORSEPOWER, 2026 MeasureUnit.KILOWATT, 2027 MeasureUnit.MEGAWATT, 2028 MeasureUnit.MILLIWATT, 2029 MeasureUnit.WATT, 2030 MeasureUnit.ATMOSPHERE, 2031 MeasureUnit.BAR, 2032 MeasureUnit.HECTOPASCAL, 2033 MeasureUnit.INCH_HG, 2034 MeasureUnit.KILOPASCAL, 2035 MeasureUnit.MEGAPASCAL, 2036 MeasureUnit.MILLIBAR, 2037 MeasureUnit.MILLIMETER_OF_MERCURY, 2038 MeasureUnit.PASCAL, 2039 MeasureUnit.POUND_PER_SQUARE_INCH, 2040 MeasureUnit.KILOMETER_PER_HOUR, 2041 MeasureUnit.KNOT, 2042 MeasureUnit.METER_PER_SECOND, 2043 MeasureUnit.MILE_PER_HOUR, 2044 MeasureUnit.CELSIUS, 2045 MeasureUnit.FAHRENHEIT, 2046 MeasureUnit.GENERIC_TEMPERATURE, 2047 MeasureUnit.KELVIN, 2048 MeasureUnit.NEWTON_METER, 2049 MeasureUnit.POUND_FOOT, 2050 MeasureUnit.ACRE_FOOT, 2051 MeasureUnit.BARREL, 2052 MeasureUnit.BUSHEL, 2053 MeasureUnit.CENTILITER, 2054 MeasureUnit.CUBIC_CENTIMETER, 2055 MeasureUnit.CUBIC_FOOT, 2056 MeasureUnit.CUBIC_INCH, 2057 MeasureUnit.CUBIC_KILOMETER, 2058 MeasureUnit.CUBIC_METER, 2059 MeasureUnit.CUBIC_MILE, 2060 MeasureUnit.CUBIC_YARD, 2061 MeasureUnit.CUP, 2062 MeasureUnit.CUP_METRIC, 2063 MeasureUnit.DECILITER, 2064 MeasureUnit.DESSERT_SPOON, 2065 MeasureUnit.DESSERT_SPOON_IMPERIAL, 2066 MeasureUnit.DRAM, 2067 MeasureUnit.DROP, 2068 MeasureUnit.FLUID_OUNCE, 2069 MeasureUnit.FLUID_OUNCE_IMPERIAL, 2070 MeasureUnit.GALLON, 2071 MeasureUnit.GALLON_IMPERIAL, 2072 MeasureUnit.HECTOLITER, 2073 MeasureUnit.JIGGER, 2074 MeasureUnit.LITER, 2075 MeasureUnit.MEGALITER, 2076 MeasureUnit.MILLILITER, 2077 MeasureUnit.PINCH, 2078 MeasureUnit.PINT, 2079 MeasureUnit.PINT_METRIC, 2080 MeasureUnit.QUART, 2081 MeasureUnit.QUART_IMPERIAL, 2082 MeasureUnit.TABLESPOON, 2083 MeasureUnit.TEASPOON, 2084 }; 2085 assertEquals("", 185, units.length); 2086 } 2087 2088 @Test TestCompatible70()2089 public void TestCompatible70() { // TestCompatible71 would be identical 2090 MeasureUnit[] units = { 2091 MeasureUnit.G_FORCE, 2092 MeasureUnit.METER_PER_SECOND_SQUARED, 2093 MeasureUnit.ARC_MINUTE, 2094 MeasureUnit.ARC_SECOND, 2095 MeasureUnit.DEGREE, 2096 MeasureUnit.RADIAN, 2097 MeasureUnit.REVOLUTION_ANGLE, 2098 MeasureUnit.ACRE, 2099 MeasureUnit.DUNAM, 2100 MeasureUnit.HECTARE, 2101 MeasureUnit.SQUARE_CENTIMETER, 2102 MeasureUnit.SQUARE_FOOT, 2103 MeasureUnit.SQUARE_INCH, 2104 MeasureUnit.SQUARE_KILOMETER, 2105 MeasureUnit.SQUARE_METER, 2106 MeasureUnit.SQUARE_MILE, 2107 MeasureUnit.SQUARE_YARD, 2108 MeasureUnit.ITEM, 2109 MeasureUnit.KARAT, 2110 MeasureUnit.MILLIGRAM_OFGLUCOSE_PER_DECILITER, 2111 MeasureUnit.MILLIGRAM_PER_DECILITER, 2112 MeasureUnit.MILLIMOLE_PER_LITER, 2113 MeasureUnit.MOLE, 2114 MeasureUnit.PERCENT, 2115 MeasureUnit.PERMILLE, 2116 MeasureUnit.PART_PER_MILLION, 2117 MeasureUnit.PERMYRIAD, 2118 MeasureUnit.LITER_PER_100KILOMETERS, 2119 MeasureUnit.LITER_PER_KILOMETER, 2120 MeasureUnit.MILE_PER_GALLON, 2121 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 2122 MeasureUnit.BIT, 2123 MeasureUnit.BYTE, 2124 MeasureUnit.GIGABIT, 2125 MeasureUnit.GIGABYTE, 2126 MeasureUnit.KILOBIT, 2127 MeasureUnit.KILOBYTE, 2128 MeasureUnit.MEGABIT, 2129 MeasureUnit.MEGABYTE, 2130 MeasureUnit.PETABYTE, 2131 MeasureUnit.TERABIT, 2132 MeasureUnit.TERABYTE, 2133 MeasureUnit.CENTURY, 2134 MeasureUnit.DAY, 2135 MeasureUnit.DAY_PERSON, 2136 MeasureUnit.DECADE, 2137 MeasureUnit.HOUR, 2138 MeasureUnit.MICROSECOND, 2139 MeasureUnit.MILLISECOND, 2140 MeasureUnit.MINUTE, 2141 MeasureUnit.MONTH, 2142 MeasureUnit.MONTH_PERSON, 2143 MeasureUnit.NANOSECOND, 2144 MeasureUnit.SECOND, 2145 MeasureUnit.WEEK, 2146 MeasureUnit.WEEK_PERSON, 2147 MeasureUnit.YEAR, 2148 MeasureUnit.YEAR_PERSON, 2149 MeasureUnit.AMPERE, 2150 MeasureUnit.MILLIAMPERE, 2151 MeasureUnit.OHM, 2152 MeasureUnit.VOLT, 2153 MeasureUnit.BRITISH_THERMAL_UNIT, 2154 MeasureUnit.CALORIE, 2155 MeasureUnit.ELECTRONVOLT, 2156 MeasureUnit.FOODCALORIE, 2157 MeasureUnit.JOULE, 2158 MeasureUnit.KILOCALORIE, 2159 MeasureUnit.KILOJOULE, 2160 MeasureUnit.KILOWATT_HOUR, 2161 MeasureUnit.THERM_US, 2162 MeasureUnit.KILOWATT_HOUR_PER_100_KILOMETER, 2163 MeasureUnit.NEWTON, 2164 MeasureUnit.POUND_FORCE, 2165 MeasureUnit.GIGAHERTZ, 2166 MeasureUnit.HERTZ, 2167 MeasureUnit.KILOHERTZ, 2168 MeasureUnit.MEGAHERTZ, 2169 MeasureUnit.DOT, 2170 MeasureUnit.DOT_PER_CENTIMETER, 2171 MeasureUnit.DOT_PER_INCH, 2172 MeasureUnit.EM, 2173 MeasureUnit.MEGAPIXEL, 2174 MeasureUnit.PIXEL, 2175 MeasureUnit.PIXEL_PER_CENTIMETER, 2176 MeasureUnit.PIXEL_PER_INCH, 2177 MeasureUnit.ASTRONOMICAL_UNIT, 2178 MeasureUnit.CENTIMETER, 2179 MeasureUnit.DECIMETER, 2180 MeasureUnit.EARTH_RADIUS, 2181 MeasureUnit.FATHOM, 2182 MeasureUnit.FOOT, 2183 MeasureUnit.FURLONG, 2184 MeasureUnit.INCH, 2185 MeasureUnit.KILOMETER, 2186 MeasureUnit.LIGHT_YEAR, 2187 MeasureUnit.METER, 2188 MeasureUnit.MICROMETER, 2189 MeasureUnit.MILE, 2190 MeasureUnit.MILE_SCANDINAVIAN, 2191 MeasureUnit.MILLIMETER, 2192 MeasureUnit.NANOMETER, 2193 MeasureUnit.NAUTICAL_MILE, 2194 MeasureUnit.PARSEC, 2195 MeasureUnit.PICOMETER, 2196 MeasureUnit.POINT, 2197 MeasureUnit.SOLAR_RADIUS, 2198 MeasureUnit.YARD, 2199 MeasureUnit.CANDELA, 2200 MeasureUnit.LUMEN, 2201 MeasureUnit.LUX, 2202 MeasureUnit.SOLAR_LUMINOSITY, 2203 MeasureUnit.CARAT, 2204 MeasureUnit.DALTON, 2205 MeasureUnit.EARTH_MASS, 2206 MeasureUnit.GRAIN, 2207 MeasureUnit.GRAM, 2208 MeasureUnit.KILOGRAM, 2209 MeasureUnit.METRIC_TON, 2210 MeasureUnit.MICROGRAM, 2211 MeasureUnit.MILLIGRAM, 2212 MeasureUnit.OUNCE, 2213 MeasureUnit.OUNCE_TROY, 2214 MeasureUnit.POUND, 2215 MeasureUnit.SOLAR_MASS, 2216 MeasureUnit.STONE, 2217 MeasureUnit.TON, 2218 MeasureUnit.GIGAWATT, 2219 MeasureUnit.HORSEPOWER, 2220 MeasureUnit.KILOWATT, 2221 MeasureUnit.MEGAWATT, 2222 MeasureUnit.MILLIWATT, 2223 MeasureUnit.WATT, 2224 MeasureUnit.ATMOSPHERE, 2225 MeasureUnit.BAR, 2226 MeasureUnit.HECTOPASCAL, 2227 MeasureUnit.INCH_HG, 2228 MeasureUnit.KILOPASCAL, 2229 MeasureUnit.MEGAPASCAL, 2230 MeasureUnit.MILLIBAR, 2231 MeasureUnit.MILLIMETER_OF_MERCURY, 2232 MeasureUnit.PASCAL, 2233 MeasureUnit.POUND_PER_SQUARE_INCH, 2234 MeasureUnit.KILOMETER_PER_HOUR, 2235 MeasureUnit.KNOT, 2236 MeasureUnit.METER_PER_SECOND, 2237 MeasureUnit.MILE_PER_HOUR, 2238 MeasureUnit.CELSIUS, 2239 MeasureUnit.FAHRENHEIT, 2240 MeasureUnit.GENERIC_TEMPERATURE, 2241 MeasureUnit.KELVIN, 2242 MeasureUnit.NEWTON_METER, 2243 MeasureUnit.POUND_FOOT, 2244 MeasureUnit.ACRE_FOOT, 2245 MeasureUnit.BARREL, 2246 MeasureUnit.BUSHEL, 2247 MeasureUnit.CENTILITER, 2248 MeasureUnit.CUBIC_CENTIMETER, 2249 MeasureUnit.CUBIC_FOOT, 2250 MeasureUnit.CUBIC_INCH, 2251 MeasureUnit.CUBIC_KILOMETER, 2252 MeasureUnit.CUBIC_METER, 2253 MeasureUnit.CUBIC_MILE, 2254 MeasureUnit.CUBIC_YARD, 2255 MeasureUnit.CUP, 2256 MeasureUnit.CUP_METRIC, 2257 MeasureUnit.DECILITER, 2258 MeasureUnit.DESSERT_SPOON, 2259 MeasureUnit.DESSERT_SPOON_IMPERIAL, 2260 MeasureUnit.DRAM, 2261 MeasureUnit.DROP, 2262 MeasureUnit.FLUID_OUNCE, 2263 MeasureUnit.FLUID_OUNCE_IMPERIAL, 2264 MeasureUnit.GALLON, 2265 MeasureUnit.GALLON_IMPERIAL, 2266 MeasureUnit.HECTOLITER, 2267 MeasureUnit.JIGGER, 2268 MeasureUnit.LITER, 2269 MeasureUnit.MEGALITER, 2270 MeasureUnit.MILLILITER, 2271 MeasureUnit.PINCH, 2272 MeasureUnit.PINT, 2273 MeasureUnit.PINT_METRIC, 2274 MeasureUnit.QUART, 2275 MeasureUnit.QUART_IMPERIAL, 2276 MeasureUnit.TABLESPOON, 2277 MeasureUnit.TEASPOON, 2278 }; 2279 assertEquals("", 187, units.length); 2280 } 2281 2282 // TestCompatible71 would be identical to TestCompatible70, 2283 // no need to add it 2284 2285 @Test TestCompatible72()2286 public void TestCompatible72() { 2287 MeasureUnit[] units = { 2288 MeasureUnit.G_FORCE, 2289 MeasureUnit.METER_PER_SECOND_SQUARED, 2290 MeasureUnit.ARC_MINUTE, 2291 MeasureUnit.ARC_SECOND, 2292 MeasureUnit.DEGREE, 2293 MeasureUnit.RADIAN, 2294 MeasureUnit.REVOLUTION_ANGLE, 2295 MeasureUnit.ACRE, 2296 MeasureUnit.DUNAM, 2297 MeasureUnit.HECTARE, 2298 MeasureUnit.SQUARE_CENTIMETER, 2299 MeasureUnit.SQUARE_FOOT, 2300 MeasureUnit.SQUARE_INCH, 2301 MeasureUnit.SQUARE_KILOMETER, 2302 MeasureUnit.SQUARE_METER, 2303 MeasureUnit.SQUARE_MILE, 2304 MeasureUnit.SQUARE_YARD, 2305 MeasureUnit.ITEM, 2306 MeasureUnit.KARAT, 2307 MeasureUnit.MILLIGRAM_OFGLUCOSE_PER_DECILITER, 2308 MeasureUnit.MILLIGRAM_PER_DECILITER, 2309 MeasureUnit.MILLIMOLE_PER_LITER, 2310 MeasureUnit.MOLE, 2311 MeasureUnit.PERCENT, 2312 MeasureUnit.PERMILLE, 2313 MeasureUnit.PART_PER_MILLION, 2314 MeasureUnit.PERMYRIAD, 2315 MeasureUnit.LITER_PER_100KILOMETERS, 2316 MeasureUnit.LITER_PER_KILOMETER, 2317 MeasureUnit.MILE_PER_GALLON, 2318 MeasureUnit.MILE_PER_GALLON_IMPERIAL, 2319 MeasureUnit.BIT, 2320 MeasureUnit.BYTE, 2321 MeasureUnit.GIGABIT, 2322 MeasureUnit.GIGABYTE, 2323 MeasureUnit.KILOBIT, 2324 MeasureUnit.KILOBYTE, 2325 MeasureUnit.MEGABIT, 2326 MeasureUnit.MEGABYTE, 2327 MeasureUnit.PETABYTE, 2328 MeasureUnit.TERABIT, 2329 MeasureUnit.TERABYTE, 2330 MeasureUnit.CENTURY, 2331 MeasureUnit.DAY, 2332 MeasureUnit.DAY_PERSON, 2333 MeasureUnit.DECADE, 2334 MeasureUnit.HOUR, 2335 MeasureUnit.MICROSECOND, 2336 MeasureUnit.MILLISECOND, 2337 MeasureUnit.MINUTE, 2338 MeasureUnit.MONTH, 2339 MeasureUnit.MONTH_PERSON, 2340 MeasureUnit.NANOSECOND, 2341 MeasureUnit.QUARTER, 2342 MeasureUnit.SECOND, 2343 MeasureUnit.WEEK, 2344 MeasureUnit.WEEK_PERSON, 2345 MeasureUnit.YEAR, 2346 MeasureUnit.YEAR_PERSON, 2347 MeasureUnit.AMPERE, 2348 MeasureUnit.MILLIAMPERE, 2349 MeasureUnit.OHM, 2350 MeasureUnit.VOLT, 2351 MeasureUnit.BRITISH_THERMAL_UNIT, 2352 MeasureUnit.CALORIE, 2353 MeasureUnit.ELECTRONVOLT, 2354 MeasureUnit.FOODCALORIE, 2355 MeasureUnit.JOULE, 2356 MeasureUnit.KILOCALORIE, 2357 MeasureUnit.KILOJOULE, 2358 MeasureUnit.KILOWATT_HOUR, 2359 MeasureUnit.THERM_US, 2360 MeasureUnit.KILOWATT_HOUR_PER_100_KILOMETER, 2361 MeasureUnit.NEWTON, 2362 MeasureUnit.POUND_FORCE, 2363 MeasureUnit.GIGAHERTZ, 2364 MeasureUnit.HERTZ, 2365 MeasureUnit.KILOHERTZ, 2366 MeasureUnit.MEGAHERTZ, 2367 MeasureUnit.DOT, 2368 MeasureUnit.DOT_PER_CENTIMETER, 2369 MeasureUnit.DOT_PER_INCH, 2370 MeasureUnit.EM, 2371 MeasureUnit.MEGAPIXEL, 2372 MeasureUnit.PIXEL, 2373 MeasureUnit.PIXEL_PER_CENTIMETER, 2374 MeasureUnit.PIXEL_PER_INCH, 2375 MeasureUnit.ASTRONOMICAL_UNIT, 2376 MeasureUnit.CENTIMETER, 2377 MeasureUnit.DECIMETER, 2378 MeasureUnit.EARTH_RADIUS, 2379 MeasureUnit.FATHOM, 2380 MeasureUnit.FOOT, 2381 MeasureUnit.FURLONG, 2382 MeasureUnit.INCH, 2383 MeasureUnit.KILOMETER, 2384 MeasureUnit.LIGHT_YEAR, 2385 MeasureUnit.METER, 2386 MeasureUnit.MICROMETER, 2387 MeasureUnit.MILE, 2388 MeasureUnit.MILE_SCANDINAVIAN, 2389 MeasureUnit.MILLIMETER, 2390 MeasureUnit.NANOMETER, 2391 MeasureUnit.NAUTICAL_MILE, 2392 MeasureUnit.PARSEC, 2393 MeasureUnit.PICOMETER, 2394 MeasureUnit.POINT, 2395 MeasureUnit.SOLAR_RADIUS, 2396 MeasureUnit.YARD, 2397 MeasureUnit.CANDELA, 2398 MeasureUnit.LUMEN, 2399 MeasureUnit.LUX, 2400 MeasureUnit.SOLAR_LUMINOSITY, 2401 MeasureUnit.CARAT, 2402 MeasureUnit.DALTON, 2403 MeasureUnit.EARTH_MASS, 2404 MeasureUnit.GRAIN, 2405 MeasureUnit.GRAM, 2406 MeasureUnit.KILOGRAM, 2407 MeasureUnit.MICROGRAM, 2408 MeasureUnit.MILLIGRAM, 2409 MeasureUnit.OUNCE, 2410 MeasureUnit.OUNCE_TROY, 2411 MeasureUnit.POUND, 2412 MeasureUnit.SOLAR_MASS, 2413 MeasureUnit.STONE, 2414 MeasureUnit.TON, 2415 MeasureUnit.TONNE, 2416 MeasureUnit.GIGAWATT, 2417 MeasureUnit.HORSEPOWER, 2418 MeasureUnit.KILOWATT, 2419 MeasureUnit.MEGAWATT, 2420 MeasureUnit.MILLIWATT, 2421 MeasureUnit.WATT, 2422 MeasureUnit.ATMOSPHERE, 2423 MeasureUnit.BAR, 2424 MeasureUnit.HECTOPASCAL, 2425 MeasureUnit.INCH_HG, 2426 MeasureUnit.KILOPASCAL, 2427 MeasureUnit.MEGAPASCAL, 2428 MeasureUnit.MILLIBAR, 2429 MeasureUnit.MILLIMETER_OF_MERCURY, 2430 MeasureUnit.PASCAL, 2431 MeasureUnit.POUND_PER_SQUARE_INCH, 2432 MeasureUnit.KILOMETER_PER_HOUR, 2433 MeasureUnit.KNOT, 2434 MeasureUnit.METER_PER_SECOND, 2435 MeasureUnit.MILE_PER_HOUR, 2436 MeasureUnit.CELSIUS, 2437 MeasureUnit.FAHRENHEIT, 2438 MeasureUnit.GENERIC_TEMPERATURE, 2439 MeasureUnit.KELVIN, 2440 MeasureUnit.NEWTON_METER, 2441 MeasureUnit.POUND_FOOT, 2442 MeasureUnit.ACRE_FOOT, 2443 MeasureUnit.BARREL, 2444 MeasureUnit.BUSHEL, 2445 MeasureUnit.CENTILITER, 2446 MeasureUnit.CUBIC_CENTIMETER, 2447 MeasureUnit.CUBIC_FOOT, 2448 MeasureUnit.CUBIC_INCH, 2449 MeasureUnit.CUBIC_KILOMETER, 2450 MeasureUnit.CUBIC_METER, 2451 MeasureUnit.CUBIC_MILE, 2452 MeasureUnit.CUBIC_YARD, 2453 MeasureUnit.CUP, 2454 MeasureUnit.CUP_METRIC, 2455 MeasureUnit.DECILITER, 2456 MeasureUnit.DESSERT_SPOON, 2457 MeasureUnit.DESSERT_SPOON_IMPERIAL, 2458 MeasureUnit.DRAM, 2459 MeasureUnit.DROP, 2460 MeasureUnit.FLUID_OUNCE, 2461 MeasureUnit.FLUID_OUNCE_IMPERIAL, 2462 MeasureUnit.GALLON, 2463 MeasureUnit.GALLON_IMPERIAL, 2464 MeasureUnit.HECTOLITER, 2465 MeasureUnit.JIGGER, 2466 MeasureUnit.LITER, 2467 MeasureUnit.MEGALITER, 2468 MeasureUnit.MILLILITER, 2469 MeasureUnit.PINCH, 2470 MeasureUnit.PINT, 2471 MeasureUnit.PINT_METRIC, 2472 MeasureUnit.QUART, 2473 MeasureUnit.QUART_IMPERIAL, 2474 MeasureUnit.TABLESPOON, 2475 MeasureUnit.TEASPOON, 2476 }; 2477 assertEquals("", 188, units.length); 2478 } 2479 2480 @Test TestExamplesInDocs()2481 public void TestExamplesInDocs() { 2482 MeasureFormat fmtFr = MeasureFormat.getInstance( 2483 ULocale.FRENCH, FormatWidth.SHORT); 2484 Measure measure = new Measure(23, MeasureUnit.CELSIUS); 2485 assertEquals("23\u202F°C", "23\u202F°C", fmtFr.format(measure)); 2486 Measure measureF = new Measure(70, MeasureUnit.FAHRENHEIT); 2487 assertEquals("70\u202F°F", "70\u202F°F", fmtFr.format(measureF)); 2488 MeasureFormat fmtFrFull = MeasureFormat.getInstance( 2489 ULocale.FRENCH, FormatWidth.WIDE); 2490 assertEquals( 2491 "70 pied et 5,3 pouces", 2492 "70 pieds et 5,3 pouces", 2493 fmtFrFull.formatMeasures( 2494 new Measure(70, MeasureUnit.FOOT), 2495 new Measure(5.3, MeasureUnit.INCH))); 2496 assertEquals( 2497 "1\u00A0pied et 1\u00A0pouce", 2498 "1\u00A0pied et 1\u00A0pouce", 2499 fmtFrFull.formatMeasures( 2500 new Measure(1, MeasureUnit.FOOT), 2501 new Measure(1, MeasureUnit.INCH))); 2502 MeasureFormat fmtFrNarrow = MeasureFormat.getInstance( 2503 ULocale.FRENCH, FormatWidth.NARROW); 2504 assertEquals( 2505 "1′ 1″", 2506 "1′ 1″", 2507 fmtFrNarrow.formatMeasures( 2508 new Measure(1, MeasureUnit.FOOT), 2509 new Measure(1, MeasureUnit.INCH))); 2510 MeasureFormat fmtEn = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.WIDE); 2511 assertEquals( 2512 "1 inch, 2 feet", 2513 "1 inch, 2 feet", 2514 fmtEn.formatMeasures( 2515 new Measure(1, MeasureUnit.INCH), 2516 new Measure(2, MeasureUnit.FOOT))); 2517 } 2518 2519 @Test TestFormatPeriodEn()2520 public void TestFormatPeriodEn() { 2521 TimeUnitAmount[] _19m = {new TimeUnitAmount(19.0, TimeUnit.MINUTE)}; 2522 TimeUnitAmount[] _1h_23_5s = { 2523 new TimeUnitAmount(1.0, TimeUnit.HOUR), 2524 new TimeUnitAmount(23.5, TimeUnit.SECOND)}; 2525 TimeUnitAmount[] _1h_23_5m = { 2526 new TimeUnitAmount(1.0, TimeUnit.HOUR), 2527 new TimeUnitAmount(23.5, TimeUnit.MINUTE)}; 2528 TimeUnitAmount[] _1h_0m_23s = { 2529 new TimeUnitAmount(1.0, TimeUnit.HOUR), 2530 new TimeUnitAmount(0.0, TimeUnit.MINUTE), 2531 new TimeUnitAmount(23.0, TimeUnit.SECOND)}; 2532 TimeUnitAmount[] _2y_5M_3w_4d = { 2533 new TimeUnitAmount(2.0, TimeUnit.YEAR), 2534 new TimeUnitAmount(5.0, TimeUnit.MONTH), 2535 new TimeUnitAmount(3.0, TimeUnit.WEEK), 2536 new TimeUnitAmount(4.0, TimeUnit.DAY)}; 2537 TimeUnitAmount[] _1m_59_9996s = { 2538 new TimeUnitAmount(1.0, TimeUnit.MINUTE), 2539 new TimeUnitAmount(59.9996, TimeUnit.SECOND)}; 2540 TimeUnitAmount[] _5h_17m = { 2541 new TimeUnitAmount(5.0, TimeUnit.HOUR), 2542 new TimeUnitAmount(17.0, TimeUnit.MINUTE)}; 2543 TimeUnitAmount[] _neg5h_17m = { 2544 new TimeUnitAmount(-5.0, TimeUnit.HOUR), 2545 new TimeUnitAmount(17.0, TimeUnit.MINUTE)}; 2546 TimeUnitAmount[] _19m_28s = { 2547 new TimeUnitAmount(19.0, TimeUnit.MINUTE), 2548 new TimeUnitAmount(28.0, TimeUnit.SECOND)}; 2549 TimeUnitAmount[] _0h_0m_9s = { 2550 new TimeUnitAmount(0.0, TimeUnit.HOUR), 2551 new TimeUnitAmount(0.0, TimeUnit.MINUTE), 2552 new TimeUnitAmount(9.0, TimeUnit.SECOND)}; 2553 TimeUnitAmount[] _0h_0m_17s = { 2554 new TimeUnitAmount(0.0, TimeUnit.HOUR), 2555 new TimeUnitAmount(0.0, TimeUnit.MINUTE), 2556 new TimeUnitAmount(17.0, TimeUnit.SECOND)}; 2557 TimeUnitAmount[] _6h_56_92m = { 2558 new TimeUnitAmount(6.0, TimeUnit.HOUR), 2559 new TimeUnitAmount(56.92, TimeUnit.MINUTE)}; 2560 TimeUnitAmount[] _3h_4s_5m = { 2561 new TimeUnitAmount(3.0, TimeUnit.HOUR), 2562 new TimeUnitAmount(4.0, TimeUnit.SECOND), 2563 new TimeUnitAmount(5.0, TimeUnit.MINUTE)}; 2564 TimeUnitAmount[] _6_7h_56_92m = { 2565 new TimeUnitAmount(6.7, TimeUnit.HOUR), 2566 new TimeUnitAmount(56.92, TimeUnit.MINUTE)}; 2567 TimeUnitAmount[] _3h_5h = { 2568 new TimeUnitAmount(3.0, TimeUnit.HOUR), 2569 new TimeUnitAmount(5.0, TimeUnit.HOUR)}; 2570 2571 Object[][] fullData = { 2572 {_1m_59_9996s, "1 minute, 59.9996 seconds"}, 2573 {_19m, "19 minutes"}, 2574 {_1h_23_5s, "1 hour, 23.5 seconds"}, 2575 {_1h_23_5m, "1 hour, 23.5 minutes"}, 2576 {_1h_0m_23s, "1 hour, 0 minutes, 23 seconds"}, 2577 {_2y_5M_3w_4d, "2 years, 5 months, 3 weeks, 4 days"}}; 2578 Object[][] abbrevData = { 2579 {_1m_59_9996s, "1 min, 59.9996 sec"}, 2580 {_19m, "19 min"}, 2581 {_1h_23_5s, "1 hr, 23.5 sec"}, 2582 {_1h_23_5m, "1 hr, 23.5 min"}, 2583 {_1h_0m_23s, "1 hr, 0 min, 23 sec"}, 2584 {_2y_5M_3w_4d, "2 yrs, 5 mths, 3 wks, 4 days"}}; 2585 Object[][] narrowData = { 2586 {_1m_59_9996s, "1m 59.9996s"}, 2587 {_19m, "19m"}, 2588 {_1h_23_5s, "1h 23.5s"}, 2589 {_1h_23_5m, "1h 23.5m"}, 2590 {_1h_0m_23s, "1h 0m 23s"}, 2591 {_2y_5M_3w_4d, "2y 5m 3w 4d"}}; 2592 2593 2594 Object[][] numericData = { 2595 {_1m_59_9996s, "1:59.9996"}, 2596 {_19m, "19m"}, 2597 {_1h_23_5s, "1:00:23.5"}, 2598 {_1h_0m_23s, "1:00:23"}, 2599 {_1h_23_5m, "1:23.5"}, 2600 {_5h_17m, "5:17"}, 2601 {_neg5h_17m, "-5h 17m"}, 2602 {_19m_28s, "19:28"}, 2603 {_2y_5M_3w_4d, "2y 5m 3w 4d"}, 2604 {_0h_0m_9s, "0:00:09"}, 2605 {_6h_56_92m, "6:56.92"}, 2606 {_6_7h_56_92m, "6:56.92"}, 2607 {_3h_4s_5m, "3h 4s 5m"}, 2608 {_3h_5h, "3h 5h"}}; 2609 Object[][] fullDataDe = { 2610 {_1m_59_9996s, "1 Minute, 59,9996 Sekunden"}, 2611 {_19m, "19 Minuten"}, 2612 {_1h_23_5s, "1 Stunde, 23,5 Sekunden"}, 2613 {_1h_23_5m, "1 Stunde, 23,5 Minuten"}, 2614 {_1h_0m_23s, "1 Stunde, 0 Minuten und 23 Sekunden"}, 2615 {_2y_5M_3w_4d, "2 Jahre, 5 Monate, 3 Wochen und 4 Tage"}}; 2616 Object[][] numericDataDe = { 2617 {_1m_59_9996s, "1:59,9996"}, 2618 {_19m, "19 Min."}, 2619 {_1h_23_5s, "1:00:23,5"}, 2620 {_1h_0m_23s, "1:00:23"}, 2621 {_1h_23_5m, "1:23,5"}, 2622 {_5h_17m, "5:17"}, 2623 {_19m_28s, "19:28"}, 2624 {_2y_5M_3w_4d, "2 J, 5 M, 3 W und 4 T"}, 2625 {_0h_0m_17s, "0:00:17"}, 2626 {_6h_56_92m, "6:56,92"}, 2627 {_3h_5h, "3 Std., 5 Std."}}; 2628 Object[][] numericDataBn = { 2629 {_1m_59_9996s, "১:৫৯.৯৯৯৬"}, 2630 {_19m, "১৯ মিঃ"}, 2631 {_1h_23_5s, "১:০০:২৩.৫"}, 2632 {_1h_0m_23s, "১:০০:২৩"}, 2633 {_1h_23_5m, "১:২৩.৫"}, 2634 {_5h_17m, "৫:১৭"}, 2635 {_19m_28s, "১৯:২৮"}, 2636 {_2y_5M_3w_4d, "২ বছর, ৫ মাস, ৩ সপ্তাহ, ৪ দিন"}, 2637 {_0h_0m_17s, "০:০০:১৭"}, 2638 {_6h_56_92m, "৬:৫৬.৯২"}, 2639 {_3h_5h, "৩ ঘঃ, ৫ ঘঃ"}}; 2640 Object[][] numericDataBnLatn = { 2641 {_1m_59_9996s, "1:59.9996"}, 2642 {_19m, "19 মিঃ"}, 2643 {_1h_23_5s, "1:00:23.5"}, 2644 {_1h_0m_23s, "1:00:23"}, 2645 {_1h_23_5m, "1:23.5"}, 2646 {_5h_17m, "5:17"}, 2647 {_19m_28s, "19:28"}, 2648 {_2y_5M_3w_4d, "2 বছর, 5 মাস, 3 সপ্তাহ, 4 দিন"}, 2649 {_0h_0m_17s, "0:00:17"}, 2650 {_6h_56_92m, "6:56.92"}, 2651 {_3h_5h, "3 ঘঃ, 5 ঘঃ"}}; 2652 2653 NumberFormat nf = NumberFormat.getNumberInstance(ULocale.ENGLISH); 2654 nf.setMaximumFractionDigits(4); 2655 MeasureFormat mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.WIDE, nf); 2656 verifyFormatPeriod("en FULL", mf, fullData); 2657 mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.SHORT, nf); 2658 verifyFormatPeriod("en SHORT", mf, abbrevData); 2659 mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.NARROW, nf); 2660 verifyFormatPeriod("en NARROW", mf, narrowData); 2661 mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.NUMERIC, nf); 2662 verifyFormatPeriod("en NUMERIC", mf, numericData); 2663 2664 nf = NumberFormat.getNumberInstance(ULocale.GERMAN); 2665 nf.setMaximumFractionDigits(4); 2666 mf = MeasureFormat.getInstance(ULocale.GERMAN, FormatWidth.WIDE, nf); 2667 verifyFormatPeriod("de FULL", mf, fullDataDe); 2668 mf = MeasureFormat.getInstance(ULocale.GERMAN, FormatWidth.NUMERIC, nf); 2669 verifyFormatPeriod("de NUMERIC", mf, numericDataDe); 2670 2671 // Same tests, with Java Locale 2672 nf = NumberFormat.getNumberInstance(Locale.GERMAN); 2673 nf.setMaximumFractionDigits(4); 2674 mf = MeasureFormat.getInstance(Locale.GERMAN, FormatWidth.WIDE, nf); 2675 verifyFormatPeriod("de FULL(Java Locale)", mf, fullDataDe); 2676 mf = MeasureFormat.getInstance(Locale.GERMAN, FormatWidth.NUMERIC, nf); 2677 verifyFormatPeriod("de NUMERIC(Java Locale)", mf, numericDataDe); 2678 2679 ULocale bengali = ULocale.forLanguageTag("bn"); 2680 nf = NumberFormat.getNumberInstance(bengali); 2681 nf.setMaximumFractionDigits(4); 2682 mf = MeasureFormat.getInstance(bengali, FormatWidth.NUMERIC, nf); 2683 verifyFormatPeriod("bn NUMERIC(Java Locale)", mf, numericDataBn); 2684 2685 bengali = ULocale.forLanguageTag("bn-u-nu-latn"); 2686 nf = NumberFormat.getNumberInstance(bengali); 2687 nf.setMaximumFractionDigits(4); 2688 mf = MeasureFormat.getInstance(bengali, FormatWidth.NUMERIC, nf); 2689 verifyFormatPeriod("bn NUMERIC(Java Locale)", mf, numericDataBnLatn); 2690 } 2691 verifyFormatPeriod(String desc, MeasureFormat mf, Object[][] testData)2692 private void verifyFormatPeriod(String desc, MeasureFormat mf, Object[][] testData) { 2693 StringBuilder builder = new StringBuilder(); 2694 boolean failure = false; 2695 for (Object[] testCase : testData) { 2696 String actual = mf.format(testCase[0]); 2697 if (!testCase[1].equals(actual)) { 2698 builder.append(String.format("%s: Expected: '%s', got: '%s'\n", desc, testCase[1], actual)); 2699 failure = true; 2700 } 2701 } 2702 if (failure) { 2703 errln(builder.toString()); 2704 } 2705 } 2706 2707 @Test Test10219FractionalPlurals()2708 public void Test10219FractionalPlurals() { 2709 double[] values = {1.588, 1.011}; 2710 String[][] expected = { 2711 {"1 minute", "1.5 minutes", "1.58 minutes"}, 2712 {"1 minute", "1.0 minutes", "1.01 minutes"} 2713 }; 2714 for (int j = 0; j < values.length; j++) { 2715 for (int i = 0; i < expected[j].length; i++) { 2716 NumberFormat nf = NumberFormat.getNumberInstance(ULocale.ENGLISH); 2717 nf.setRoundingMode(BigDecimal.ROUND_DOWN); 2718 nf.setMinimumFractionDigits(i); 2719 nf.setMaximumFractionDigits(i); 2720 MeasureFormat mf = MeasureFormat.getInstance( 2721 ULocale.ENGLISH, FormatWidth.WIDE, nf); 2722 assertEquals("Test10219", expected[j][i], mf.format(new Measure(values[j], MeasureUnit.MINUTE))); 2723 } 2724 } 2725 } 2726 2727 @Test TestGreek()2728 public void TestGreek() { 2729 String[] locales = {"el_GR", "el"}; 2730 final MeasureUnit[] units = new MeasureUnit[]{ 2731 MeasureUnit.SECOND, 2732 MeasureUnit.MINUTE, 2733 MeasureUnit.HOUR, 2734 MeasureUnit.DAY, 2735 MeasureUnit.WEEK, 2736 MeasureUnit.MONTH, 2737 MeasureUnit.YEAR}; 2738 FormatWidth[] styles = new FormatWidth[] {FormatWidth.WIDE, FormatWidth.SHORT}; 2739 int[] numbers = new int[] {1, 7}; 2740 String[] expected = { 2741 // "el_GR" 1 wide 2742 "1 δευτερόλεπτο", 2743 "1 λεπτό", 2744 "1 ώρα", 2745 "1 ημέρα", 2746 "1 εβδομάδα", 2747 "1 μήνας", 2748 "1 έτος", 2749 // "el_GR" 1 short 2750 "1 δευτ.", 2751 "1 λ.", 2752 "1 ώ.", 2753 "1 ημέρα", 2754 "1 εβδ.", 2755 "1 μήν.", 2756 "1 έτ.", // year (one) 2757 // "el_GR" 7 wide 2758 "7 δευτερόλεπτα", 2759 "7 λεπτά", 2760 "7 ώρες", 2761 "7 ημέρες", 2762 "7 εβδομάδες", 2763 "7 μήνες", 2764 "7 έτη", 2765 // "el_GR" 7 short 2766 "7 δευτ.", 2767 "7 λ.", 2768 "7 ώ.", // hour (other) 2769 "7 ημέρες", 2770 "7 εβδ.", 2771 "7 μήν.", 2772 "7 έτ.", // year (other) 2773 // "el" 1 wide 2774 "1 δευτερόλεπτο", 2775 "1 λεπτό", 2776 "1 ώρα", 2777 "1 ημέρα", 2778 "1 εβδομάδα", 2779 "1 μήνας", 2780 "1 έτος", 2781 // "el" 1 short 2782 "1 δευτ.", 2783 "1 λ.", 2784 "1 ώ.", 2785 "1 ημέρα", 2786 "1 εβδ.", 2787 "1 μήν.", 2788 "1 έτ.", // year (one) 2789 // "el" 7 wide 2790 "7 δευτερόλεπτα", 2791 "7 λεπτά", 2792 "7 ώρες", 2793 "7 ημέρες", 2794 "7 εβδομάδες", 2795 "7 μήνες", 2796 "7 έτη", 2797 // "el" 7 short 2798 "7 δευτ.", 2799 "7 λ.", 2800 "7 ώ.", // hour (other) 2801 "7 ημέρες", 2802 "7 εβδ.", 2803 "7 μήν.", 2804 "7 έτ."}; // year (other 2805 int counter = 0; 2806 String formatted; 2807 for ( int locIndex = 0; locIndex < locales.length; ++locIndex ) { 2808 for( int numIndex = 0; numIndex < numbers.length; ++numIndex ) { 2809 for ( int styleIndex = 0; styleIndex < styles.length; ++styleIndex ) { 2810 for ( int unitIndex = 0; unitIndex < units.length; ++unitIndex ) { 2811 Measure m = new Measure(numbers[numIndex], units[unitIndex]); 2812 MeasureFormat fmt = MeasureFormat.getInstance(new ULocale(locales[locIndex]), styles[styleIndex]); 2813 formatted = fmt.format(m); 2814 assertEquals( 2815 "locale: " + locales[locIndex] 2816 + ", style: " + styles[styleIndex] 2817 + ", units: " + units[unitIndex] 2818 + ", value: " + numbers[numIndex], 2819 expected[counter], formatted); 2820 ++counter; 2821 } 2822 } 2823 } 2824 } 2825 } 2826 2827 @Test testAUnit()2828 public void testAUnit() { 2829 String lastType = null; 2830 for (MeasureUnit expected : MeasureUnit.getAvailable()) { 2831 String type = expected.getType(); 2832 String code = expected.getSubtype(); 2833 if (!type.equals(lastType)) { 2834 logln(type); 2835 lastType = type; 2836 } 2837 MeasureUnit actual = MeasureUnit.internalGetInstance(type, code); 2838 assertSame("Identity check", expected, actual); 2839 } 2840 2841 // The return value should contain only unique elements 2842 assertUnique(MeasureUnit.getAvailable()); 2843 } 2844 assertUnique(Collection<?> coll)2845 static void assertUnique(Collection<?> coll) { 2846 int expectedSize = new HashSet<>(coll).size(); 2847 int actualSize = coll.size(); 2848 assertEquals("Collection should contain only unique elements", expectedSize, actualSize); 2849 } 2850 2851 @Test testFormatSingleArg()2852 public void testFormatSingleArg() { 2853 MeasureFormat mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.WIDE); 2854 assertEquals("", "5 meters", mf.format(new Measure(5, MeasureUnit.METER))); 2855 } 2856 2857 @Test testFormatMeasuresZeroArg()2858 public void testFormatMeasuresZeroArg() { 2859 MeasureFormat mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.WIDE); 2860 assertEquals("", "", mf.formatMeasures()); 2861 } 2862 2863 @Test testFormatMeasuresOneArg()2864 public void testFormatMeasuresOneArg() { 2865 MeasureFormat mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.WIDE); 2866 assertEquals("", "5 meters", mf.formatMeasures(new Measure(5, MeasureUnit.METER))); 2867 } 2868 2869 2870 2871 @Test testMultiples()2872 public void testMultiples() { 2873 ULocale russia = new ULocale("ru"); 2874 Object[][] data = new Object[][] { 2875 {ULocale.ENGLISH, FormatWidth.WIDE, "2 miles, 1 foot, 2.3 inches"}, 2876 {ULocale.ENGLISH, FormatWidth.SHORT, "2 mi, 1 ft, 2.3 in"}, 2877 {ULocale.ENGLISH, FormatWidth.NARROW, "2mi 1\u2032 2.3\u2033"}, 2878 {russia, FormatWidth.WIDE, "2 \u043C\u0438\u043B\u0438 1 \u0444\u0443\u0442 2,3 \u0434\u044E\u0439\u043C\u0430"}, 2879 {russia, FormatWidth.SHORT, "2 \u043C\u0438 1 \u0444\u0442 2,3 \u0434\u044E\u0439\u043C."}, 2880 {russia, FormatWidth.NARROW, "2 \u043C\u0438 1 \u0444\u0442 2,3 \u0434\u044E\u0439\u043C."}, 2881 }; 2882 for (Object[] row : data) { 2883 MeasureFormat mf = MeasureFormat.getInstance( 2884 (ULocale) row[0], (FormatWidth) row[1]); 2885 assertEquals( 2886 "testMultiples", 2887 row[2], 2888 mf.formatMeasures( 2889 new Measure(2, MeasureUnit.MILE), 2890 new Measure(1, MeasureUnit.FOOT), 2891 new Measure(2.3, MeasureUnit.INCH))); 2892 } 2893 } 2894 2895 @Test testManyLocaleDurations()2896 public void testManyLocaleDurations() { 2897 Measure hours = new Measure(5, MeasureUnit.HOUR); 2898 Measure minutes = new Measure(37, MeasureUnit.MINUTE); 2899 ULocale ulocDanish = new ULocale("da"); 2900 ULocale ulocSpanish = new ULocale("es"); 2901 ULocale ulocFinnish = new ULocale("fi"); 2902 ULocale ulocIcelandic = new ULocale("is"); 2903 ULocale ulocNorwegianBok = new ULocale("nb"); 2904 ULocale ulocNorwegianNyn = new ULocale("nn"); 2905 ULocale ulocDutch = new ULocale("nl"); 2906 ULocale ulocSwedish = new ULocale("sv"); 2907 Object[][] data = new Object[][] { 2908 { ulocDanish, FormatWidth.NARROW, "5 t og 37 m" }, 2909 { ulocDanish, FormatWidth.NUMERIC, "5.37" }, 2910 { ULocale.GERMAN, FormatWidth.NARROW, "5 Std., 37 Min." }, 2911 { ULocale.GERMAN, FormatWidth.NUMERIC, "5:37" }, 2912 { ULocale.ENGLISH, FormatWidth.NARROW, "5h 37m" }, 2913 { ULocale.ENGLISH, FormatWidth.NUMERIC, "5:37" }, 2914 { ulocSpanish, FormatWidth.NARROW, "5h 37min" }, 2915 { ulocSpanish, FormatWidth.NUMERIC, "5:37" }, 2916 { ulocFinnish, FormatWidth.NARROW, "5t 37min" }, 2917 { ulocFinnish, FormatWidth.NUMERIC, "5.37" }, 2918 { ULocale.FRENCH, FormatWidth.NARROW, "5h 37min" }, 2919 { ULocale.FRENCH, FormatWidth.NUMERIC, "5:37" }, 2920 { ulocIcelandic, FormatWidth.NARROW, "5 klst. og 37 m\u00EDn." }, 2921 { ulocIcelandic, FormatWidth.NUMERIC, "5:37" }, 2922 { ULocale.JAPANESE, FormatWidth.NARROW, "5h37m" }, 2923 { ULocale.JAPANESE, FormatWidth.NUMERIC, "5:37" }, 2924 { ulocNorwegianBok, FormatWidth.NARROW, "5t, 37m" }, 2925 { ulocNorwegianBok, FormatWidth.NUMERIC, "5:37" }, 2926 { ulocDutch, FormatWidth.NARROW, "5 u, 37 m" }, 2927 { ulocDutch, FormatWidth.NUMERIC, "5:37" }, 2928 { ulocNorwegianNyn, FormatWidth.NARROW, "5t 37m" }, 2929 { ulocNorwegianNyn, FormatWidth.NUMERIC, "5:37" }, 2930 { ulocSwedish, FormatWidth.NARROW, "5h 37m" }, 2931 { ulocSwedish, FormatWidth.NUMERIC, "5:37" }, 2932 { ULocale.CHINESE, FormatWidth.NARROW, "5\u5C0F\u65F637\u5206\u949F" }, 2933 { ULocale.CHINESE, FormatWidth.NUMERIC, "5:37" }, 2934 }; 2935 for (Object[] row : data) { 2936 MeasureFormat mf = null; 2937 try{ 2938 mf = MeasureFormat.getInstance( (ULocale)row[0], (FormatWidth)row[1] ); 2939 } catch(Exception e) { 2940 errln("Exception creating MeasureFormat for locale " + row[0] + ", width " + 2941 row[1] + ": " + e); 2942 continue; 2943 } 2944 String result = mf.formatMeasures(hours, minutes); 2945 if (!result.equals(row[2])) { 2946 errln("MeasureFormat.formatMeasures for locale " + row[0] + ", width " + 2947 row[1] + ", expected \"" + (String)row[2] + "\", got \"" + result + "\"" ); 2948 } 2949 } 2950 } 2951 2952 @Test testSimplePer()2953 public void testSimplePer() { 2954 Object DONT_CARE = null; 2955 Object[][] data = new Object[][] { 2956 // per unit pattern 2957 {FormatWidth.WIDE, 1.0, MeasureUnit.SECOND, "1 pound per second", DONT_CARE, 0, 0}, 2958 {FormatWidth.WIDE, 2.0, MeasureUnit.SECOND, "2 pounds per second", DONT_CARE, 0, 0}, 2959 // compound pattern 2960 {FormatWidth.WIDE, 1.0, MeasureUnit.MINUTE, "1 pound per minute", DONT_CARE, 0, 0}, 2961 {FormatWidth.WIDE, 2.0, MeasureUnit.MINUTE, "2 pounds per minute", DONT_CARE, 0, 0}, 2962 // per unit 2963 {FormatWidth.SHORT, 1.0, MeasureUnit.SECOND, "1 lb/s", DONT_CARE, 0, 0}, 2964 {FormatWidth.SHORT, 2.0, MeasureUnit.SECOND, "2 lb/s", DONT_CARE, 0, 0}, 2965 // compound 2966 {FormatWidth.SHORT, 1.0, MeasureUnit.MINUTE, "1 lb/min", DONT_CARE, 0, 0}, 2967 {FormatWidth.SHORT, 2.0, MeasureUnit.MINUTE, "2 lb/min", DONT_CARE, 0, 0}, 2968 // per unit 2969 {FormatWidth.NARROW, 1.0, MeasureUnit.SECOND, "1#/s", DONT_CARE, 0, 0}, 2970 {FormatWidth.NARROW, 2.0, MeasureUnit.SECOND, "2#/s", DONT_CARE, 0, 0}, 2971 // compound 2972 {FormatWidth.NARROW, 1.0, MeasureUnit.MINUTE, "1#/min", DONT_CARE, 0, 0}, 2973 {FormatWidth.NARROW, 2.0, MeasureUnit.MINUTE, "2#/min", DONT_CARE, 0, 0}, 2974 // field positions 2975 {FormatWidth.SHORT, 23.3, MeasureUnit.SECOND, "23.3 lb/s", NumberFormat.Field.DECIMAL_SEPARATOR, 2, 3}, 2976 {FormatWidth.SHORT, 23.3, MeasureUnit.SECOND, "23.3 lb/s", NumberFormat.Field.INTEGER, 0, 2}, 2977 {FormatWidth.SHORT, 23.3, MeasureUnit.MINUTE, "23.3 lb/min", NumberFormat.Field.DECIMAL_SEPARATOR, 2, 3}, 2978 {FormatWidth.SHORT, 23.3, MeasureUnit.MINUTE, "23.3 lb/min", NumberFormat.Field.INTEGER, 0, 2}, 2979 2980 }; 2981 2982 for (Object[] row : data) { 2983 FormatWidth formatWidth = (FormatWidth) row[0]; 2984 Number amount = (Number) row[1]; 2985 MeasureUnit perUnit = (MeasureUnit) row[2]; 2986 String expected = row[3].toString(); 2987 NumberFormat.Field field = (NumberFormat.Field) row[4]; 2988 int startOffset = ((Integer) row[5]).intValue(); 2989 int endOffset = ((Integer) row[6]).intValue(); 2990 MeasureFormat mf = MeasureFormat.getInstance( 2991 ULocale.ENGLISH, formatWidth); 2992 FieldPosition pos = field != null ? new FieldPosition(field) : new FieldPosition(0); 2993 String prefix = "Prefix: "; 2994 assertEquals( 2995 "", 2996 prefix + expected, 2997 mf.formatMeasurePerUnit( 2998 new Measure(amount, MeasureUnit.POUND), 2999 perUnit, 3000 new StringBuilder(prefix), 3001 pos).toString()); 3002 if (field != DONT_CARE) { 3003 assertEquals("startOffset", startOffset, pos.getBeginIndex() - prefix.length()); 3004 assertEquals("endOffset", endOffset, pos.getEndIndex() - prefix.length()); 3005 } 3006 } 3007 } 3008 3009 @Test testNumeratorPlurals()3010 public void testNumeratorPlurals() { 3011 ULocale polish = new ULocale("pl"); 3012 Object[][] data = new Object[][] { 3013 {1, "1 stopa na sekundę"}, 3014 {2, "2 stopy na sekundę"}, 3015 {5, "5 stóp na sekundę"}, 3016 {1.5, "1,5 stopy na sekundę"}}; 3017 3018 for (Object[] row : data) { 3019 MeasureFormat mf = MeasureFormat.getInstance(polish, FormatWidth.WIDE); 3020 assertEquals( 3021 "", 3022 row[1], 3023 mf.formatMeasurePerUnit( 3024 new Measure((Number) row[0], MeasureUnit.FOOT), 3025 MeasureUnit.SECOND, 3026 new StringBuilder(), 3027 new FieldPosition(0)).toString()); 3028 } 3029 } 3030 3031 @Test testGram()3032 public void testGram() { 3033 MeasureFormat mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.SHORT); 3034 assertEquals( 3035 "testGram", 3036 "1 g", 3037 mf.format(new Measure(1, MeasureUnit.GRAM))); 3038 assertEquals( 3039 "testGram", 3040 "1 G", 3041 mf.format(new Measure(1, MeasureUnit.G_FORCE))); 3042 } 3043 3044 @Test testCurrencies()3045 public void testCurrencies() { 3046 Measure USD_1 = new Measure(1.0, Currency.getInstance("USD")); 3047 Measure USD_2 = new Measure(2.0, Currency.getInstance("USD")); 3048 Measure USD_NEG_1 = new Measure(-1.0, Currency.getInstance("USD")); 3049 MeasureFormat mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.WIDE); 3050 assertEquals("Wide currency", "-1.00 US dollars", mf.format(USD_NEG_1)); 3051 assertEquals("Wide currency", "1.00 US dollars", mf.format(USD_1)); 3052 assertEquals("Wide currency", "2.00 US dollars", mf.format(USD_2)); 3053 mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.SHORT); 3054 assertEquals("short currency", "-USD 1.00", mf.format(USD_NEG_1)); 3055 assertEquals("short currency", "USD 1.00", mf.format(USD_1)); 3056 assertEquals("short currency", "USD 2.00", mf.format(USD_2)); 3057 mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.NARROW); 3058 assertEquals("narrow currency", "-$1.00", mf.format(USD_NEG_1)); 3059 assertEquals("narrow currency", "$1.00", mf.format(USD_1)); 3060 assertEquals("narrow currency", "$2.00", mf.format(USD_2)); 3061 mf = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.NUMERIC); 3062 assertEquals("numeric currency", "-$1.00", mf.format(USD_NEG_1)); 3063 assertEquals("numeric currency", "$1.00", mf.format(USD_1)); 3064 assertEquals("numeric currency", "$2.00", mf.format(USD_2)); 3065 3066 mf = MeasureFormat.getInstance(ULocale.JAPAN, FormatWidth.WIDE); 3067 // Locale jp does NOT put a space between the number and the currency long name: 3068 // https://unicode.org/cldr/trac/browser/tags/release-32-0-1/common/main/ja.xml?rev=13805#L7046 3069 assertEquals("Wide currency", "-1.00\u7C73\u30C9\u30EB", mf.format(USD_NEG_1)); 3070 assertEquals("Wide currency", "1.00\u7C73\u30C9\u30EB", mf.format(USD_1)); 3071 assertEquals("Wide currency", "2.00\u7C73\u30C9\u30EB", mf.format(USD_2)); 3072 3073 Measure CAD_1 = new Measure(1.0, Currency.getInstance("CAD")); 3074 mf = MeasureFormat.getInstance(ULocale.CANADA, FormatWidth.SHORT); 3075 assertEquals("short currency", "CAD 1.00", mf.format(CAD_1)); 3076 } 3077 3078 @Test testDisplayNames()3079 public void testDisplayNames() { 3080 Object[][] data = new Object[][] { 3081 // Unit, locale, width, expected result 3082 { MeasureUnit.YEAR, "en", FormatWidth.WIDE, "years" }, 3083 { MeasureUnit.YEAR, "ja", FormatWidth.WIDE, "年" }, 3084 { MeasureUnit.YEAR, "es", FormatWidth.WIDE, "años" }, 3085 { MeasureUnit.YEAR, "pt", FormatWidth.WIDE, "anos" }, 3086 { MeasureUnit.YEAR, "pt-PT", FormatWidth.WIDE, "anos" }, 3087 { MeasureUnit.AMPERE, "en", FormatWidth.WIDE, "amperes" }, 3088 { MeasureUnit.AMPERE, "ja", FormatWidth.WIDE, "アンペア" }, 3089 { MeasureUnit.AMPERE, "es", FormatWidth.WIDE, "amperios" }, 3090 { MeasureUnit.AMPERE, "pt", FormatWidth.WIDE, "amperes" }, 3091 { MeasureUnit.AMPERE, "pt-PT", FormatWidth.WIDE, "amperes" }, 3092 { MeasureUnit.METER_PER_SECOND_SQUARED, "pt", FormatWidth.WIDE, "metros por segundo ao quadrado" }, 3093 { MeasureUnit.METER_PER_SECOND_SQUARED, "pt-PT", FormatWidth.WIDE, "metros por segundo quadrado" }, 3094 { MeasureUnit.SQUARE_KILOMETER, "pt", FormatWidth.NARROW, "km²" }, 3095 { MeasureUnit.SQUARE_KILOMETER, "pt", FormatWidth.SHORT, "km²" }, 3096 { MeasureUnit.SQUARE_KILOMETER, "pt", FormatWidth.WIDE, "quilômetros quadrados" }, 3097 { MeasureUnit.SECOND, "pt-PT", FormatWidth.NARROW, "s" }, 3098 { MeasureUnit.SECOND, "pt-PT", FormatWidth.SHORT, "s" }, 3099 { MeasureUnit.SECOND, "pt-PT", FormatWidth.WIDE, "segundos" }, 3100 { MeasureUnit.SECOND, "pt", FormatWidth.NARROW, "s" }, 3101 { MeasureUnit.SECOND, "pt", FormatWidth.SHORT, "s" }, 3102 { MeasureUnit.SECOND, "pt", FormatWidth.WIDE, "segundos" }, 3103 }; 3104 3105 for (Object[] test : data) { 3106 MeasureUnit unit = (MeasureUnit) test[0]; 3107 ULocale locale = ULocale.forLanguageTag((String) test[1]); 3108 FormatWidth formatWidth = (FormatWidth) test[2]; 3109 String expected = (String) test[3]; 3110 3111 MeasureFormat mf = MeasureFormat.getInstance(locale, formatWidth); 3112 String actual = mf.getUnitDisplayName(unit); 3113 assertEquals(String.format("Unit Display Name for %s, %s, %s", unit, locale, formatWidth), 3114 expected, actual); 3115 } 3116 } 3117 3118 @Test testFieldPosition()3119 public void testFieldPosition() { 3120 MeasureFormat fmt = MeasureFormat.getInstance( 3121 ULocale.ENGLISH, FormatWidth.SHORT); 3122 FieldPosition pos = new FieldPosition(NumberFormat.Field.DECIMAL_SEPARATOR); 3123 fmt.format(new Measure(43.5, MeasureUnit.FOOT), new StringBuffer("123456: "), pos); 3124 assertEquals("beginIndex", 10, pos.getBeginIndex()); 3125 assertEquals("endIndex", 11, pos.getEndIndex()); 3126 3127 pos = new FieldPosition(NumberFormat.Field.DECIMAL_SEPARATOR); 3128 fmt.format(new Measure(43, MeasureUnit.FOOT), new StringBuffer(), pos); 3129 assertEquals("beginIndex", 0, pos.getBeginIndex()); 3130 assertEquals("endIndex", 0, pos.getEndIndex()); 3131 } 3132 3133 @Test testFieldPositionMultiple()3134 public void testFieldPositionMultiple() { 3135 MeasureFormat fmt = MeasureFormat.getInstance( 3136 ULocale.ENGLISH, FormatWidth.SHORT); 3137 FieldPosition pos = new FieldPosition(NumberFormat.Field.INTEGER); 3138 String result = fmt.formatMeasures( 3139 new StringBuilder(), 3140 pos, 3141 new Measure(354, MeasureUnit.METER), 3142 new Measure(23, MeasureUnit.CENTIMETER)).toString(); 3143 assertEquals("result", "354 m, 23 cm", result); 3144 3145 // According to javadocs for {@link Format#format} FieldPosition is set to 3146 // beginning and end of first such field encountered instead of the last 3147 // such field encountered. 3148 assertEquals("beginIndex", 0, pos.getBeginIndex()); 3149 assertEquals("endIndex", 3, pos.getEndIndex()); 3150 3151 pos = new FieldPosition(NumberFormat.Field.DECIMAL_SEPARATOR); 3152 result = fmt.formatMeasures( 3153 new StringBuilder("123456: "), 3154 pos, 3155 new Measure(354, MeasureUnit.METER), 3156 new Measure(23, MeasureUnit.CENTIMETER), 3157 new Measure(5.4, MeasureUnit.MILLIMETER)).toString(); 3158 assertEquals("result", "123456: 354 m, 23 cm, 5.4 mm", result); 3159 assertEquals("beginIndex", 23, pos.getBeginIndex()); 3160 assertEquals("endIndex", 24, pos.getEndIndex()); 3161 3162 result = fmt.formatMeasures( 3163 new StringBuilder(), 3164 pos, 3165 new Measure(3, MeasureUnit.METER), 3166 new Measure(23, MeasureUnit.CENTIMETER), 3167 new Measure(5.4, MeasureUnit.MILLIMETER)).toString(); 3168 assertEquals("result", "3 m, 23 cm, 5.4 mm", result); 3169 assertEquals("beginIndex", 13, pos.getBeginIndex()); 3170 assertEquals("endIndex", 14, pos.getEndIndex()); 3171 3172 pos = new FieldPosition(NumberFormat.Field.DECIMAL_SEPARATOR); 3173 result = fmt.formatMeasures( 3174 new StringBuilder("123456: "), 3175 pos, 3176 new Measure(3, MeasureUnit.METER), 3177 new Measure(23, MeasureUnit.CENTIMETER), 3178 new Measure(5, MeasureUnit.MILLIMETER)).toString(); 3179 assertEquals("result", "123456: 3 m, 23 cm, 5 mm", result); 3180 assertEquals("beginIndex", 0, pos.getBeginIndex()); 3181 assertEquals("endIndex", 0, pos.getEndIndex()); 3182 3183 pos = new FieldPosition(NumberFormat.Field.INTEGER); 3184 result = fmt.formatMeasures( 3185 new StringBuilder("123456: "), 3186 pos, 3187 new Measure(57, MeasureUnit.MILLIMETER)).toString(); 3188 assertEquals("result", "123456: 57 mm", result); 3189 assertEquals("beginIndex", 8, pos.getBeginIndex()); 3190 assertEquals("endIndex", 10, pos.getEndIndex()); 3191 3192 } 3193 3194 @Test testOldFormatWithList()3195 public void testOldFormatWithList() { 3196 List<Measure> measures = new ArrayList<>(2); 3197 measures.add(new Measure(5, MeasureUnit.ACRE)); 3198 measures.add(new Measure(3000, MeasureUnit.SQUARE_FOOT)); 3199 MeasureFormat fmt = MeasureFormat.getInstance( 3200 ULocale.ENGLISH, FormatWidth.WIDE); 3201 assertEquals("", "5 acres, 3,000 square feet", fmt.format(measures)); 3202 assertEquals("", "5 acres", fmt.format(measures.subList(0, 1))); 3203 List<String> badList = new ArrayList<>(); 3204 badList.add("be"); 3205 badList.add("you"); 3206 try { 3207 fmt.format(badList); 3208 fail("Expected IllegalArgumentException."); 3209 } catch (IllegalArgumentException expected) { 3210 // Expected 3211 } 3212 } 3213 3214 @Test testOldFormatWithArray()3215 public void testOldFormatWithArray() { 3216 Measure[] measures = new Measure[] { 3217 new Measure(5, MeasureUnit.ACRE), 3218 new Measure(3000, MeasureUnit.SQUARE_FOOT), 3219 }; 3220 MeasureFormat fmt = MeasureFormat.getInstance( 3221 ULocale.ENGLISH, FormatWidth.WIDE); 3222 assertEquals("", "5 acres, 3,000 square feet", fmt.format(measures)); 3223 } 3224 3225 @Test testOldFormatBadArg()3226 public void testOldFormatBadArg() { 3227 MeasureFormat fmt = MeasureFormat.getInstance( 3228 ULocale.ENGLISH, FormatWidth.WIDE); 3229 try { 3230 fmt.format("be"); 3231 fail("Expected IllegalArgumentExceptino."); 3232 } catch (IllegalArgumentException e) { 3233 // Expected 3234 } 3235 } 3236 3237 @Test testUnitPerUnitResolution()3238 public void testUnitPerUnitResolution() { 3239 // Ticket 11274 3240 MeasureFormat fmt = MeasureFormat.getInstance(Locale.ENGLISH, FormatWidth.SHORT); 3241 3242 // This fails unless we resolve to MeasureUnit.POUND_PER_SQUARE_INCH 3243 assertEquals("", "50 psi", 3244 fmt.formatMeasurePerUnit( 3245 new Measure(50, MeasureUnit.POUND_FORCE), 3246 MeasureUnit.SQUARE_INCH, 3247 new StringBuilder(), 3248 new FieldPosition(0)).toString()); 3249 } 3250 3251 @Test testEqHashCode()3252 public void testEqHashCode() { 3253 MeasureFormat mf = MeasureFormat.getInstance(ULocale.CANADA, FormatWidth.SHORT); 3254 MeasureFormat mfeq = MeasureFormat.getInstance(ULocale.CANADA, FormatWidth.SHORT); 3255 MeasureFormat mfne = MeasureFormat.getInstance(ULocale.CANADA, FormatWidth.WIDE); 3256 MeasureFormat mfne2 = MeasureFormat.getInstance(ULocale.ENGLISH, FormatWidth.SHORT); 3257 verifyEqualsHashCode(mf, mfeq, mfne); 3258 verifyEqualsHashCode(mf, mfeq, mfne2); 3259 } 3260 3261 @Test testEqHashCodeOfMeasure()3262 public void testEqHashCodeOfMeasure() { 3263 Measure _3feetDouble = new Measure(3.0, MeasureUnit.FOOT); 3264 Measure _3feetInt = new Measure(3, MeasureUnit.FOOT); 3265 Measure _4feetInt = new Measure(4, MeasureUnit.FOOT); 3266 verifyEqualsHashCode(_3feetDouble, _3feetInt, _4feetInt); 3267 } 3268 3269 @Test testGetLocale()3270 public void testGetLocale() { 3271 MeasureFormat mf = MeasureFormat.getInstance(ULocale.GERMAN, FormatWidth.SHORT); 3272 assertEquals("", ULocale.GERMAN, mf.getLocale(ULocale.VALID_LOCALE)); 3273 } 3274 3275 @Test TestSerial()3276 public void TestSerial() { 3277 checkStreamingEquality(MeasureUnit.CELSIUS); 3278 checkStreamingEquality(MeasureFormat.getInstance(ULocale.FRANCE, FormatWidth.NARROW)); 3279 checkStreamingEquality(Currency.getInstance("EUR")); 3280 checkStreamingEquality(MeasureFormat.getInstance(ULocale.GERMAN, FormatWidth.SHORT)); 3281 checkStreamingEquality(MeasureFormat.getCurrencyFormat(ULocale.ITALIAN)); 3282 } 3283 3284 @Test TestSerialFormatWidthEnum()3285 public void TestSerialFormatWidthEnum() { 3286 // FormatWidth enum values must map to the same ordinal values for all time in order for 3287 // serialization to work. 3288 assertEquals("FormatWidth.WIDE", 0, FormatWidth.WIDE.ordinal()); 3289 assertEquals("FormatWidth.SHORT", 1, FormatWidth.SHORT.ordinal()); 3290 assertEquals("FormatWidth.NARROW", 2, FormatWidth.NARROW.ordinal()); 3291 assertEquals("FormatWidth.NUMERIC", 3, FormatWidth.NUMERIC.ordinal()); 3292 } 3293 3294 @Test testCurrencyFormatStandInForMeasureFormat()3295 public void testCurrencyFormatStandInForMeasureFormat() { 3296 MeasureFormat mf = MeasureFormat.getCurrencyFormat(ULocale.ENGLISH); 3297 assertEquals( 3298 "70 feet, 5.3 inches", 3299 "70 feet, 5.3 inches", 3300 mf.formatMeasures( 3301 new Measure(70, MeasureUnit.FOOT), 3302 new Measure(5.3, MeasureUnit.INCH))); 3303 assertEquals("getLocale", ULocale.ENGLISH, mf.getLocale()); 3304 assertEquals("getNumberFormat", ULocale.ENGLISH, mf.getNumberFormat().getLocale(ULocale.VALID_LOCALE)); 3305 assertEquals("getWidth", MeasureFormat.FormatWidth.WIDE, mf.getWidth()); 3306 } 3307 3308 @Test testCurrencyFormatLocale()3309 public void testCurrencyFormatLocale() { 3310 MeasureFormat mfu = MeasureFormat.getCurrencyFormat(ULocale.FRANCE); 3311 MeasureFormat mfj = MeasureFormat.getCurrencyFormat(Locale.FRANCE); 3312 3313 assertEquals("getCurrencyFormat ULocale/Locale", mfu, mfj); 3314 } 3315 3316 @Test testCurrencyFormatParseIsoCode()3317 public void testCurrencyFormatParseIsoCode() throws ParseException { 3318 MeasureFormat mf = MeasureFormat.getCurrencyFormat(ULocale.ENGLISH); 3319 CurrencyAmount result = (CurrencyAmount) mf.parseObject("GTQ 34.56"); 3320 assertEquals("Parse should succeed", result.getNumber().doubleValue(), 34.56, 0.0); 3321 assertEquals("Should parse ISO code GTQ even though the currency is USD", 3322 "GTQ", result.getCurrency().getCurrencyCode()); 3323 } 3324 3325 @Test testDoubleZero()3326 public void testDoubleZero() { 3327 ULocale en = new ULocale("en"); 3328 NumberFormat nf = NumberFormat.getInstance(en); 3329 nf.setMinimumFractionDigits(2); 3330 nf.setMaximumFractionDigits(2); 3331 MeasureFormat mf = MeasureFormat.getInstance(en, FormatWidth.WIDE, nf); 3332 assertEquals( 3333 "Positive Rounding", 3334 "4 hours, 23 minutes, 16.00 seconds", 3335 mf.formatMeasures( 3336 new Measure(4.7, MeasureUnit.HOUR), 3337 new Measure(23, MeasureUnit.MINUTE), 3338 new Measure(16, MeasureUnit.SECOND))); 3339 assertEquals( 3340 "Negative Rounding", 3341 "-4 hours, 23 minutes, 16.00 seconds", 3342 mf.formatMeasures( 3343 new Measure(-4.7, MeasureUnit.HOUR), 3344 new Measure(23, MeasureUnit.MINUTE), 3345 new Measure(16, MeasureUnit.SECOND))); 3346 3347 } 3348 3349 @Test testIndividualPluralFallback()3350 public void testIndividualPluralFallback() { 3351 // See ticket #11986 "incomplete fallback in MeasureFormat". 3352 // In CLDR 28, fr_CA temperature-generic/short has only the "one" form, 3353 // and falls back to fr for the "other" form. 3354 MeasureFormat mf = MeasureFormat.getInstance(new ULocale("fr_CA"), FormatWidth.SHORT); 3355 Measure twoDeg = new Measure(2, MeasureUnit.GENERIC_TEMPERATURE); 3356 assertEquals("2 deg temp in fr_CA", "2°", mf.format(twoDeg)); 3357 } 3358 3359 @Test testPopulateCache()3360 public void testPopulateCache() { 3361 // Quick check that the lazily added additions to the MeasureUnit cache are present. 3362 assertTrue("MeasureUnit: unexpectedly few currencies defined", MeasureUnit.getAvailable("currency").size() > 50); 3363 } 3364 3365 @Test testParseObject()3366 public void testParseObject() { 3367 MeasureFormat mf = MeasureFormat.getInstance(Locale.GERMAN, FormatWidth.NARROW); 3368 try { 3369 mf.parseObject("3m", null); 3370 fail("MeasureFormat.parseObject(String, ParsePosition) " + 3371 "should throw an UnsupportedOperationException"); 3372 } catch (UnsupportedOperationException expected) { 3373 } 3374 } 3375 3376 @Test testCLDRUnitAvailability()3377 public void testCLDRUnitAvailability() { 3378 Set<MeasureUnit> knownUnits = new HashSet<>(); 3379 Class cMeasureUnit, cTimeUnit; 3380 try { 3381 cMeasureUnit = Class.forName("com.ibm.icu.util.MeasureUnit"); 3382 cTimeUnit = Class.forName("com.ibm.icu.util.TimeUnit"); 3383 } catch (ClassNotFoundException e) { 3384 fail("Count not load MeasureUnit or TimeUnit class: " + e.getMessage()); 3385 return; 3386 } 3387 for (Field field : cMeasureUnit.getFields()) { 3388 if (field.getGenericType() == cMeasureUnit || field.getGenericType() == cTimeUnit) { 3389 try { 3390 MeasureUnit unit = (MeasureUnit) field.get(cMeasureUnit); 3391 knownUnits.add(unit); 3392 } catch (IllegalArgumentException e) { 3393 fail(e.getMessage()); 3394 return; 3395 } catch (IllegalAccessException e) { 3396 fail(e.getMessage()); 3397 return; 3398 } 3399 } 3400 } 3401 for (String type : MeasureUnit.getAvailableTypes()) { 3402 if (type.equals("currency") 3403 || type.equals("compound") 3404 || type.equals("coordinate") 3405 || type.equals("none")) { 3406 continue; 3407 } 3408 for (MeasureUnit unit : MeasureUnit.getAvailable(type)) { 3409 if (!knownUnits.contains(unit)) { 3410 fail("Unit present in CLDR but not available via constant in MeasureUnit: " + unit); 3411 } 3412 } 3413 } 3414 } 3415 3416 @Test testBug11966()3417 public void testBug11966() { 3418 Locale locale = new Locale("en", "AU"); 3419 MeasureFormat.getInstance(locale, MeasureFormat.FormatWidth.WIDE); 3420 // Should not throw an exception. 3421 } 3422 3423 @Test test20332_PersonUnits()3424 public void test20332_PersonUnits() { 3425 Object[][] cases = new Object[][] { 3426 {ULocale.US, MeasureUnit.YEAR_PERSON, MeasureFormat.FormatWidth.NARROW, "25y"}, 3427 {ULocale.US, MeasureUnit.YEAR_PERSON, MeasureFormat.FormatWidth.SHORT, "25 yrs"}, 3428 {ULocale.US, MeasureUnit.YEAR_PERSON, MeasureFormat.FormatWidth.WIDE, "25 years"}, 3429 {ULocale.US, MeasureUnit.MONTH_PERSON, MeasureFormat.FormatWidth.NARROW, "25m"}, 3430 {ULocale.US, MeasureUnit.MONTH_PERSON, MeasureFormat.FormatWidth.SHORT, "25 mths"}, 3431 {ULocale.US, MeasureUnit.MONTH_PERSON, MeasureFormat.FormatWidth.WIDE, "25 months"}, 3432 {ULocale.US, MeasureUnit.WEEK_PERSON, MeasureFormat.FormatWidth.NARROW, "25w"}, 3433 {ULocale.US, MeasureUnit.WEEK_PERSON, MeasureFormat.FormatWidth.SHORT, "25 wks"}, 3434 {ULocale.US, MeasureUnit.WEEK_PERSON, MeasureFormat.FormatWidth.WIDE, "25 weeks"}, 3435 {ULocale.US, MeasureUnit.DAY_PERSON, MeasureFormat.FormatWidth.NARROW, "25d"}, 3436 {ULocale.US, MeasureUnit.DAY_PERSON, MeasureFormat.FormatWidth.SHORT, "25 days"}, 3437 {ULocale.US, MeasureUnit.DAY_PERSON, MeasureFormat.FormatWidth.WIDE, "25 days"} 3438 }; 3439 for (Object[] cas : cases) { 3440 ULocale locale = (ULocale) cas[0]; 3441 MeasureUnit unit = (MeasureUnit) cas[1]; 3442 MeasureFormat.FormatWidth width = (MeasureFormat.FormatWidth) cas[2]; 3443 String expected = (String) cas[3]; 3444 3445 MeasureFormat fmt = MeasureFormat.getInstance(locale, width); 3446 String result = fmt.formatMeasures(new Measure(25, unit)); 3447 assertEquals("" + locale + " " + unit + " " + width, expected, result); 3448 } 3449 } 3450 3451 // DO NOT DELETE THIS FUNCTION! It may appear as dead code, but we use this to generate code 3452 // for MeasureFormat during the release process. getUnitsToPerParts()3453 static Map<MeasureUnit, Pair<MeasureUnit, MeasureUnit>> getUnitsToPerParts() { 3454 TreeMap<String, List<MeasureUnit>> allUnits = getAllUnits(); 3455 Map<MeasureUnit, Pair<String, String>> unitsToPerStrings = 3456 new HashMap<>(); 3457 Map<String, MeasureUnit> namesToUnits = new HashMap<>(); 3458 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3459 String type = entry.getKey(); 3460 // Currency types are always atomic units, so we can skip these 3461 if (type.equals("currency")) { 3462 continue; 3463 } 3464 for (MeasureUnit unit : entry.getValue()) { 3465 String javaName = toJAVAName(unit); 3466 String[] nameParts = javaName.split("_PER_"); 3467 if (nameParts.length == 1) { 3468 namesToUnits.put(nameParts[0], unit); 3469 } else if (nameParts.length == 2) { 3470 unitsToPerStrings.put(unit, Pair.of(nameParts[0], nameParts[1])); 3471 } 3472 } 3473 } 3474 Map<MeasureUnit, Pair<MeasureUnit, MeasureUnit>> unitsToPerUnits = 3475 new HashMap<>(); 3476 for (Map.Entry<MeasureUnit, Pair<String, String>> entry : unitsToPerStrings.entrySet()) { 3477 Pair<String, String> perStrings = entry.getValue(); 3478 MeasureUnit unit = namesToUnits.get(perStrings.first); 3479 MeasureUnit perUnit = namesToUnits.get(perStrings.second); 3480 if (unit != null && perUnit != null) { 3481 unitsToPerUnits.put(entry.getKey(), Pair.of(unit, perUnit)); 3482 } 3483 } 3484 return unitsToPerUnits; 3485 } 3486 3487 // DO NOT DELETE THIS FUNCTION! It may appear as dead code, but we use this to generate code 3488 // for MeasureFormat during the release process. generateCXXHConstants(String thisVersion)3489 static void generateCXXHConstants(String thisVersion) { 3490 Map<String, MeasureUnit> seen = new HashMap<>(); 3491 System.out.println("// Start generated createXXX methods"); 3492 System.out.println(); 3493 TreeMap<String, List<MeasureUnit>> allUnits = getAllUnits(); 3494 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3495 String type = entry.getKey(); 3496 if (type.equals("currency")) { 3497 continue; 3498 } 3499 for (MeasureUnit unit : entry.getValue()) { 3500 String code = unit.getSubtype(); 3501 String name = toCamelCase(unit); 3502 String javaName = toJAVAName(unit); 3503 checkForDup(seen, name, unit); 3504 if (isDraft(javaName)) { 3505 System.out.println("#ifndef U_HIDE_DRAFT_API"); 3506 } 3507 System.out.println(" /**"); 3508 System.out.println(" * Returns by pointer, unit of " + type + ": " + code + "."); 3509 System.out.println(" * Caller owns returned value and must free it."); 3510 System.out.printf(" * Also see {@link #get%s()}.\n", name); 3511 System.out.println(" * @param status ICU error code."); 3512 if (isDraft(javaName)) { 3513 System.out.println(" * @draft ICU " + getVersion(javaName, thisVersion)); 3514 } else { 3515 System.out.println(" * @stable ICU " + getVersion(javaName, thisVersion)); 3516 } 3517 System.out.println(" */"); 3518 System.out.printf(" static MeasureUnit *create%s(UErrorCode &status);\n", name); 3519 System.out.println(); 3520 System.out.println(" /**"); 3521 System.out.println(" * Returns by value, unit of " + type + ": " + code + "."); 3522 System.out.printf(" * Also see {@link #create%s()}.\n", name); 3523 String getterVersion = getVersion(javaName, thisVersion); 3524 if (Integer.valueOf(getterVersion) < 64) { 3525 getterVersion = "64"; 3526 } 3527 if (isDraft(javaName)) { 3528 System.out.println(" * @draft ICU " + getterVersion); 3529 } else { 3530 System.out.println(" * @stable ICU " + getterVersion); 3531 } 3532 System.out.println(" */"); 3533 System.out.printf(" static MeasureUnit get%s();\n", name); 3534 if (isDraft(javaName)) { 3535 System.out.println("#endif /* U_HIDE_DRAFT_API */"); 3536 } 3537 System.out.println(""); 3538 } 3539 } 3540 System.out.println("// End generated createXXX methods"); 3541 } 3542 checkForDup( Map<String, MeasureUnit> seen, String name, MeasureUnit unit)3543 private static void checkForDup( 3544 Map<String, MeasureUnit> seen, String name, MeasureUnit unit) { 3545 if (seen.containsKey(name)) { 3546 throw new RuntimeException("\nCollision!!" + unit + ", " + seen.get(name)); 3547 } else { 3548 seen.put(name, unit); 3549 } 3550 } 3551 3552 // DO NOT DELETE THIS FUNCTION! It may appear as dead code, but we use this to generate code 3553 // for MeasureFormat during the release process. updateJAVAVersions(String thisVersion)3554 static void updateJAVAVersions(String thisVersion) { 3555 System.out.println(); 3556 Map<String, MeasureUnit> seen = new HashMap<>(); 3557 TreeMap<String, List<MeasureUnit>> allUnits = getAllUnits(); 3558 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3559 String type = entry.getKey(); 3560 if (type.equals("currency")) { 3561 continue; 3562 } 3563 for (MeasureUnit unit : entry.getValue()) { 3564 String javaName = toJAVAName(unit); 3565 checkForDup(seen, javaName, unit); 3566 if (!JAVA_VERSION_MAP.containsKey(javaName)) { 3567 System.out.printf(" {\"%s\", \"%s\"},\n", javaName, thisVersion); 3568 } 3569 } 3570 } 3571 } 3572 getAllUnits()3573 static TreeMap<String, List<MeasureUnit>> getAllUnits() { 3574 TreeMap<String, List<MeasureUnit>> allUnits = new TreeMap<>(); 3575 for (String type : MeasureUnit.getAvailableTypes()) { 3576 ArrayList<MeasureUnit> units = new ArrayList<>(MeasureUnit.getAvailable(type)); 3577 Collections.sort( 3578 units, 3579 new Comparator<MeasureUnit>() { 3580 3581 @Override 3582 public int compare(MeasureUnit o1, MeasureUnit o2) { 3583 return o1.getSubtype().compareTo(o2.getSubtype()); 3584 } 3585 3586 }); 3587 allUnits.put(type, units); 3588 } 3589 return allUnits; 3590 } 3591 3592 // DO NOT DELETE THIS FUNCTION! It may appear as dead code, but we use this to generate code 3593 // for MeasureFormat during the release process. generateCXXConstants()3594 static void generateCXXConstants() { 3595 System.out.println("// Start generated code for measunit.cpp"); 3596 System.out.println(""); 3597 TreeMap<String, List<MeasureUnit>> allUnits = getAllUnits(); 3598 3599 // Hack: for C++, add base unit here, but ignore them when printing the create methods. 3600 // Also keep track of the base unit offset to make the C++ default constructor faster. 3601 allUnits.put("none", Arrays.asList(new MeasureUnit[] {NoUnit.BASE})); 3602 int baseTypeIdx = -1; 3603 int baseSubTypeIdx = -1; 3604 3605 System.out.println("// Maps from Type ID to offset in gSubTypes."); 3606 System.out.println("static const int32_t gOffsets[] = {"); 3607 int index = 0; 3608 int typeCount = 0; 3609 int currencyIndex = -1; 3610 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3611 System.out.printf(" %d,\n", index); 3612 if (entry.getKey() == "currency") { 3613 currencyIndex = typeCount; 3614 } 3615 typeCount++; 3616 index += entry.getValue().size(); 3617 } 3618 assertTrue("currency present", currencyIndex >= 0); 3619 System.out.printf(" %d\n", index); 3620 System.out.println("};"); 3621 System.out.println(); 3622 System.out.println("static const int32_t kCurrencyOffset = " + currencyIndex + ";"); 3623 System.out.println(); 3624 System.out.println("// Must be sorted alphabetically."); 3625 System.out.println("static const char * const gTypes[] = {"); 3626 boolean first = true; 3627 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3628 if (!first) { 3629 System.out.println(","); 3630 } 3631 System.out.print(" \"" + entry.getKey() + "\""); 3632 first = false; 3633 } 3634 System.out.println(); 3635 System.out.println("};"); 3636 System.out.println(); 3637 System.out.println("// Must be grouped by type and sorted alphabetically within each type."); 3638 System.out.println("static const char * const gSubTypes[] = {"); 3639 first = true; 3640 int offset = 0; 3641 int typeIdx = 0; 3642 Map<MeasureUnit, Integer> measureUnitToOffset = new HashMap<>(); 3643 Map<MeasureUnit, Pair<Integer, Integer>> measureUnitToTypeSubType = 3644 new HashMap<>(); 3645 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3646 int subTypeIdx = 0; 3647 for (MeasureUnit unit : entry.getValue()) { 3648 if (!first) { 3649 System.out.println(","); 3650 } 3651 if (unit != null) { 3652 System.out.print(" \"" + unit.getSubtype() + "\""); 3653 } else { 3654 assertEquals("unit only null for \"none\" type", "none", entry.getKey()); 3655 System.out.print(" \"\""); 3656 } 3657 first = false; 3658 measureUnitToOffset.put(unit, offset); 3659 measureUnitToTypeSubType.put(unit, Pair.of(typeIdx, subTypeIdx)); 3660 if (unit == NoUnit.BASE) { 3661 baseTypeIdx = typeIdx; 3662 baseSubTypeIdx = subTypeIdx; 3663 } 3664 offset++; 3665 subTypeIdx++; 3666 } 3667 typeIdx++; 3668 } 3669 System.out.println(); 3670 System.out.println("};"); 3671 System.out.println(); 3672 3673 // Build unit per unit offsets to corresponding type sub types sorted by 3674 // unit first and then per unit. 3675 TreeMap<OrderedPair<Integer, Integer>, Pair<Integer, Integer>> unitPerUnitOffsetsToTypeSubType 3676 = new TreeMap<>(); 3677 for (Map.Entry<MeasureUnit, Pair<MeasureUnit, MeasureUnit>> entry 3678 : getUnitsToPerParts().entrySet()) { 3679 Pair<MeasureUnit, MeasureUnit> unitPerUnit = entry.getValue(); 3680 unitPerUnitOffsetsToTypeSubType.put( 3681 OrderedPair.of( 3682 measureUnitToOffset.get(unitPerUnit.first), 3683 measureUnitToOffset.get(unitPerUnit.second)), 3684 measureUnitToTypeSubType.get(entry.getKey())); 3685 } 3686 3687 // Print out the fast-path for the default constructor 3688 System.out.println("// Shortcuts to the base unit in order to make the default constructor fast"); 3689 System.out.println("static const int32_t kBaseTypeIdx = " + baseTypeIdx + ";"); 3690 System.out.println("static const int32_t kBaseSubTypeIdx = " + baseSubTypeIdx + ";"); 3691 System.out.println(); 3692 3693 Map<String, MeasureUnit> seen = new HashMap<>(); 3694 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3695 3696 String type = entry.getKey(); 3697 if (type.equals("currency") || type.equals("none")) { 3698 continue; 3699 } 3700 for (MeasureUnit unit : entry.getValue()) { 3701 String name = toCamelCase(unit); 3702 Pair<Integer, Integer> typeSubType = measureUnitToTypeSubType.get(unit); 3703 if (typeSubType == null) { 3704 throw new IllegalStateException(); 3705 } 3706 checkForDup(seen, name, unit); 3707 System.out.printf("MeasureUnit *MeasureUnit::create%s(UErrorCode &status) {\n", name); 3708 System.out.printf(" return MeasureUnit::create(%d, %d, status);\n", 3709 typeSubType.first, typeSubType.second); 3710 System.out.println("}"); 3711 System.out.println(); 3712 System.out.printf("MeasureUnit MeasureUnit::get%s() {\n", name); 3713 System.out.printf(" return MeasureUnit(%d, %d);\n", 3714 typeSubType.first, typeSubType.second); 3715 System.out.println("}"); 3716 System.out.println(); 3717 } 3718 } 3719 System.out.println("// End generated code for measunit.cpp"); 3720 } 3721 toCamelCase(MeasureUnit unit)3722 private static String toCamelCase(MeasureUnit unit) { 3723 StringBuilder result = new StringBuilder(); 3724 boolean caps = true; 3725 String code = unit.getSubtype(); 3726 3727 String replacement = CLDR_NAME_REMAP.get(code); 3728 if (replacement != null) { 3729 code = replacement; 3730 } 3731 3732 int len = code.length(); 3733 for (int i = 0; i < len; i++) { 3734 char ch = code.charAt(i); 3735 if (ch == '-') { 3736 caps = true; 3737 } else if (Character.isDigit(ch)) { 3738 caps = true; 3739 result.append(ch); 3740 } else if (caps) { 3741 result.append(Character.toUpperCase(ch)); 3742 caps = false; 3743 } else { 3744 result.append(ch); 3745 } 3746 } 3747 return result.toString(); 3748 } 3749 isTypeHidden(String type)3750 static boolean isTypeHidden(String type) { 3751 return "currency".equals(type); 3752 } 3753 3754 // DO NOT DELETE THIS FUNCTION! It may appear as dead code, but we use this to generate code 3755 // for MeasureFormat during the release process. generateBackwardCompatibilityTest(String version)3756 static void generateBackwardCompatibilityTest(String version) { 3757 Map<String, MeasureUnit> seen = new HashMap<>(); 3758 System.out.println(); 3759 System.out.printf(" public void TestCompatible%s() {\n", version.replace(".", "_")); 3760 System.out.println(" MeasureUnit[] units = {"); 3761 TreeMap<String, List<MeasureUnit>> allUnits = getAllUnits(); 3762 int count = 0; 3763 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3764 if (isTypeHidden(entry.getKey())) { 3765 continue; 3766 } 3767 for (MeasureUnit unit : entry.getValue()) { 3768 String javaName = toJAVAName(unit); 3769 checkForDup(seen, javaName, unit); 3770 System.out.printf(" MeasureUnit.%s,\n", javaName); 3771 count++; 3772 } 3773 } 3774 System.out.println(" };"); 3775 System.out.printf(" assertEquals(\"\", %d, units.length);\n", count); 3776 System.out.println(" }"); 3777 } 3778 3779 // DO NOT DELETE THIS FUNCTION! It may appear as dead code, but we use this to generate code 3780 // for MeasureFormat during the release process. generateCXXBackwardCompatibilityTest(String version)3781 static void generateCXXBackwardCompatibilityTest(String version) { 3782 System.out.println(); 3783 Map<String, MeasureUnit> seen = new HashMap<>(); 3784 System.out.printf("void MeasureFormatTest::TestCompatible%s() {\n", version.replace(".", "_")); 3785 System.out.println(" UErrorCode status = U_ZERO_ERROR;"); 3786 System.out.println(" LocalPointer<MeasureUnit> measureUnit;"); 3787 System.out.println(" MeasureUnit measureUnitValue;"); 3788 TreeMap<String, List<MeasureUnit>> allUnits = getAllUnits(); 3789 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3790 if (isTypeHidden(entry.getKey())) { 3791 continue; 3792 } 3793 for (MeasureUnit unit : entry.getValue()) { 3794 String camelCase = toCamelCase(unit); 3795 checkForDup(seen, camelCase, unit); 3796 System.out.printf(" measureUnit.adoptInstead(MeasureUnit::create%s(status));\n", camelCase); 3797 System.out.printf(" measureUnitValue = MeasureUnit::get%s();\n", camelCase); 3798 } 3799 } 3800 System.out.println(" assertSuccess(\"\", status);"); 3801 System.out.println("}"); 3802 } 3803 toJAVAName(MeasureUnit unit)3804 static String toJAVAName(MeasureUnit unit) { 3805 String code = unit.getSubtype(); 3806 String type = unit.getType(); 3807 3808 String replacement = CLDR_NAME_REMAP.get(code); 3809 if (replacement != null) { 3810 code = replacement; 3811 } 3812 3813 String name = code.toUpperCase(Locale.ENGLISH).replace("-", "_"); 3814 if (type.equals("angle")) { 3815 if (code.equals("minute") || code.equals("second")) { 3816 name = "ARC_" + name; 3817 } 3818 } 3819 return name; 3820 } 3821 3822 // DO NOT DELETE THIS FUNCTION! It may appear as dead code, but we use this to generate code 3823 // for MeasureFormat during the release process. generateConstants(String thisVersion)3824 static void generateConstants(String thisVersion) { 3825 System.out.println(" // Start generated MeasureUnit constants"); 3826 System.out.println(); 3827 Map<String, MeasureUnit> seen = new HashMap<>(); 3828 TreeMap<String, List<MeasureUnit>> allUnits = getAllUnits(); 3829 for (Map.Entry<String, List<MeasureUnit>> entry : allUnits.entrySet()) { 3830 String type = entry.getKey(); 3831 if (isTypeHidden(type)) { 3832 continue; 3833 } 3834 for (MeasureUnit unit : entry.getValue()) { 3835 String name = toJAVAName(unit); 3836 String code = unit.getSubtype(); 3837 checkForDup(seen, name, unit); 3838 System.out.println(" /**"); 3839 System.out.println(" * Constant for unit of " + type + 3840 ": " + 3841 code); 3842 // Special case JAVA had old constants for time from before. 3843 if ("duration".equals(type) && TIME_CODES.contains(code)) { 3844 System.out.println(" * @stable ICU 4.0"); 3845 } 3846 else if (isDraft(name)) { 3847 System.out.println(" * @draft ICU " + getVersion(name, thisVersion)); 3848 } else { 3849 System.out.println(" * @stable ICU " + getVersion(name, thisVersion)); 3850 } 3851 System.out.println(" */"); 3852 if ("duration".equals(type) && TIME_CODES.contains(code)) { 3853 System.out.println(" public static final TimeUnit " + name + " = (TimeUnit) MeasureUnit.internalGetInstance(\"" + 3854 type + 3855 "\", \"" + 3856 code + 3857 "\");"); 3858 } else { 3859 System.out.println(" public static final MeasureUnit " + name + " = MeasureUnit.internalGetInstance(\"" + 3860 type + 3861 "\", \"" + 3862 code + 3863 "\");"); 3864 } 3865 System.out.println(); 3866 } 3867 } 3868 System.out.println(" // End generated MeasureUnit constants"); 3869 } 3870 getVersion(String javaName, String thisVersion)3871 private static String getVersion(String javaName, String thisVersion) { 3872 String version = JAVA_VERSION_MAP.get(javaName); 3873 if (version == null) { 3874 return thisVersion; 3875 } 3876 return version; 3877 } 3878 isDraft(String javaName)3879 private static boolean isDraft(String javaName) { 3880 String version = JAVA_VERSION_MAP.get(javaName); 3881 if (version == null) { 3882 return true; 3883 } 3884 return DRAFT_VERSION_SET.contains(version); 3885 } 3886 checkStreamingEquality(T item)3887 public <T extends Serializable> void checkStreamingEquality(T item) { 3888 try { 3889 ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); 3890 ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteOut); 3891 objectOutputStream.writeObject(item); 3892 objectOutputStream.close(); 3893 byte[] contents = byteOut.toByteArray(); 3894 logln("bytes: " + contents.length + "; " + item.getClass() + ": " + showBytes(contents)); 3895 ByteArrayInputStream byteIn = new ByteArrayInputStream(contents); 3896 ObjectInputStream objectInputStream = new ObjectInputStream(byteIn); 3897 Object obj = objectInputStream.readObject(); 3898 assertEquals("Streamed Object equals ", item, obj); 3899 } catch (IOException e) { 3900 e.printStackTrace(); 3901 assertNull("Test Serialization " + item.getClass(), e); 3902 } catch (ClassNotFoundException e) { 3903 assertNull("Test Serialization " + item.getClass(), e); 3904 } 3905 } 3906 3907 /** 3908 * @param contents 3909 * @return 3910 */ showBytes(byte[] contents)3911 private String showBytes(byte[] contents) { 3912 StringBuilder b = new StringBuilder("["); 3913 for (int i = 0; i < contents.length; ++i) { 3914 int item = contents[i] & 0xFF; 3915 if (item >= 0x20 && item <= 0x7F) { 3916 b.append((char) item); 3917 } else { 3918 b.append('(').append(Utility.hex(item, 2)).append(')'); 3919 } 3920 } 3921 return b.append(']').toString(); 3922 } 3923 verifyEqualsHashCode(Object o, Object eq, Object ne)3924 private void verifyEqualsHashCode(Object o, Object eq, Object ne) { 3925 assertEquals("verifyEqualsHashCodeSame", o, o); 3926 assertEquals("verifyEqualsHashCodeEq", o, eq); 3927 assertNotEquals("verifyEqualsHashCodeNe", o, ne); 3928 assertNotEquals("verifyEqualsHashCodeEqTrans", eq, ne); 3929 assertEquals("verifyEqualsHashCodeHashEq", o.hashCode(), eq.hashCode()); 3930 3931 // May be a flaky test, but generally should be true. 3932 // May need to comment this out later. 3933 assertNotEquals("verifyEqualsHashCodeHashNe", o.hashCode(), ne.hashCode()); 3934 } 3935 3936 public static class MeasureUnitHandler implements SerializableTestUtility.Handler 3937 { 3938 @Override getTestObjects()3939 public Object[] getTestObjects() 3940 { 3941 MeasureUnit items[] = { 3942 MeasureUnit.CELSIUS, 3943 Currency.getInstance("EUR") 3944 }; 3945 return items; 3946 } 3947 @Override hasSameBehavior(Object a, Object b)3948 public boolean hasSameBehavior(Object a, Object b) 3949 { 3950 MeasureUnit a1 = (MeasureUnit) a; 3951 MeasureUnit b1 = (MeasureUnit) b; 3952 return a1.getType().equals(b1.getType()) 3953 && a1.getSubtype().equals(b1.getSubtype()); 3954 } 3955 } 3956 3957 public static class MeasureFormatHandler implements SerializableTestUtility.Handler 3958 { 3959 FormatHandler.NumberFormatHandler nfh = new FormatHandler.NumberFormatHandler(); 3960 3961 @Override getTestObjects()3962 public Object[] getTestObjects() 3963 { 3964 MeasureFormat items[] = { 3965 MeasureFormat.getInstance(ULocale.FRANCE, FormatWidth.SHORT), 3966 MeasureFormat.getInstance( 3967 ULocale.FRANCE, 3968 FormatWidth.WIDE, 3969 NumberFormat.getIntegerInstance(ULocale.CANADA_FRENCH)), 3970 }; 3971 return items; 3972 } 3973 @Override hasSameBehavior(Object a, Object b)3974 public boolean hasSameBehavior(Object a, Object b) 3975 { 3976 MeasureFormat a1 = (MeasureFormat) a; 3977 MeasureFormat b1 = (MeasureFormat) b; 3978 boolean getLocaleEqual = a1.getLocale().equals(b1.getLocale()); 3979 boolean getWidthEqual = a1.getWidth().equals(b1.getWidth()); 3980 boolean numFmtHasSameBehavior = nfh.hasSameBehavior(a1.getNumberFormat(), b1.getNumberFormat()); 3981 if (getLocaleEqual && getWidthEqual && numFmtHasSameBehavior) { 3982 return true; 3983 } 3984 System.out.println("MeasureFormatHandler.hasSameBehavior fails:"); 3985 if (!getLocaleEqual) { 3986 System.out.println("- getLocale equality fails: old a1: " + a1.getLocale().getName() + "; test b1: " + b1.getLocale().getName()); 3987 } 3988 if (!getWidthEqual) { 3989 System.out.println("- getWidth equality fails: old a1: " + a1.getWidth().name() + "; test b1: " + b1.getWidth().name()); 3990 } 3991 if (!numFmtHasSameBehavior) { 3992 System.out.println("- getNumberFormat hasSameBehavior fails"); 3993 } 3994 return false; 3995 } 3996 } 3997 3998 @Test TestNumericTimeNonLatin()3999 public void TestNumericTimeNonLatin() { 4000 ULocale ulocale = ULocale.forLanguageTag("bn"); 4001 MeasureFormat fmt = MeasureFormat.getInstance(ulocale, FormatWidth.NUMERIC); 4002 String actual = fmt.formatMeasures(new Measure(12, MeasureUnit.MINUTE), new Measure(39.12345, MeasureUnit.SECOND)); 4003 assertEquals("Incorrect digits", "১২:৩৯.১২৩", actual); 4004 } 4005 4006 @Test TestNumericTime()4007 public void TestNumericTime() { 4008 MeasureFormat fmt = MeasureFormat.getInstance(ULocale.forLanguageTag("en"), FormatWidth.NUMERIC); 4009 4010 Measure hours = new Measure(112, MeasureUnit.HOUR); 4011 Measure minutes = new Measure(113, MeasureUnit.MINUTE); 4012 Measure seconds = new Measure(114, MeasureUnit.SECOND); 4013 Measure fhours = new Measure(112.8765, MeasureUnit.HOUR); 4014 Measure fminutes = new Measure(113.8765, MeasureUnit.MINUTE); 4015 Measure fseconds = new Measure(114.8765, MeasureUnit.SECOND); 4016 4017 Assert.assertEquals("112h", fmt.formatMeasures(hours)); 4018 Assert.assertEquals("113m", fmt.formatMeasures(minutes)); 4019 Assert.assertEquals("114s", fmt.formatMeasures(seconds)); 4020 4021 Assert.assertEquals("112.876h", fmt.formatMeasures(fhours)); 4022 Assert.assertEquals("113.876m", fmt.formatMeasures(fminutes)); 4023 Assert.assertEquals("114.876s", fmt.formatMeasures(fseconds)); 4024 4025 Assert.assertEquals("112:113", fmt.formatMeasures(hours, minutes)); 4026 Assert.assertEquals("112:00:114", fmt.formatMeasures(hours, seconds)); 4027 Assert.assertEquals("113:114", fmt.formatMeasures(minutes, seconds)); 4028 4029 Assert.assertEquals("112:113.876", fmt.formatMeasures(hours, fminutes)); 4030 Assert.assertEquals("112:00:114.876", fmt.formatMeasures(hours, fseconds)); 4031 Assert.assertEquals("113:114.876", fmt.formatMeasures(minutes, fseconds)); 4032 4033 Assert.assertEquals("112:113", fmt.formatMeasures(fhours, minutes)); 4034 Assert.assertEquals("112:00:114", fmt.formatMeasures(fhours, seconds)); 4035 Assert.assertEquals("113:114", fmt.formatMeasures(fminutes, seconds)); 4036 4037 Assert.assertEquals("112:113.876", fmt.formatMeasures(fhours, fminutes)); 4038 Assert.assertEquals("112:00:114.876", fmt.formatMeasures(fhours, fseconds)); 4039 Assert.assertEquals("113:114.876", fmt.formatMeasures(fminutes, fseconds)); 4040 4041 Assert.assertEquals("112:113:114", fmt.formatMeasures(hours, minutes, seconds)); 4042 Assert.assertEquals("112:113:114.876", fmt.formatMeasures(fhours, fminutes, fseconds)); 4043 } 4044 4045 @Test TestNumericTimeSomeSpecialFormats()4046 public void TestNumericTimeSomeSpecialFormats() { 4047 Measure fhours = new Measure(2.8765432, MeasureUnit.HOUR); 4048 Measure fminutes = new Measure(3.8765432, MeasureUnit.MINUTE); 4049 4050 // Latvian is one of the very few locales 0-padding the hour 4051 MeasureFormat fmt = MeasureFormat.getInstance(ULocale.forLanguageTag("lt"), FormatWidth.NUMERIC); 4052 Assert.assertEquals("02:03,877", fmt.formatMeasures(fhours, fminutes)); 4053 4054 // Danish is one of the very few locales using '.' as separator 4055 fmt = MeasureFormat.getInstance(ULocale.forLanguageTag("da"), FormatWidth.NUMERIC); 4056 Assert.assertEquals("2.03,877", fmt.formatMeasures(fhours, fminutes)); 4057 } 4058 4059 @Test TestIdentifiers()4060 public void TestIdentifiers() { 4061 class TestCase { 4062 final String id; 4063 final String normalized; 4064 4065 TestCase(String id, String normalized) { 4066 this.id = id; 4067 this.normalized = normalized; 4068 } 4069 } 4070 4071 TestCase cases[] = { 4072 // Correctly normalized identifiers should not change 4073 new TestCase("square-meter-per-square-meter", "square-meter-per-square-meter"), 4074 new TestCase("kilogram-meter-per-square-meter-square-second", 4075 "kilogram-meter-per-square-meter-square-second"), 4076 new TestCase("square-mile-and-square-foot", "square-mile-and-square-foot"), 4077 new TestCase("square-foot-and-square-mile", "square-foot-and-square-mile"), 4078 new TestCase("per-cubic-centimeter", "per-cubic-centimeter"), 4079 new TestCase("per-kilometer", "per-kilometer"), 4080 4081 // Normalization of power and per 4082 new TestCase("pow2-foot-and-pow2-mile", "square-foot-and-square-mile"), 4083 new TestCase("gram-square-gram-per-dekagram", "cubic-gram-per-dekagram"), 4084 new TestCase("kilogram-per-meter-per-second", "kilogram-per-meter-second"), 4085 new TestCase("kilometer-per-second-per-megaparsec", "kilometer-per-megaparsec-second"), 4086 4087 // Correct order of units, as per unitQuantities in CLDR's units.xml 4088 new TestCase("newton-meter", "newton-meter"), 4089 new TestCase("meter-newton", "newton-meter"), 4090 new TestCase("pound-force-foot", "pound-force-foot"), 4091 new TestCase("foot-pound-force", "pound-force-foot"), 4092 new TestCase("kilowatt-hour", "kilowatt-hour"), 4093 new TestCase("hour-kilowatt", "kilowatt-hour"), 4094 4095 // Testing prefixes are parsed and produced correctly (ensures no 4096 // collisions in the enum values) 4097 new TestCase("yoctofoot", "yoctofoot"), 4098 new TestCase("zeptofoot", "zeptofoot"), 4099 new TestCase("attofoot", "attofoot"), 4100 new TestCase("femtofoot", "femtofoot"), 4101 new TestCase("picofoot", "picofoot"), 4102 new TestCase("nanofoot", "nanofoot"), 4103 new TestCase("microfoot", "microfoot"), 4104 new TestCase("millifoot", "millifoot"), 4105 new TestCase("centifoot", "centifoot"), 4106 new TestCase("decifoot", "decifoot"), 4107 new TestCase("foot", "foot"), 4108 new TestCase("dekafoot", "dekafoot"), 4109 new TestCase("hectofoot", "hectofoot"), 4110 new TestCase("kilofoot", "kilofoot"), 4111 new TestCase("megafoot", "megafoot"), 4112 new TestCase("gigafoot", "gigafoot"), 4113 new TestCase("terafoot", "terafoot"), 4114 new TestCase("petafoot", "petafoot"), 4115 new TestCase("exafoot", "exafoot"), 4116 new TestCase("zettafoot", "zettafoot"), 4117 new TestCase("yottafoot", "yottafoot"), 4118 new TestCase("kibibyte", "kibibyte"), 4119 new TestCase("mebibyte", "mebibyte"), 4120 new TestCase("gibibyte", "gibibyte"), 4121 new TestCase("tebibyte", "tebibyte"), 4122 new TestCase("pebibyte", "pebibyte"), 4123 new TestCase("exbibyte", "exbibyte"), 4124 new TestCase("zebibyte", "zebibyte"), 4125 new TestCase("yobibyte", "yobibyte"), 4126 4127 // Testing aliases 4128 new TestCase("foodcalorie", "foodcalorie"), 4129 new TestCase("dot-per-centimeter", "dot-per-centimeter"), 4130 new TestCase("dot-per-inch", "dot-per-inch"), 4131 new TestCase("dot", "dot"), 4132 4133 // Testing sort order of prefixes. 4134 new TestCase("megafoot-mebifoot-kibifoot-kilofoot", "mebifoot-megafoot-kibifoot-kilofoot"), 4135 new TestCase("per-megafoot-mebifoot-kibifoot-kilofoot", "per-mebifoot-megafoot-kibifoot-kilofoot"), 4136 new TestCase("megafoot-mebifoot-kibifoot-kilofoot-per-megafoot-mebifoot-kibifoot-kilofoot", "mebifoot-megafoot-kibifoot-kilofoot-per-mebifoot-megafoot-kibifoot-kilofoot"), 4137 new TestCase("microfoot-millifoot-megafoot-mebifoot-kibifoot-kilofoot", "mebifoot-megafoot-kibifoot-kilofoot-millifoot-microfoot"), 4138 new TestCase("per-microfoot-millifoot-megafoot-mebifoot-kibifoot-kilofoot", "per-mebifoot-megafoot-kibifoot-kilofoot-millifoot-microfoot"), 4139 }; 4140 4141 for (TestCase testCase : cases) { 4142 MeasureUnit unit = MeasureUnit.forIdentifier(testCase.id); 4143 4144 final String actual = unit.getIdentifier(); 4145 assertEquals(testCase.id, testCase.normalized, actual); 4146 } 4147 4148 assertEquals("for empty identifiers, the MeasureUnit will be null", 4149 null, MeasureUnit.forIdentifier("")); 4150 } 4151 4152 @Test TestInvalidIdentifiers()4153 public void TestInvalidIdentifiers() { 4154 final String inputs[] = { 4155 "kilo", 4156 "kilokilo", 4157 "onekilo", 4158 "meterkilo", 4159 "meter-kilo", 4160 "k", 4161 "meter-", 4162 "meter+", 4163 "-meter", 4164 "+meter", 4165 "-kilometer", 4166 "+kilometer", 4167 "-pow2-meter", 4168 "+pow2-meter", 4169 "p2-meter", 4170 "p4-meter", 4171 "+", 4172 "-", 4173 "-mile", 4174 "-and-mile", 4175 "-per-mile", 4176 "one", 4177 "one-one", 4178 "one-per-mile", 4179 "one-per-cubic-centimeter", 4180 "square--per-meter", 4181 "metersecond", // Must have compound part in between single units 4182 4183 // Negative powers not supported in mixed units yet. TODO(CLDR-13701). 4184 "per-hour-and-hertz", 4185 "hertz-and-per-hour", 4186 4187 // Compound units not supported in mixed units yet. TODO(CLDR-13701). 4188 "kilonewton-meter-and-newton-meter", 4189 }; 4190 4191 for (String input : inputs) { 4192 try { 4193 MeasureUnit.forIdentifier(input); 4194 Assert.fail("An IllegalArgumentException must be thrown"); 4195 } catch (IllegalArgumentException e) { 4196 continue; 4197 } 4198 } 4199 } 4200 4201 @Test TestIdentifierDetails()4202 public void TestIdentifierDetails() { 4203 MeasureUnit joule = MeasureUnit.forIdentifier("joule"); 4204 assertEquals("Initial joule", "joule", joule.getIdentifier()); 4205 4206 // "Invalid prefix" test not needed: in Java we cannot pass a 4207 // non-existent enum instance. (In C++ an int can be typecast.) 4208 4209 MeasureUnit unit = joule.withPrefix(MeasureUnit.MeasurePrefix.HECTO); 4210 assertEquals("Joule with hecto prefix", "hectojoule", unit.getIdentifier()); 4211 4212 unit = unit.withPrefix(MeasureUnit.MeasurePrefix.EXBI); 4213 assertEquals("Joule with exbi prefix", "exbijoule", unit.getIdentifier()); 4214 } 4215 4216 @Test TestPrefixes()4217 public void TestPrefixes() { 4218 class TestCase { 4219 final MeasureUnit.MeasurePrefix prefix; 4220 final int expectedBase; 4221 final int expectedPower; 4222 4223 TestCase(MeasureUnit.MeasurePrefix prefix, int expectedBase, int expectedPower) { 4224 this.prefix = prefix; 4225 this.expectedBase = expectedBase; 4226 this.expectedPower = expectedPower; 4227 } 4228 } 4229 4230 TestCase cases[] = { 4231 new TestCase(MeasureUnit.MeasurePrefix.YOCTO, 10, -24), 4232 new TestCase(MeasureUnit.MeasurePrefix.ZEPTO, 10, -21), 4233 new TestCase(MeasureUnit.MeasurePrefix.ATTO, 10, -18), 4234 new TestCase(MeasureUnit.MeasurePrefix.FEMTO, 10, -15), 4235 new TestCase(MeasureUnit.MeasurePrefix.PICO, 10, -12), 4236 new TestCase(MeasureUnit.MeasurePrefix.NANO, 10, -9), 4237 new TestCase(MeasureUnit.MeasurePrefix.MICRO, 10, -6), 4238 new TestCase(MeasureUnit.MeasurePrefix.MILLI, 10, -3), 4239 new TestCase(MeasureUnit.MeasurePrefix.CENTI, 10, -2), 4240 new TestCase(MeasureUnit.MeasurePrefix.DECI, 10, -1), 4241 new TestCase(MeasureUnit.MeasurePrefix.ONE, 10, 0), 4242 new TestCase(MeasureUnit.MeasurePrefix.DEKA, 10, 1), 4243 new TestCase(MeasureUnit.MeasurePrefix.HECTO, 10, 2), 4244 new TestCase(MeasureUnit.MeasurePrefix.KILO, 10, 3), 4245 new TestCase(MeasureUnit.MeasurePrefix.MEGA, 10, 6), 4246 new TestCase(MeasureUnit.MeasurePrefix.GIGA, 10, 9), 4247 new TestCase(MeasureUnit.MeasurePrefix.TERA, 10, 12), 4248 new TestCase(MeasureUnit.MeasurePrefix.PETA, 10, 15), 4249 new TestCase(MeasureUnit.MeasurePrefix.EXA, 10, 18), 4250 new TestCase(MeasureUnit.MeasurePrefix.ZETTA, 10, 21), 4251 new TestCase(MeasureUnit.MeasurePrefix.YOTTA, 10, 24), 4252 new TestCase(MeasureUnit.MeasurePrefix.KIBI, 1024, 1), 4253 new TestCase(MeasureUnit.MeasurePrefix.MEBI, 1024, 2), 4254 new TestCase(MeasureUnit.MeasurePrefix.GIBI, 1024, 3), 4255 new TestCase(MeasureUnit.MeasurePrefix.TEBI, 1024, 4), 4256 new TestCase(MeasureUnit.MeasurePrefix.PEBI, 1024, 5), 4257 new TestCase(MeasureUnit.MeasurePrefix.EXBI, 1024, 6), 4258 new TestCase(MeasureUnit.MeasurePrefix.ZEBI, 1024, 7), 4259 new TestCase(MeasureUnit.MeasurePrefix.YOBI, 1024, 8), 4260 }; 4261 4262 for (TestCase testCase : cases) { 4263 MeasureUnit m = MeasureUnit.AMPERE.withPrefix(testCase.prefix); 4264 assertEquals("getPrefixPower()", testCase.expectedPower, m.getPrefix().getPower()); 4265 assertEquals("getPrefixBase()", testCase.expectedBase, m.getPrefix().getBase()); 4266 } 4267 } 4268 4269 @Test TestParseBuiltIns()4270 public void TestParseBuiltIns() { 4271 for (MeasureUnit unit : MeasureUnit.getAvailable()) { 4272 System.out.println("unit ident: " + unit.getIdentifier() + ", type: " + unit.getType()); 4273 if (unit.getType() == "currency") { 4274 continue; 4275 } 4276 4277 // Prove that all built-in units are parseable, except "generic" temperature: 4278 if (unit == MeasureUnit.GENERIC_TEMPERATURE) { 4279 try { 4280 MeasureUnit.forIdentifier(unit.getIdentifier()); 4281 Assert.fail("GENERIC_TEMPERATURE should not be parseable"); 4282 } catch (IllegalArgumentException e) { 4283 continue; 4284 } 4285 } else { 4286 MeasureUnit parsed = MeasureUnit.forIdentifier(unit.getIdentifier()); 4287 assertTrue("parsed MeasureUnit '" + parsed + "'' should equal built-in '" + unit + "'", 4288 unit.equals(parsed)); 4289 } 4290 } 4291 } 4292 4293 @Test TestParseToBuiltIn()4294 public void TestParseToBuiltIn() { 4295 class TestCase { 4296 final String identifier; 4297 MeasureUnit expectedBuiltin; 4298 4299 TestCase(String identifier, MeasureUnit expectedBuiltin) { 4300 this.identifier = identifier; 4301 this.expectedBuiltin = expectedBuiltin; 4302 } 4303 } 4304 4305 TestCase cases[] = { 4306 new TestCase("meter-per-second-per-second", MeasureUnit.METER_PER_SECOND_SQUARED), 4307 new TestCase("meter-per-second-second", MeasureUnit.METER_PER_SECOND_SQUARED), 4308 new TestCase("centimeter-centimeter", MeasureUnit.SQUARE_CENTIMETER), 4309 new TestCase("square-foot", MeasureUnit.SQUARE_FOOT), 4310 new TestCase("pow2-inch", MeasureUnit.SQUARE_INCH), 4311 new TestCase("milligram-per-deciliter", MeasureUnit.MILLIGRAM_PER_DECILITER), 4312 new TestCase("pound-force-per-pow2-inch", MeasureUnit.POUND_PER_SQUARE_INCH), 4313 new TestCase("yard-pow2-yard", MeasureUnit.CUBIC_YARD), 4314 new TestCase("square-yard-yard", MeasureUnit.CUBIC_YARD), 4315 }; 4316 4317 for (TestCase testCase : cases) { 4318 MeasureUnit m = MeasureUnit.forIdentifier(testCase.identifier); 4319 assertTrue(testCase.identifier + " parsed to builtin", m.equals(testCase.expectedBuiltin)); 4320 } 4321 } 4322 4323 @Test TestCompoundUnitOperations()4324 public void TestCompoundUnitOperations() { 4325 MeasureUnit.forIdentifier("kilometer-per-second-joule"); 4326 4327 MeasureUnit kilometer = MeasureUnit.KILOMETER; 4328 MeasureUnit cubicMeter = MeasureUnit.CUBIC_METER; 4329 MeasureUnit meter = kilometer.withPrefix(MeasureUnit.MeasurePrefix.ONE); 4330 MeasureUnit centimeter1 = kilometer.withPrefix(MeasureUnit.MeasurePrefix.CENTI); 4331 MeasureUnit centimeter2 = meter.withPrefix(MeasureUnit.MeasurePrefix.CENTI); 4332 MeasureUnit cubicDecimeter = cubicMeter.withPrefix(MeasureUnit.MeasurePrefix.DECI); 4333 4334 verifySingleUnit(kilometer, MeasureUnit.MeasurePrefix.KILO, 1, "kilometer"); 4335 verifySingleUnit(meter, MeasureUnit.MeasurePrefix.ONE, 1, "meter"); 4336 verifySingleUnit(centimeter1, MeasureUnit.MeasurePrefix.CENTI, 1, "centimeter"); 4337 verifySingleUnit(centimeter2, MeasureUnit.MeasurePrefix.CENTI, 1, "centimeter"); 4338 verifySingleUnit(cubicDecimeter, MeasureUnit.MeasurePrefix.DECI, 3, "cubic-decimeter"); 4339 4340 assertTrue("centimeter equality", centimeter1.equals( centimeter2)); 4341 assertTrue("kilometer inequality", !centimeter1.equals( kilometer)); 4342 4343 MeasureUnit squareMeter = meter.withDimensionality(2); 4344 MeasureUnit overCubicCentimeter = centimeter1.withDimensionality(-3); 4345 MeasureUnit quarticKilometer = kilometer.withDimensionality(4); 4346 MeasureUnit overQuarticKilometer1 = kilometer.withDimensionality(-4); 4347 4348 verifySingleUnit(squareMeter, MeasureUnit.MeasurePrefix.ONE, 2, "square-meter"); 4349 verifySingleUnit(overCubicCentimeter, MeasureUnit.MeasurePrefix.CENTI, -3, "per-cubic-centimeter"); 4350 verifySingleUnit(quarticKilometer, MeasureUnit.MeasurePrefix.KILO, 4, "pow4-kilometer"); 4351 verifySingleUnit(overQuarticKilometer1, MeasureUnit.MeasurePrefix.KILO, -4, "per-pow4-kilometer"); 4352 4353 assertTrue("power inequality", quarticKilometer != overQuarticKilometer1); 4354 4355 MeasureUnit overQuarticKilometer2 = quarticKilometer.reciprocal(); 4356 MeasureUnit overQuarticKilometer3 = kilometer.product(kilometer) 4357 .product(kilometer) 4358 .product(kilometer) 4359 .reciprocal(); 4360 MeasureUnit overQuarticKilometer4 = meter.withDimensionality(4) 4361 .reciprocal() 4362 .withPrefix(MeasureUnit.MeasurePrefix.KILO); 4363 4364 verifySingleUnit(overQuarticKilometer2, MeasureUnit.MeasurePrefix.KILO, -4, "per-pow4-kilometer"); 4365 verifySingleUnit(overQuarticKilometer3, MeasureUnit.MeasurePrefix.KILO, -4, "per-pow4-kilometer"); 4366 verifySingleUnit(overQuarticKilometer4, MeasureUnit.MeasurePrefix.KILO, -4, "per-pow4-kilometer"); 4367 4368 assertTrue("reciprocal equality", overQuarticKilometer1.equals(overQuarticKilometer2)); 4369 assertTrue("reciprocal equality", overQuarticKilometer1.equals(overQuarticKilometer3)); 4370 assertTrue("reciprocal equality", overQuarticKilometer1.equals(overQuarticKilometer4)); 4371 4372 MeasureUnit kiloSquareSecond = MeasureUnit.SECOND 4373 .withDimensionality(2).withPrefix(MeasureUnit.MeasurePrefix.KILO); 4374 MeasureUnit meterSecond = meter.product(kiloSquareSecond); 4375 MeasureUnit cubicMeterSecond1 = meter.withDimensionality(3).product(kiloSquareSecond); 4376 MeasureUnit centimeterSecond1 = meter.withPrefix(MeasureUnit.MeasurePrefix.CENTI).product(kiloSquareSecond); 4377 MeasureUnit secondCubicMeter = kiloSquareSecond.product(meter.withDimensionality(3)); 4378 MeasureUnit secondCentimeter = kiloSquareSecond.product(meter.withPrefix(MeasureUnit.MeasurePrefix.CENTI)); 4379 MeasureUnit secondCentimeterPerKilometer = secondCentimeter.product(kilometer.reciprocal()); 4380 4381 verifySingleUnit(kiloSquareSecond, MeasureUnit.MeasurePrefix.KILO, 2, "square-kilosecond"); 4382 String meterSecondSub[] = { 4383 "meter", "square-kilosecond" 4384 }; 4385 verifyCompoundUnit(meterSecond, "meter-square-kilosecond", 4386 meterSecondSub, meterSecondSub.length); 4387 String cubicMeterSecond1Sub[] = { 4388 "cubic-meter", "square-kilosecond" 4389 }; 4390 verifyCompoundUnit(cubicMeterSecond1, "cubic-meter-square-kilosecond", 4391 cubicMeterSecond1Sub, cubicMeterSecond1Sub.length); 4392 String centimeterSecond1Sub[] = { 4393 "centimeter", "square-kilosecond" 4394 }; 4395 verifyCompoundUnit(centimeterSecond1, "centimeter-square-kilosecond", 4396 centimeterSecond1Sub, centimeterSecond1Sub.length); 4397 String secondCubicMeterSub[] = { 4398 "cubic-meter", "square-kilosecond" 4399 }; 4400 verifyCompoundUnit(secondCubicMeter, "cubic-meter-square-kilosecond", 4401 secondCubicMeterSub, secondCubicMeterSub.length); 4402 String secondCentimeterSub[] = { 4403 "centimeter", "square-kilosecond" 4404 }; 4405 verifyCompoundUnit(secondCentimeter, "centimeter-square-kilosecond", 4406 secondCentimeterSub, secondCentimeterSub.length); 4407 String secondCentimeterPerKilometerSub[] = { 4408 "centimeter", "square-kilosecond", "per-kilometer" 4409 }; 4410 verifyCompoundUnit(secondCentimeterPerKilometer, "centimeter-square-kilosecond-per-kilometer", 4411 secondCentimeterPerKilometerSub, secondCentimeterPerKilometerSub.length); 4412 4413 assertTrue("reordering equality", cubicMeterSecond1.equals(secondCubicMeter)); 4414 assertTrue("additional simple units inequality", !secondCubicMeter.equals(secondCentimeter)); 4415 4416 // Don't allow get/set power or SI or binary prefix on compound units 4417 try { 4418 meterSecond.getDimensionality(); 4419 fail("UnsupportedOperationException must be thrown"); 4420 } catch (UnsupportedOperationException e) { 4421 // Expecting an exception to be thrown 4422 } 4423 4424 try { 4425 meterSecond.withDimensionality(3); 4426 fail("UnsupportedOperationException must be thrown"); 4427 } catch (UnsupportedOperationException e) { 4428 // Expecting an exception to be thrown 4429 } 4430 4431 try { 4432 meterSecond.getPrefix(); 4433 fail("UnsupportedOperationException must be thrown"); 4434 } catch (UnsupportedOperationException e) { 4435 // Expecting an exception to be thrown 4436 } 4437 4438 try { 4439 meterSecond.withPrefix(MeasureUnit.MeasurePrefix.CENTI); 4440 fail("UnsupportedOperationException must be thrown"); 4441 } catch (UnsupportedOperationException e) { 4442 // Expecting an exception to be thrown 4443 } 4444 4445 MeasureUnit footInch = MeasureUnit.forIdentifier("foot-and-inch"); 4446 MeasureUnit inchFoot = MeasureUnit.forIdentifier("inch-and-foot"); 4447 4448 String footInchSub[] = { 4449 "foot", "inch" 4450 }; 4451 verifyMixedUnit(footInch, "foot-and-inch", 4452 footInchSub, footInchSub.length); 4453 String inchFootSub[] = { 4454 "inch", "foot" 4455 }; 4456 verifyMixedUnit(inchFoot, "inch-and-foot", 4457 inchFootSub, inchFootSub.length); 4458 4459 assertTrue("order matters inequality", !footInch.equals(inchFoot)); 4460 4461 4462 MeasureUnit dimensionless = NoUnit.BASE; 4463 MeasureUnit dimensionless2 = MeasureUnit.forIdentifier(""); 4464 assertEquals("dimensionless equality", dimensionless, dimensionless2); 4465 4466 // We support starting from an "identity" MeasureUnit and then combining it 4467 // with others via product: 4468 MeasureUnit kilometer2 = kilometer.product(dimensionless); 4469 4470 verifySingleUnit(kilometer2, MeasureUnit.MeasurePrefix.KILO, 1, "kilometer"); 4471 assertTrue("kilometer equality", kilometer.equals(kilometer2)); 4472 4473 // Test out-of-range powers 4474 MeasureUnit power15 = MeasureUnit.forIdentifier("pow15-kilometer"); 4475 verifySingleUnit(power15, MeasureUnit.MeasurePrefix.KILO, 15, "pow15-kilometer"); 4476 4477 try { 4478 MeasureUnit.forIdentifier("pow16-kilometer"); 4479 fail("An IllegalArgumentException must be thrown"); 4480 } catch (IllegalArgumentException e) { 4481 // Expecting an exception to be thrown 4482 } 4483 4484 try { 4485 power15.product(kilometer); 4486 fail("An IllegalArgumentException must be thrown"); 4487 } catch (IllegalArgumentException e) { 4488 // Expecting an exception to be thrown 4489 } 4490 4491 MeasureUnit powerN15 = MeasureUnit.forIdentifier("per-pow15-kilometer"); 4492 verifySingleUnit(powerN15, MeasureUnit.MeasurePrefix.KILO, -15, "per-pow15-kilometer"); 4493 4494 try { 4495 MeasureUnit.forIdentifier("per-pow16-kilometer"); 4496 fail("An IllegalArgumentException must be thrown"); 4497 } catch (IllegalArgumentException e) { 4498 // Expecting an exception to be thrown 4499 } 4500 4501 try { 4502 powerN15.product(overQuarticKilometer1); 4503 fail("An IllegalArgumentException must be thrown"); 4504 } catch (IllegalArgumentException e) { 4505 // Expecting an exception to be thrown 4506 } 4507 } 4508 4509 @Test TestDimensionlessBehaviour()4510 public void TestDimensionlessBehaviour() { 4511 MeasureUnit dimensionless = MeasureUnit.forIdentifier(""); 4512 MeasureUnit dimensionless2 = NoUnit.BASE; 4513 MeasureUnit dimensionless3 = null; 4514 MeasureUnit dimensionless4 = MeasureUnit.forIdentifier(null); 4515 4516 assertEquals("dimensionless must be equals", dimensionless, dimensionless2); 4517 assertEquals("dimensionless must be equals", dimensionless2, dimensionless3); 4518 assertEquals("dimensionless must be equals", dimensionless3, dimensionless4); 4519 4520 // product(dimensionless) 4521 MeasureUnit mile = MeasureUnit.MILE; 4522 mile = mile.product(dimensionless); 4523 verifySingleUnit(mile, MeasureUnit.MeasurePrefix.ONE, 1, "mile"); 4524 } 4525 verifySingleUnit(MeasureUnit singleMeasureUnit, MeasureUnit.MeasurePrefix prefix, int power, String identifier)4526 private void verifySingleUnit(MeasureUnit singleMeasureUnit, MeasureUnit.MeasurePrefix prefix, int power, String identifier) { 4527 assertEquals(identifier + ": SI or binary prefix", prefix, singleMeasureUnit.getPrefix()); 4528 4529 assertEquals(identifier + ": Power", power, singleMeasureUnit.getDimensionality()); 4530 4531 assertEquals(identifier + ": Identifier", identifier, singleMeasureUnit.getIdentifier()); 4532 4533 assertTrue(identifier + ": Constructor", singleMeasureUnit.equals(MeasureUnit.forIdentifier(identifier))); 4534 4535 assertEquals(identifier + ": Complexity", MeasureUnit.Complexity.SINGLE, singleMeasureUnit.getComplexity()); 4536 } 4537 4538 4539 // Kilogram is a "base unit", although it's also "gram" with a kilo- prefix. 4540 // This tests that it is handled in the preferred manner. 4541 @Test TestKilogramIdentifier()4542 public void TestKilogramIdentifier() { 4543 // SI unit of mass 4544 MeasureUnit kilogram = MeasureUnit.forIdentifier("kilogram"); 4545 // Metric mass unit 4546 MeasureUnit gram = MeasureUnit.forIdentifier("gram"); 4547 // Microgram: still a built-in type 4548 MeasureUnit microgram = MeasureUnit.forIdentifier("microgram"); 4549 // Nanogram: not a built-in type at this time 4550 MeasureUnit nanogram = MeasureUnit.forIdentifier("nanogram"); 4551 4552 assertEquals("parsed kilogram equals built-in kilogram", MeasureUnit.KILOGRAM.getType(), 4553 kilogram.getType()); 4554 assertEquals("parsed kilogram equals built-in kilogram", MeasureUnit.KILOGRAM.getSubtype(), 4555 kilogram.getSubtype()); 4556 assertEquals("parsed gram equals built-in gram", MeasureUnit.GRAM.getType(), gram.getType()); 4557 assertEquals("parsed gram equals built-in gram", MeasureUnit.GRAM.getSubtype(), 4558 gram.getSubtype()); 4559 assertEquals("parsed microgram equals built-in microgram", MeasureUnit.MICROGRAM.getType(), 4560 microgram.getType()); 4561 assertEquals("parsed microgram equals built-in microgram", MeasureUnit.MICROGRAM.getSubtype(), 4562 microgram.getSubtype()); 4563 assertEquals("nanogram", null, nanogram.getType()); 4564 assertEquals("nanogram", "nanogram", nanogram.getIdentifier()); 4565 4566 assertEquals("prefix of kilogram", MeasureUnit.MeasurePrefix.KILO, kilogram.getPrefix()); 4567 assertEquals("prefix of gram", MeasureUnit.MeasurePrefix.ONE, gram.getPrefix()); 4568 assertEquals("prefix of microgram", MeasureUnit.MeasurePrefix.MICRO, microgram.getPrefix()); 4569 assertEquals("prefix of nanogram", MeasureUnit.MeasurePrefix.NANO, nanogram.getPrefix()); 4570 4571 MeasureUnit tmp = kilogram.withPrefix(MeasureUnit.MeasurePrefix.MILLI); 4572 assertEquals("Kilogram + milli should be milligram, got: " + tmp.getIdentifier(), 4573 MeasureUnit.MILLIGRAM.getIdentifier(), tmp.getIdentifier()); 4574 } 4575 4576 @Test TestInternalMeasureUnitImpl()4577 public void TestInternalMeasureUnitImpl() { 4578 MeasureUnitImpl mu1 = MeasureUnitImpl.forIdentifier("meter"); 4579 assertEquals("mu1 initial identifier", null, mu1.getIdentifier()); 4580 assertEquals("mu1 initial complexity", MeasureUnit.Complexity.SINGLE, mu1.getComplexity()); 4581 assertEquals("mu1 initial units length", 1, mu1.getSingleUnits().size()); 4582 assertEquals("mu1 initial units[0]", "meter", mu1.getSingleUnits().get(0).getSimpleUnitID()); 4583 4584 // Producing identifier via build(): the MeasureUnitImpl instance gets modified 4585 // while it also gets assigned to tmp's internal measureUnitImpl. 4586 MeasureUnit tmp = mu1.build(); 4587 assertEquals("mu1 post-build identifier", "meter", mu1.getIdentifier()); 4588 assertEquals("mu1 post-build complexity", MeasureUnit.Complexity.SINGLE, mu1.getComplexity()); 4589 assertEquals("mu1 post-build units length", 1, mu1.getSingleUnits().size()); 4590 assertEquals("mu1 post-build units[0]", "meter", mu1.getSingleUnits().get(0).getSimpleUnitID()); 4591 assertEquals("MeasureUnit tmp identifier", "meter", tmp.getIdentifier()); 4592 4593 mu1 = MeasureUnitImpl.forIdentifier("hour-and-minute-and-second"); 4594 assertEquals("mu1 = HMS: identifier", null, mu1.getIdentifier()); 4595 assertEquals("mu1 = HMS: complexity", MeasureUnit.Complexity.MIXED, mu1.getComplexity()); 4596 assertEquals("mu1 = HMS: units length", 3, mu1.getSingleUnits().size()); 4597 assertEquals("mu1 = HMS: units[0]", "hour", mu1.getSingleUnits().get(0).getSimpleUnitID()); 4598 assertEquals("mu1 = HMS: units[1]", "minute", mu1.getSingleUnits().get(1).getSimpleUnitID()); 4599 assertEquals("mu1 = HMS: units[2]", "second", mu1.getSingleUnits().get(2).getSimpleUnitID()); 4600 4601 MeasureUnitImpl m2 = MeasureUnitImpl.forIdentifier("meter"); 4602 m2.appendSingleUnit(MeasureUnit.METER.getCopyOfMeasureUnitImpl().getSingleUnitImpl()); 4603 assertEquals("append meter twice: complexity", MeasureUnit.Complexity.SINGLE, m2.getComplexity()); 4604 assertEquals("append meter twice: units length", 1, m2.getSingleUnits().size()); 4605 assertEquals("append meter twice: units[0]", "meter", m2.getSingleUnits().get(0).getSimpleUnitID()); 4606 assertEquals("append meter twice: identifier", "square-meter", m2.build().getIdentifier()); 4607 4608 MeasureUnitImpl mcm = MeasureUnitImpl.forIdentifier("meter"); 4609 mcm.appendSingleUnit(MeasureUnit.CENTIMETER.getCopyOfMeasureUnitImpl().getSingleUnitImpl()); 4610 assertEquals("append meter & centimeter: complexity", MeasureUnit.Complexity.COMPOUND, mcm.getComplexity()); 4611 assertEquals("append meter & centimeter: units length", 2, mcm.getSingleUnits().size()); 4612 assertEquals("append meter & centimeter: units[0]", "meter", mcm.getSingleUnits().get(0).getSimpleUnitID()); 4613 assertEquals("append meter & centimeter: units[1]", "meter", mcm.getSingleUnits().get(1).getSimpleUnitID()); 4614 assertEquals("append meter & centimeter: identifier", "meter-centimeter", mcm.build().getIdentifier()); 4615 4616 MeasureUnitImpl m2m = MeasureUnitImpl.forIdentifier("meter-square-meter"); 4617 assertEquals("meter-square-meter: complexity", MeasureUnit.Complexity.SINGLE, m2m.getComplexity()); 4618 assertEquals("meter-square-meter: units length", 1, m2m.getSingleUnits().size()); 4619 assertEquals("meter-square-meter: units[0]", "meter", m2m.getSingleUnits().get(0).getSimpleUnitID()); 4620 assertEquals("meter-square-meter: identifier", "cubic-meter", m2m.build().getIdentifier()); 4621 4622 } 4623 verifyCompoundUnit( MeasureUnit unit, String identifier, String subIdentifiers[], int subIdentifierCount)4624 private void verifyCompoundUnit( 4625 MeasureUnit unit, 4626 String identifier, 4627 String subIdentifiers[], 4628 int subIdentifierCount) { 4629 assertEquals(identifier + ": Identifier", 4630 identifier, 4631 unit.getIdentifier()); 4632 4633 assertTrue(identifier + ": Constructor", 4634 unit.equals(MeasureUnit.forIdentifier(identifier))); 4635 4636 assertEquals(identifier + ": Complexity", 4637 MeasureUnit.Complexity.COMPOUND, 4638 unit.getComplexity()); 4639 4640 List<MeasureUnit> subUnits = unit.splitToSingleUnits(); 4641 assertEquals(identifier + ": Length", subIdentifierCount, subUnits.size()); 4642 for (int i = 0; ; i++) { 4643 if (i >= subIdentifierCount || i >= subUnits.size()) break; 4644 assertEquals(identifier + ": Sub-unit #" + i, 4645 subIdentifiers[i], 4646 subUnits.get(i).getIdentifier()); 4647 assertEquals(identifier + ": Sub-unit Complexity", 4648 MeasureUnit.Complexity.SINGLE, 4649 subUnits.get(i).getComplexity()); 4650 } 4651 } 4652 verifyMixedUnit( MeasureUnit unit, String identifier, String subIdentifiers[], int subIdentifierCount)4653 private void verifyMixedUnit( 4654 MeasureUnit unit, 4655 String identifier, 4656 String subIdentifiers[], 4657 int subIdentifierCount) { 4658 assertEquals(identifier + ": Identifier", 4659 identifier, 4660 unit.getIdentifier()); 4661 assertTrue(identifier + ": Constructor", 4662 unit.equals(MeasureUnit.forIdentifier(identifier))); 4663 4664 assertEquals(identifier + ": Complexity", 4665 MeasureUnit.Complexity.MIXED, 4666 unit.getComplexity()); 4667 4668 List<MeasureUnit> subUnits = unit.splitToSingleUnits(); 4669 assertEquals(identifier + ": Length", subIdentifierCount, subUnits.size()); 4670 for (int i = 0; ; i++) { 4671 if (i >= subIdentifierCount || i >= subUnits.size()) break; 4672 assertEquals(identifier + ": Sub-unit #" + i, 4673 subIdentifiers[i], 4674 subUnits.get(i).getIdentifier()); 4675 } 4676 } 4677 } 4678