1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html#License 3 /* 4 ******************************************************************************* 5 * Copyright (C) 2007-2011, International Business Machines Corporation and * 6 * others. All Rights Reserved. * 7 ******************************************************************************* 8 */ 9 10 package com.ibm.icu.tests; 11 12 import java.math.BigInteger; 13 import java.text.FieldPosition; 14 import java.text.ParseException; 15 import java.text.ParsePosition; 16 import java.util.Locale; 17 18 import com.ibm.icu.text.NumberFormat; 19 import com.ibm.icu.util.ULocale; 20 21 public class NumberFormatTest extends ICUTestCase { 22 23 /* 24 * Test method for 'com.ibm.icu.x.text.NumberFormat.NumberFormat(NumberFormat)' 25 */ 26 public void testNumberFormat() { 27 NumberFormat nf = new NumberFormat(java.text.NumberFormat.getInstance()); 28 assertEquals(nf, NumberFormat.getInstance()); 29 } 30 31 /* 32 * Test method for 'com.ibm.icu.x.text.NumberFormat.format(Object, StringBuffer, FieldPosition)' 33 */ 34 public void testFormatObjectStringBufferFieldPosition() { 35 Number num = new Long(1234L); 36 StringBuffer buf = new StringBuffer(); 37 FieldPosition fp = new FieldPosition(NumberFormat.INTEGER_FIELD); 38 NumberFormat.getInstance().format(num, buf, fp); 39 assertEquals("1,234", buf.toString()); 40 assertEquals(0, fp.getBeginIndex()); 41 assertEquals(5, fp.getEndIndex()); 42 } 43 44 /* 45 * Test method for 'com.ibm.icu.x.text.NumberFormat.parseObject(String, ParsePosition)' 46 */ 47 public void testParseObjectStringParsePosition() { 48 ParsePosition pp = new ParsePosition(0); 49 Object result = NumberFormat.getInstance().parse("1,234", pp); 50 assertEquals(result, new Long(1234)); 51 } 52 53 /* 54 * Test method for 'com.ibm.icu.x.text.NumberFormat.format(double)' 55 */ 56 public void testFormatDouble() { 57 assertEquals("1,234.567", NumberFormat.getInstance().format(1234.567)); 58 } 59 60 /* 61 * Test method for 'com.ibm.icu.x.text.NumberFormat.format(long)' 62 */ 63 public void testFormatLong() { 64 assertEquals("1,234", NumberFormat.getInstance().format(1234L)); 65 } 66 67 /* 68 * Test method for 'com.ibm.icu.x.text.NumberFormat.format(BigInteger)' 69 */ 70 public void testFormatBigInteger() { 71 // note, java doesn't handle biginteger with full precision. 72 BigInteger bi = new BigInteger("123456"); 73 assertEquals("123,456", java.text.NumberFormat.getInstance().format(bi)); 74 } 75 76 /* 77 * Test method for 'com.ibm.icu.x.text.NumberFormat.format(double, StringBuffer, FieldPosition)' 78 */ 79 public void testFormatDoubleStringBufferFieldPosition() { 80 StringBuffer buf = new StringBuffer(); 81 FieldPosition fp = new FieldPosition(NumberFormat.FRACTION_FIELD); 82 assertEquals("123,456.789", NumberFormat.getInstance().format(123456.789, buf, fp).toString()); 83 assertEquals(8, fp.getBeginIndex()); 84 assertEquals(11, fp.getEndIndex()); 85 } 86 87 /* 88 * Test method for 'com.ibm.icu.x.text.NumberFormat.format(long, StringBuffer, FieldPosition)' 89 */ 90 public void testFormatLongStringBufferFieldPosition() { 91 StringBuffer buf = new StringBuffer(); 92 FieldPosition fp = new FieldPosition(NumberFormat.Field.GROUPING_SEPARATOR); 93 assertEquals("123,456", NumberFormat.getInstance().format(123456L, buf, fp).toString()); 94 assertEquals(3, fp.getBeginIndex()); 95 assertEquals(4, fp.getEndIndex()); 96 } 97 98 /* 99 * Test method for 'com.ibm.icu.x.text.NumberFormat.format(BigInteger, StringBuffer, FieldPosition)' 100 */ 101 public void testFormatBigIntegerStringBufferFieldPosition() { 102 // note, java doesn't handle biginteger with full precision. 103 StringBuffer buf = new StringBuffer(); 104 FieldPosition fp = new FieldPosition(0); 105 BigInteger bi = new BigInteger("123456"); 106 assertEquals("123,456", java.text.NumberFormat.getInstance().format(bi, buf, fp).toString()); 107 } 108 109 /* 110 * Test method for 'com.ibm.icu.x.text.NumberFormat.parse(String, ParsePosition)' 111 */ 112 public void testParseStringParsePosition() { 113 ParsePosition pp = new ParsePosition(3); 114 assertEquals(new Long(123456), NumberFormat.getInstance().parse("xxx123,456yyy", pp)); 115 assertEquals(10, pp.getIndex()); 116 } 117 118 /* 119 * Test method for 'com.ibm.icu.x.text.NumberFormat.parse(String)' 120 */ 121 public void testParseString() throws ParseException { 122 Number result = NumberFormat.getInstance().parse("123,456,yyy"); 123 assertEquals(new Long(123456), result); 124 } 125 126 /* 127 * Test method for 'com.ibm.icu.x.text.NumberFormat.isParseIntegerOnly()' 128 */ 129 public void testIsParseIntegerOnly() { 130 NumberFormat nf = NumberFormat.getInstance(); 131 nf.setParseIntegerOnly(true); 132 assertTrue(nf.isParseIntegerOnly()); 133 nf.setParseIntegerOnly(false); 134 assertFalse(nf.isParseIntegerOnly()); 135 } 136 137 /* 138 * Test method for 'com.ibm.icu.x.text.NumberFormat.setParseIntegerOnly(boolean)' 139 */ 140 public void testSetParseIntegerOnly() throws ParseException { 141 String str = "123.456,yyy"; 142 NumberFormat nf = NumberFormat.getInstance(); 143 assertEquals(new Double(123.456), nf.parse(str)); 144 nf.setParseIntegerOnly(true); 145 assertEquals(new Long(123), nf.parse(str)); 146 } 147 148 /* 149 * Test method for 'com.ibm.icu.x.text.NumberFormat.getInstance()' 150 */ 151 public void testGetInstance() { 152 // used everywhere, no need to test 153 } 154 155 /* 156 * Test method for 'com.ibm.icu.x.text.NumberFormat.getInstance(Locale)' 157 */ 158 public void testGetInstanceLocale() { 159 NumberFormat nf = NumberFormat.getInstance(Locale.GERMANY); 160 assertEquals("123,456", nf.format(123.456)); 161 } 162 163 /* 164 * Test method for 'com.ibm.icu.x.text.NumberFormat.getInstance(ULocale)' 165 */ 166 public void testGetInstanceULocale() { 167 NumberFormat nf = NumberFormat.getInstance(ULocale.GERMANY); 168 assertEquals("123,456", nf.format(123.456)); 169 } 170 171 /* 172 * Test method for 'com.ibm.icu.x.text.NumberFormat.getNumberInstance()' 173 */ 174 public void testGetNumberInstance() { 175 NumberFormat nf = NumberFormat.getNumberInstance(); 176 assertEquals("123,456.789", nf.format(123456.789)); 177 } 178 179 /* 180 * Test method for 'com.ibm.icu.x.text.NumberFormat.getNumberInstance(Locale)' 181 */ 182 public void testGetNumberInstanceLocale() { 183 NumberFormat nf = NumberFormat.getNumberInstance(Locale.GERMANY); 184 assertEquals("123.456,789", nf.format(123456.789)); 185 } 186 187 /* 188 * Test method for 'com.ibm.icu.x.text.NumberFormat.getNumberInstance(ULocale)' 189 */ 190 public void testGetNumberInstanceULocale() { 191 NumberFormat nf = NumberFormat.getNumberInstance(ULocale.GERMANY); 192 assertEquals("123.456,789", nf.format(123456.789)); 193 } 194 195 /* 196 * Test method for 'com.ibm.icu.x.text.NumberFormat.getIntegerInstance()' 197 */ 198 public void testGetIntegerInstance() { 199 NumberFormat nf = NumberFormat.getIntegerInstance(); 200 assertEquals("123,457", nf.format(123456.789)); // rounds 201 } 202 203 /* 204 * Test method for 'com.ibm.icu.x.text.NumberFormat.getIntegerInstance(Locale)' 205 */ 206 public void testGetIntegerInstanceLocale() { 207 NumberFormat nf = NumberFormat.getIntegerInstance(Locale.GERMANY); 208 assertEquals("123.457", nf.format(123456.789)); // rounds 209 } 210 211 /* 212 * Test method for 'com.ibm.icu.x.text.NumberFormat.getIntegerInstance(ULocale)' 213 */ 214 public void testGetIntegerInstanceULocale() { 215 NumberFormat nf = NumberFormat.getIntegerInstance(ULocale.GERMANY); 216 assertEquals("123.457", nf.format(123456.789)); // rounds 217 } 218 219 /* 220 * Test method for 'com.ibm.icu.x.text.NumberFormat.getCurrencyInstance()' 221 */ 222 public void testGetCurrencyInstance() { 223 NumberFormat nf = NumberFormat.getCurrencyInstance(); 224 assertEquals("$123,456.99", nf.format(123456.99)); 225 } 226 227 /* 228 * Test method for 'com.ibm.icu.x.text.NumberFormat.getCurrencyInstance(Locale)' 229 */ 230 public void testGetCurrencyInstanceLocale() { 231 NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.GERMANY); 232 assertEquals("123.456,99 \u20AC", nf.format(123456.99)); 233 } 234 235 /* 236 * Test method for 'com.ibm.icu.x.text.NumberFormat.getCurrencyInstance(ULocale)' 237 */ 238 public void testGetCurrencyInstanceULocale() { 239 NumberFormat nf = NumberFormat.getCurrencyInstance(ULocale.GERMANY); 240 assertEquals("123.456,99 \u20AC", nf.format(123456.99)); 241 } 242 243 /* 244 * Test method for 'com.ibm.icu.x.text.NumberFormat.getPercentInstance()' 245 */ 246 public void testGetPercentInstance() { 247 NumberFormat nf = NumberFormat.getPercentInstance(); 248 assertEquals("123,456%", nf.format(1234.56)); 249 } 250 251 /* 252 * Test method for 'com.ibm.icu.x.text.NumberFormat.getPercentInstance(Locale)' 253 */ 254 public void testGetPercentInstanceLocale() { 255 NumberFormat nf = NumberFormat.getPercentInstance(Locale.GERMANY); 256 assertEquals("123.456%", nf.format(1234.56)); 257 } 258 259 /* 260 * Test method for 'com.ibm.icu.x.text.NumberFormat.getPercentInstance(ULocale)' 261 */ 262 public void testGetPercentInstanceULocale() { 263 NumberFormat nf = NumberFormat.getPercentInstance(ULocale.GERMANY); 264 assertEquals("123.456%", nf.format(1234.56)); 265 } 266 267 /* 268 * Test method for 'com.ibm.icu.x.text.NumberFormat.getScientificInstance()' 269 */ 270 public void testGetScientificInstance() { 271 NumberFormat nf = NumberFormat.getScientificInstance(); 272 assertEquals(".123456E4", nf.format(1234.56)); 273 } 274 275 /* 276 * Test method for 'com.ibm.icu.x.text.NumberFormat.getScientificInstance(Locale)' 277 */ 278 public void testGetScientificInstanceLocale() { 279 NumberFormat nf = NumberFormat.getScientificInstance(Locale.GERMANY); 280 assertEquals(",123456E4", nf.format(1234.56)); 281 } 282 283 /* 284 * Test method for 'com.ibm.icu.x.text.NumberFormat.getScientificInstance(ULocale)' 285 */ 286 public void testGetScientificInstanceULocale() { 287 NumberFormat nf = NumberFormat.getScientificInstance(ULocale.GERMANY); 288 assertEquals(",123456E4", nf.format(1234.56)); 289 } 290 291 /* 292 * Test method for 'com.ibm.icu.x.text.NumberFormat.getAvailableLocales()' 293 */ 294 public void testGetAvailableLocales() { 295 Locale[] ilocales = NumberFormat.getAvailableLocales(); 296 if (ICUTestCase.testingWrapper) { 297 Locale[] jlocales = java.text.NumberFormat.getAvailableLocales(); 298 for (int i = 0; i < ilocales.length; ++i) { 299 assertEquals(jlocales[i], ilocales[i]); 300 } 301 } 302 } 303 304 /* 305 * Test method for 'com.ibm.icu.x.text.NumberFormat.getAvailableULocales()' 306 */ 307 public void testGetAvailableULocales() { 308 ULocale[] ulocales = NumberFormat.getAvailableULocales(); 309 if (ICUTestCase.testingWrapper) { 310 Locale[] jlocales = java.text.NumberFormat.getAvailableLocales(); 311 for (int i = 0; i < ulocales.length; ++i) { 312 assertEquals(jlocales[i], ulocales[i].toLocale()); 313 } 314 } 315 } 316 317 /* 318 * Test method for 'com.ibm.icu.x.text.NumberFormat.isGroupingUsed()' 319 */ 320 public void testIsGroupingUsed() { 321 NumberFormat nf = NumberFormat.getInstance(); 322 nf.setGroupingUsed(true); 323 assertTrue(nf.isGroupingUsed()); 324 nf.setGroupingUsed(false); 325 assertFalse(nf.isGroupingUsed()); 326 } 327 328 /* 329 * Test method for 'com.ibm.icu.x.text.NumberFormat.setGroupingUsed(boolean)' 330 */ 331 public void testSetGroupingUsed() { 332 NumberFormat nf = NumberFormat.getInstance(); 333 assertEquals("123,456,789", nf.format(123456789)); 334 nf.setGroupingUsed(false); 335 assertEquals("123456789", nf.format(123456789)); 336 } 337 338 /* 339 * Test method for 'com.ibm.icu.x.text.NumberFormat.getMaximumIntegerDigits()' 340 */ 341 public void testGetMaximumIntegerDigits() { 342 NumberFormat nf = NumberFormat.getInstance(); 343 nf.setMaximumIntegerDigits(4); 344 assertEquals(4, nf.getMaximumIntegerDigits()); 345 nf.setMaximumIntegerDigits(6); 346 assertEquals(6, nf.getMaximumIntegerDigits()); 347 } 348 349 /* 350 * Test method for 'com.ibm.icu.x.text.NumberFormat.setMaximumIntegerDigits(int)' 351 */ 352 public void testSetMaximumIntegerDigits() { 353 NumberFormat nf = NumberFormat.getInstance(); 354 nf.setMaximumIntegerDigits(4); 355 assertEquals("3,456", nf.format(123456)); // high digits truncated 356 } 357 358 /* 359 * Test method for 'com.ibm.icu.x.text.NumberFormat.getMinimumIntegerDigits()' 360 */ 361 public void testGetMinimumIntegerDigits() { 362 NumberFormat nf = NumberFormat.getInstance(); 363 nf.setMinimumIntegerDigits(4); 364 assertEquals(4, nf.getMinimumIntegerDigits()); 365 nf.setMinimumIntegerDigits(6); 366 assertEquals(6, nf.getMinimumIntegerDigits()); 367 } 368 369 /* 370 * Test method for 'com.ibm.icu.x.text.NumberFormat.setMinimumIntegerDigits(int)' 371 */ 372 public void testSetMinimumIntegerDigits() { 373 NumberFormat nf = NumberFormat.getInstance(); 374 nf.setMinimumIntegerDigits(4); 375 assertEquals("0,012", nf.format(12)); // pad out with zero, grouping still used 376 } 377 378 /* 379 * Test method for 'com.ibm.icu.x.text.NumberFormat.getMaximumFractionDigits()' 380 */ 381 public void testGetMaximumFractionDigits() { 382 NumberFormat nf = NumberFormat.getInstance(); 383 nf.setMaximumFractionDigits(4); 384 assertEquals(4, nf.getMaximumFractionDigits()); 385 nf.setMaximumFractionDigits(6); 386 assertEquals(6, nf.getMaximumFractionDigits()); 387 } 388 389 /* 390 * Test method for 'com.ibm.icu.x.text.NumberFormat.setMaximumFractionDigits(int)' 391 */ 392 public void testSetMaximumFractionDigits() { 393 NumberFormat nf = NumberFormat.getInstance(); 394 nf.setMaximumFractionDigits(4); 395 assertEquals("1.2346", nf.format(1.2345678)); // low digits rounded 396 } 397 398 /* 399 * Test method for 'com.ibm.icu.x.text.NumberFormat.getMinimumFractionDigits()' 400 */ 401 public void testGetMinimumFractionDigits() { 402 NumberFormat nf = NumberFormat.getInstance(); 403 nf.setMinimumFractionDigits(4); 404 assertEquals(4, nf.getMinimumFractionDigits()); 405 nf.setMinimumFractionDigits(6); 406 assertEquals(6, nf.getMinimumFractionDigits()); 407 } 408 409 /* 410 * Test method for 'com.ibm.icu.x.text.NumberFormat.setMinimumFractionDigits(int)' 411 */ 412 public void testSetMinimumFractionDigits() { 413 NumberFormat nf = NumberFormat.getInstance(); 414 nf.setMinimumFractionDigits(4); 415 assertEquals("1.2000", nf.format(1.2)); 416 } 417 418 /* 419 * Test method for 'com.ibm.icu.x.text.NumberFormat.toString()' 420 */ 421 public void testToString() { 422 assertNotNull(NumberFormat.getInstance().toString()); 423 } 424 425 /* 426 * Test method for 'com.ibm.icu.x.text.NumberFormat.hashCode()' 427 */ 428 public void testHashCode() { 429 NumberFormat nf = NumberFormat.getInstance(); 430 NumberFormat eq = NumberFormat.getInstance(Locale.US); 431 NumberFormat neq = NumberFormat.getInstance(Locale.GERMANY); 432 433 ICUTestCase.testEHCS(nf, eq, neq); 434 } 435 436 /* 437 * Test method for 'com.ibm.icu.x.text.NumberFormat.clone()' 438 */ 439 public void testClone() { 440 // see testHashCode 441 } 442 443 /* 444 * Test method for 'com.ibm.icu.x.text.NumberFormat.equals(Object)' 445 */ 446 public void testEqualsObject() { 447 // see testHashCode 448 } 449 } 450