/*
Disables a replacement rule given by the replacementRule parameter
*/
void PortingRules::disableRule(QtSimpleXml &replacementRule)
{
RuleDescription ruleDescription(replacementRule);
disabledRules.append(ruleDescription);
}
/*
Checks if a replacement rule is disabled or not
*/
bool PortingRules::isRuleDisabled(QtSimpleXml &replacementRule) const
{
RuleDescription ruleDescription(replacementRule);
return disabledRules.contains(ruleDescription);
}
void
PluralRulesTest::testGetAllKeywordValues() {
const char* data[] = {
"a: n in 2..5", "a: 2,3,4,5; other: null; b:",
"a: n not in 2..5", "a: null; other: null",
"a: n within 2..5", "a: null; other: null",
"a: n not within 2..5", "a: null; other: null",
"a: n in 2..5 or n within 6..8", "a: null", // ignore 'other' here on out, always null
"a: n in 2..5 and n within 6..8", "a:",
"a: n in 2..5 and n within 5..8", "a: 5",
"a: n within 2..5 and n within 6..8", "a:", // our sampling catches these
"a: n within 2..5 and n within 5..8", "a: 5", // ''
"a: n within 1..2 and n within 2..3 or n within 3..4 and n within 4..5", "a: 2,4",
"a: n within 1..2 and n within 2..3 or n within 3..4 and n within 4..5 "
"or n within 5..6 and n within 6..7", "a: null", // but not this...
"a: n mod 3 is 0", "a: null",
"a: n mod 3 is 0 and n within 1..2", "a:",
"a: n mod 3 is 0 and n within 0..5", "a: 0,3",
"a: n mod 3 is 0 and n within 0..6", "a: null", // similarly with mod, we don't catch...
"a: n mod 3 is 0 and n in 3..12", "a: 3,6,9,12",
NULL
};
for (int i = 0; data[i] != NULL; i += 2) {
UErrorCode status = U_ZERO_ERROR;
UnicodeString ruleDescription(data[i], -1, US_INV);
const char* result = data[i+1];
logln("[%d] %s", i >> 1, data[i]);
PluralRules *p = PluralRules::createRules(ruleDescription, status);
if (p == NULL || U_FAILURE(status)) {
errln("file %s, line %d: could not create rules from '%s'\n"
" ErrorCode: %s\n",
__FILE__, __LINE__, data[i], u_errorName(status));
continue;
}
// TODO: fix samples implementation, re-enable test.
(void)result;
#if 0
const char* rp = result;
while (*rp) {
while (*rp == ' ') ++rp;
if (!rp) {
break;
}
const char* ep = rp;
while (*ep && *ep != ':') ++ep;
status = U_ZERO_ERROR;
UnicodeString keyword(rp, ep - rp, US_INV);
double samples[4]; // no test above should have more samples than 4
int32_t count = p->getAllKeywordValues(keyword, &samples[0], 4, status);
if (U_FAILURE(status)) {
errln("error getting samples for %s", rp);
break;
}
if (count > 4) {
errln("count > 4 for keyword %s", rp);
count = 4;
}
if (*ep) {
++ep; // skip colon
while (*ep && *ep == ' ') ++ep; // and spaces
}
UBool ok = TRUE;
if (count == -1) {
if (*ep != 'n') {
errln("expected values for keyword %s but got -1 (%s)", rp, ep);
ok = FALSE;
}
} else if (*ep == 'n') {
errln("expected count of -1, got %d, for keyword %s (%s)", count, rp, ep);
ok = FALSE;
}
// We'll cheat a bit here. The samples happend to be in order and so are our
// expected values, so we'll just test in order until a failure. If the
// implementation changes to return samples in an arbitrary order, this test
// must change. There's no actual restriction on the order of the samples.
for (int j = 0; ok && j < count; ++j ) { // we've verified count < 4
double val = samples[j];
if (*ep == 0 || *ep == ';') {
errln("got unexpected value[%d]: %g", j, val);
ok = FALSE;
break;
}
char* xp;
double expectedVal = strtod(ep, &xp);
if (xp == ep) {
// internal error
errln("yikes!");
ok = FALSE;
break;
}
ep = xp;
if (expectedVal != val) {
errln("expected %g but got %g", expectedVal, val);
ok = FALSE;
break;
}
if (*ep == ',') ++ep;
}
if (ok && count != -1) {
if (!(*ep == 0 || *ep == ';')) {
errln("file: %s, line %d, didn't get expected value: %s", __FILE__, __LINE__, ep);
ok = FALSE;
}
}
while (*ep && *ep != ';') ++ep;
if (*ep == ';') ++ep;
rp = ep;
}
#endif
delete p;
}
}
