Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(21)

Unified Diff: source/test/intltest/measfmttest.cpp

Issue 845603002: Update ICU to 54.1 step 1 (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/icu.git@master
Patch Set: remove unusued directories Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « source/test/intltest/loctest.cpp ('k') | source/test/intltest/nptrans.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: source/test/intltest/measfmttest.cpp
diff --git a/source/test/intltest/measfmttest.cpp b/source/test/intltest/measfmttest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ccbc75729a70ae4435f4ecc99a7b8e49329f9f8b
--- /dev/null
+++ b/source/test/intltest/measfmttest.cpp
@@ -0,0 +1,1491 @@
+/*
+*******************************************************************************
+* Copyright (C) 2014, International Business Machines Corporation and *
+* others. All Rights Reserved. *
+*******************************************************************************
+*
+* File MEASFMTTEST.CPP
+*
+*******************************************************************************
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "intltest.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/decimfmt.h"
+#include "unicode/measfmt.h"
+#include "unicode/measure.h"
+#include "unicode/measunit.h"
+#include "unicode/tmunit.h"
+#include "unicode/plurrule.h"
+#include "charstr.h"
+#include "unicode/reldatefmt.h"
+
+struct ExpectedResult {
+ const Measure *measures;
+ int32_t count;
+ const char *expected;
+};
+
+class MeasureFormatTest : public IntlTest {
+public:
+ MeasureFormatTest() {
+ }
+
+ void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
+private:
+ void TestBasic();
+ void TestCompatible53_1();
+ void TestCompatible54_1();
+ void TestGetAvailable();
+ void TestExamplesInDocs();
+ void TestFormatPeriodEn();
+ void Test10219FractionalPlurals();
+ void TestGreek();
+ void TestFormatSingleArg();
+ void TestFormatMeasuresZeroArg();
+ void TestMultiplesWithPer();
+ void TestSimplePer();
+ void TestNumeratorPlurals();
+ void TestMultiples();
+ void TestGram();
+ void TestCurrencies();
+ void TestFieldPosition();
+ void TestFieldPositionMultiple();
+ void TestFieldPositionMultipleWithPer();
+ void TestBadArg();
+ void TestEquality();
+ void TestGroupingSeparator();
+ void TestDoubleZero();
+ void verifyFormat(
+ const char *description,
+ const MeasureFormat &fmt,
+ const Measure *measures,
+ int32_t measureCount,
+ const char *expected);
+ void verifyFormatWithPrefix(
+ const char *description,
+ const MeasureFormat &fmt,
+ const UnicodeString &prefix,
+ const Measure *measures,
+ int32_t measureCount,
+ const char *expected);
+ void verifyFormat(
+ const char *description,
+ const MeasureFormat &fmt,
+ const ExpectedResult *expectedResults,
+ int32_t count);
+ void helperTestSimplePer(
+ const Locale &locale,
+ UMeasureFormatWidth width,
+ double value,
+ const MeasureUnit &unit,
+ const MeasureUnit &perUnit,
+ const char *expected);
+ void helperTestMultiplesWithPer(
+ const Locale &locale,
+ UMeasureFormatWidth width,
+ const MeasureUnit &unit,
+ const char *expected);
+ void helperTestMultiples(
+ const Locale &locale,
+ UMeasureFormatWidth width,
+ const char *expected);
+ void verifyFieldPosition(
+ const char *description,
+ const MeasureFormat &fmt,
+ const UnicodeString &prefix,
+ const Measure *measures,
+ int32_t measureCount,
+ NumberFormat::EAlignmentFields field,
+ int32_t start,
+ int32_t end);
+ void verifyFieldPositionWithPer(
+ const char *description,
+ const MeasureFormat &fmt,
+ const UnicodeString &prefix,
+ const Measure *measures,
+ int32_t measureCount,
+ const MeasureUnit &perUnit,
+ NumberFormat::EAlignmentFields field,
+ int32_t start,
+ int32_t end);
+};
+
+void MeasureFormatTest::runIndexedTest(
+ int32_t index, UBool exec, const char *&name, char *) {
+ if (exec) {
+ logln("TestSuite MeasureFormatTest: ");
+ }
+ TESTCASE_AUTO_BEGIN;
+ TESTCASE_AUTO(TestBasic);
+ TESTCASE_AUTO(TestCompatible53_1);
+ TESTCASE_AUTO(TestCompatible54_1);
+ TESTCASE_AUTO(TestGetAvailable);
+ TESTCASE_AUTO(TestExamplesInDocs);
+ TESTCASE_AUTO(TestFormatPeriodEn);
+ TESTCASE_AUTO(Test10219FractionalPlurals);
+ TESTCASE_AUTO(TestGreek);
+ TESTCASE_AUTO(TestFormatSingleArg);
+ TESTCASE_AUTO(TestFormatMeasuresZeroArg);
+ TESTCASE_AUTO(TestMultiplesWithPer);
+ TESTCASE_AUTO(TestSimplePer);
+ TESTCASE_AUTO(TestNumeratorPlurals);
+ TESTCASE_AUTO(TestMultiples);
+ TESTCASE_AUTO(TestGram);
+ TESTCASE_AUTO(TestCurrencies);
+ TESTCASE_AUTO(TestFieldPosition);
+ TESTCASE_AUTO(TestFieldPositionMultiple);
+ TESTCASE_AUTO(TestFieldPositionMultipleWithPer);
+ TESTCASE_AUTO(TestBadArg);
+ TESTCASE_AUTO(TestEquality);
+ TESTCASE_AUTO(TestGroupingSeparator);
+ TESTCASE_AUTO(TestDoubleZero);
+ TESTCASE_AUTO_END;
+}
+
+void MeasureFormatTest::TestCompatible53_1() {
+ UErrorCode status = U_ZERO_ERROR;
+ LocalPointer<MeasureUnit> measureUnit;
+ measureUnit.adoptInstead(MeasureUnit::createGForce(status));
+ measureUnit.adoptInstead(MeasureUnit::createArcMinute(status));
+ measureUnit.adoptInstead(MeasureUnit::createArcSecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createDegree(status));
+ measureUnit.adoptInstead(MeasureUnit::createAcre(status));
+ measureUnit.adoptInstead(MeasureUnit::createHectare(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareFoot(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareKilometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareMeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareMile(status));
+ measureUnit.adoptInstead(MeasureUnit::createDay(status));
+ measureUnit.adoptInstead(MeasureUnit::createHour(status));
+ measureUnit.adoptInstead(MeasureUnit::createMillisecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createMinute(status));
+ measureUnit.adoptInstead(MeasureUnit::createMonth(status));
+ measureUnit.adoptInstead(MeasureUnit::createSecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createWeek(status));
+ measureUnit.adoptInstead(MeasureUnit::createYear(status));
+ measureUnit.adoptInstead(MeasureUnit::createCentimeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createFoot(status));
+ measureUnit.adoptInstead(MeasureUnit::createInch(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createLightYear(status));
+ measureUnit.adoptInstead(MeasureUnit::createMeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createMile(status));
+ measureUnit.adoptInstead(MeasureUnit::createMillimeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createPicometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createYard(status));
+ measureUnit.adoptInstead(MeasureUnit::createGram(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilogram(status));
+ measureUnit.adoptInstead(MeasureUnit::createOunce(status));
+ measureUnit.adoptInstead(MeasureUnit::createPound(status));
+ measureUnit.adoptInstead(MeasureUnit::createHorsepower(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilowatt(status));
+ measureUnit.adoptInstead(MeasureUnit::createWatt(status));
+ measureUnit.adoptInstead(MeasureUnit::createHectopascal(status));
+ measureUnit.adoptInstead(MeasureUnit::createInchHg(status));
+ measureUnit.adoptInstead(MeasureUnit::createMillibar(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilometerPerHour(status));
+ measureUnit.adoptInstead(MeasureUnit::createMeterPerSecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createMilePerHour(status));
+ measureUnit.adoptInstead(MeasureUnit::createCelsius(status));
+ measureUnit.adoptInstead(MeasureUnit::createFahrenheit(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicKilometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicMile(status));
+ measureUnit.adoptInstead(MeasureUnit::createLiter(status));
+ assertSuccess("", status);
+}
+
+void MeasureFormatTest::TestCompatible54_1() {
+ UErrorCode status = U_ZERO_ERROR;
+ LocalPointer<MeasureUnit> measureUnit;
+ measureUnit.adoptInstead(MeasureUnit::createGForce(status));
+ measureUnit.adoptInstead(MeasureUnit::createMeterPerSecondSquared(status));
+ measureUnit.adoptInstead(MeasureUnit::createArcMinute(status));
+ measureUnit.adoptInstead(MeasureUnit::createArcSecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createDegree(status));
+ measureUnit.adoptInstead(MeasureUnit::createRadian(status));
+ measureUnit.adoptInstead(MeasureUnit::createAcre(status));
+ measureUnit.adoptInstead(MeasureUnit::createHectare(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareCentimeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareFoot(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareInch(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareKilometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareMeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareMile(status));
+ measureUnit.adoptInstead(MeasureUnit::createSquareYard(status));
+ measureUnit.adoptInstead(MeasureUnit::createLiterPerKilometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createMilePerGallon(status));
+ measureUnit.adoptInstead(MeasureUnit::createBit(status));
+ measureUnit.adoptInstead(MeasureUnit::createByte(status));
+ measureUnit.adoptInstead(MeasureUnit::createGigabit(status));
+ measureUnit.adoptInstead(MeasureUnit::createGigabyte(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilobit(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilobyte(status));
+ measureUnit.adoptInstead(MeasureUnit::createMegabit(status));
+ measureUnit.adoptInstead(MeasureUnit::createMegabyte(status));
+ measureUnit.adoptInstead(MeasureUnit::createTerabit(status));
+ measureUnit.adoptInstead(MeasureUnit::createTerabyte(status));
+ measureUnit.adoptInstead(MeasureUnit::createDay(status));
+ measureUnit.adoptInstead(MeasureUnit::createHour(status));
+ measureUnit.adoptInstead(MeasureUnit::createMicrosecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createMillisecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createMinute(status));
+ measureUnit.adoptInstead(MeasureUnit::createMonth(status));
+ measureUnit.adoptInstead(MeasureUnit::createNanosecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createSecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createWeek(status));
+ measureUnit.adoptInstead(MeasureUnit::createYear(status));
+ measureUnit.adoptInstead(MeasureUnit::createAmpere(status));
+ measureUnit.adoptInstead(MeasureUnit::createMilliampere(status));
+ measureUnit.adoptInstead(MeasureUnit::createOhm(status));
+ measureUnit.adoptInstead(MeasureUnit::createVolt(status));
+ measureUnit.adoptInstead(MeasureUnit::createCalorie(status));
+ measureUnit.adoptInstead(MeasureUnit::createFoodcalorie(status));
+ measureUnit.adoptInstead(MeasureUnit::createJoule(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilocalorie(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilojoule(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilowattHour(status));
+ measureUnit.adoptInstead(MeasureUnit::createGigahertz(status));
+ measureUnit.adoptInstead(MeasureUnit::createHertz(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilohertz(status));
+ measureUnit.adoptInstead(MeasureUnit::createMegahertz(status));
+ measureUnit.adoptInstead(MeasureUnit::createAstronomicalUnit(status));
+ measureUnit.adoptInstead(MeasureUnit::createCentimeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createDecimeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createFathom(status));
+ measureUnit.adoptInstead(MeasureUnit::createFoot(status));
+ measureUnit.adoptInstead(MeasureUnit::createFurlong(status));
+ measureUnit.adoptInstead(MeasureUnit::createInch(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createLightYear(status));
+ measureUnit.adoptInstead(MeasureUnit::createMeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createMicrometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createMile(status));
+ measureUnit.adoptInstead(MeasureUnit::createMillimeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createNanometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createNauticalMile(status));
+ measureUnit.adoptInstead(MeasureUnit::createParsec(status));
+ measureUnit.adoptInstead(MeasureUnit::createPicometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createYard(status));
+ measureUnit.adoptInstead(MeasureUnit::createLux(status));
+ measureUnit.adoptInstead(MeasureUnit::createCarat(status));
+ measureUnit.adoptInstead(MeasureUnit::createGram(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilogram(status));
+ measureUnit.adoptInstead(MeasureUnit::createMetricTon(status));
+ measureUnit.adoptInstead(MeasureUnit::createMicrogram(status));
+ measureUnit.adoptInstead(MeasureUnit::createMilligram(status));
+ measureUnit.adoptInstead(MeasureUnit::createOunce(status));
+ measureUnit.adoptInstead(MeasureUnit::createOunceTroy(status));
+ measureUnit.adoptInstead(MeasureUnit::createPound(status));
+ measureUnit.adoptInstead(MeasureUnit::createStone(status));
+ measureUnit.adoptInstead(MeasureUnit::createTon(status));
+ measureUnit.adoptInstead(MeasureUnit::createGigawatt(status));
+ measureUnit.adoptInstead(MeasureUnit::createHorsepower(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilowatt(status));
+ measureUnit.adoptInstead(MeasureUnit::createMegawatt(status));
+ measureUnit.adoptInstead(MeasureUnit::createMilliwatt(status));
+ measureUnit.adoptInstead(MeasureUnit::createWatt(status));
+ measureUnit.adoptInstead(MeasureUnit::createHectopascal(status));
+ measureUnit.adoptInstead(MeasureUnit::createInchHg(status));
+ measureUnit.adoptInstead(MeasureUnit::createMillibar(status));
+ measureUnit.adoptInstead(MeasureUnit::createMillimeterOfMercury(status));
+ measureUnit.adoptInstead(MeasureUnit::createPoundPerSquareInch(status));
+ measureUnit.adoptInstead(MeasureUnit::createKarat(status));
+ measureUnit.adoptInstead(MeasureUnit::createKilometerPerHour(status));
+ measureUnit.adoptInstead(MeasureUnit::createMeterPerSecond(status));
+ measureUnit.adoptInstead(MeasureUnit::createMilePerHour(status));
+ measureUnit.adoptInstead(MeasureUnit::createCelsius(status));
+ measureUnit.adoptInstead(MeasureUnit::createFahrenheit(status));
+ measureUnit.adoptInstead(MeasureUnit::createKelvin(status));
+ measureUnit.adoptInstead(MeasureUnit::createAcreFoot(status));
+ measureUnit.adoptInstead(MeasureUnit::createBushel(status));
+ measureUnit.adoptInstead(MeasureUnit::createCentiliter(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicCentimeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicFoot(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicInch(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicKilometer(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicMeter(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicMile(status));
+ measureUnit.adoptInstead(MeasureUnit::createCubicYard(status));
+ measureUnit.adoptInstead(MeasureUnit::createCup(status));
+ measureUnit.adoptInstead(MeasureUnit::createDeciliter(status));
+ measureUnit.adoptInstead(MeasureUnit::createFluidOunce(status));
+ measureUnit.adoptInstead(MeasureUnit::createGallon(status));
+ measureUnit.adoptInstead(MeasureUnit::createHectoliter(status));
+ measureUnit.adoptInstead(MeasureUnit::createLiter(status));
+ measureUnit.adoptInstead(MeasureUnit::createMegaliter(status));
+ measureUnit.adoptInstead(MeasureUnit::createMilliliter(status));
+ measureUnit.adoptInstead(MeasureUnit::createPint(status));
+ measureUnit.adoptInstead(MeasureUnit::createQuart(status));
+ measureUnit.adoptInstead(MeasureUnit::createTablespoon(status));
+ measureUnit.adoptInstead(MeasureUnit::createTeaspoon(status));
+ assertSuccess("", status);
+}
+
+void MeasureFormatTest::TestBasic() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureUnit *ptr1 = MeasureUnit::createArcMinute(status);
+ MeasureUnit *ptr2 = MeasureUnit::createArcMinute(status);
+ if (!(*ptr1 == *ptr2)) {
+ errln("Expect == to work.");
+ }
+ if (*ptr1 != *ptr2) {
+ errln("Expect != to work.");
+ }
+ MeasureUnit *ptr3 = MeasureUnit::createMeter(status);
+ if (*ptr1 == *ptr3) {
+ errln("Expect == to work.");
+ }
+ if (!(*ptr1 != *ptr3)) {
+ errln("Expect != to work.");
+ }
+ MeasureUnit *ptr4 = (MeasureUnit *) ptr1->clone();
+ if (*ptr1 != *ptr4) {
+ errln("Expect clone to work.");
+ }
+ MeasureUnit stack;
+ stack = *ptr1;
+ if (*ptr1 != stack) {
+ errln("Expect assignment to work.");
+ }
+
+ delete ptr1;
+ delete ptr2;
+ delete ptr3;
+ delete ptr4;
+}
+
+void MeasureFormatTest::TestGetAvailable() {
+ MeasureUnit *units = NULL;
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t totalCount = MeasureUnit::getAvailable(units, 0, status);
+ while (status == U_BUFFER_OVERFLOW_ERROR) {
+ status = U_ZERO_ERROR;
+ delete [] units;
+ units = new MeasureUnit[totalCount];
+ totalCount = MeasureUnit::getAvailable(units, totalCount, status);
+ }
+ if (U_FAILURE(status)) {
+ dataerrln("Failure creating format object - %s", u_errorName(status));
+ delete [] units;
+ return;
+ }
+ if (totalCount < 200) {
+ errln("Expect at least 200 measure units including currencies.");
+ }
+ delete [] units;
+ StringEnumeration *types = MeasureUnit::getAvailableTypes(status);
+ if (U_FAILURE(status)) {
+ dataerrln("Failure getting types - %s", u_errorName(status));
+ delete types;
+ return;
+ }
+ if (types->count(status) < 10) {
+ errln("Expect at least 10 distinct unit types.");
+ }
+ units = NULL;
+ int32_t unitCapacity = 0;
+ int32_t unitCountSum = 0;
+ for (
+ const char* type = types->next(NULL, status);
+ type != NULL;
+ type = types->next(NULL, status)) {
+ int32_t unitCount = MeasureUnit::getAvailable(type, units, unitCapacity, status);
+ while (status == U_BUFFER_OVERFLOW_ERROR) {
+ status = U_ZERO_ERROR;
+ delete [] units;
+ units = new MeasureUnit[unitCount];
+ unitCapacity = unitCount;
+ unitCount = MeasureUnit::getAvailable(type, units, unitCapacity, status);
+ }
+ if (U_FAILURE(status)) {
+ dataerrln("Failure getting units - %s", u_errorName(status));
+ delete [] units;
+ delete types;
+ return;
+ }
+ if (unitCount < 1) {
+ errln("Expect at least one unit count per type.");
+ }
+ unitCountSum += unitCount;
+ }
+ if (unitCountSum != totalCount) {
+ errln("Expected total unit count to equal sum of unit counts by type.");
+ }
+ delete [] units;
+ delete types;
+}
+
+void MeasureFormatTest::TestExamplesInDocs() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureFormat fmtFr(Locale::getFrench(), UMEASFMT_WIDTH_SHORT, status);
+ MeasureFormat fmtFrFull(
+ Locale::getFrench(), UMEASFMT_WIDTH_WIDE, status);
+ MeasureFormat fmtFrNarrow(
+ Locale::getFrench(), UMEASFMT_WIDTH_NARROW, status);
+ MeasureFormat fmtEn(Locale::getUS(), UMEASFMT_WIDTH_WIDE, status);
+ if (!assertSuccess("Error creating formatters", status)) {
+ return;
+ }
+ Measure measureC(23, MeasureUnit::createCelsius(status), status);
+ Measure measureF(70, MeasureUnit::createFahrenheit(status), status);
+ Measure feetAndInches[] = {
+ Measure(70, MeasureUnit::createFoot(status), status),
+ Measure(5.3, MeasureUnit::createInch(status), status)};
+ Measure footAndInch[] = {
+ Measure(1, MeasureUnit::createFoot(status), status),
+ Measure(1, MeasureUnit::createInch(status), status)};
+ Measure inchAndFeet[] = {
+ Measure(1, MeasureUnit::createInch(status), status),
+ Measure(2, MeasureUnit::createFoot(status), status)};
+ if (!assertSuccess("Error creating measurements.", status)) {
+ return;
+ }
+ verifyFormat(
+ "Celsius",
+ fmtFr,
+ &measureC,
+ 1,
+ "23 \\u00B0C");
+ verifyFormatWithPrefix(
+ "Celsius",
+ fmtFr,
+ "Prefix: ",
+ &measureC,
+ 1,
+ "Prefix: 23 \\u00B0C");
+ verifyFormat(
+ "Fahrenheit",
+ fmtFr,
+ &measureF,
+ 1,
+ "70 \\u00B0F");
+ verifyFormat(
+ "Feet and inches",
+ fmtFrFull,
+ feetAndInches,
+ UPRV_LENGTHOF(feetAndInches),
+ "70 pieds et 5,3 pouces");
+ verifyFormatWithPrefix(
+ "Feet and inches",
+ fmtFrFull,
+ "Prefix: ",
+ feetAndInches,
+ UPRV_LENGTHOF(feetAndInches),
+ "Prefix: 70 pieds et 5,3 pouces");
+ verifyFormat(
+ "Foot and inch",
+ fmtFrFull,
+ footAndInch,
+ UPRV_LENGTHOF(footAndInch),
+ "1 pied et 1 pouce");
+ verifyFormat(
+ "Foot and inch narrow",
+ fmtFrNarrow,
+ footAndInch,
+ UPRV_LENGTHOF(footAndInch),
+ "1\\u2032 1\\u2033");
+ verifyFormat(
+ "Inch and feet",
+ fmtEn,
+ inchAndFeet,
+ UPRV_LENGTHOF(inchAndFeet),
+ "1 inch, 2 feet");
+}
+
+void MeasureFormatTest::TestFormatPeriodEn() {
+ UErrorCode status = U_ZERO_ERROR;
+ Measure t_19m[] = {Measure(19, MeasureUnit::createMinute(status), status)};
+ Measure t_1h_23_5s[] = {
+ Measure(1.0, MeasureUnit::createHour(status), status),
+ Measure(23.5, MeasureUnit::createSecond(status), status)
+ };
+ Measure t_1h_23_5m[] = {
+ Measure(1.0, MeasureUnit::createHour(status), status),
+ Measure(23.5, MeasureUnit::createMinute(status), status)
+ };
+ Measure t_1h_0m_23s[] = {
+ Measure(
+ 1.0,
+ TimeUnit::createInstance(
+ TimeUnit::UTIMEUNIT_HOUR, status),
+ status),
+ Measure(
+ 0.0,
+ TimeUnit::createInstance(
+ TimeUnit::UTIMEUNIT_MINUTE, status),
+ status),
+ Measure(
+ 23,
+ TimeUnit::createInstance(
+ TimeUnit::UTIMEUNIT_SECOND, status),
+ status)
+ };
+ Measure t_2y_5M_3w_4d[] = {
+ Measure(2.0, MeasureUnit::createYear(status), status),
+ Measure(5.0, MeasureUnit::createMonth(status), status),
+ Measure(3.0, MeasureUnit::createWeek(status), status),
+ Measure(4.0, MeasureUnit::createDay(status), status)
+ };
+ Measure t_1m_59_9996s[] = {
+ Measure(1.0, MeasureUnit::createMinute(status), status),
+ Measure(59.9996, MeasureUnit::createSecond(status), status)
+ };
+ Measure t_5h_17m[] = {
+ Measure(5.0, MeasureUnit::createHour(status), status),
+ Measure(17.0, MeasureUnit::createMinute(status), status)
+ };
+ Measure t_neg5h_17m[] = {
+ Measure(-5.0, MeasureUnit::createHour(status), status),
+ Measure(17.0, MeasureUnit::createMinute(status), status)
+ };
+ Measure t_19m_28s[] = {
+ Measure(19.0, MeasureUnit::createMinute(status), status),
+ Measure(28.0, MeasureUnit::createSecond(status), status)
+ };
+ Measure t_0h_0m_9s[] = {
+ Measure(0.0, MeasureUnit::createHour(status), status),
+ Measure(0.0, MeasureUnit::createMinute(status), status),
+ Measure(9.0, MeasureUnit::createSecond(status), status)
+ };
+ Measure t_0h_0m_17s[] = {
+ Measure(0.0, MeasureUnit::createHour(status), status),
+ Measure(0.0, MeasureUnit::createMinute(status), status),
+ Measure(17.0, MeasureUnit::createSecond(status), status)
+ };
+ Measure t_6h_56_92m[] = {
+ Measure(6.0, MeasureUnit::createHour(status), status),
+ Measure(56.92, MeasureUnit::createMinute(status), status)
+ };
+ Measure t_3h_4s_5m[] = {
+ Measure(3.0, MeasureUnit::createHour(status), status),
+ Measure(4.0, MeasureUnit::createSecond(status), status),
+ Measure(5.0, MeasureUnit::createMinute(status), status)
+ };
+ Measure t_6_7h_56_92m[] = {
+ Measure(6.7, MeasureUnit::createHour(status), status),
+ Measure(56.92, MeasureUnit::createMinute(status), status)
+ };
+
+ Measure t_3h_5h[] = {
+ Measure(3.0, MeasureUnit::createHour(status), status),
+ Measure(5.0, MeasureUnit::createHour(status), status)
+ };
+
+ if (!assertSuccess("Error creating Measure objects", status)) {
+ return;
+ }
+
+ ExpectedResult fullData[] = {
+ {t_1m_59_9996s, UPRV_LENGTHOF(t_1m_59_9996s), "1 minute, 59.9996 seconds"},
+ {t_19m, UPRV_LENGTHOF(t_19m), "19 minutes"},
+ {t_1h_23_5s, UPRV_LENGTHOF(t_1h_23_5s), "1 hour, 23.5 seconds"},
+ {t_1h_23_5m, UPRV_LENGTHOF(t_1h_23_5m), "1 hour, 23.5 minutes"},
+ {t_1h_0m_23s, UPRV_LENGTHOF(t_1h_0m_23s), "1 hour, 0 minutes, 23 seconds"},
+ {t_2y_5M_3w_4d, UPRV_LENGTHOF(t_2y_5M_3w_4d), "2 years, 5 months, 3 weeks, 4 days"}};
+
+ ExpectedResult abbrevData[] = {
+ {t_1m_59_9996s, UPRV_LENGTHOF(t_1m_59_9996s), "1 min, 59.9996 secs"},
+ {t_19m, UPRV_LENGTHOF(t_19m), "19 mins"},
+ {t_1h_23_5s, UPRV_LENGTHOF(t_1h_23_5s), "1 hr, 23.5 secs"},
+ {t_1h_23_5m, UPRV_LENGTHOF(t_1h_23_5m), "1 hr, 23.5 mins"},
+ {t_1h_0m_23s, UPRV_LENGTHOF(t_1h_0m_23s), "1 hr, 0 mins, 23 secs"},
+ {t_2y_5M_3w_4d, UPRV_LENGTHOF(t_2y_5M_3w_4d), "2 yrs, 5 mths, 3 wks, 4 days"}};
+
+ ExpectedResult narrowData[] = {
+ {t_1m_59_9996s, UPRV_LENGTHOF(t_1m_59_9996s), "1m 59.9996s"},
+ {t_19m, UPRV_LENGTHOF(t_19m), "19m"},
+ {t_1h_23_5s, UPRV_LENGTHOF(t_1h_23_5s), "1h 23.5s"},
+ {t_1h_23_5m, UPRV_LENGTHOF(t_1h_23_5m), "1h 23.5m"},
+ {t_1h_0m_23s, UPRV_LENGTHOF(t_1h_0m_23s), "1h 0m 23s"},
+ {t_2y_5M_3w_4d, UPRV_LENGTHOF(t_2y_5M_3w_4d), "2y 5m 3w 4d"}};
+
+ ExpectedResult numericData[] = {
+ {t_1m_59_9996s, UPRV_LENGTHOF(t_1m_59_9996s), "1:59.9996"},
+ {t_19m, UPRV_LENGTHOF(t_19m), "19m"},
+ {t_1h_23_5s, UPRV_LENGTHOF(t_1h_23_5s), "1:00:23.5"},
+ {t_1h_23_5m, UPRV_LENGTHOF(t_1h_23_5m), "1:23.5"},
+ {t_1h_0m_23s, UPRV_LENGTHOF(t_1h_0m_23s), "1:00:23"},
+ {t_5h_17m, UPRV_LENGTHOF(t_5h_17m), "5:17"},
+ {t_neg5h_17m, UPRV_LENGTHOF(t_neg5h_17m), "-5h 17m"},
+ {t_19m_28s, UPRV_LENGTHOF(t_19m_28s), "19:28"},
+ {t_2y_5M_3w_4d, UPRV_LENGTHOF(t_2y_5M_3w_4d), "2y 5m 3w 4d"},
+ {t_0h_0m_9s, UPRV_LENGTHOF(t_0h_0m_9s), "0:00:09"},
+ {t_6h_56_92m, UPRV_LENGTHOF(t_6h_56_92m), "6:56.92"},
+ {t_6_7h_56_92m, UPRV_LENGTHOF(t_6_7h_56_92m), "6:56.92"},
+ {t_3h_4s_5m, UPRV_LENGTHOF(t_3h_4s_5m), "3h 4s 5m"},
+ {t_3h_5h, UPRV_LENGTHOF(t_3h_5h), "3h 5h"}};
+
+ ExpectedResult fullDataDe[] = {
+ {t_1m_59_9996s, UPRV_LENGTHOF(t_1m_59_9996s), "1 Minute und 59,9996 Sekunden"},
+ {t_19m, UPRV_LENGTHOF(t_19m), "19 Minuten"},
+ {t_1h_23_5s, UPRV_LENGTHOF(t_1h_23_5s), "1 Stunde und 23,5 Sekunden"},
+ {t_1h_23_5m, UPRV_LENGTHOF(t_1h_23_5m), "1 Stunde und 23,5 Minuten"},
+ {t_1h_0m_23s, UPRV_LENGTHOF(t_1h_0m_23s), "1 Stunde, 0 Minuten und 23 Sekunden"},
+ {t_2y_5M_3w_4d, UPRV_LENGTHOF(t_2y_5M_3w_4d), "2 Jahre, 5 Monate, 3 Wochen und 4 Tage"}};
+
+ ExpectedResult numericDataDe[] = {
+ {t_1m_59_9996s, UPRV_LENGTHOF(t_1m_59_9996s), "1:59,9996"},
+ {t_19m, UPRV_LENGTHOF(t_19m), "19 Min."},
+ {t_1h_23_5s, UPRV_LENGTHOF(t_1h_23_5s), "1:00:23,5"},
+ {t_1h_23_5m, UPRV_LENGTHOF(t_1h_23_5m), "1:23,5"},
+ {t_1h_0m_23s, UPRV_LENGTHOF(t_1h_0m_23s), "1:00:23"},
+ {t_5h_17m, UPRV_LENGTHOF(t_5h_17m), "5:17"},
+ {t_19m_28s, UPRV_LENGTHOF(t_19m_28s), "19:28"},
+ {t_2y_5M_3w_4d, UPRV_LENGTHOF(t_2y_5M_3w_4d), "2 J, 5 M, 3 W und 4 T"},
+ {t_0h_0m_17s, UPRV_LENGTHOF(t_0h_0m_17s), "0:00:17"},
+ {t_6h_56_92m, UPRV_LENGTHOF(t_6h_56_92m), "6:56,92"},
+ {t_3h_5h, UPRV_LENGTHOF(t_3h_5h), "3 Std., 5 Std."}};
+
+ Locale en(Locale::getEnglish());
+ LocalPointer<NumberFormat> nf(NumberFormat::createInstance(en, status));
+ if (U_FAILURE(status)) {
+ dataerrln("Error creating number format en object - %s", u_errorName(status));
+ return;
+ }
+ nf->setMaximumFractionDigits(4);
+ MeasureFormat mf(en, UMEASFMT_WIDTH_WIDE, (NumberFormat *) nf->clone(), status);
+ if (!assertSuccess("Error creating measure format en WIDE", status)) {
+ return;
+ }
+ verifyFormat("en WIDE", mf, fullData, UPRV_LENGTHOF(fullData));
+
+ // exercise copy constructor
+ {
+ MeasureFormat mf2(mf);
+ verifyFormat("en WIDE copy", mf2, fullData, UPRV_LENGTHOF(fullData));
+ }
+ // exercise clone
+ {
+ MeasureFormat *mf3 = (MeasureFormat *) mf.clone();
+ verifyFormat("en WIDE copy", *mf3, fullData, UPRV_LENGTHOF(fullData));
+ delete mf3;
+ }
+ mf = MeasureFormat(en, UMEASFMT_WIDTH_SHORT, (NumberFormat *) nf->clone(), status);
+ if (!assertSuccess("Error creating measure format en SHORT", status)) {
+ return;
+ }
+ verifyFormat("en SHORT", mf, abbrevData, UPRV_LENGTHOF(abbrevData));
+ mf = MeasureFormat(en, UMEASFMT_WIDTH_NARROW, (NumberFormat *) nf->clone(), status);
+ if (!assertSuccess("Error creating measure format en NARROW", status)) {
+ return;
+ }
+ verifyFormat("en NARROW", mf, narrowData, UPRV_LENGTHOF(narrowData));
+ mf = MeasureFormat(en, UMEASFMT_WIDTH_NUMERIC, (NumberFormat *) nf->clone(), status);
+ if (!assertSuccess("Error creating measure format en NUMERIC", status)) {
+ return;
+ }
+ verifyFormat("en NUMERIC", mf, numericData, UPRV_LENGTHOF(numericData));
+
+ Locale de(Locale::getGerman());
+ nf.adoptInstead(NumberFormat::createInstance(de, status));
+ if (!assertSuccess("Error creating number format de object", status)) {
+ return;
+ }
+ nf->setMaximumFractionDigits(4);
+ mf = MeasureFormat(de, UMEASFMT_WIDTH_WIDE, (NumberFormat *) nf->clone(), status);
+ if (!assertSuccess("Error creating measure format de WIDE", status)) {
+ return;
+ }
+ verifyFormat("de WIDE", mf, fullDataDe, UPRV_LENGTHOF(fullDataDe));
+ mf = MeasureFormat(de, UMEASFMT_WIDTH_NUMERIC, (NumberFormat *) nf->clone(), status);
+ if (!assertSuccess("Error creating measure format de NUMERIC", status)) {
+ return;
+ }
+ verifyFormat("de NUMERIC", mf, numericDataDe, UPRV_LENGTHOF(numericDataDe));
+}
+
+void MeasureFormatTest::Test10219FractionalPlurals() {
+ Locale en(Locale::getEnglish());
+ double values[] = {1.588, 1.011};
+ const char *expected[2][3] = {
+ {"1 minute", "1.5 minutes", "1.58 minutes"},
+ {"1 minute", "1.0 minutes", "1.01 minutes"}
+ };
+ UErrorCode status = U_ZERO_ERROR;
+ for (int j = 0; j < UPRV_LENGTHOF(values); j++) {
+ for (int i = 0; i < UPRV_LENGTHOF(expected[j]); i++) {
+ DecimalFormat *df =
+ (DecimalFormat *) NumberFormat::createInstance(en, status);
+ if (U_FAILURE(status)) {
+ dataerrln("Error creating Number format - %s", u_errorName(status));
+ return;
+ }
+ df->setRoundingMode(DecimalFormat::kRoundDown);
+ df->setMinimumFractionDigits(i);
+ df->setMaximumFractionDigits(i);
+ MeasureFormat mf(en, UMEASFMT_WIDTH_WIDE, df, status);
+ if (!assertSuccess("Error creating Measure format", status)) {
+ return;
+ }
+ Measure measure(values[j], MeasureUnit::createMinute(status), status);
+ if (!assertSuccess("Error creating Measure unit", status)) {
+ return;
+ }
+ verifyFormat("Test10219", mf, &measure, 1, expected[j][i]);
+ }
+ }
+}
+
+static MeasureUnit toMeasureUnit(MeasureUnit *adopted) {
+ MeasureUnit result(*adopted);
+ delete adopted;
+ return result;
+}
+
+void MeasureFormatTest::TestGreek() {
+ Locale locales[] = {Locale("el_GR"), Locale("el")};
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureUnit units[] = {
+ toMeasureUnit(MeasureUnit::createSecond(status)),
+ toMeasureUnit(MeasureUnit::createMinute(status)),
+ toMeasureUnit(MeasureUnit::createHour(status)),
+ toMeasureUnit(MeasureUnit::createDay(status)),
+ toMeasureUnit(MeasureUnit::createWeek(status)),
+ toMeasureUnit(MeasureUnit::createMonth(status)),
+ toMeasureUnit(MeasureUnit::createYear(status))};
+ if (!assertSuccess("Error creating Measure units", status)) {
+ return;
+ }
+ UMeasureFormatWidth styles[] = {
+ UMEASFMT_WIDTH_WIDE,
+ UMEASFMT_WIDTH_SHORT};
+ int32_t numbers[] = {1, 7};
+ const char *expected[] = {
+ // "el_GR" 1 wide
+ "1 \\u03B4\\u03B5\\u03C5\\u03C4\\u03B5\\u03C1\\u03CC\\u03BB\\u03B5\\u03C0\\u03C4\\u03BF",
+ "1 \\u03BB\\u03B5\\u03C0\\u03C4\\u03CC",
+ "1 \\u03CE\\u03C1\\u03B1",
+ "1 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B1",
+ "1 \\u03B5\\u03B2\\u03B4\\u03BF\\u03BC\\u03AC\\u03B4\\u03B1",
+ "1 \\u03BC\\u03AE\\u03BD\\u03B1\\u03C2",
+ "1 \\u03AD\\u03C4\\u03BF\\u03C2",
+ // "el_GR" 1 short
+ "1 \\u03B4\\u03B5\\u03C5\\u03C4.",
+ "1 \\u03BB\\u03B5\\u03C0.",
+ "1 \\u03CE\\u03C1\\u03B1",
+ "1 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B1",
+ "1 \\u03B5\\u03B2\\u03B4.",
+ "1 \\u03BC\\u03AE\\u03BD.",
+ "1 \\u03AD\\u03C4.", // year (one)
+ // "el_GR" 7 wide
+ "7 \\u03B4\\u03B5\\u03C5\\u03C4\\u03B5\\u03C1\\u03CC\\u03BB\\u03B5\\u03C0\\u03C4\\u03B1",
+ "7 \\u03BB\\u03B5\\u03C0\\u03C4\\u03AC",
+ "7 \\u03CE\\u03C1\\u03B5\\u03C2",
+ "7 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B5\\u03C2",
+ "7 \\u03B5\\u03B2\\u03B4\\u03BF\\u03BC\\u03AC\\u03B4\\u03B5\\u03C2",
+ "7 \\u03BC\\u03AE\\u03BD\\u03B5\\u03C2",
+ "7 \\u03AD\\u03C4\\u03B7",
+ // "el_GR" 7 short
+ "7 \\u03B4\\u03B5\\u03C5\\u03C4.",
+ "7 \\u03BB\\u03B5\\u03C0.",
+ "7 \\u03CE\\u03C1.", // hour (other)
+ "7 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B5\\u03C2",
+ "7 \\u03B5\\u03B2\\u03B4.",
+ "7 \\u03BC\\u03AE\\u03BD.",
+ "7 \\u03AD\\u03C4.", // year (other)
+
+ // "el" 1 wide
+ "1 \\u03B4\\u03B5\\u03C5\\u03C4\\u03B5\\u03C1\\u03CC\\u03BB\\u03B5\\u03C0\\u03C4\\u03BF",
+ "1 \\u03BB\\u03B5\\u03C0\\u03C4\\u03CC",
+ "1 \\u03CE\\u03C1\\u03B1",
+ "1 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B1",
+ "1 \\u03B5\\u03B2\\u03B4\\u03BF\\u03BC\\u03AC\\u03B4\\u03B1",
+ "1 \\u03BC\\u03AE\\u03BD\\u03B1\\u03C2",
+ "1 \\u03AD\\u03C4\\u03BF\\u03C2",
+ // "el" 1 short
+ "1 \\u03B4\\u03B5\\u03C5\\u03C4.",
+ "1 \\u03BB\\u03B5\\u03C0.",
+ "1 \\u03CE\\u03C1\\u03B1",
+ "1 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B1",
+ "1 \\u03B5\\u03B2\\u03B4.",
+ "1 \\u03BC\\u03AE\\u03BD.",
+ "1 \\u03AD\\u03C4.", // year (one)
+ // "el" 7 wide
+ "7 \\u03B4\\u03B5\\u03C5\\u03C4\\u03B5\\u03C1\\u03CC\\u03BB\\u03B5\\u03C0\\u03C4\\u03B1",
+ "7 \\u03BB\\u03B5\\u03C0\\u03C4\\u03AC",
+ "7 \\u03CE\\u03C1\\u03B5\\u03C2",
+ "7 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B5\\u03C2",
+ "7 \\u03B5\\u03B2\\u03B4\\u03BF\\u03BC\\u03AC\\u03B4\\u03B5\\u03C2",
+ "7 \\u03BC\\u03AE\\u03BD\\u03B5\\u03C2",
+ "7 \\u03AD\\u03C4\\u03B7",
+ // "el" 7 short
+ "7 \\u03B4\\u03B5\\u03C5\\u03C4.",
+ "7 \\u03BB\\u03B5\\u03C0.",
+ "7 \\u03CE\\u03C1.", // hour (other)
+ "7 \\u03B7\\u03BC\\u03AD\\u03C1\\u03B5\\u03C2",
+ "7 \\u03B5\\u03B2\\u03B4.",
+ "7 \\u03BC\\u03AE\\u03BD.",
+ "7 \\u03AD\\u03C4."}; // year (other)
+
+ int32_t counter = 0;
+ for (int32_t locIndex = 0; locIndex < UPRV_LENGTHOF(locales); ++locIndex ) {
+ for( int32_t numIndex = 0; numIndex < UPRV_LENGTHOF(numbers); ++numIndex ) {
+ for ( int32_t styleIndex = 0; styleIndex < UPRV_LENGTHOF(styles); ++styleIndex ) {
+ for ( int32_t unitIndex = 0; unitIndex < UPRV_LENGTHOF(units); ++unitIndex ) {
+ Measure measure(numbers[numIndex], new MeasureUnit(units[unitIndex]), status);
+ if (!assertSuccess("Error creating Measure", status)) {
+ return;
+ }
+ MeasureFormat fmt(locales[locIndex], styles[styleIndex], status);
+ if (!assertSuccess("Error creating Measure format", status)) {
+ return;
+ }
+ verifyFormat("TestGreek", fmt, &measure, 1, expected[counter]);
+ ++counter;
+ }
+ }
+ }
+ }
+}
+
+void MeasureFormatTest::TestFormatSingleArg() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_WIDE, status);
+ if (!assertSuccess("Error creating formatter", status)) {
+ return;
+ }
+ UnicodeString buffer;
+ FieldPosition pos(0);
+ fmt.format(
+ new Measure(3.5, MeasureUnit::createFoot(status), status),
+ buffer,
+ pos,
+ status);
+ if (!assertSuccess("Error formatting", status)) {
+ return;
+ }
+ assertEquals(
+ "TestFormatSingleArg",
+ UnicodeString("3.5 feet"),
+ buffer);
+}
+
+void MeasureFormatTest::TestFormatMeasuresZeroArg() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_WIDE, status);
+ verifyFormat("TestFormatMeasuresZeroArg", fmt, NULL, 0, "");
+}
+
+void MeasureFormatTest::TestMultiplesWithPer() {
+ Locale en("en");
+ UErrorCode status = U_ZERO_ERROR;
+ LocalPointer<MeasureUnit> second(MeasureUnit::createSecond(status));
+ LocalPointer<MeasureUnit> minute(MeasureUnit::createMinute(status));
+ if (!assertSuccess("", status)) {
+ return;
+ }
+
+ // Per unit test.
+ helperTestMultiplesWithPer(
+ en, UMEASFMT_WIDTH_WIDE, *second, "2 miles, 1 foot, 2.3 inches per second");
+ helperTestMultiplesWithPer(
+ en, UMEASFMT_WIDTH_SHORT, *second, "2 mi, 1 ft, 2.3 inps");
+ helperTestMultiplesWithPer(
+ en, UMEASFMT_WIDTH_NARROW, *second, "2mi 1\\u2032 2.3\\u2033/s");
+
+ // Fallback compound per test
+ helperTestMultiplesWithPer(
+ en, UMEASFMT_WIDTH_WIDE, *minute, "2 miles, 1 foot, 2.3 inches per minute");
+ helperTestMultiplesWithPer(
+ en, UMEASFMT_WIDTH_SHORT, *minute, "2 mi, 1 ft, 2.3 in/min");
+ helperTestMultiplesWithPer(
+ en, UMEASFMT_WIDTH_NARROW, *minute, "2mi 1\\u2032 2.3\\u2033/m");
+}
+
+void MeasureFormatTest::TestSimplePer() {
+ Locale en("en");
+ UErrorCode status = U_ZERO_ERROR;
+ LocalPointer<MeasureUnit> second(MeasureUnit::createSecond(status));
+ LocalPointer<MeasureUnit> minute(MeasureUnit::createMinute(status));
+ LocalPointer<MeasureUnit> pound(MeasureUnit::createPound(status));
+ if (!assertSuccess("", status)) {
+ return;
+ }
+
+ helperTestSimplePer(
+ en, UMEASFMT_WIDTH_SHORT, 1.0, *pound, *second, "1 lbps");
+ helperTestSimplePer(
+ en, UMEASFMT_WIDTH_SHORT, 2.0, *pound, *second, "2 lbps");
+ helperTestSimplePer(
+ en, UMEASFMT_WIDTH_SHORT, 1.0, *pound, *minute, "1 lb/min");
+ helperTestSimplePer(
+ en, UMEASFMT_WIDTH_SHORT, 2.0, *pound, *minute, "2 lb/min");
+}
+
+void MeasureFormatTest::TestNumeratorPlurals() {
+ Locale pl("pl");
+ UErrorCode status = U_ZERO_ERROR;
+ LocalPointer<MeasureUnit> second(MeasureUnit::createSecond(status));
+ LocalPointer<MeasureUnit> foot(MeasureUnit::createFoot(status));
+ if (!assertSuccess("", status)) {
+ return;
+ }
+
+ helperTestSimplePer(
+ pl, UMEASFMT_WIDTH_WIDE, 1.0, *foot, *second, "1 stopa na sekund\\u0119");
+ helperTestSimplePer(
+ pl, UMEASFMT_WIDTH_WIDE, 2.0, *foot, *second, "2 stopy na sekund\\u0119");
+ helperTestSimplePer(
+ pl, UMEASFMT_WIDTH_WIDE, 5.0, *foot, *second, "5 st\\u00f3p na sekund\\u0119");
+ helperTestSimplePer(
+ pl, UMEASFMT_WIDTH_WIDE, 1.5, *foot, *second, "1,5 stopy na sekund\\u0119");
+}
+
+void MeasureFormatTest::helperTestSimplePer(
+ const Locale &locale,
+ UMeasureFormatWidth width,
+ double value,
+ const MeasureUnit &unit,
+ const MeasureUnit &perUnit,
+ const char *expected) {
+ UErrorCode status = U_ZERO_ERROR;
+ FieldPosition pos(0);
+ MeasureFormat fmt(locale, width, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ Measure measure(value, (MeasureUnit *) unit.clone(), status);
+ if (!assertSuccess("Error creating measure object", status)) {
+ return;
+ }
+ UnicodeString buffer;
+ fmt.formatMeasuresPer(
+ &measure,
+ 1,
+ perUnit,
+ buffer,
+ pos,
+ status);
+ if (!assertSuccess("Error formatting measures with per", status)) {
+ return;
+ }
+ assertEquals(
+ "TestSimplePer",
+ UnicodeString(expected).unescape(),
+ buffer);
+}
+
+void MeasureFormatTest::helperTestMultiplesWithPer(
+ const Locale &locale,
+ UMeasureFormatWidth width,
+ const MeasureUnit &perUnit,
+ const char *expected) {
+ UErrorCode status = U_ZERO_ERROR;
+ FieldPosition pos(0);
+ MeasureFormat fmt(locale, width, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ Measure measures[] = {
+ Measure(2, MeasureUnit::createMile(status), status),
+ Measure(1, MeasureUnit::createFoot(status), status),
+ Measure(2.3, MeasureUnit::createInch(status), status)};
+ if (!assertSuccess("Error creating measures", status)) {
+ return;
+ }
+ UnicodeString buffer;
+ fmt.formatMeasuresPer(
+ measures,
+ UPRV_LENGTHOF(measures),
+ perUnit,
+ buffer,
+ pos,
+ status);
+ if (!assertSuccess("Error formatting measures with per", status)) {
+ return;
+ }
+ assertEquals(
+ "TestMultiplesWithPer",
+ UnicodeString(expected).unescape(),
+ buffer);
+}
+
+void MeasureFormatTest::TestMultiples() {
+ Locale ru("ru");
+ Locale en("en");
+ helperTestMultiples(en, UMEASFMT_WIDTH_WIDE, "2 miles, 1 foot, 2.3 inches");
+ helperTestMultiples(en, UMEASFMT_WIDTH_SHORT, "2 mi, 1 ft, 2.3 in");
+ helperTestMultiples(en, UMEASFMT_WIDTH_NARROW, "2mi 1\\u2032 2.3\\u2033");
+ helperTestMultiples(ru, UMEASFMT_WIDTH_WIDE, "2 \\u043C\\u0438\\u043B\\u0438, 1 \\u0444\\u0443\\u0442 \\u0438 2,3 \\u0434\\u044E\\u0439\\u043C\\u0430");
+ helperTestMultiples(ru, UMEASFMT_WIDTH_SHORT, "2 \\u043C\\u0438\\u043B\\u0438, 1 \\u0444\\u0443\\u0442, 2,3 \\u0434\\u044E\\u0439\\u043C.");
+ helperTestMultiples(ru, UMEASFMT_WIDTH_NARROW, "2 \\u043C\\u0438\\u043B\\u044C 1 \\u0444\\u0443\\u0442 2,3 \\u0434\\u044E\\u0439\\u043C\\u0430");
+}
+
+void MeasureFormatTest::helperTestMultiples(
+ const Locale &locale,
+ UMeasureFormatWidth width,
+ const char *expected) {
+ UErrorCode status = U_ZERO_ERROR;
+ FieldPosition pos(0);
+ MeasureFormat fmt(locale, width, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ Measure measures[] = {
+ Measure(2, MeasureUnit::createMile(status), status),
+ Measure(1, MeasureUnit::createFoot(status), status),
+ Measure(2.3, MeasureUnit::createInch(status), status)};
+ if (!assertSuccess("Error creating measures", status)) {
+ return;
+ }
+ UnicodeString buffer;
+ fmt.formatMeasures(measures, UPRV_LENGTHOF(measures), buffer, pos, status);
+ if (!assertSuccess("Error formatting measures", status)) {
+ return;
+ }
+ assertEquals("TestMultiples", UnicodeString(expected).unescape(), buffer);
+}
+
+void MeasureFormatTest::TestGram() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ Measure gram(1, MeasureUnit::createGram(status), status);
+ Measure gforce(1, MeasureUnit::createGForce(status), status);
+ if (!assertSuccess("Error creating measures", status)) {
+ return;
+ }
+ verifyFormat("TestGram", fmt, &gram, 1, "1 g");
+ verifyFormat("TestGram", fmt, &gforce, 1, "1 G");
+}
+
+void MeasureFormatTest::TestCurrencies() {
+ UChar USD[] = {'U', 'S', 'D', 0};
+ UErrorCode status = U_ZERO_ERROR;
+ CurrencyAmount USD_1(1.0, USD, status);
+ CurrencyAmount USD_2(2.0, USD, status);
+ CurrencyAmount USD_NEG_1(-1.0, USD, status);
+ if (!assertSuccess("Error creating measures", status)) {
+ return;
+ }
+ Locale en("en");
+ MeasureFormat fmt(en, UMEASFMT_WIDTH_WIDE, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ verifyFormat("TestCurrenciesWide", fmt, &USD_NEG_1, 1, "-1.00 US dollars");
+ verifyFormat("TestCurrenciesWide", fmt, &USD_1, 1, "1.00 US dollars");
+ verifyFormat("TestCurrenciesWide", fmt, &USD_2, 1, "2.00 US dollars");
+ fmt = MeasureFormat(en, UMEASFMT_WIDTH_SHORT, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ verifyFormat("TestCurrenciesShort", fmt, &USD_NEG_1, 1, "-USD1.00");
+ verifyFormat("TestCurrenciesShort", fmt, &USD_1, 1, "USD1.00");
+ verifyFormat("TestCurrenciesShort", fmt, &USD_2, 1, "USD2.00");
+ fmt = MeasureFormat(en, UMEASFMT_WIDTH_NARROW, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ verifyFormat("TestCurrenciesNarrow", fmt, &USD_NEG_1, 1, "-$1.00");
+ verifyFormat("TestCurrenciesNarrow", fmt, &USD_1, 1, "$1.00");
+ verifyFormat("TestCurrenciesNarrow", fmt, &USD_2, 1, "$2.00");
+ fmt = MeasureFormat(en, UMEASFMT_WIDTH_NUMERIC, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ verifyFormat("TestCurrenciesNumeric", fmt, &USD_NEG_1, 1, "-$1.00");
+ verifyFormat("TestCurrenciesNumeric", fmt, &USD_1, 1, "$1.00");
+ verifyFormat("TestCurrenciesNumeric", fmt, &USD_2, 1, "$2.00");
+}
+
+void MeasureFormatTest::TestFieldPosition() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ Measure measure(43.5, MeasureUnit::createFoot(status), status);
+ if (!assertSuccess("Error creating measure object 1", status)) {
+ return;
+ }
+ UnicodeString prefix("123456: ");
+ verifyFieldPosition(
+ "",
+ fmt,
+ prefix,
+ &measure,
+ 1,
+ NumberFormat::kDecimalSeparatorField,
+ 10,
+ 11);
+ measure = Measure(43, MeasureUnit::createFoot(status), status);
+ if (!assertSuccess("Error creating measure object 2", status)) {
+ return;
+ }
+ verifyFieldPosition(
+ "",
+ fmt,
+ prefix,
+ &measure,
+ 1,
+ NumberFormat::kDecimalSeparatorField,
+ 0,
+ 0);
+}
+
+void MeasureFormatTest::TestFieldPositionMultiple() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ Measure first[] = {
+ Measure(354, MeasureUnit::createMeter(status), status),
+ Measure(23, MeasureUnit::createCentimeter(status), status)};
+ Measure second[] = {
+ Measure(354, MeasureUnit::createMeter(status), status),
+ Measure(23, MeasureUnit::createCentimeter(status), status),
+ Measure(5.4, MeasureUnit::createMillimeter(status), status)};
+ Measure third[] = {
+ Measure(3, MeasureUnit::createMeter(status), status),
+ Measure(23, MeasureUnit::createCentimeter(status), status),
+ Measure(5, MeasureUnit::createMillimeter(status), status)};
+ if (!assertSuccess("Error creating measure objects", status)) {
+ return;
+ }
+ UnicodeString prefix("123456: ");
+ verifyFieldPosition(
+ "Integer",
+ fmt,
+ prefix,
+ first,
+ UPRV_LENGTHOF(first),
+ NumberFormat::kIntegerField,
+ 8,
+ 11);
+ verifyFieldPosition(
+ "Decimal separator",
+ fmt,
+ prefix,
+ second,
+ UPRV_LENGTHOF(second),
+ NumberFormat::kDecimalSeparatorField,
+ 23,
+ 24);
+ verifyFieldPosition(
+ "no decimal separator",
+ fmt,
+ prefix,
+ third,
+ UPRV_LENGTHOF(third),
+ NumberFormat::kDecimalSeparatorField,
+ 0,
+ 0);
+}
+
+void MeasureFormatTest::TestFieldPositionMultipleWithPer() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ Measure first[] = {
+ Measure(354, MeasureUnit::createMeter(status), status),
+ Measure(23, MeasureUnit::createCentimeter(status), status)};
+ Measure second[] = {
+ Measure(354, MeasureUnit::createMeter(status), status),
+ Measure(23, MeasureUnit::createCentimeter(status), status),
+ Measure(5.4, MeasureUnit::createMillimeter(status), status)};
+ Measure third[] = {
+ Measure(3, MeasureUnit::createMeter(status), status),
+ Measure(23, MeasureUnit::createCentimeter(status), status),
+ Measure(5, MeasureUnit::createMillimeter(status), status)};
+ if (!assertSuccess("Error creating measure objects", status)) {
+ return;
+ }
+ UnicodeString prefix("123456: ");
+
+ LocalPointer<MeasureUnit> secondUnit(MeasureUnit::createSecond(status));
+ LocalPointer<MeasureUnit> minuteUnit(MeasureUnit::createMinute(status));
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+
+ // per unit test
+ verifyFieldPositionWithPer(
+ "Integer",
+ fmt,
+ prefix,
+ first,
+ UPRV_LENGTHOF(first),
+ *secondUnit,
+ NumberFormat::kIntegerField,
+ 8,
+ 11);
+ verifyFieldPositionWithPer(
+ "Decimal separator",
+ fmt,
+ prefix,
+ second,
+ UPRV_LENGTHOF(second),
+ *secondUnit,
+ NumberFormat::kDecimalSeparatorField,
+ 23,
+ 24);
+ verifyFieldPositionWithPer(
+ "no decimal separator",
+ fmt,
+ prefix,
+ third,
+ UPRV_LENGTHOF(third),
+ *secondUnit,
+ NumberFormat::kDecimalSeparatorField,
+ 0,
+ 0);
+
+ // Fallback to compound per test
+ verifyFieldPositionWithPer(
+ "Integer",
+ fmt,
+ prefix,
+ first,
+ UPRV_LENGTHOF(first),
+ *minuteUnit,
+ NumberFormat::kIntegerField,
+ 8,
+ 11);
+ verifyFieldPositionWithPer(
+ "Decimal separator",
+ fmt,
+ prefix,
+ second,
+ UPRV_LENGTHOF(second),
+ *minuteUnit,
+ NumberFormat::kDecimalSeparatorField,
+ 23,
+ 24);
+ verifyFieldPositionWithPer(
+ "no decimal separator",
+ fmt,
+ prefix,
+ third,
+ UPRV_LENGTHOF(third),
+ *minuteUnit,
+ NumberFormat::kDecimalSeparatorField,
+ 0,
+ 0);
+}
+
+void MeasureFormatTest::TestBadArg() {
+ UErrorCode status = U_ZERO_ERROR;
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ FieldPosition pos(0);
+ UnicodeString buffer;
+ fmt.format(
+ 9.3,
+ buffer,
+ pos,
+ status);
+ if (status != U_ILLEGAL_ARGUMENT_ERROR) {
+ errln("Expected ILLEGAL_ARGUMENT_ERROR");
+ }
+}
+
+void MeasureFormatTest::TestEquality() {
+ UErrorCode status = U_ZERO_ERROR;
+ NumberFormat* nfeq = NumberFormat::createInstance("en", status);
+ NumberFormat* nfne = NumberFormat::createInstance("fr", status);
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_SHORT, status);
+ MeasureFormat fmtEq2("en", UMEASFMT_WIDTH_SHORT, nfeq, status);
+ MeasureFormat fmtne1("en", UMEASFMT_WIDTH_WIDE, status);
+ MeasureFormat fmtne2("fr", UMEASFMT_WIDTH_SHORT, status);
+ MeasureFormat fmtne3("en", UMEASFMT_WIDTH_SHORT, nfne, status);
+ if (U_FAILURE(status)) {
+ dataerrln("Error creating MeasureFormats - %s", u_errorName(status));
+ return;
+ }
+ MeasureFormat fmtEq(fmt);
+ assertTrue("Equal", fmt == fmtEq);
+ assertTrue("Equal2", fmt == fmtEq2);
+ assertFalse("Equal Neg", fmt != fmtEq);
+ assertTrue("Not Equal 1", fmt != fmtne1);
+ assertFalse("Not Equal Neg 1", fmt == fmtne1);
+ assertTrue("Not Equal 2", fmt != fmtne2);
+ assertTrue("Not Equal 3", fmt != fmtne3);
+}
+
+void MeasureFormatTest::TestGroupingSeparator() {
+ UErrorCode status = U_ZERO_ERROR;
+ Locale en("en");
+ MeasureFormat fmt(en, UMEASFMT_WIDTH_SHORT, status);
+ if (!assertSuccess("Error creating format object", status)) {
+ return;
+ }
+ Measure ms[] = {
+ Measure(INT32_MAX, MeasureUnit::createYear(status), status),
+ Measure(INT32_MIN, MeasureUnit::createMonth(status), status),
+ Measure(-987, MeasureUnit::createDay(status), status),
+ Measure(1362, MeasureUnit::createHour(status), status),
+ Measure(987, MeasureUnit::createMinute(status), status)};
+ FieldPosition pos(NumberFormat::kGroupingSeparatorField);
+ UnicodeString appendTo;
+ fmt.formatMeasures(ms, 5, appendTo, pos, status);
+ if (!assertSuccess("Error formatting", status)) {
+ return;
+ }
+ assertEquals(
+ "grouping separator",
+ "2,147,483,647 yrs, -2,147,483,648 mths, -987 days, 1,362 hrs, 987 mins",
+ appendTo);
+ assertEquals("begin index", 9, pos.getBeginIndex());
+ assertEquals("end index", 10, pos.getEndIndex());
+}
+
+void MeasureFormatTest::TestDoubleZero() {
+ UErrorCode status = U_ZERO_ERROR;
+ Measure measures[] = {
+ Measure(4.7, MeasureUnit::createHour(status), status),
+ Measure(23, MeasureUnit::createMinute(status), status),
+ Measure(16, MeasureUnit::createSecond(status), status)};
+ Locale en("en");
+ NumberFormat *nf = NumberFormat::createInstance(en, status);
+ MeasureFormat fmt("en", UMEASFMT_WIDTH_WIDE, nf, status);
+ UnicodeString appendTo;
+ FieldPosition pos(FieldPosition::DONT_CARE);
+ if (U_FAILURE(status)) {
+ dataerrln("Error creating formatter - %s", u_errorName(status));
+ return;
+ }
+ nf->setMinimumFractionDigits(2);
+ nf->setMaximumFractionDigits(2);
+ fmt.formatMeasures(measures, UPRV_LENGTHOF(measures), appendTo, pos, status);
+ if (!assertSuccess("Error formatting", status)) {
+ return;
+ }
+ assertEquals(
+ "TestDoubleZero",
+ UnicodeString("4 hours, 23 minutes, 16.00 seconds"),
+ appendTo);
+ measures[0] = Measure(-4.7, MeasureUnit::createHour(status), status);
+ appendTo.remove();
+ fmt.formatMeasures(measures, UPRV_LENGTHOF(measures), appendTo, pos, status);
+ if (!assertSuccess("Error formatting", status)) {
+ return;
+ }
+ assertEquals(
+ "TestDoubleZero",
+ UnicodeString("-4 hours, 23 minutes, 16.00 seconds"),
+ appendTo);
+}
+
+void MeasureFormatTest::verifyFieldPosition(
+ const char *description,
+ const MeasureFormat &fmt,
+ const UnicodeString &prefix,
+ const Measure *measures,
+ int32_t measureCount,
+ NumberFormat::EAlignmentFields field,
+ int32_t start,
+ int32_t end) {
+ // 8 char lead
+ UnicodeString result(prefix);
+ FieldPosition pos(field);
+ UErrorCode status = U_ZERO_ERROR;
+ CharString ch;
+ const char *descPrefix = ch.append(description, status)
+ .append(": ", status).data();
+ CharString beginIndex;
+ beginIndex.append(descPrefix, status).append("beginIndex", status);
+ CharString endIndex;
+ endIndex.append(descPrefix, status).append("endIndex", status);
+ fmt.formatMeasures(measures, measureCount, result, pos, status);
+ if (!assertSuccess("Error formatting", status)) {
+ return;
+ }
+ assertEquals(beginIndex.data(), start, pos.getBeginIndex());
+ assertEquals(endIndex.data(), end, pos.getEndIndex());
+}
+
+void MeasureFormatTest::verifyFieldPositionWithPer(
+ const char *description,
+ const MeasureFormat &fmt,
+ const UnicodeString &prefix,
+ const Measure *measures,
+ int32_t measureCount,
+ const MeasureUnit &perUnit,
+ NumberFormat::EAlignmentFields field,
+ int32_t start,
+ int32_t end) {
+ UnicodeString result(prefix);
+ FieldPosition pos(field);
+ UErrorCode status = U_ZERO_ERROR;
+ CharString ch;
+ const char *descPrefix = ch.append(description, status)
+ .append(": ", status).data();
+ CharString beginIndex;
+ beginIndex.append(descPrefix, status).append("beginIndex", status);
+ CharString endIndex;
+ endIndex.append(descPrefix, status).append("endIndex", status);
+ fmt.formatMeasuresPer(
+ measures,
+ measureCount,
+ perUnit,
+ result,
+ pos,
+ status);
+ if (!assertSuccess("Error formatting", status)) {
+ return;
+ }
+ assertEquals(beginIndex.data(), start, pos.getBeginIndex());
+ assertEquals(endIndex.data(), end, pos.getEndIndex());
+}
+
+void MeasureFormatTest::verifyFormat(
+ const char *description,
+ const MeasureFormat &fmt,
+ const Measure *measures,
+ int32_t measureCount,
+ const char *expected) {
+ verifyFormatWithPrefix(
+ description,
+ fmt,
+ "",
+ measures,
+ measureCount,
+ expected);
+}
+
+void MeasureFormatTest::verifyFormatWithPrefix(
+ const char *description,
+ const MeasureFormat &fmt,
+ const UnicodeString &prefix,
+ const Measure *measures,
+ int32_t measureCount,
+ const char *expected) {
+ UnicodeString result(prefix);
+ FieldPosition pos(0);
+ UErrorCode status = U_ZERO_ERROR;
+ fmt.formatMeasures(measures, measureCount, result, pos, status);
+ if (!assertSuccess("Error formatting", status)) {
+ return;
+ }
+ assertEquals(description, UnicodeString(expected).unescape(), result);
+}
+
+void MeasureFormatTest::verifyFormat(
+ const char *description,
+ const MeasureFormat &fmt,
+ const ExpectedResult *expectedResults,
+ int32_t count) {
+ for (int32_t i = 0; i < count; ++i) {
+ verifyFormat(description, fmt, expectedResults[i].measures, expectedResults[i].count, expectedResults[i].expected);
+ }
+}
+
+extern IntlTest *createMeasureFormatTest() {
+ return new MeasureFormatTest();
+}
+
+#endif
+
« no previous file with comments | « source/test/intltest/loctest.cpp ('k') | source/test/intltest/nptrans.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698