1235 lines
40 KiB
C++
1235 lines
40 KiB
C++
/*
|
|
**********************************************************************
|
|
* Copyright (C) 2001 Alan Liu ,International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
**********************************************************************
|
|
* Date Name Description
|
|
* 10/20/99 alan Creation.
|
|
* 03/22/2000 Madhu Added additional tests
|
|
**********************************************************************
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "usettest.h"
|
|
#include "unicode/uniset.h"
|
|
#include "unicode/uchar.h"
|
|
#include "unicode/usetiter.h"
|
|
|
|
|
|
UnicodeString operator+(const UnicodeString& left, const UnicodeSet& set) {
|
|
UnicodeString pat;
|
|
set.toPattern(pat);
|
|
return left + UnicodeSetTest::escape(pat);
|
|
}
|
|
|
|
#define CASE(id,test) case id: \
|
|
name = #test; \
|
|
if (exec) { \
|
|
logln(#test "---"); \
|
|
logln((UnicodeString)""); \
|
|
test(); \
|
|
} \
|
|
break
|
|
|
|
void
|
|
UnicodeSetTest::runIndexedTest(int32_t index, UBool exec,
|
|
const char* &name, char* /*par*/) {
|
|
// if (exec) logln((UnicodeString)"TestSuite UnicodeSetTest");
|
|
switch (index) {
|
|
CASE(0,TestPatterns);
|
|
CASE(1,TestAddRemove);
|
|
CASE(2,TestCategories);
|
|
CASE(3,TestCloneEqualHash);
|
|
CASE(4,TestMinimalRep);
|
|
CASE(5,TestAPI);
|
|
CASE(6,TestScriptSet);
|
|
CASE(7,TestPropertySet);
|
|
CASE(8,TestClone);
|
|
CASE(9,TestExhaustive);
|
|
CASE(10,TestToPattern);
|
|
CASE(11,TestIndexOf);
|
|
CASE(12,TestStrings);
|
|
CASE(13,TestStringPatterns);
|
|
CASE(14,Testj2268);
|
|
default: name = ""; break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* UVector was improperly copying contents
|
|
* This code will crash this is still true
|
|
*/
|
|
void UnicodeSetTest::Testj2268() {
|
|
UnicodeSet t;
|
|
t.add(UnicodeString("abc"));
|
|
UnicodeSet test(t);
|
|
UnicodeString ustrPat;
|
|
test.toPattern(ustrPat, TRUE);
|
|
}
|
|
|
|
/**
|
|
* Test that toPattern() round trips with syntax characters and
|
|
* whitespace.
|
|
*/
|
|
void UnicodeSetTest::TestToPattern() {
|
|
static const char* OTHER_TOPATTERN_TESTS[] = {
|
|
"[[:latin:]&[:greek:]]",
|
|
"[[:latin:]-[:greek:]]",
|
|
"[:nonspacing mark:]",
|
|
NULL
|
|
};
|
|
|
|
for (int32_t j=0; OTHER_TOPATTERN_TESTS[j]!=NULL; ++j) {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
UnicodeSet s(OTHER_TOPATTERN_TESTS[j], ec);
|
|
if (U_FAILURE(ec)) {
|
|
errln((UnicodeString)"FAIL: bad pattern " + OTHER_TOPATTERN_TESTS[j]);
|
|
continue;
|
|
}
|
|
checkPat(OTHER_TOPATTERN_TESTS[j], s);
|
|
}
|
|
|
|
for (UChar32 i = 0; i <= 0x10FFFF; ++i) {
|
|
if ((i <= 0xFF && !u_isalpha(i)) || u_isspace(i)) {
|
|
|
|
// check various combinations to make sure they all work.
|
|
if (i != 0 && !toPatternAux(i, i)){
|
|
continue;
|
|
}
|
|
if (!toPatternAux(0, i)){
|
|
continue;
|
|
}
|
|
if (!toPatternAux(i, 0xFFFF)){
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UBool UnicodeSetTest::toPatternAux(UChar32 start, UChar32 end) {
|
|
|
|
// use Integer.toString because Utility.hex doesn't handle ints
|
|
UnicodeString pat = "";
|
|
// TODO do these in hex
|
|
//String source = "0x" + Integer.toString(start,16).toUpperCase();
|
|
//if (start != end) source += "..0x" + Integer.toString(end,16).toUpperCase();
|
|
UnicodeString source;
|
|
source = source + (uint32_t)start;
|
|
if (start != end)
|
|
source = source + ".." + (uint32_t)end;
|
|
UnicodeSet testSet;
|
|
testSet.add(start, end);
|
|
return checkPat(source, testSet);
|
|
}
|
|
|
|
UBool UnicodeSetTest::checkPat(const UnicodeString& source,
|
|
const UnicodeSet& testSet) {
|
|
// What we want to make sure of is that a pattern generated
|
|
// by toPattern(), with or without escaped unprintables, can
|
|
// be passed back into the UnicodeSet constructor.
|
|
UnicodeString pat0;
|
|
|
|
testSet.toPattern(pat0, TRUE);
|
|
|
|
if (!checkPat(source + " (escaped)", testSet, pat0)) return FALSE;
|
|
|
|
//String pat1 = unescapeLeniently(pat0);
|
|
//if (!checkPat(source + " (in code)", testSet, pat1)) return false;
|
|
|
|
UnicodeString pat2;
|
|
testSet.toPattern(pat2, FALSE);
|
|
if (!checkPat(source, testSet, pat2)) return FALSE;
|
|
|
|
//String pat3 = unescapeLeniently(pat2);
|
|
// if (!checkPat(source + " (in code)", testSet, pat3)) return false;
|
|
|
|
//logln(source + " => " + pat0 + ", " + pat1 + ", " + pat2 + ", " + pat3);
|
|
logln((UnicodeString)source + " => " + pat0 + ", " + pat2);
|
|
return TRUE;
|
|
}
|
|
|
|
UBool UnicodeSetTest::checkPat(const UnicodeString& source,
|
|
const UnicodeSet& testSet,
|
|
const UnicodeString& pat) {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
UnicodeSet testSet2(pat, ec);
|
|
if (testSet2 != testSet) {
|
|
errln((UnicodeString)"Fail toPattern: " + source + " => " + pat);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
UnicodeSetTest::TestPatterns(void) {
|
|
UnicodeSet set;
|
|
expectPattern(set, UnicodeString("[[a-m]&[d-z]&[k-y]]", ""), "km");
|
|
expectPattern(set, UnicodeString("[[a-z]-[m-y]-[d-r]]", ""), "aczz");
|
|
expectPattern(set, UnicodeString("[a\\-z]", ""), "--aazz");
|
|
expectPattern(set, UnicodeString("[-az]", ""), "--aazz");
|
|
expectPattern(set, UnicodeString("[az-]", ""), "--aazz");
|
|
expectPattern(set, UnicodeString("[[[a-z]-[aeiou]i]]", ""), "bdfnptvz");
|
|
|
|
// Throw in a test of complement
|
|
set.complement();
|
|
UnicodeString exp;
|
|
exp.append((UChar)0x0000).append("aeeoouu").append((UChar)(0x007a+1)).append((UChar)0xFFFF);
|
|
expectPairs(set, exp);
|
|
}
|
|
|
|
void
|
|
UnicodeSetTest::TestCategories(void) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const char* pat = " [:Lu:] "; // Whitespace ok outside [:..:]
|
|
UnicodeSet set(pat, status);
|
|
if (U_FAILURE(status)) {
|
|
errln((UnicodeString)"Fail: Can't construct set with " + pat);
|
|
} else {
|
|
expectContainment(set, pat, "ABC", "abc");
|
|
}
|
|
|
|
UChar32 i;
|
|
int32_t failures = 0;
|
|
// Make sure generation of L doesn't pollute cached Lu set
|
|
// First generate L, then Lu
|
|
set.applyPattern("[:L:]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
for (i=0; i<0x200; ++i) {
|
|
UBool l = u_isalpha((UChar)i);
|
|
if (l != set.contains(i)) {
|
|
errln((UnicodeString)"FAIL: L contains " + (unsigned short)i + " = " +
|
|
set.contains(i));
|
|
if (++failures == 10) break;
|
|
}
|
|
}
|
|
|
|
set.applyPattern("[:Lu:]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
for (i=0; i<0x200; ++i) {
|
|
UBool lu = (u_charType((UChar)i) == U_UPPERCASE_LETTER);
|
|
if (lu != set.contains(i)) {
|
|
errln((UnicodeString)"FAIL: Lu contains " + (unsigned short)i + " = " +
|
|
set.contains(i));
|
|
if (++failures == 20) break;
|
|
}
|
|
}
|
|
}
|
|
void
|
|
UnicodeSetTest::TestCloneEqualHash(void) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
int8_t category=U_LOWERCASE_LETTER;
|
|
UnicodeSet *set1=new UnicodeSet(category, status); // :Ll: Letter, lowercase
|
|
UnicodeSet *set1a=new UnicodeSet("[:Ll:]", status); // Letter, lowercase
|
|
if (U_FAILURE(status)){
|
|
errln((UnicodeString)"FAIL: Can't construst set with category->Ll");
|
|
return;
|
|
}
|
|
category=U_DECIMAL_DIGIT_NUMBER;
|
|
UnicodeSet *set2=new UnicodeSet(category, status); //Number, Decimal digit
|
|
UnicodeSet *set2a=new UnicodeSet("[:Nd:]", status); //Number, Decimal digit
|
|
if (U_FAILURE(status)){
|
|
errln((UnicodeString)"FAIL: Can't construct set with category->Nd");
|
|
return;
|
|
}
|
|
|
|
if (*set1 != *set1a) {
|
|
errln("FAIL: category constructor for Ll broken");
|
|
}
|
|
if (*set2 != *set2a) {
|
|
errln("FAIL: category constructor for Nd broken");
|
|
}
|
|
delete set1a;
|
|
delete set2a;
|
|
|
|
logln("Testing copy construction");
|
|
UnicodeSet *set1copy=new UnicodeSet(*set1);
|
|
if(*set1 != *set1copy || *set1 == *set2 ||
|
|
getPairs(*set1) != getPairs(*set1copy) ||
|
|
set1->hashCode() != set1copy->hashCode()){
|
|
errln("FAIL : Error in copy construction");
|
|
return;
|
|
}
|
|
|
|
logln("Testing =operator");
|
|
UnicodeSet set1equal=*set1;
|
|
UnicodeSet set2equal=*set2;
|
|
if(set1equal != *set1 || set1equal != *set1copy || set2equal != *set2 ||
|
|
set2equal == *set1 || set2equal == *set1copy || set2equal == set1equal){
|
|
errln("FAIL: Error in =operator");
|
|
}
|
|
|
|
logln("Testing clone()");
|
|
UnicodeSet *set1clone=(UnicodeSet*)set1->clone();
|
|
UnicodeSet *set2clone=(UnicodeSet*)set2->clone();
|
|
if(*set1clone != *set1 || *set1clone != *set1copy || *set1clone != set1equal ||
|
|
*set2clone != *set2 || *set2clone == *set1copy || *set2clone != set2equal ||
|
|
*set2clone == *set1 || *set2clone == set1equal || *set2clone == *set1clone){
|
|
errln("FAIL: Error in clone");
|
|
}
|
|
|
|
logln("Testing hashcode");
|
|
if(set1->hashCode() != set1equal.hashCode() || set1->hashCode() != set1clone->hashCode() ||
|
|
set2->hashCode() != set2equal.hashCode() || set2->hashCode() != set2clone->hashCode() ||
|
|
set1copy->hashCode() != set1equal.hashCode() || set1copy->hashCode() != set1clone->hashCode() ||
|
|
set1->hashCode() == set2->hashCode() || set1copy->hashCode() == set2->hashCode() ||
|
|
set2->hashCode() == set1clone->hashCode() || set2->hashCode() == set1equal.hashCode() ){
|
|
errln("FAIL: Error in hashCode()");
|
|
}
|
|
|
|
delete set1;
|
|
delete set1copy;
|
|
delete set2;
|
|
delete set1clone;
|
|
delete set2clone;
|
|
|
|
|
|
}
|
|
void
|
|
UnicodeSetTest::TestAddRemove(void) {
|
|
UnicodeSet set; // Construct empty set
|
|
doAssert(set.isEmpty() == TRUE, "set should be empty");
|
|
doAssert(set.size() == 0, "size should be 0");
|
|
set.add(0x0061, 0x007a);
|
|
expectPairs(set, "az");
|
|
doAssert(set.isEmpty() == FALSE, "set should not be empty");
|
|
doAssert(set.size() != 0, "size should not be equal to 0");
|
|
doAssert(set.size() == 26, "size should be equal to 26");
|
|
set.remove(0x006d, 0x0070);
|
|
expectPairs(set, "alqz");
|
|
doAssert(set.size() == 22, "size should be equal to 22");
|
|
set.remove(0x0065, 0x0067);
|
|
expectPairs(set, "adhlqz");
|
|
doAssert(set.size() == 19, "size should be equal to 19");
|
|
set.remove(0x0064, 0x0069);
|
|
expectPairs(set, "acjlqz");
|
|
doAssert(set.size() == 16, "size should be equal to 16");
|
|
set.remove(0x0063, 0x0072);
|
|
expectPairs(set, "absz");
|
|
doAssert(set.size() == 10, "size should be equal to 10");
|
|
set.add(0x0066, 0x0071);
|
|
expectPairs(set, "abfqsz");
|
|
doAssert(set.size() == 22, "size should be equal to 22");
|
|
set.remove(0x0061, 0x0067);
|
|
expectPairs(set, "hqsz");
|
|
set.remove(0x0061, 0x007a);
|
|
expectPairs(set, "");
|
|
doAssert(set.isEmpty() == TRUE, "set should be empty");
|
|
doAssert(set.size() == 0, "size should be 0");
|
|
set.add(0x0061);
|
|
doAssert(set.isEmpty() == FALSE, "set should not be empty");
|
|
doAssert(set.size() == 1, "size should not be equal to 1");
|
|
set.add(0x0062);
|
|
set.add(0x0063);
|
|
expectPairs(set, "ac");
|
|
doAssert(set.size() == 3, "size should not be equal to 3");
|
|
set.add(0x0070);
|
|
set.add(0x0071);
|
|
expectPairs(set, "acpq");
|
|
doAssert(set.size() == 5, "size should not be equal to 5");
|
|
set.clear();
|
|
expectPairs(set, "");
|
|
doAssert(set.isEmpty() == TRUE, "set should be empty");
|
|
doAssert(set.size() == 0, "size should be 0");
|
|
|
|
// Try removing an entire set from another set
|
|
expectPattern(set, "[c-x]", "cx");
|
|
UnicodeSet set2;
|
|
expectPattern(set2, "[f-ky-za-bc[vw]]", "acfkvwyz");
|
|
set.removeAll(set2);
|
|
expectPairs(set, "deluxx");
|
|
|
|
// Try adding an entire set to another set
|
|
expectPattern(set, "[jackiemclean]", "aacceein");
|
|
expectPattern(set2, "[hitoshinamekatajamesanderson]", "aadehkmort");
|
|
set.addAll(set2);
|
|
expectPairs(set, "aacehort");
|
|
doAssert(set.containsAll(set2) == TRUE, "set should contain all the elements in set2");
|
|
|
|
// Try retaining an set of elements contained in another set (intersection)
|
|
UnicodeSet set3;
|
|
expectPattern(set3, "[a-c]", "ac");
|
|
doAssert(set.containsAll(set3) == FALSE, "set doesn't contain all the elements in set3");
|
|
set3.remove(0x0062);
|
|
expectPairs(set3, "aacc");
|
|
doAssert(set.containsAll(set3) == TRUE, "set should contain all the elements in set3");
|
|
set.retainAll(set3);
|
|
expectPairs(set, "aacc");
|
|
doAssert(set.size() == set3.size(), "set.size() should be set3.size()");
|
|
doAssert(set.containsAll(set3) == TRUE, "set should contain all the elements in set3");
|
|
set.clear();
|
|
doAssert(set.size() != set3.size(), "set.size() != set3.size()");
|
|
|
|
// Test commutativity
|
|
expectPattern(set, "[hitoshinamekatajamesanderson]", "aadehkmort");
|
|
expectPattern(set2, "[jackiemclean]", "aacceein");
|
|
set.addAll(set2);
|
|
expectPairs(set, "aacehort");
|
|
doAssert(set.containsAll(set2) == TRUE, "set should contain all the elements in set2");
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Make sure minimal representation is maintained.
|
|
*/
|
|
void UnicodeSetTest::TestMinimalRep() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
// This is pretty thoroughly tested by checkCanonicalRep()
|
|
// run against the exhaustive operation results. Use the code
|
|
// here for debugging specific spot problems.
|
|
|
|
// 1 overlap against 2
|
|
UnicodeSet set("[h-km-q]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
UnicodeSet set2("[i-o]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
set.addAll(set2);
|
|
expectPairs(set, "hq");
|
|
// right
|
|
set.applyPattern("[a-m]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
set2.applyPattern("[e-o]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
set.addAll(set2);
|
|
expectPairs(set, "ao");
|
|
// left
|
|
set.applyPattern("[e-o]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
set2.applyPattern("[a-m]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
set.addAll(set2);
|
|
expectPairs(set, "ao");
|
|
// 1 overlap against 3
|
|
set.applyPattern("[a-eg-mo-w]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
set2.applyPattern("[d-q]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
set.addAll(set2);
|
|
expectPairs(set, "aw");
|
|
}
|
|
|
|
void UnicodeSetTest::TestAPI() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
// default ct
|
|
UnicodeSet set;
|
|
if (!set.isEmpty() || set.getRangeCount() != 0) {
|
|
errln((UnicodeString)"FAIL, set should be empty but isn't: " +
|
|
set);
|
|
}
|
|
|
|
// clear(), isEmpty()
|
|
set.add(0x0061);
|
|
if (set.isEmpty()) {
|
|
errln((UnicodeString)"FAIL, set shouldn't be empty but is: " +
|
|
set);
|
|
}
|
|
set.clear();
|
|
if (!set.isEmpty()) {
|
|
errln((UnicodeString)"FAIL, set should be empty but isn't: " +
|
|
set);
|
|
}
|
|
|
|
// size()
|
|
set.clear();
|
|
if (set.size() != 0) {
|
|
errln((UnicodeString)"FAIL, size should be 0, but is " + set.size() +
|
|
": " + set);
|
|
}
|
|
set.add(0x0061);
|
|
if (set.size() != 1) {
|
|
errln((UnicodeString)"FAIL, size should be 1, but is " + set.size() +
|
|
": " + set);
|
|
}
|
|
set.add(0x0031, 0x0039);
|
|
if (set.size() != 10) {
|
|
errln((UnicodeString)"FAIL, size should be 10, but is " + set.size() +
|
|
": " + set);
|
|
}
|
|
|
|
// contains(first, last)
|
|
set.clear();
|
|
set.applyPattern("[A-Y 1-8 b-d l-y]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
for (int32_t i = 0; i<set.getRangeCount(); ++i) {
|
|
UChar32 a = set.getRangeStart(i);
|
|
UChar32 b = set.getRangeEnd(i);
|
|
if (!set.contains(a, b)) {
|
|
errln((UnicodeString)"FAIL, should contain " + (unsigned short)a + '-' + (unsigned short)b +
|
|
" but doesn't: " + set);
|
|
}
|
|
if (set.contains((UChar32)(a-1), b)) {
|
|
errln((UnicodeString)"FAIL, shouldn't contain " +
|
|
(unsigned short)(a-1) + '-' + (unsigned short)b +
|
|
" but does: " + set);
|
|
}
|
|
if (set.contains(a, (UChar32)(b+1))) {
|
|
errln((UnicodeString)"FAIL, shouldn't contain " +
|
|
(unsigned short)a + '-' + (unsigned short)(b+1) +
|
|
" but does: " + set);
|
|
}
|
|
}
|
|
|
|
// Ported InversionList test.
|
|
UnicodeSet a((UChar32)3,(UChar32)10);
|
|
UnicodeSet b((UChar32)7,(UChar32)15);
|
|
UnicodeSet c;
|
|
|
|
logln((UnicodeString)"a [3-10]: " + a);
|
|
logln((UnicodeString)"b [7-15]: " + b);
|
|
c = a; c.addAll(b);
|
|
UnicodeSet exp((UChar32)3,(UChar32)15);
|
|
if (c == exp) {
|
|
logln((UnicodeString)"c.set(a).add(b): " + c);
|
|
} else {
|
|
errln((UnicodeString)"FAIL: c.set(a).add(b) = " + c + ", expect " + exp);
|
|
}
|
|
c.complement();
|
|
exp.set((UChar32)0, (UChar32)2);
|
|
exp.add((UChar32)16, UnicodeSet::MAX_VALUE);
|
|
if (c == exp) {
|
|
logln((UnicodeString)"c.complement(): " + c);
|
|
} else {
|
|
errln((UnicodeString)"FAIL: c.complement() = " + c + ", expect " + exp);
|
|
}
|
|
c.complement();
|
|
exp.set((UChar32)3, (UChar32)15);
|
|
if (c == exp) {
|
|
logln((UnicodeString)"c.complement(): " + c);
|
|
} else {
|
|
errln((UnicodeString)"FAIL: c.complement() = " + c + ", expect " + exp);
|
|
}
|
|
c = a; c.complementAll(b);
|
|
exp.set((UChar32)3,(UChar32)6);
|
|
exp.add((UChar32)11,(UChar32) 15);
|
|
if (c == exp) {
|
|
logln((UnicodeString)"c.set(a).exclusiveOr(b): " + c);
|
|
} else {
|
|
errln((UnicodeString)"FAIL: c.set(a).exclusiveOr(b) = " + c + ", expect " + exp);
|
|
}
|
|
|
|
exp = c;
|
|
bitsToSet(setToBits(c), c);
|
|
if (c == exp) {
|
|
logln((UnicodeString)"bitsToSet(setToBits(c)): " + c);
|
|
} else {
|
|
errln((UnicodeString)"FAIL: bitsToSet(setToBits(c)) = " + c + ", expect " + exp);
|
|
}
|
|
|
|
// Additional tests for coverage JB#2118
|
|
//UnicodeSet::complement(class UnicodeString const &)
|
|
//UnicodeSet::complementAll(class UnicodeString const &)
|
|
//UnicodeSet::containsNone(class UnicodeSet const &)
|
|
//UnicodeSet::containsNone(long,long)
|
|
//UnicodeSet::containsSome(class UnicodeSet const &)
|
|
//UnicodeSet::containsSome(long,long)
|
|
//UnicodeSet::removeAll(class UnicodeString const &)
|
|
//UnicodeSet::retain(long)
|
|
//UnicodeSet::retainAll(class UnicodeString const &)
|
|
//UnicodeSet::serialize(unsigned short *,long,enum UErrorCode &)
|
|
//UnicodeSetIterator::getString(void)
|
|
set.clear();
|
|
set.complement("ab");
|
|
exp.applyPattern("[{ab}]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
if (set != exp) { errln("FAIL: complement(\"ab\")"); return; }
|
|
|
|
UnicodeSetIterator iset(set);
|
|
if (!iset.next() || !iset.isString()) {
|
|
errln("FAIL: UnicodeSetIterator::next/isString");
|
|
} else if (iset.getString() != "ab") {
|
|
errln("FAIL: UnicodeSetIterator::getString");
|
|
}
|
|
|
|
set.add((UChar32)0x61, (UChar32)0x7A);
|
|
set.complementAll("alan");
|
|
exp.applyPattern("[{ab}b-kmo-z]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
if (set != exp) { errln("FAIL: complementAll(\"alan\")"); return; }
|
|
|
|
exp.applyPattern("[a-z]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
if (set.containsNone(exp)) { errln("FAIL: containsNone(UnicodeSet)"); }
|
|
if (!set.containsSome(exp)) { errln("FAIL: containsSome(UnicodeSet)"); }
|
|
exp.applyPattern("[aln]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
if (!set.containsNone(exp)) { errln("FAIL: containsNone(UnicodeSet)"); }
|
|
if (set.containsSome(exp)) { errln("FAIL: containsSome(UnicodeSet)"); }
|
|
|
|
if (set.containsNone((UChar32)0x61, (UChar32)0x7A)) {
|
|
errln("FAIL: containsNone(UChar32, UChar32)");
|
|
}
|
|
if (!set.containsSome((UChar32)0x61, (UChar32)0x7A)) {
|
|
errln("FAIL: containsSome(UChar32, UChar32)");
|
|
}
|
|
if (!set.containsNone((UChar32)0x41, (UChar32)0x5A)) {
|
|
errln("FAIL: containsNone(UChar32, UChar32)");
|
|
}
|
|
if (set.containsSome((UChar32)0x41, (UChar32)0x5A)) {
|
|
errln("FAIL: containsSome(UChar32, UChar32)");
|
|
}
|
|
|
|
set.removeAll("liu");
|
|
exp.applyPattern("[{ab}b-hj-kmo-tv-z]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
if (set != exp) { errln("FAIL: removeAll(\"liu\")"); return; }
|
|
|
|
set.retainAll("star");
|
|
exp.applyPattern("[rst]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
if (set != exp) { errln("FAIL: retainAll(\"star\")"); return; }
|
|
|
|
set.retain((UChar32)0x73);
|
|
exp.applyPattern("[s]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
if (set != exp) { errln("FAIL: retain('s')"); return; }
|
|
|
|
uint16_t buf[32];
|
|
int32_t slen = set.serialize(buf, sizeof(buf)/sizeof(buf[0]), status);
|
|
if (U_FAILURE(status)) { errln("FAIL: serialize"); return; }
|
|
if (slen != 3 || buf[0] != 2 || buf[1] != 0x73 || buf[2] != 0x74) {
|
|
errln("FAIL: serialize");
|
|
return;
|
|
}
|
|
}
|
|
|
|
void UnicodeSetTest::TestStrings() {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
|
|
UnicodeSet* testList[] = {
|
|
UnicodeSet::createFromAll("abc"),
|
|
new UnicodeSet("[a-c]", ec),
|
|
|
|
&(UnicodeSet::createFrom("ch")->add('a','z').add("ll")),
|
|
new UnicodeSet("[{ll}{ch}a-z]", ec),
|
|
|
|
UnicodeSet::createFrom("ab}c"),
|
|
new UnicodeSet("[{ab\\}c}]", ec),
|
|
|
|
&((new UnicodeSet('a','z'))->add('A', 'Z').retain('M','m').complement('X')),
|
|
new UnicodeSet("[[a-zA-Z]&[M-m]-[X]]", ec),
|
|
|
|
NULL
|
|
};
|
|
|
|
if (U_FAILURE(ec)) {
|
|
errln("FAIL: couldn't construct test sets");
|
|
}
|
|
|
|
for (int32_t i = 0; testList[i] != NULL; i+=2) {
|
|
if (U_SUCCESS(ec)) {
|
|
UnicodeString pat0, pat1;
|
|
testList[i]->toPattern(pat0, TRUE);
|
|
testList[i+1]->toPattern(pat1, TRUE);
|
|
if (*testList[i] == *testList[i+1]) {
|
|
logln((UnicodeString)"Ok: " + pat0 + " == " + pat1);
|
|
} else {
|
|
logln((UnicodeString)"FAIL: " + pat0 + " != " + pat1);
|
|
}
|
|
}
|
|
delete testList[i];
|
|
delete testList[i+1];
|
|
}
|
|
}
|
|
|
|
static const char NOT[] = "%%%%";
|
|
|
|
/**
|
|
* Test pattern behavior of multicharacter strings.
|
|
*/
|
|
void UnicodeSetTest::TestStringPatterns() {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
UnicodeSet* s = new UnicodeSet("[a-z {aa} {ab}]", ec);
|
|
|
|
// This loop isn't a loop. It's here to make the compiler happy.
|
|
// If you're curious, try removing it and changing the 'break'
|
|
// statements (except for the last) to goto's.
|
|
for (;;) {
|
|
if (U_FAILURE(ec)) break;
|
|
const char* exp1[] = {"aa", "ab", NOT, "ac", NULL};
|
|
expectToPattern(*s, "[a-z{aa}{ab}]", exp1);
|
|
|
|
s->add("ac");
|
|
const char* exp2[] = {"aa", "ab", "ac", NOT, "xy", NULL};
|
|
expectToPattern(*s, "[a-z{aa}{ab}{ac}]", exp2);
|
|
|
|
s->applyPattern("[a-z {\\{l} {r\\}}]", ec);
|
|
if (U_FAILURE(ec)) break;
|
|
const char* exp3[] = {"{l", "r}", NOT, "xy", NULL};
|
|
expectToPattern(*s, "[a-z{\\{l}{r\\}}]", exp3);
|
|
|
|
s->add("[]");
|
|
const char* exp4[] = {"{l", "r}", "[]", NOT, "xy", NULL};
|
|
expectToPattern(*s, "[a-z{\\[\\]}{r\\}}{\\{l}]", exp4);
|
|
|
|
s->applyPattern("[a-z {\\u4E01\\u4E02}{\\n\\r}]", ec);
|
|
if (U_FAILURE(ec)) break;
|
|
const char* exp5[] = {"\\u4E01\\u4E02", "\n\r", NULL};
|
|
expectToPattern(*s, "[a-z{\\u4E01\\u4E02}{\\n\\r}]", exp5);
|
|
|
|
// j2189
|
|
s->clear();
|
|
s->add(UnicodeString("abc", ""));
|
|
s->add(UnicodeString("abc", ""));
|
|
const char* exp6[] = {"abc", NOT, "ab", NULL};
|
|
expectToPattern(*s, "[{abc}]", exp6);
|
|
|
|
break;
|
|
}
|
|
|
|
if (U_FAILURE(ec)) errln("FAIL: pattern parse error");
|
|
delete s;
|
|
}
|
|
|
|
/**
|
|
* Test the [:Latin:] syntax.
|
|
*/
|
|
void UnicodeSetTest::TestScriptSet() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UnicodeSet set("[:Latin:]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
expectContainment(set, "[:Latin:]", "aA", CharsToUnicodeString("\\u0391\\u03B1"));
|
|
|
|
UnicodeSet set2("[:Greek:]", status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
expectContainment(set2, "[:Greek:]", CharsToUnicodeString("\\u0391\\u03B1"), "aA");
|
|
|
|
/* Jitterbug 1423 */
|
|
UnicodeSet set3("[[:Common:][:Inherited:]]",status);
|
|
if (U_FAILURE(status)) { errln("FAIL"); return; }
|
|
expectContainment(set3, "[[:Common:][:Inherited:]]", CharsToUnicodeString("\\U00003099\\U0001D169\\u0000"), "aA");
|
|
|
|
}
|
|
|
|
/**
|
|
* Test the [:Latin:] syntax.
|
|
*/
|
|
void UnicodeSetTest::TestPropertySet() {
|
|
static const char* DATA[] = {
|
|
// Pattern, Chars IN, Chars NOT in
|
|
|
|
"[:Latin:]",
|
|
"aA",
|
|
"\\u0391\\u03B1",
|
|
|
|
"[\\p{Greek}]",
|
|
"\\u0391\\u03B1",
|
|
"aA",
|
|
|
|
"\\P{ GENERAL Category = upper case letter }",
|
|
"abc",
|
|
"ABC",
|
|
|
|
// Combining class: @since ICU 2.2
|
|
// Check both symbolic and numeric
|
|
"\\p{ccc=Nukta}",
|
|
"\\u0ABC",
|
|
"abc",
|
|
|
|
"\\p{Canonical Combining Class = 11}",
|
|
"\\u05B1",
|
|
"\\u05B2",
|
|
|
|
"[:c c c = iota subscript :]",
|
|
"\\u0345",
|
|
"xyz",
|
|
|
|
// Bidi class: @since ICU 2.2
|
|
"\\p{bidiclass=lefttoright}",
|
|
"abc",
|
|
"\\u0671\\u0672",
|
|
|
|
// Binary properties: @since ICU 2.2
|
|
"\\p{ideographic}",
|
|
"\\u4E0A",
|
|
"x",
|
|
|
|
"[:math=false:]",
|
|
"q",
|
|
"(*+)",
|
|
|
|
// JB#1767 \N{}, \p{ASCII}
|
|
"[:Ascii:]",
|
|
"abc\\u0000\\u007F",
|
|
"\\u0080\\u4E00",
|
|
|
|
"[\\N{ latin small letter a }[:name= latin small letter z:]]",
|
|
"az",
|
|
"qrs",
|
|
|
|
// JB#2015
|
|
"[:any:]",
|
|
"a\\U0010FFFF",
|
|
"",
|
|
|
|
"[:nv=0.5:]",
|
|
"\\u00BD\\u0F2A",
|
|
"\\u00BC",
|
|
|
|
// JB#2653: Age
|
|
"[:Age=1.1:]",
|
|
"\\u03D6", // 1.1
|
|
"\\u03D8\\u03D9", // 3.2
|
|
|
|
"[:Age=3.2:]",
|
|
"\\u03D8\\u03D9",
|
|
"\\u03D6", // 1.1
|
|
};
|
|
|
|
static const int32_t DATA_LEN = sizeof(DATA)/sizeof(DATA[0]);
|
|
|
|
for (int32_t i=0; i<DATA_LEN; i+=3) {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
UnicodeSet set(DATA[i], ec);
|
|
if (U_FAILURE(ec)) {
|
|
errln((UnicodeString)"FAIL: pattern \"" +
|
|
DATA[i] + "\" => " + u_errorName(ec));
|
|
continue;
|
|
}
|
|
expectContainment(set, CharsToUnicodeString(DATA[i+1]),
|
|
CharsToUnicodeString(DATA[i+2]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test cloning of UnicodeSet. For C++, we test the copy constructor.
|
|
*/
|
|
void UnicodeSetTest::TestClone() {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
UnicodeSet s("[abcxyz]", ec);
|
|
UnicodeSet t(s);
|
|
expectContainment(t, "abc", "def");
|
|
}
|
|
|
|
/**
|
|
* Test the indexOf() and charAt() methods.
|
|
*/
|
|
void UnicodeSetTest::TestIndexOf() {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
UnicodeSet set("[a-cx-y3578]", ec);
|
|
if (U_FAILURE(ec)) {
|
|
errln("FAIL: UnicodeSet constructor");
|
|
return;
|
|
}
|
|
for (int32_t i=0; i<set.size(); ++i) {
|
|
UChar32 c = set.charAt(i);
|
|
if (set.indexOf(c) != i) {
|
|
errln("FAIL: charAt(%d) = %X => indexOf() => %d",
|
|
i, c, set.indexOf(c));
|
|
}
|
|
}
|
|
UChar32 c = set.charAt(set.size());
|
|
if (c != -1) {
|
|
errln("FAIL: charAt(<out of range>) = %X", c);
|
|
}
|
|
int32_t j = set.indexOf((UChar32)0x71/*'q'*/);
|
|
if (j != -1) {
|
|
errln((UnicodeString)"FAIL: indexOf('q') = " + j);
|
|
}
|
|
}
|
|
|
|
void UnicodeSetTest::TestExhaustive() {
|
|
// exhaustive tests. Simulate UnicodeSets with integers.
|
|
// That gives us very solid tests (except for large memory tests).
|
|
|
|
int32_t limit = 128;
|
|
|
|
UnicodeSet x, y, z, aa;
|
|
|
|
for (int32_t i = 0; i < limit; ++i) {
|
|
bitsToSet(i, x);
|
|
logln((UnicodeString)"Testing " + i + ", " + x);
|
|
_testComplement(i, x, y);
|
|
|
|
// AS LONG AS WE ARE HERE, check roundtrip
|
|
checkRoundTrip(bitsToSet(i, aa));
|
|
|
|
for (int32_t j = 0; j < limit; ++j) {
|
|
_testAdd(i,j, x,y,z);
|
|
_testXor(i,j, x,y,z);
|
|
_testRetain(i,j, x,y,z);
|
|
_testRemove(i,j, x,y,z);
|
|
}
|
|
}
|
|
}
|
|
|
|
void UnicodeSetTest::_testComplement(int32_t a, UnicodeSet& x, UnicodeSet& z) {
|
|
bitsToSet(a, x);
|
|
z = x;
|
|
z.complement();
|
|
int32_t c = setToBits(z);
|
|
if (c != (~a)) {
|
|
errln((UnicodeString)"FAILED: add: ~" + x + " != " + z);
|
|
errln((UnicodeString)"FAILED: add: ~" + a + " != " + c);
|
|
}
|
|
checkCanonicalRep(z, (UnicodeString)"complement " + a);
|
|
}
|
|
|
|
void UnicodeSetTest::_testAdd(int32_t a, int32_t b, UnicodeSet& x, UnicodeSet& y, UnicodeSet& z) {
|
|
bitsToSet(a, x);
|
|
bitsToSet(b, y);
|
|
z = x;
|
|
z.addAll(y);
|
|
int32_t c = setToBits(z);
|
|
if (c != (a | b)) {
|
|
errln((UnicodeString)"FAILED: add: " + x + " | " + y + " != " + z);
|
|
errln((UnicodeString)"FAILED: add: " + a + " | " + b + " != " + c);
|
|
}
|
|
checkCanonicalRep(z, (UnicodeString)"add " + a + "," + b);
|
|
}
|
|
|
|
void UnicodeSetTest::_testRetain(int32_t a, int32_t b, UnicodeSet& x, UnicodeSet& y, UnicodeSet& z) {
|
|
bitsToSet(a, x);
|
|
bitsToSet(b, y);
|
|
z = x;
|
|
z.retainAll(y);
|
|
int32_t c = setToBits(z);
|
|
if (c != (a & b)) {
|
|
errln((UnicodeString)"FAILED: retain: " + x + " & " + y + " != " + z);
|
|
errln((UnicodeString)"FAILED: retain: " + a + " & " + b + " != " + c);
|
|
}
|
|
checkCanonicalRep(z, (UnicodeString)"retain " + a + "," + b);
|
|
}
|
|
|
|
void UnicodeSetTest::_testRemove(int32_t a, int32_t b, UnicodeSet& x, UnicodeSet& y, UnicodeSet& z) {
|
|
bitsToSet(a, x);
|
|
bitsToSet(b, y);
|
|
z = x;
|
|
z.removeAll(y);
|
|
int32_t c = setToBits(z);
|
|
if (c != (a &~ b)) {
|
|
errln((UnicodeString)"FAILED: remove: " + x + " &~ " + y + " != " + z);
|
|
errln((UnicodeString)"FAILED: remove: " + a + " &~ " + b + " != " + c);
|
|
}
|
|
checkCanonicalRep(z, (UnicodeString)"remove " + a + "," + b);
|
|
}
|
|
|
|
void UnicodeSetTest::_testXor(int32_t a, int32_t b, UnicodeSet& x, UnicodeSet& y, UnicodeSet& z) {
|
|
bitsToSet(a, x);
|
|
bitsToSet(b, y);
|
|
z = x;
|
|
z.complementAll(y);
|
|
int32_t c = setToBits(z);
|
|
if (c != (a ^ b)) {
|
|
errln((UnicodeString)"FAILED: complement: " + x + " ^ " + y + " != " + z);
|
|
errln((UnicodeString)"FAILED: complement: " + a + " ^ " + b + " != " + c);
|
|
}
|
|
checkCanonicalRep(z, (UnicodeString)"complement " + a + "," + b);
|
|
}
|
|
|
|
/**
|
|
* Check that ranges are monotonically increasing and non-
|
|
* overlapping.
|
|
*/
|
|
void UnicodeSetTest::checkCanonicalRep(const UnicodeSet& set, const UnicodeString& msg) {
|
|
int32_t n = set.getRangeCount();
|
|
if (n < 0) {
|
|
errln((UnicodeString)"FAIL result of " + msg +
|
|
": range count should be >= 0 but is " +
|
|
n /*+ " for " + set.toPattern())*/);
|
|
return;
|
|
}
|
|
UChar32 last = 0;
|
|
for (int32_t i=0; i<n; ++i) {
|
|
UChar32 start = set.getRangeStart(i);
|
|
UChar32 end = set.getRangeEnd(i);
|
|
if (start > end) {
|
|
errln((UnicodeString)"FAIL result of " + msg +
|
|
": range " + (i+1) +
|
|
" start > end: " + (int)start + ", " + (int)end +
|
|
" for " + set);
|
|
}
|
|
if (i > 0 && start <= last) {
|
|
errln((UnicodeString)"FAIL result of " + msg +
|
|
": range " + (i+1) +
|
|
" overlaps previous range: " + (int)start + ", " + (int)end +
|
|
" for " + set);
|
|
}
|
|
last = end;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Convert a bitmask to a UnicodeSet.
|
|
*/
|
|
UnicodeSet& UnicodeSetTest::bitsToSet(int32_t a, UnicodeSet& result) {
|
|
result.clear();
|
|
for (UChar32 i = 0; i < 32; ++i) {
|
|
if ((a & (1<<i)) != 0) {
|
|
result.add(i);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Convert a UnicodeSet to a bitmask. Only the characters
|
|
* U+0000 to U+0020 are represented in the bitmask.
|
|
*/
|
|
int32_t UnicodeSetTest::setToBits(const UnicodeSet& x) {
|
|
int32_t result = 0;
|
|
for (int32_t i = 0; i < 32; ++i) {
|
|
if (x.contains((UChar32)i)) {
|
|
result |= (1<<i);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Return the representation of an inversion list based UnicodeSet
|
|
* as a pairs list. Ranges are listed in ascending Unicode order.
|
|
* For example, the set [a-zA-M3] is represented as "33AMaz".
|
|
*/
|
|
UnicodeString UnicodeSetTest::getPairs(const UnicodeSet& set) {
|
|
UnicodeString pairs;
|
|
for (int32_t i=0; i<set.getRangeCount(); ++i) {
|
|
UChar32 start = set.getRangeStart(i);
|
|
UChar32 end = set.getRangeEnd(i);
|
|
if (end > 0xFFFF) {
|
|
end = 0xFFFF;
|
|
i = set.getRangeCount(); // Should be unnecessary
|
|
}
|
|
pairs.append((UChar)start).append((UChar)end);
|
|
}
|
|
return pairs;
|
|
}
|
|
|
|
/**
|
|
* Basic consistency check for a few items.
|
|
* That the iterator works, and that we can create a pattern and
|
|
* get the same thing back
|
|
*/
|
|
void UnicodeSetTest::checkRoundTrip(const UnicodeSet& s) {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
|
|
UnicodeSet t(s);
|
|
checkEqual(s, t, "copy ct");
|
|
|
|
t = s;
|
|
checkEqual(s, t, "operator=");
|
|
|
|
copyWithIterator(t, s, FALSE);
|
|
checkEqual(s, t, "iterator roundtrip");
|
|
|
|
copyWithIterator(t, s, TRUE); // try range
|
|
checkEqual(s, t, "iterator roundtrip");
|
|
|
|
UnicodeString pat; s.toPattern(pat, FALSE);
|
|
t.applyPattern(pat, ec);
|
|
if (U_FAILURE(ec)) {
|
|
errln("FAIL: applyPattern");
|
|
return;
|
|
} else {
|
|
checkEqual(s, t, "toPattern(false)");
|
|
}
|
|
|
|
s.toPattern(pat, TRUE);
|
|
t.applyPattern(pat, ec);
|
|
if (U_FAILURE(ec)) {
|
|
errln("FAIL: applyPattern");
|
|
return;
|
|
} else {
|
|
checkEqual(s, t, "toPattern(true)");
|
|
}
|
|
}
|
|
|
|
void UnicodeSetTest::copyWithIterator(UnicodeSet& t, const UnicodeSet& s, UBool withRange) {
|
|
t.clear();
|
|
UnicodeSetIterator it(s);
|
|
if (withRange) {
|
|
while (it.nextRange()) {
|
|
if (it.isString()) {
|
|
t.add(it.getString());
|
|
} else {
|
|
t.add(it.getCodepoint(), it.getCodepointEnd());
|
|
}
|
|
}
|
|
} else {
|
|
while (it.next()) {
|
|
if (it.isString()) {
|
|
t.add(it.getString());
|
|
} else {
|
|
t.add(it.getCodepoint());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UBool UnicodeSetTest::checkEqual(const UnicodeSet& s, const UnicodeSet& t, const char* message) {
|
|
UnicodeString source; s.toPattern(source, TRUE);
|
|
UnicodeString result; t.toPattern(result, TRUE);
|
|
if (s != t) {
|
|
errln((UnicodeString)"FAIL: " + message
|
|
+ "; source = " + source
|
|
+ "; result = " + result
|
|
);
|
|
return FALSE;
|
|
} else {
|
|
logln((UnicodeString)"Ok: " + message
|
|
+ "; source = " + source
|
|
+ "; result = " + result
|
|
);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
UnicodeSetTest::expectContainment(const UnicodeSet& set,
|
|
const UnicodeString& charsIn,
|
|
const UnicodeString& charsOut) {
|
|
UnicodeString pat;
|
|
set.toPattern(pat);
|
|
expectContainment(set, pat, charsIn, charsOut);
|
|
}
|
|
|
|
void
|
|
UnicodeSetTest::expectContainment(const UnicodeSet& set,
|
|
const UnicodeString& setName,
|
|
const UnicodeString& charsIn,
|
|
const UnicodeString& charsOut) {
|
|
UnicodeString bad;
|
|
int32_t i;
|
|
for (i=0; i<charsIn.length(); ++i) {
|
|
UChar32 c = charsIn.char32At(i);
|
|
if(c>0xFFFF) i++;
|
|
|
|
if (!set.contains(c)) {
|
|
bad.append(c);
|
|
}
|
|
}
|
|
if (bad.length() > 0) {
|
|
errln((UnicodeString)"Fail: set " + setName + " does not contain " + prettify(bad) +
|
|
", expected containment of " + prettify(charsIn));
|
|
} else {
|
|
logln((UnicodeString)"Ok: set " + setName + " contains " + prettify(charsIn));
|
|
}
|
|
|
|
bad.truncate(0);
|
|
for (i=0; i<charsOut.length(); ++i) {
|
|
UChar c = charsOut.charAt(i);
|
|
if (set.contains(c)) {
|
|
bad.append(c);
|
|
}
|
|
}
|
|
if (bad.length() > 0) {
|
|
logln((UnicodeString)"Fail: set " + setName + " contains " + prettify(bad) +
|
|
", expected non-containment of " + prettify(charsOut));
|
|
} else {
|
|
logln((UnicodeString)"Ok: set " + setName + " does not contain " + prettify(charsOut));
|
|
}
|
|
}
|
|
|
|
void
|
|
UnicodeSetTest::expectPattern(UnicodeSet& set,
|
|
const UnicodeString& pattern,
|
|
const UnicodeString& expectedPairs){
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
set.applyPattern(pattern, status);
|
|
if (U_FAILURE(status)) {
|
|
errln(UnicodeString("FAIL: applyPattern(\"") + pattern +
|
|
"\") failed");
|
|
return;
|
|
} else {
|
|
if (getPairs(set) != expectedPairs ) {
|
|
errln(UnicodeString("FAIL: applyPattern(\"") + pattern +
|
|
"\") => pairs \"" +
|
|
escape(getPairs(set)) + "\", expected \"" +
|
|
escape(expectedPairs) + "\"");
|
|
} else {
|
|
logln(UnicodeString("Ok: applyPattern(\"") + pattern +
|
|
"\") => pairs \"" +
|
|
escape(getPairs(set)) + "\"");
|
|
}
|
|
}
|
|
// the result of calling set.toPattern(), which is the string representation of
|
|
// this set(set), is passed to a UnicodeSet constructor, and tested that it
|
|
// will produce another set that is equal to this one.
|
|
UnicodeString temppattern;
|
|
set.toPattern(temppattern);
|
|
UnicodeSet *tempset=new UnicodeSet(temppattern, status);
|
|
if (U_FAILURE(status)) {
|
|
errln(UnicodeString("FAIL: applyPattern(\""+ pattern + "\").toPattern() => " + temppattern + " => invalid pattern"));
|
|
return;
|
|
}
|
|
if(*tempset != set || getPairs(*tempset) != getPairs(set)){
|
|
errln(UnicodeString("FAIL: applyPattern(\""+ pattern + "\").toPattern() => " + temppattern + " => pairs \""+ escape(getPairs(*tempset)) + "\", expected pairs \"" +
|
|
escape(getPairs(set)) + "\""));
|
|
} else{
|
|
logln(UnicodeString("Ok: applyPattern(\""+ pattern + "\").toPattern() => " + temppattern + " => pairs \"" + escape(getPairs(*tempset)) + "\""));
|
|
}
|
|
|
|
delete tempset;
|
|
|
|
}
|
|
|
|
void
|
|
UnicodeSetTest::expectPairs(const UnicodeSet& set, const UnicodeString& expectedPairs) {
|
|
if (getPairs(set) != expectedPairs) {
|
|
errln(UnicodeString("FAIL: Expected pair list \"") +
|
|
escape(expectedPairs) + "\", got \"" +
|
|
escape(getPairs(set)) + "\"");
|
|
}
|
|
}
|
|
|
|
void UnicodeSetTest::expectToPattern(const UnicodeSet& set,
|
|
const UnicodeString& expPat,
|
|
const char** expStrings) {
|
|
UnicodeString pat;
|
|
set.toPattern(pat, TRUE);
|
|
if (pat == expPat) {
|
|
logln((UnicodeString)"Ok: toPattern() => \"" + pat + "\"");
|
|
} else {
|
|
errln((UnicodeString)"FAIL: toPattern() => \"" + pat + "\", expected \"" + expPat + "\"");
|
|
return;
|
|
}
|
|
UBool in = TRUE;
|
|
for (int32_t i=0; expStrings[i] != NULL; ++i) {
|
|
if (expStrings[i] == NOT) { // sic; pointer comparison
|
|
in = FALSE;
|
|
continue;
|
|
}
|
|
UnicodeString s = CharsToUnicodeString(expStrings[i]);
|
|
UBool contained = set.contains(s);
|
|
if (contained == in) {
|
|
logln((UnicodeString)"Ok: " + expPat +
|
|
(contained ? " contains {" : " does not contain {") +
|
|
escape(expStrings[i]) + "}");
|
|
} else {
|
|
errln((UnicodeString)"FAIL: " + expPat +
|
|
(contained ? " contains {" : " does not contain {") +
|
|
escape(expStrings[i]) + "}");
|
|
}
|
|
}
|
|
}
|
|
|
|
static UChar toHexString(int32_t i) { return (UChar)(i + (i < 10 ? 0x30 : (0x41 - 10))); }
|
|
|
|
void
|
|
UnicodeSetTest::doAssert(UBool condition, const char *message)
|
|
{
|
|
if (!condition) {
|
|
errln(UnicodeString("ERROR : ") + message);
|
|
}
|
|
}
|
|
|
|
UnicodeString
|
|
UnicodeSetTest::escape(const UnicodeString& s) {
|
|
UnicodeString buf;
|
|
for (int32_t i=0; i<s.length(); ++i)
|
|
{
|
|
UChar c = s[(int32_t)i];
|
|
if (0x0020 <= c && c <= 0x007F) {
|
|
buf += c;
|
|
} else {
|
|
buf += (UChar)0x5c; buf += (UChar)0x55;
|
|
buf += toHexString((c & 0xF000) >> 12);
|
|
buf += toHexString((c & 0x0F00) >> 8);
|
|
buf += toHexString((c & 0x00F0) >> 4);
|
|
buf += toHexString(c & 0x000F);
|
|
}
|
|
}
|
|
return buf;
|
|
}
|