309 lines
11 KiB
C++
309 lines
11 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#include <set>
|
|
|
|
#include "unicode/formattedvalue.h"
|
|
#include "unicode/unum.h"
|
|
#include "unicode/udat.h"
|
|
#include "intltest.h"
|
|
#include "itformat.h"
|
|
|
|
|
|
class FormattedValueTest : public IntlTest {
|
|
public:
|
|
void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
|
|
private:
|
|
void testBasic();
|
|
void testSetters();
|
|
void testLocalPointer();
|
|
|
|
void assertAllPartsEqual(
|
|
UnicodeString messagePrefix,
|
|
const ConstrainedFieldPosition& cfpos,
|
|
int32_t matching,
|
|
UFieldCategory category,
|
|
int32_t field,
|
|
int32_t start,
|
|
int32_t limit,
|
|
int64_t context);
|
|
};
|
|
|
|
void FormattedValueTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char *) {
|
|
if (exec) {
|
|
logln("TestSuite FormattedValueTest: ");
|
|
}
|
|
TESTCASE_AUTO_BEGIN;
|
|
TESTCASE_AUTO(testBasic);
|
|
TESTCASE_AUTO(testSetters);
|
|
TESTCASE_AUTO(testLocalPointer);
|
|
TESTCASE_AUTO_END;
|
|
}
|
|
|
|
|
|
void FormattedValueTest::testBasic() {
|
|
IcuTestErrorCode status(*this, "testBasic");
|
|
ConstrainedFieldPosition cfpos;
|
|
assertAllPartsEqual(
|
|
u"basic",
|
|
cfpos,
|
|
7,
|
|
UFIELD_CATEGORY_UNDEFINED,
|
|
0,
|
|
0,
|
|
0,
|
|
0LL);
|
|
}
|
|
|
|
void FormattedValueTest::testSetters() {
|
|
IcuTestErrorCode status(*this, "testSetters");
|
|
ConstrainedFieldPosition cfpos;
|
|
|
|
cfpos.constrainCategory(UFIELD_CATEGORY_DATE);
|
|
assertAllPartsEqual(
|
|
u"setters 0",
|
|
cfpos,
|
|
4,
|
|
UFIELD_CATEGORY_DATE,
|
|
0,
|
|
0,
|
|
0,
|
|
0LL);
|
|
|
|
cfpos.constrainField(UFIELD_CATEGORY_NUMBER, UNUM_COMPACT_FIELD);
|
|
assertAllPartsEqual(
|
|
u"setters 1",
|
|
cfpos,
|
|
2,
|
|
UFIELD_CATEGORY_NUMBER,
|
|
UNUM_COMPACT_FIELD,
|
|
0,
|
|
0,
|
|
0LL);
|
|
|
|
cfpos.setInt64IterationContext(42424242424242LL);
|
|
assertAllPartsEqual(
|
|
u"setters 2",
|
|
cfpos,
|
|
2,
|
|
UFIELD_CATEGORY_NUMBER,
|
|
UNUM_COMPACT_FIELD,
|
|
0,
|
|
0,
|
|
42424242424242LL);
|
|
|
|
cfpos.setState(UFIELD_CATEGORY_NUMBER, UNUM_COMPACT_FIELD, 5, 10);
|
|
assertAllPartsEqual(
|
|
u"setters 3",
|
|
cfpos,
|
|
2,
|
|
UFIELD_CATEGORY_NUMBER,
|
|
UNUM_COMPACT_FIELD,
|
|
5,
|
|
10,
|
|
42424242424242LL);
|
|
|
|
cfpos.reset();
|
|
assertAllPartsEqual(
|
|
u"setters 4",
|
|
cfpos,
|
|
7,
|
|
UFIELD_CATEGORY_UNDEFINED,
|
|
0,
|
|
0,
|
|
0,
|
|
0LL);
|
|
}
|
|
|
|
void FormattedValueTest::testLocalPointer() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
LocalUConstrainedFieldPositionPointer ucfpos(ucfpos_open(&status));
|
|
assertSuccess("Openining LocalUConstrainedFieldPositionPointer", status);
|
|
assertEquals(u"Test that object is valid",
|
|
0LL,
|
|
ucfpos_getInt64IterationContext(ucfpos.getAlias(), &status));
|
|
assertSuccess("Using LocalUConstrainedFieldPositionPointer", status);
|
|
}
|
|
|
|
/** For matching, turn on these bits:
|
|
*
|
|
* 1 = UNUM_INTEGER_FIELD
|
|
* 2 = UNUM_COMPACT_FIELD
|
|
* 4 = UDAT_AM_PM_FIELD
|
|
*/
|
|
void FormattedValueTest::assertAllPartsEqual(
|
|
UnicodeString messagePrefix,
|
|
const ConstrainedFieldPosition& cfpos,
|
|
int32_t matching,
|
|
UFieldCategory category,
|
|
int32_t field,
|
|
int32_t start,
|
|
int32_t limit,
|
|
int64_t context) {
|
|
assertEquals(messagePrefix + u": category",
|
|
category, cfpos.getCategory());
|
|
assertEquals(messagePrefix + u": field",
|
|
field, cfpos.getField());
|
|
assertEquals(messagePrefix + u": start",
|
|
start, cfpos.getStart());
|
|
assertEquals(messagePrefix + u": limit",
|
|
limit, cfpos.getLimit());
|
|
assertEquals(messagePrefix + u": context",
|
|
context, cfpos.getInt64IterationContext());
|
|
|
|
assertEquals(messagePrefix + u": integer field",
|
|
(UBool) ((matching & 1) != 0), cfpos.matchesField(UFIELD_CATEGORY_NUMBER, UNUM_INTEGER_FIELD));
|
|
assertEquals(messagePrefix + u": compact field",
|
|
(UBool) ((matching & 2) != 0), cfpos.matchesField(UFIELD_CATEGORY_NUMBER, UNUM_COMPACT_FIELD));
|
|
assertEquals(messagePrefix + u": date field",
|
|
(UBool) ((matching & 4) != 0), cfpos.matchesField(UFIELD_CATEGORY_DATE, UDAT_AM_PM_FIELD));
|
|
}
|
|
|
|
|
|
void IntlTestWithFieldPosition::checkFormattedValue(
|
|
const char16_t* message,
|
|
const FormattedValue& fv,
|
|
UnicodeString expectedString,
|
|
UFieldCategory expectedCategory,
|
|
const UFieldPosition* expectedFieldPositions,
|
|
int32_t length) {
|
|
LocalArray<UFieldPositionWithCategory> converted(new UFieldPositionWithCategory[length]);
|
|
for (int32_t i=0; i<length; i++) {
|
|
converted[i].category = expectedCategory;
|
|
converted[i].field = expectedFieldPositions[i].field;
|
|
converted[i].beginIndex = expectedFieldPositions[i].beginIndex;
|
|
converted[i].endIndex = expectedFieldPositions[i].endIndex;
|
|
}
|
|
checkMixedFormattedValue(message, fv, expectedString, converted.getAlias(), length);
|
|
}
|
|
|
|
|
|
UnicodeString CFPosToUnicodeString(const ConstrainedFieldPosition& cfpos) {
|
|
UnicodeString sb;
|
|
sb.append(u"CFPos[");
|
|
sb.append(Int64ToUnicodeString(cfpos.getStart()));
|
|
sb.append(u'-');
|
|
sb.append(Int64ToUnicodeString(cfpos.getLimit()));
|
|
sb.append(u' ');
|
|
sb.append(Int64ToUnicodeString(cfpos.getCategory()));
|
|
sb.append(u':');
|
|
sb.append(Int64ToUnicodeString(cfpos.getField()));
|
|
sb.append(u']');
|
|
return sb;
|
|
}
|
|
|
|
|
|
void IntlTestWithFieldPosition::checkMixedFormattedValue(
|
|
const char16_t* message,
|
|
const FormattedValue& fv,
|
|
UnicodeString expectedString,
|
|
const UFieldPositionWithCategory* expectedFieldPositions,
|
|
int32_t length) {
|
|
IcuTestErrorCode status(*this, "checkMixedFormattedValue");
|
|
UnicodeString baseMessage = UnicodeString(message) + u": " + fv.toString(status) + u": ";
|
|
|
|
// Check string values
|
|
assertEquals(baseMessage + u"string", expectedString, fv.toString(status));
|
|
assertEquals(baseMessage + u"temp string", expectedString, fv.toTempString(status));
|
|
|
|
// The temp string is guaranteed to be NUL-terminated
|
|
UnicodeString readOnlyAlias = fv.toTempString(status);
|
|
if (!status.errIfFailureAndReset()) {
|
|
assertEquals(baseMessage + u"NUL-terminated",
|
|
0, readOnlyAlias.getBuffer()[readOnlyAlias.length()]);
|
|
}
|
|
|
|
// Check nextPosition over all fields
|
|
ConstrainedFieldPosition cfpos;
|
|
for (int32_t i = 0; i < length; i++) {
|
|
assertTrue(baseMessage + u"A has next position @ " + Int64ToUnicodeString(i),
|
|
fv.nextPosition(cfpos, status));
|
|
int32_t expectedCategory = expectedFieldPositions[i].category;
|
|
int32_t expectedField = expectedFieldPositions[i].field;
|
|
int32_t expectedStart = expectedFieldPositions[i].beginIndex;
|
|
int32_t expectedLimit = expectedFieldPositions[i].endIndex;
|
|
assertEquals(baseMessage + u"A category @ " + Int64ToUnicodeString(i),
|
|
expectedCategory, cfpos.getCategory());
|
|
assertEquals(baseMessage + u"A field @ " + Int64ToUnicodeString(i),
|
|
expectedField, cfpos.getField());
|
|
assertEquals(baseMessage + u"A start @ " + Int64ToUnicodeString(i),
|
|
expectedStart, cfpos.getStart());
|
|
assertEquals(baseMessage + u"A limit @ " + Int64ToUnicodeString(i),
|
|
expectedLimit, cfpos.getLimit());
|
|
}
|
|
UBool afterLoopResult = fv.nextPosition(cfpos, status);
|
|
assertFalse(baseMessage + u"A after loop: " + CFPosToUnicodeString(cfpos), afterLoopResult);
|
|
|
|
// Check nextPosition constrained over each category one at a time
|
|
for (int32_t category=0; category<UFIELD_CATEGORY_COUNT; category++) {
|
|
cfpos.reset();
|
|
cfpos.constrainCategory(static_cast<UFieldCategory>(category));
|
|
for (int32_t i = 0; i < length; i++) {
|
|
if (expectedFieldPositions[i].category != category) {
|
|
continue;
|
|
}
|
|
assertTrue(baseMessage + u"B has next position @ " + Int64ToUnicodeString(i),
|
|
fv.nextPosition(cfpos, status));
|
|
int32_t expectedCategory = expectedFieldPositions[i].category;
|
|
int32_t expectedField = expectedFieldPositions[i].field;
|
|
int32_t expectedStart = expectedFieldPositions[i].beginIndex;
|
|
int32_t expectedLimit = expectedFieldPositions[i].endIndex;
|
|
assertEquals(baseMessage + u"B category @ " + Int64ToUnicodeString(i),
|
|
expectedCategory, cfpos.getCategory());
|
|
assertEquals(baseMessage + u"B field @ " + Int64ToUnicodeString(i),
|
|
expectedField, cfpos.getField());
|
|
assertEquals(baseMessage + u"B start @ " + Int64ToUnicodeString(i),
|
|
expectedStart, cfpos.getStart());
|
|
assertEquals(baseMessage + u"B limit @ " + Int64ToUnicodeString(i),
|
|
expectedLimit, cfpos.getLimit());
|
|
}
|
|
UBool afterLoopResult = fv.nextPosition(cfpos, status);
|
|
assertFalse(baseMessage + u"B after loop @ " + CFPosToUnicodeString(cfpos), afterLoopResult);
|
|
}
|
|
|
|
// Check nextPosition constrained over each field one at a time
|
|
std::set<std::pair<UFieldCategory, int32_t>> uniqueFields;
|
|
for (int32_t i = 0; i < length; i++) {
|
|
uniqueFields.insert({expectedFieldPositions[i].category, expectedFieldPositions[i].field});
|
|
}
|
|
for (std::pair<UFieldCategory, int32_t> categoryAndField : uniqueFields) {
|
|
cfpos.reset();
|
|
cfpos.constrainField(categoryAndField.first, categoryAndField.second);
|
|
for (int32_t i = 0; i < length; i++) {
|
|
if (expectedFieldPositions[i].category != categoryAndField.first) {
|
|
continue;
|
|
}
|
|
if (expectedFieldPositions[i].field != categoryAndField.second) {
|
|
continue;
|
|
}
|
|
assertTrue(baseMessage + u"C has next position @ " + Int64ToUnicodeString(i),
|
|
fv.nextPosition(cfpos, status));
|
|
int32_t expectedCategory = expectedFieldPositions[i].category;
|
|
int32_t expectedField = expectedFieldPositions[i].field;
|
|
int32_t expectedStart = expectedFieldPositions[i].beginIndex;
|
|
int32_t expectedLimit = expectedFieldPositions[i].endIndex;
|
|
assertEquals(baseMessage + u"C category @ " + Int64ToUnicodeString(i),
|
|
expectedCategory, cfpos.getCategory());
|
|
assertEquals(baseMessage + u"C field @ " + Int64ToUnicodeString(i),
|
|
expectedField, cfpos.getField());
|
|
assertEquals(baseMessage + u"C start @ " + Int64ToUnicodeString(i),
|
|
expectedStart, cfpos.getStart());
|
|
assertEquals(baseMessage + u"C limit @ " + Int64ToUnicodeString(i),
|
|
expectedLimit, cfpos.getLimit());
|
|
}
|
|
UBool afterLoopResult = fv.nextPosition(cfpos, status);
|
|
assertFalse(baseMessage + u"C after loop: " + CFPosToUnicodeString(cfpos), afterLoopResult);
|
|
}
|
|
}
|
|
|
|
|
|
extern IntlTest *createFormattedValueTest() {
|
|
return new FormattedValueTest();
|
|
}
|
|
|
|
#endif /* !UCONFIG_NO_FORMATTING */
|