diff --git a/jre_emul/android/libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/CurrencyTest.java b/jre_emul/android/libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/CurrencyTest.java new file mode 100644 index 0000000000..a04257a31f --- /dev/null +++ b/jre_emul/android/libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/CurrencyTest.java @@ -0,0 +1,407 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.harmony.tests.java.util; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Currency; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Locale; +import java.util.Set; + +public class CurrencyTest extends junit.framework.TestCase { + + private Locale originalLocale; + + @Override + protected void setUp() throws Exception { + super.setUp(); + originalLocale = Locale.getDefault(); + } + + @Override + protected void tearDown() { + Locale.setDefault(originalLocale); + } + + /** + * java.util.Currency#getInstance(java.lang.String) + */ + public void test_getInstanceLjava_lang_String() { + // see test_getInstanceLjava_util_Locale() tests + } + + /** + * java.util.Currency#getInstance(java.util.Locale) + */ + public void test_getInstanceLjava_util_Locale() { + /* + * the behaviour in all these three cases should be the same since this + * method ignores language and variant component of the locale. + */ + Currency c0 = Currency.getInstance("CAD"); + Currency c1 = Currency.getInstance(new Locale("en", "CA")); + assertTrue( + "Currency.getInstance(new Locale(\"en\",\"CA\")) isn't equal to Currency.getInstance(\"CAD\")", + c1 == c0); + Currency c2 = Currency.getInstance(new Locale("fr", "CA")); + assertTrue( + "Currency.getInstance(new Locale(\"fr\",\"CA\")) isn't equal to Currency.getInstance(\"CAD\")", + c2 == c0); + Currency c3 = Currency.getInstance(new Locale("", "CA")); + assertTrue( + "Currency.getInstance(new Locale(\"\",\"CA\")) isn't equal to Currency.getInstance(\"CAD\")", + c3 == c0); + + c0 = Currency.getInstance("JPY"); + c1 = Currency.getInstance(new Locale("ja", "JP")); + assertTrue( + "Currency.getInstance(new Locale(\"ja\",\"JP\")) isn't equal to Currency.getInstance(\"JPY\")", + c1 == c0); + c2 = Currency.getInstance(new Locale("", "JP")); + assertTrue( + "Currency.getInstance(new Locale(\"\",\"JP\")) isn't equal to Currency.getInstance(\"JPY\")", + c2 == c0); + c3 = Currency.getInstance(new Locale("bogus", "JP")); + assertTrue( + "Currency.getInstance(new Locale(\"bogus\",\"JP\")) isn't equal to Currency.getInstance(\"JPY\")", + c3 == c0); + + Locale localeGu = new Locale("gu", "IN"); + Currency cGu = Currency.getInstance(localeGu); + Locale localeKn = new Locale("kn", "IN"); + Currency cKn = Currency.getInstance(localeKn); + assertTrue("Currency.getInstance(Locale_" + localeGu.toString() + "))" + + "isn't equal to " + "Currency.getInstance(Locale_" + + localeKn.toString() + "))", cGu == cKn); + + // some teritories do not have currencies, like Antarctica + Locale loc = new Locale("", "AQ"); + try { + Currency curr = Currency.getInstance(loc); + assertNull( + "Currency.getInstance(new Locale(\"\", \"AQ\")) did not return null", + curr); + } catch (IllegalArgumentException e) { + fail("Unexpected IllegalArgumentException " + e); + } + + /* These return valid currencies in iOS. + // unsupported/legacy iso3 countries + loc = new Locale("", "ZR"); + try { + Currency curr = Currency.getInstance(loc); + fail("Expected IllegalArgumentException"); + } catch (IllegalArgumentException e) { + } + + loc = new Locale("", "ZAR"); + try { + Currency curr = Currency.getInstance(loc); + fail("Expected IllegalArgumentException"); + } catch (IllegalArgumentException e) { + } + + loc = new Locale("", "FX"); + try { + Currency curr = Currency.getInstance(loc); + fail("Expected IllegalArgumentException"); + } catch (IllegalArgumentException e) { + } + + loc = new Locale("", "FXX"); + try { + Currency curr = Currency.getInstance(loc); + fail("Expected IllegalArgumentException"); + } catch (IllegalArgumentException e) { + }*/ + } + + /** + * java.util.Currency#getSymbol() + */ + public void test_getSymbol() { + Currency currK = Currency.getInstance("KRW"); + Currency currI = Currency.getInstance("IEP"); + Currency currUS = Currency.getInstance("USD"); + + Locale.setDefault(Locale.US); + // BEGIN android-changed + // KRW currency symbol is \u20a9 since CLDR1.7 release. + assertEquals("currK.getSymbol()", "\u20a9", currK.getSymbol()); + // IEP currency symbol is IEP since CLDR2.0 release. + assertEquals("currI.getSymbol()", "IEP", currI.getSymbol()); + // END android-changed + assertEquals("currUS.getSymbol()", "$", currUS.getSymbol()); + + Locale.setDefault(new Locale("en", "IE")); + // BEGIN android-changed + assertEquals("currK.getSymbol()", "\u20a9", currK.getSymbol()); + assertEquals("currI.getSymbol()", "IEP", currI.getSymbol()); + assertEquals("currUS.getSymbol()1", "US$", currUS.getSymbol()); + // END android-changed + + // Test what happens if the default is an invalid locale, one with the country Korea (KR) + // but a currently unsupported language. "kr" == Kanuri (Korean is actually "ko"). + // All these values are those defined in the "root" locale or the currency code if one isn't + // defined. + Locale.setDefault(new Locale("kr", "KR")); + // BEGIN android-changed + assertEquals("currK.getSymbol()", "\u20a9", currK.getSymbol()); + assertEquals("currI.getSymbol()", "IEP", currI.getSymbol()); + /* NSNumberFormatter returns "$" for the currency symbol here. + assertEquals("currUS.getSymbol()2", "US$", currUS.getSymbol());*/ + // END android-changed + } + + /** + * java.util.Currency#getSymbol(java.util.Locale) + */ + public void test_getSymbolLjava_util_Locale() { + //Tests was simplified because java specification not + // includes strong requirements for returning symbol. + // on android platform used wrong character for yen + // sign: \u00a5 instead of \uffe5 + Locale[] desiredLocales = new Locale[]{ + Locale.JAPAN, Locale.JAPANESE, + Locale.FRANCE, Locale.FRENCH, + Locale.US, Locale.UK, + Locale.CANADA, Locale.CANADA_FRENCH, + Locale.ENGLISH, + new Locale("ja", "JP"), new Locale("", "JP"), + + new Locale("fr", "FR"), new Locale("", "FR"), + + new Locale("en", "US"), new Locale("", "US"), + new Locale("es", "US"), new Locale("ar", "US"), + new Locale("ja", "US"), + + new Locale("en", "CA"), new Locale("fr", "CA"), + new Locale("", "CA"), new Locale("ar", "CA"), + + new Locale("ja", "JP"), new Locale("", "JP"), + new Locale("ar", "JP"), + + new Locale("ja", "AE"), new Locale("en", "AE"), + new Locale("ar", "AE"), + + new Locale("da", "DK"), new Locale("", "DK"), + + new Locale("da", ""), new Locale("ja", ""), + new Locale("en", "")}; + + Set availableLocales = new HashSet(Arrays.asList(Locale.getAvailableLocales())); + + ArrayList locales = new ArrayList(); + for (Locale desiredLocale : desiredLocales) { + if (availableLocales.contains(desiredLocale)) { + locales.add(desiredLocale); + } + } + + Locale[] loc1 = locales.toArray(new Locale[locales.size()]); + + String[] euro = new String[] {"EUR", "\u20ac"}; + // \u00a5 and \uffe5 are actually the same symbol, just different code points. + // But the RI returns the \uffe5 and Android returns those with \u00a5 + String[] yen = new String[] {"JPY", "\u00a5", "\u00a5JP", "JP\u00a5", "\uffe5", "\uffe5JP", "JP\uffe5"}; + String[] dollar = new String[] {"USD", "$", "US$", "$US", "$ US"}; + // BEGIN android-changed + // Starting CLDR 1.7 release, currency symbol for CAD changed to CA$ in some locales such as ja. + String[] cDollar = new String[] {"CA$", "CAD", "$", "Can$", "$CA"}; + // END android-changed + + Currency currE = Currency.getInstance("EUR"); + Currency currJ = Currency.getInstance("JPY"); + Currency currUS = Currency.getInstance("USD"); + Currency currCA = Currency.getInstance("CAD"); + + int i, j, k; + boolean flag; + + for(k = 0; k < loc1.length; k++) { + Locale.setDefault(loc1[k]); + + for (i = 0; i < loc1.length; i++) { + flag = false; + for (j = 0; j < euro.length; j++) { + if (currE.getSymbol(loc1[i]).equals(euro[j])) { + flag = true; + break; + } + } + assertTrue("Default Locale is: " + Locale.getDefault() + + ". For locale " + loc1[i] + + " the Euro currency returned " + + currE.getSymbol(loc1[i]) + + ". Expected was one of these: " + + Arrays.toString(euro), flag); + } + + for (i = 0; i < loc1.length; i++) { + flag = false; + for (j = 0; j < yen.length; j++) { + if (currJ.getSymbol(loc1[i]).equals(yen[j])) { + flag = true; + break; + } + } + assertTrue("Default Locale is: " + Locale.getDefault() + + ". For locale " + loc1[i] + + " the Yen currency returned " + + currJ.getSymbol(loc1[i]) + + ". Expected was one of these: " + + Arrays.toString(yen), flag); + } + + for (i = 0; i < loc1.length; i++) { + flag = false; + for (j = 0; j < dollar.length; j++) { + if (currUS.getSymbol(loc1[i]).equals(dollar[j])) { + flag = true; + break; + } + } + assertTrue("Default Locale is: " + Locale.getDefault() + + ". For locale " + loc1[i] + + " the Dollar currency returned " + + currUS.getSymbol(loc1[i]) + + ". Expected was one of these: " + + Arrays.toString(dollar), flag); + } + + for (i = 0; i < loc1.length; i++) { + flag = false; + for (j = 0; j < cDollar.length; j++) { + if (currCA.getSymbol(loc1[i]).equals(cDollar[j])) { + flag = true; + break; + } + } + assertTrue("Default Locale is: " + Locale.getDefault() + + ". For locale " + loc1[i] + + " the Canadian Dollar currency returned " + + currCA.getSymbol(loc1[i]) + + ". Expected was one of these: " + + Arrays.toString(cDollar), flag); + } + } + } + + /** + * java.util.Currency#getDefaultFractionDigits() + */ + public void test_getDefaultFractionDigits() { + + Currency c1 = Currency.getInstance("TND"); + c1.getDefaultFractionDigits(); + assertEquals(" Currency.getInstance(\"" + c1 + + "\") returned incorrect number of digits. ", 3, c1 + .getDefaultFractionDigits()); + + Currency c2 = Currency.getInstance("EUR"); + c2.getDefaultFractionDigits(); + assertEquals(" Currency.getInstance(\"" + c2 + + "\") returned incorrect number of digits. ", 2, c2 + .getDefaultFractionDigits()); + + Currency c3 = Currency.getInstance("JPY"); + c3.getDefaultFractionDigits(); + assertEquals(" Currency.getInstance(\"" + c3 + + "\") returned incorrect number of digits. ", 0, c3 + .getDefaultFractionDigits()); + + Currency c4 = Currency.getInstance("XXX"); + c4.getDefaultFractionDigits(); + assertEquals(" Currency.getInstance(\"" + c4 + + "\") returned incorrect number of digits. ", -1, c4 + .getDefaultFractionDigits()); + } + + /** + * java.util.Currency#getCurrencyCode() Note: lines under remarks + * (Locale.CHINESE, Locale.ENGLISH, Locale.FRENCH, Locale.GERMAN, + * Locale.ITALIAN, Locale.JAPANESE, Locale.KOREAN) raises exception + * on SUN VM + */ + public void test_getCurrencyCode() { + final Collection locVal = Arrays.asList( + Locale.CANADA, + Locale.CANADA_FRENCH, + Locale.CHINA, + // Locale.CHINESE, + // Locale.ENGLISH, + Locale.FRANCE, + // Locale.FRENCH, + // Locale.GERMAN, + Locale.GERMANY, + // Locale.ITALIAN, + Locale.ITALY, Locale.JAPAN, + // Locale.JAPANESE, + Locale.KOREA, + // Locale.KOREAN, + Locale.PRC, Locale.SIMPLIFIED_CHINESE, Locale.TAIWAN, Locale.TRADITIONAL_CHINESE, + Locale.UK, Locale.US); + final Collection locDat = Arrays.asList("CAD", "CAD", "CNY", "EUR", "EUR", "EUR", + "JPY", "KRW", "CNY", "CNY", "TWD", "TWD", "GBP", "USD"); + + Iterator dat = locDat.iterator(); + for (Locale l : locVal) { + String d = dat.next().trim(); + assertEquals("For locale " + l + " currency code wrong", Currency.getInstance(l) + .getCurrencyCode(), d); + } + } + + /** + * java.util.Currency#toString() Note: lines under remarks + * (Locale.CHINESE, Locale.ENGLISH, Locale.FRENCH, Locale.GERMAN, + * Locale.ITALIAN, Locale.JAPANESE, Locale.KOREAN) raises exception + * on SUN VM + */ + public void test_toString() { + final Collection locVal = Arrays.asList( + Locale.CANADA, + Locale.CANADA_FRENCH, + Locale.CHINA, + // Locale.CHINESE, + // Locale.ENGLISH, + Locale.FRANCE, + // Locale.FRENCH, + // Locale.GERMAN, + Locale.GERMANY, + // Locale.ITALIAN, + Locale.ITALY, Locale.JAPAN, + // Locale.JAPANESE, + Locale.KOREA, + // Locale.KOREAN, + Locale.PRC, Locale.SIMPLIFIED_CHINESE, Locale.TAIWAN, Locale.TRADITIONAL_CHINESE, + Locale.UK, Locale.US); + final Collection locDat = Arrays.asList("CAD", "CAD", "CNY", "EUR", "EUR", "EUR", + "JPY", "KRW", "CNY", "CNY", "TWD", "TWD", "GBP", "USD"); + + Iterator dat = locDat.iterator(); + for (Locale l : locVal) { + String d = dat.next().trim(); + assertEquals("For locale " + l + " Currency.toString method returns wrong value", + Currency.getInstance(l).toString(), d); + } + } +} diff --git a/jre_emul/android/libcore/luni/src/main/java/java/util/Currency.java b/jre_emul/android/libcore/luni/src/main/java/java/util/Currency.java index f43ddae35c..70314f14ee 100644 --- a/jre_emul/android/libcore/luni/src/main/java/java/util/Currency.java +++ b/jre_emul/android/libcore/luni/src/main/java/java/util/Currency.java @@ -31,12 +31,14 @@ public final class Currency implements Serializable { private static final HashMap codesToCurrencies = new HashMap(); private static final HashMap localesToCurrencies = new HashMap(); + private static final LinkedHashSet availableCurrencyCodes = + constructAvailableCurrencyCodes(); + private final String currencyCode; private Currency(String currencyCode) { this.currencyCode = currencyCode; - String symbol = ICU.getCurrencySymbol(Locale.US, currencyCode); - if (symbol == null) { + if (!availableCurrencyCodes.contains(currencyCode)) { throw new IllegalArgumentException("Unsupported ISO 4217 currency code: " + currencyCode); } @@ -72,14 +74,8 @@ public static Currency getInstance(Locale locale) { if (currency != null) { return currency; } - String country = locale.getCountry(); - String variant = locale.getVariant(); - if (!variant.isEmpty() && (variant.equals("EURO") || variant.equals("HK") || - variant.equals("PREEURO"))) { - country = country + "_" + variant; - } - String currencyCode = ICU.getCurrencyCode(country); + String currencyCode = ICU.getCurrencyCode(locale); if (currencyCode == null) { throw new IllegalArgumentException("Unsupported ISO 3166 country: " + locale); } else if (currencyCode.equals("XXX")) { @@ -91,14 +87,21 @@ public static Currency getInstance(Locale locale) { } } + private static LinkedHashSet constructAvailableCurrencyCodes() { + LinkedHashSet result = new LinkedHashSet(); + for (String code : ICU.getAvailableCurrencyCodes()) { + result.add(code); + } + return result; + } + /** * Returns a set of all known currencies. * @since 1.7 */ public static Set getAvailableCurrencies() { Set result = new LinkedHashSet(); - String[] currencyCodes = ICU.getAvailableCurrencyCodes(); - for (String currencyCode : currencyCodes) { + for (String currencyCode : availableCurrencyCodes) { result.add(Currency.getInstance(currencyCode)); } return result; diff --git a/jre_emul/android/libcore/luni/src/main/java/libcore/icu/ICU.java b/jre_emul/android/libcore/luni/src/main/java/libcore/icu/ICU.java index 3450e93331..267d3a1674 100644 --- a/jre_emul/android/libcore/luni/src/main/java/libcore/icu/ICU.java +++ b/jre_emul/android/libcore/luni/src/main/java/libcore/icu/ICU.java @@ -296,9 +296,8 @@ public static native String getCurrencyDisplayName(Locale locale, String currenc return [nativeLocale displayNameForKey:NSLocaleCurrencyCode value:currencyCode]; ]-*/; - public static native String getCurrencyCode(String localeId) /*-[ - NSLocale *nativeLocale = - AUTORELEASE([[NSLocale alloc] initWithLocaleIdentifier:localeId]); + public static native String getCurrencyCode(Locale locale) /*-[ + NSLocale *nativeLocale = [NSLocale localeWithLocaleIdentifier:[locale toLanguageTag]]; NSNumberFormatter *formatter = AUTORELEASE([[NSNumberFormatter alloc] init]); [formatter setNumberStyle:NSNumberFormatterCurrencyStyle]; [formatter setLocale:nativeLocale]; diff --git a/jre_emul/android/libcore/luni/src/test/java/libcore/java/util/CurrencyTest.java b/jre_emul/android/libcore/luni/src/test/java/libcore/java/util/CurrencyTest.java new file mode 100644 index 0000000000..d6e3e173e8 --- /dev/null +++ b/jre_emul/android/libcore/luni/src/test/java/libcore/java/util/CurrencyTest.java @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package libcore.java.util; + +import java.util.Currency; +import java.util.Locale; +import java.util.Set; + +import libcore.util.SerializationTester; + +public class CurrencyTest extends junit.framework.TestCase { + // Regression test to ensure that Currency.getSymbol(Locale) returns the + // currency code if ICU doesn't have a localization of the symbol. The + // harmony Currency tests don't test this, and their DecimalFormat tests + // only test it as a side-effect, and in a way that only detected my + // specific mistake of returning null (returning "stinky" would have + // passed). + public void test_getSymbol_fallback() throws Exception { + // This assumes that AED never becomes a currency important enough to + // Canada that Canadians give it a localized (to Canada) symbol. + assertEquals("AED", Currency.getInstance("AED").getSymbol(Locale.CANADA)); + } + + // Regression test to ensure that Currency.getInstance(String) throws if + // given an invalid ISO currency code. + public void test_getInstance_illegal_currency_code() throws Exception { + Currency.getInstance("USD"); + try { + Currency.getInstance("BOGO-DOLLARS"); + fail("expected IllegalArgumentException for invalid ISO currency code"); + } catch (IllegalArgumentException expected) { + } + } + + public void testGetAvailableCurrencies() throws Exception { + Set all = Currency.getAvailableCurrencies(); + // Confirm that a few well-known stable currencies are present. + assertTrue(all.toString(), all.contains(Currency.getInstance("CHF"))); + assertTrue(all.toString(), all.contains(Currency.getInstance("EUR"))); + assertTrue(all.toString(), all.contains(Currency.getInstance("GBP"))); + assertTrue(all.toString(), all.contains(Currency.getInstance("JPY"))); + assertTrue(all.toString(), all.contains(Currency.getInstance("USD"))); + } + + public void test_getDisplayName() throws Exception { + assertEquals("Swiss Franc", Currency.getInstance("CHF").getDisplayName(Locale.US)); + assertEquals("Schweizer Franken", Currency.getInstance("CHF").getDisplayName(new Locale("de", "CH"))); + assertEquals("franc suisse", Currency.getInstance("CHF").getDisplayName(new Locale("fr", "CH"))); + assertEquals("franco svizzero", Currency.getInstance("CHF").getDisplayName(new Locale("it", "CH"))); + } + + public void test_getDefaultFractionDigits() throws Exception { + assertEquals(2, Currency.getInstance("USD").getDefaultFractionDigits()); + assertEquals(0, Currency.getInstance("JPY").getDefaultFractionDigits()); + assertEquals(-1, Currency.getInstance("XXX").getDefaultFractionDigits()); + } + + // http://code.google.com/p/android/issues/detail?id=38622 + public void test_getSymbol_38622() throws Exception { + // The CLDR data had the Portuguese symbol for "EUR" in pt, not in pt_PT. + // We weren't falling back from pt_PT to pt, so we didn't find it and would + // default to U+00A4 CURRENCY SIGN (¤) rather than €. + Locale pt_BR = new Locale("pt", "BR"); + Locale pt_PT = new Locale("pt", "PT"); + assertEquals("R$", Currency.getInstance(pt_BR).getSymbol(pt_BR)); + assertEquals("R$", Currency.getInstance(pt_BR).getSymbol(pt_PT)); + assertEquals("€", Currency.getInstance(pt_PT).getSymbol(pt_BR)); + assertEquals("€", Currency.getInstance(pt_PT).getSymbol(pt_PT)); + } + + public void test_nullLocales() { + Currency currency = Currency.getInstance(Locale.getDefault()); + try { + currency.getSymbol(null); + fail(); + } catch (NullPointerException expected) {} + } + + public void testSerialization() throws Exception { + Currency usd = Currency.getInstance("USD"); + String actual = SerializationTester.serializeHex(usd); + String expected = "aced0005737200126a6176612e7574696c2e43757272656e6379fdcd934a5911a91f02" + + "00014c000c63757272656e6379436f64657400124c6a6176612f6c616e672f537472696e673b7870" + + "740003555344"; + assertEquals(expected, actual); + + Currency deserializedUsd = (Currency) SerializationTester.deserializeHex(expected); + assertSame("Currency objects should be singletons", usd, deserializedUsd); + } + + /* getNumericCode is not implemented in J2ObjC. + public void test_getNumericCode() throws Exception { + assertEquals(840, Currency.getInstance("USD").getNumericCode()); + assertEquals(826, Currency.getInstance("GBP").getNumericCode()); + assertEquals(999, Currency.getInstance("XXX").getNumericCode()); + assertEquals(0, Currency.getInstance("XFU").getNumericCode()); + }*/ +} diff --git a/jre_emul/tests.mk b/jre_emul/tests.mk index a1aec002dc..737a3656b3 100644 --- a/jre_emul/tests.mk +++ b/jre_emul/tests.mk @@ -355,6 +355,7 @@ TEST_SOURCES := \ libcore/java/text/SimpleDateFormatTest.java \ libcore/java/util/BitSetTest.java \ libcore/java/util/CalendarTest.java \ + libcore/java/util/CurrencyTest.java \ libcore/java/util/EventObjectTest.java \ libcore/java/util/FormatterTest.java \ libcore/java/util/ObjectsTest.java \ @@ -558,6 +559,7 @@ TEST_SOURCES := \ org/apache/harmony/tests/java/math/BigIntegerOrTest.java \ org/apache/harmony/tests/java/math/BigIntegerSubtractTest.java \ org/apache/harmony/tests/java/nio/channels/ChannelsTest.java \ + org/apache/harmony/tests/java/util/CurrencyTest.java \ org/apache/harmony/tests/java/util/HashMapTest.java \ org/apache/harmony/tests/java/util/HashtableTest.java \ org/apache/harmony/tests/java/util/LinkedHashMapTest.java \