ICU-13388 remove unused code in break iterator tests.
X-SVN-Rev: 40697
This commit is contained in:
Andy Heninger
parent
6d58ccae2a
commit
9a542da329
@ -75,7 +75,6 @@ void RBBITest::runIndexedTest( int32_t index, UBool exec, const char* &name, cha
|
|||||||
#endif
|
#endif
|
||||||
#if !UCONFIG_NO_FILE_IO
|
#if !UCONFIG_NO_FILE_IO
|
||||||
TESTCASE_AUTO(TestUnicodeFiles);
|
TESTCASE_AUTO(TestUnicodeFiles);
|
||||||
TESTCASE_AUTO(TestEmptyString);
|
|
||||||
#endif
|
#endif
|
||||||
TESTCASE_AUTO(TestGetAvailableLocales);
|
TESTCASE_AUTO(TestGetAvailableLocales);
|
||||||
TESTCASE_AUTO(TestGetDisplayName);
|
TESTCASE_AUTO(TestGetDisplayName);
|
||||||
@ -110,147 +109,6 @@ void RBBITest::runIndexedTest( int32_t index, UBool exec, const char* &name, cha
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
//---------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// class BITestData Holds a set of Break iterator test data and results
|
|
||||||
// Includes
|
|
||||||
// - the string data to be broken
|
|
||||||
// - a vector of the expected break positions.
|
|
||||||
// - a vector of source line numbers for the data,
|
|
||||||
// (to help see where errors occured.)
|
|
||||||
// - The expected break tag values.
|
|
||||||
// - Vectors of actual break positions and tag values.
|
|
||||||
// - Functions for comparing actual with expected and
|
|
||||||
// reporting errors.
|
|
||||||
//
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
class BITestData {
|
|
||||||
public:
|
|
||||||
UnicodeString fDataToBreak;
|
|
||||||
UVector fExpectedBreakPositions;
|
|
||||||
UVector fExpectedTags;
|
|
||||||
UVector fLineNum;
|
|
||||||
UVector fActualBreakPositions; // Test Results.
|
|
||||||
UVector fActualTags;
|
|
||||||
|
|
||||||
BITestData(UErrorCode &status);
|
|
||||||
void addDataChunk(const char *data, int32_t tag, int32_t lineNum, UErrorCode status);
|
|
||||||
void checkResults(const char *heading, RBBITest *test);
|
|
||||||
void err(const char *heading, RBBITest *test, int32_t expectedIdx, int32_t actualIdx);
|
|
||||||
void clearResults();
|
|
||||||
};
|
|
||||||
|
|
||||||
//
|
|
||||||
// Constructor.
|
|
||||||
//
|
|
||||||
BITestData::BITestData(UErrorCode &status)
|
|
||||||
: fExpectedBreakPositions(status), fExpectedTags(status), fLineNum(status), fActualBreakPositions(status),
|
|
||||||
fActualTags(status)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// addDataChunk. Add a section (non-breaking) piece if data to the test data.
|
|
||||||
// The macro form collects the line number, which is helpful
|
|
||||||
// when tracking down failures.
|
|
||||||
//
|
|
||||||
// A null data item is inserted at the start of each test's data
|
|
||||||
// to put the starting zero into the data list. The position saved for
|
|
||||||
// each non-null item is its ending position.
|
|
||||||
//
|
|
||||||
#define ADD_DATACHUNK(td, data, tag, status) td.addDataChunk(data, tag, __LINE__, status);
|
|
||||||
void BITestData::addDataChunk(const char *data, int32_t tag, int32_t lineNum, UErrorCode status) {
|
|
||||||
if (U_FAILURE(status)) {return;}
|
|
||||||
if (data != NULL) {
|
|
||||||
fDataToBreak.append(CharsToUnicodeString(data));
|
|
||||||
}
|
|
||||||
fExpectedBreakPositions.addElement(fDataToBreak.length(), status);
|
|
||||||
fExpectedTags.addElement(tag, status);
|
|
||||||
fLineNum.addElement(lineNum, status);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//
|
|
||||||
// checkResults. Compare the actual and expected break positions, report any differences.
|
|
||||||
//
|
|
||||||
void BITestData::checkResults(const char *heading, RBBITest *test) {
|
|
||||||
int32_t expectedIndex = 0;
|
|
||||||
int32_t actualIndex = 0;
|
|
||||||
|
|
||||||
for (;;) {
|
|
||||||
// If we've run through both the expected and actual results vectors, we're done.
|
|
||||||
// break out of the loop.
|
|
||||||
if (expectedIndex >= fExpectedBreakPositions.size() &&
|
|
||||||
actualIndex >= fActualBreakPositions.size()) {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
if (expectedIndex >= fExpectedBreakPositions.size()) {
|
|
||||||
err(heading, test, expectedIndex-1, actualIndex);
|
|
||||||
actualIndex++;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (actualIndex >= fActualBreakPositions.size()) {
|
|
||||||
err(heading, test, expectedIndex, actualIndex-1);
|
|
||||||
expectedIndex++;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (fActualBreakPositions.elementAti(actualIndex) != fExpectedBreakPositions.elementAti(expectedIndex)) {
|
|
||||||
err(heading, test, expectedIndex, actualIndex);
|
|
||||||
// Try to resync the positions of the indices, to avoid a rash of spurious erros.
|
|
||||||
if (fActualBreakPositions.elementAti(actualIndex) < fExpectedBreakPositions.elementAti(expectedIndex)) {
|
|
||||||
actualIndex++;
|
|
||||||
} else {
|
|
||||||
expectedIndex++;
|
|
||||||
}
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (fActualTags.elementAti(actualIndex) != fExpectedTags.elementAti(expectedIndex)) {
|
|
||||||
test->errln("%s, tag mismatch. Test Line = %d, expected tag=%d, got %d",
|
|
||||||
heading, fLineNum.elementAt(expectedIndex),
|
|
||||||
fExpectedTags.elementAti(expectedIndex), fActualTags.elementAti(actualIndex));
|
|
||||||
}
|
|
||||||
|
|
||||||
actualIndex++;
|
|
||||||
expectedIndex++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// err - An error was found. Report it, along with information about where the
|
|
||||||
// incorrectly broken test data appeared in the source file.
|
|
||||||
//
|
|
||||||
void BITestData::err(const char *heading, RBBITest *test, int32_t expectedIdx, int32_t actualIdx)
|
|
||||||
{
|
|
||||||
int32_t expected = fExpectedBreakPositions.elementAti(expectedIdx);
|
|
||||||
int32_t actual = fActualBreakPositions.elementAti(actualIdx);
|
|
||||||
int32_t o = 0;
|
|
||||||
int32_t line = fLineNum.elementAti(expectedIdx);
|
|
||||||
if (expectedIdx > 0) {
|
|
||||||
// The line numbers are off by one because a premature break occurs somewhere
|
|
||||||
// within the previous item, rather than at the start of the current (expected) item.
|
|
||||||
// We want to report the offset of the unexpected break from the start of
|
|
||||||
// this previous item.
|
|
||||||
o = actual - fExpectedBreakPositions.elementAti(expectedIdx-1);
|
|
||||||
}
|
|
||||||
if (actual < expected) {
|
|
||||||
test->errln("%s unexpected break at offset %d in test item from line %d. actual break: %d expected break: %d", heading, o, line, actual, expected);
|
|
||||||
} else {
|
|
||||||
test->errln("%s Failed to find break at end of item from line %d. actual break: %d expected break: %d", heading, line, actual, expected);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void BITestData::clearResults() {
|
|
||||||
fActualBreakPositions.removeAllElements();
|
|
||||||
fActualTags.removeAllElements();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//--------------------------------------------------------------------------------------
|
//--------------------------------------------------------------------------------------
|
||||||
//
|
//
|
||||||
// RBBITest constructor and destructor
|
// RBBITest constructor and destructor
|
||||||
@ -345,277 +203,12 @@ void RBBITest::TestBug3818() {
|
|||||||
delete bi;
|
delete bi;
|
||||||
}
|
}
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
//
|
|
||||||
// generalIteratorTest Given a break iterator and a set of test data,
|
|
||||||
// Run the tests and report the results.
|
|
||||||
//
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
void RBBITest::generalIteratorTest(RuleBasedBreakIterator& bi, BITestData &td)
|
|
||||||
{
|
|
||||||
|
|
||||||
bi.setText(td.fDataToBreak);
|
|
||||||
|
|
||||||
testFirstAndNext(bi, td);
|
|
||||||
|
|
||||||
testLastAndPrevious(bi, td);
|
|
||||||
|
|
||||||
testFollowing(bi, td);
|
|
||||||
testPreceding(bi, td);
|
|
||||||
testIsBoundary(bi, td);
|
|
||||||
doMultipleSelectionTest(bi, td);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//
|
|
||||||
// testFirstAndNext. Run the iterator forwards in the obvious first(), next()
|
|
||||||
// kind of loop.
|
|
||||||
//
|
|
||||||
void RBBITest::testFirstAndNext(RuleBasedBreakIterator& bi, BITestData &td)
|
|
||||||
{
|
|
||||||
UErrorCode status = U_ZERO_ERROR;
|
|
||||||
int32_t p;
|
|
||||||
int32_t lastP = -1;
|
|
||||||
int32_t tag;
|
|
||||||
|
|
||||||
logln("Test first and next");
|
|
||||||
bi.setText(td.fDataToBreak);
|
|
||||||
td.clearResults();
|
|
||||||
|
|
||||||
for (p=bi.first(); p!=RuleBasedBreakIterator::DONE; p=bi.next()) {
|
|
||||||
td.fActualBreakPositions.addElement(p, status); // Save result.
|
|
||||||
tag = bi.getRuleStatus();
|
|
||||||
td.fActualTags.addElement(tag, status);
|
|
||||||
if (p <= lastP) {
|
|
||||||
// If the iterator is not making forward progress, stop.
|
|
||||||
// No need to raise an error here, it'll be detected in the normal check of results.
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
lastP = p;
|
|
||||||
}
|
|
||||||
td.checkResults("testFirstAndNext", this);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//
|
|
||||||
// TestLastAndPrevious. Run the iterator backwards, starting with last().
|
|
||||||
//
|
|
||||||
void RBBITest::testLastAndPrevious(RuleBasedBreakIterator& bi, BITestData &td)
|
|
||||||
{
|
|
||||||
UErrorCode status = U_ZERO_ERROR;
|
|
||||||
int32_t p;
|
|
||||||
int32_t lastP = 0x7ffffffe;
|
|
||||||
int32_t tag;
|
|
||||||
|
|
||||||
logln("Test last and previous");
|
|
||||||
bi.setText(td.fDataToBreak);
|
|
||||||
td.clearResults();
|
|
||||||
|
|
||||||
for (p=bi.last(); p!=RuleBasedBreakIterator::DONE; p=bi.previous()) {
|
|
||||||
// Save break position. Insert it at start of vector of results, shoving
|
|
||||||
// already-saved results further towards the end.
|
|
||||||
td.fActualBreakPositions.insertElementAt(p, 0, status);
|
|
||||||
// bi.previous(); // TODO: Why does this fix things up????
|
|
||||||
// bi.next();
|
|
||||||
tag = bi.getRuleStatus();
|
|
||||||
td.fActualTags.insertElementAt(tag, 0, status);
|
|
||||||
if (p >= lastP) {
|
|
||||||
// If the iterator is not making progress, stop.
|
|
||||||
// No need to raise an error here, it'll be detected in the normal check of results.
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
lastP = p;
|
|
||||||
}
|
|
||||||
td.checkResults("testLastAndPrevious", this);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void RBBITest::testFollowing(RuleBasedBreakIterator& bi, BITestData &td)
|
|
||||||
{
|
|
||||||
UErrorCode status = U_ZERO_ERROR;
|
|
||||||
int32_t p;
|
|
||||||
int32_t tag;
|
|
||||||
int32_t lastP = -2; // A value that will never be returned as a break position.
|
|
||||||
// cannot be -1; that is returned for DONE.
|
|
||||||
int i;
|
|
||||||
|
|
||||||
logln("testFollowing():");
|
|
||||||
bi.setText(td.fDataToBreak);
|
|
||||||
td.clearResults();
|
|
||||||
|
|
||||||
// Save the starting point, since we won't get that out of following.
|
|
||||||
p = bi.first();
|
|
||||||
td.fActualBreakPositions.addElement(p, status); // Save result.
|
|
||||||
tag = bi.getRuleStatus();
|
|
||||||
td.fActualTags.addElement(tag, status);
|
|
||||||
|
|
||||||
for (i = 0; i <= td.fDataToBreak.length()+1; i++) {
|
|
||||||
p = bi.following(i);
|
|
||||||
if (p != lastP) {
|
|
||||||
if (p == RuleBasedBreakIterator::DONE) {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
// We've reached a new break position. Save it.
|
|
||||||
td.fActualBreakPositions.addElement(p, status); // Save result.
|
|
||||||
tag = bi.getRuleStatus();
|
|
||||||
td.fActualTags.addElement(tag, status);
|
|
||||||
lastP = p;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// The loop normally exits by means of the break in the middle.
|
|
||||||
// Make sure that the index was at the correct position for the break iterator to have
|
|
||||||
// returned DONE.
|
|
||||||
if (i != td.fDataToBreak.length()) {
|
|
||||||
errln("testFollowing(): iterator returned DONE prematurely.");
|
|
||||||
}
|
|
||||||
|
|
||||||
// Full check of all results.
|
|
||||||
td.checkResults("testFollowing", this);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
void RBBITest::testPreceding(RuleBasedBreakIterator& bi, BITestData &td) {
|
|
||||||
UErrorCode status = U_ZERO_ERROR;
|
|
||||||
int32_t p;
|
|
||||||
int32_t tag;
|
|
||||||
int32_t lastP = 0x7ffffffe;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
logln("testPreceding():");
|
|
||||||
bi.setText(td.fDataToBreak);
|
|
||||||
td.clearResults();
|
|
||||||
|
|
||||||
p = bi.last();
|
|
||||||
td.fActualBreakPositions.addElement(p, status);
|
|
||||||
tag = bi.getRuleStatus();
|
|
||||||
td.fActualTags.addElement(tag, status);
|
|
||||||
|
|
||||||
for (i = td.fDataToBreak.length(); i>=-1; i--) {
|
|
||||||
p = bi.preceding(i);
|
|
||||||
if (p != lastP) {
|
|
||||||
if (p == RuleBasedBreakIterator::DONE) {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
// We've reached a new break position. Save it.
|
|
||||||
td.fActualBreakPositions.insertElementAt(p, 0, status);
|
|
||||||
lastP = p;
|
|
||||||
tag = bi.getRuleStatus();
|
|
||||||
td.fActualTags.insertElementAt(tag, 0, status);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// The loop normally exits by means of the break in the middle.
|
|
||||||
// Make sure that the index was at the correct position for the break iterator to have
|
|
||||||
// returned DONE.
|
|
||||||
if (i != 0) {
|
|
||||||
errln("testPreceding(): iterator returned DONE prematurely.");
|
|
||||||
}
|
|
||||||
|
|
||||||
// Full check of all results.
|
|
||||||
td.checkResults("testPreceding", this);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
void RBBITest::testIsBoundary(RuleBasedBreakIterator& bi, BITestData &td) {
|
|
||||||
UErrorCode status = U_ZERO_ERROR;
|
|
||||||
int i;
|
|
||||||
int32_t tag;
|
|
||||||
|
|
||||||
logln("testIsBoundary():");
|
|
||||||
bi.setText(td.fDataToBreak);
|
|
||||||
td.clearResults();
|
|
||||||
|
|
||||||
for (i = 0; i <= td.fDataToBreak.length(); i++) {
|
|
||||||
if (bi.isBoundary(i)) {
|
|
||||||
td.fActualBreakPositions.addElement(i, status); // Save result.
|
|
||||||
tag = bi.getRuleStatus();
|
|
||||||
td.fActualTags.addElement(tag, status);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
td.checkResults("testIsBoundary: ", this);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
void RBBITest::doMultipleSelectionTest(RuleBasedBreakIterator& iterator, BITestData &td)
|
|
||||||
{
|
|
||||||
iterator.setText(td.fDataToBreak);
|
|
||||||
|
|
||||||
RuleBasedBreakIterator* testIterator =(RuleBasedBreakIterator*)iterator.clone();
|
|
||||||
int32_t offset = iterator.first();
|
|
||||||
int32_t testOffset;
|
|
||||||
int32_t count = 0;
|
|
||||||
|
|
||||||
logln("doMultipleSelectionTest text of length: %d", td.fDataToBreak.length());
|
|
||||||
|
|
||||||
if (*testIterator != iterator)
|
|
||||||
errln("clone() or operator!= failed: two clones compared unequal");
|
|
||||||
|
|
||||||
do {
|
|
||||||
testOffset = testIterator->first();
|
|
||||||
testOffset = testIterator->next(count);
|
|
||||||
if (offset != testOffset)
|
|
||||||
errln(UnicodeString("next(n) and next() not returning consistent results: for step ") + count + ", next(n) returned " + testOffset + " and next() had " + offset);
|
|
||||||
|
|
||||||
if (offset != RuleBasedBreakIterator::DONE) {
|
|
||||||
count++;
|
|
||||||
offset = iterator.next();
|
|
||||||
|
|
||||||
if (offset != RuleBasedBreakIterator::DONE && *testIterator == iterator) {
|
|
||||||
errln("operator== failed: Two unequal iterators compared equal. count=%d offset=%d", count, offset);
|
|
||||||
if (count > 10000 || offset == -1) {
|
|
||||||
errln("operator== failed too many times. Stopping test.");
|
|
||||||
if (offset == -1) {
|
|
||||||
errln("Does (RuleBasedBreakIterator::DONE == -1)?");
|
|
||||||
}
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} while (offset != RuleBasedBreakIterator::DONE);
|
|
||||||
|
|
||||||
// now do it backwards...
|
|
||||||
offset = iterator.last();
|
|
||||||
count = 0;
|
|
||||||
|
|
||||||
do {
|
|
||||||
testOffset = testIterator->last();
|
|
||||||
testOffset = testIterator->next(count); // next() with a negative arg is same as previous
|
|
||||||
if (offset != testOffset)
|
|
||||||
errln(UnicodeString("next(n) and next() not returning consistent results: for step ") + count + ", next(n) returned " + testOffset + " and next() had " + offset);
|
|
||||||
|
|
||||||
if (offset != RuleBasedBreakIterator::DONE) {
|
|
||||||
count--;
|
|
||||||
offset = iterator.previous();
|
|
||||||
}
|
|
||||||
} while (offset != RuleBasedBreakIterator::DONE);
|
|
||||||
|
|
||||||
delete testIterator;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
//---------------------------------------------
|
//---------------------------------------------
|
||||||
//
|
//
|
||||||
// other tests
|
// other tests
|
||||||
//
|
//
|
||||||
//---------------------------------------------
|
//---------------------------------------------
|
||||||
void RBBITest::TestEmptyString()
|
|
||||||
{
|
|
||||||
UnicodeString text = "";
|
|
||||||
UErrorCode status = U_ZERO_ERROR;
|
|
||||||
|
|
||||||
BITestData x(status);
|
|
||||||
ADD_DATACHUNK(x, "", 0, status); // Break at start of data
|
|
||||||
RuleBasedBreakIterator* bi = (RuleBasedBreakIterator *)BreakIterator::createLineInstance(Locale::getDefault(), status);
|
|
||||||
if (U_FAILURE(status))
|
|
||||||
{
|
|
||||||
errcheckln(status, "Failed to create the BreakIterator for default locale in TestEmptyString. - %s", u_errorName(status));
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
generalIteratorTest(*bi, x);
|
|
||||||
delete bi;
|
|
||||||
}
|
|
||||||
|
|
||||||
void RBBITest::TestGetAvailableLocales()
|
void RBBITest::TestGetAvailableLocales()
|
||||||
{
|
{
|
||||||
|
|||||||
@ -41,7 +41,6 @@ public:
|
|||||||
|
|
||||||
void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL );
|
void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL );
|
||||||
|
|
||||||
void TestEmptyString();
|
|
||||||
void TestGetAvailableLocales();
|
void TestGetAvailableLocales();
|
||||||
void TestGetDisplayName();
|
void TestGetDisplayName();
|
||||||
void TestEndBehaviour();
|
void TestEndBehaviour();
|
||||||
@ -85,40 +84,6 @@ private:
|
|||||||
* internal methods to prepare test data
|
* internal methods to prepare test data
|
||||||
**/
|
**/
|
||||||
|
|
||||||
/**
|
|
||||||
* Perform tests of BreakIterator forward and backward functionality
|
|
||||||
* on different kinds of iterators (word, sentence, line and character).
|
|
||||||
* It tests the methods first(), next(), current(), preceding(), following()
|
|
||||||
* previous() and isBoundary().
|
|
||||||
* It makes use of internal functions to achieve this.
|
|
||||||
**/
|
|
||||||
void generalIteratorTest(RuleBasedBreakIterator& bi, BITestData &td);
|
|
||||||
/**
|
|
||||||
* Internal method to perform iteration and test the first() and next() functions
|
|
||||||
**/
|
|
||||||
void testFirstAndNext(RuleBasedBreakIterator& bi, BITestData &td);
|
|
||||||
/**
|
|
||||||
* Internal method to perform iteration and test the last() and previous() functions
|
|
||||||
**/
|
|
||||||
void testLastAndPrevious(RuleBasedBreakIterator& bi, BITestData &td);
|
|
||||||
/**
|
|
||||||
* Internal method to perform iteration and test the following() function
|
|
||||||
**/
|
|
||||||
void testFollowing(RuleBasedBreakIterator& bi, BITestData &td);
|
|
||||||
/**
|
|
||||||
* Internal method to perform iteration and test the preceding() function
|
|
||||||
**/
|
|
||||||
void testPreceding(RuleBasedBreakIterator& bi, BITestData &td);
|
|
||||||
/**
|
|
||||||
* Internal method to perform iteration and test the isBoundary() function
|
|
||||||
**/
|
|
||||||
void testIsBoundary(RuleBasedBreakIterator& bi, BITestData &td);
|
|
||||||
/**
|
|
||||||
* Internal method to perform tests of BreakIterator multiple selection functionality
|
|
||||||
* on different kinds of iterators (word, sentence, line and character)
|
|
||||||
**/
|
|
||||||
void doMultipleSelectionTest(RuleBasedBreakIterator& iterator, BITestData &td);
|
|
||||||
|
|
||||||
void RunMonkey(BreakIterator *bi, RBBIMonkeyKind &mk, const char *name, uint32_t seed,
|
void RunMonkey(BreakIterator *bi, RBBIMonkeyKind &mk, const char *name, uint32_t seed,
|
||||||
int32_t loopCount, UBool useUText);
|
int32_t loopCount, UBool useUText);
|
||||||
|
|
||||||
|
|||||||
@ -9,11 +9,8 @@
|
|||||||
package com.ibm.icu.dev.test.rbbi;
|
package com.ibm.icu.dev.test.rbbi;
|
||||||
|
|
||||||
import java.text.StringCharacterIterator;
|
import java.text.StringCharacterIterator;
|
||||||
import java.util.ArrayList;
|
|
||||||
import java.util.List;
|
|
||||||
import java.util.Locale;
|
import java.util.Locale;
|
||||||
|
|
||||||
import org.junit.Before;
|
|
||||||
import org.junit.Test;
|
import org.junit.Test;
|
||||||
import org.junit.runner.RunWith;
|
import org.junit.runner.RunWith;
|
||||||
import org.junit.runners.JUnit4;
|
import org.junit.runners.JUnit4;
|
||||||
@ -23,190 +20,19 @@ import com.ibm.icu.text.BreakIterator;
|
|||||||
import com.ibm.icu.text.FilteredBreakIteratorBuilder;
|
import com.ibm.icu.text.FilteredBreakIteratorBuilder;
|
||||||
import com.ibm.icu.util.ULocale;
|
import com.ibm.icu.util.ULocale;
|
||||||
|
|
||||||
@SuppressWarnings("unused")
|
|
||||||
@RunWith(JUnit4.class)
|
@RunWith(JUnit4.class)
|
||||||
public class BreakIteratorTest extends TestFmwk
|
public class BreakIteratorTest extends TestFmwk
|
||||||
{
|
{
|
||||||
private BreakIterator characterBreak;
|
|
||||||
private BreakIterator wordBreak;
|
|
||||||
private BreakIterator lineBreak;
|
|
||||||
private BreakIterator sentenceBreak;
|
|
||||||
private BreakIterator titleBreak;
|
|
||||||
|
|
||||||
public BreakIteratorTest()
|
public BreakIteratorTest()
|
||||||
{
|
{
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Before
|
|
||||||
public void init(){
|
|
||||||
characterBreak = BreakIterator.getCharacterInstance();
|
|
||||||
wordBreak = BreakIterator.getWordInstance();
|
|
||||||
lineBreak = BreakIterator.getLineInstance();
|
|
||||||
//logln("Creating sentence iterator...");
|
|
||||||
sentenceBreak = BreakIterator.getSentenceInstance();
|
|
||||||
//logln("Finished creating sentence iterator...");
|
|
||||||
titleBreak = BreakIterator.getTitleInstance();
|
|
||||||
}
|
|
||||||
//=========================================================================
|
//=========================================================================
|
||||||
// general test subroutines
|
// general test subroutines
|
||||||
//=========================================================================
|
//=========================================================================
|
||||||
|
|
||||||
private List<String> _testFirstAndNext(BreakIterator bi, String text) {
|
|
||||||
int p = bi.first();
|
|
||||||
int lastP = p;
|
|
||||||
List<String> result = new ArrayList<String>();
|
|
||||||
|
|
||||||
if (p != 0)
|
|
||||||
errln("first() returned " + p + " instead of 0");
|
|
||||||
while (p != BreakIterator.DONE) {
|
|
||||||
p = bi.next();
|
|
||||||
if (p != BreakIterator.DONE) {
|
|
||||||
if (p <= lastP)
|
|
||||||
errln("next() failed to move forward: next() on position "
|
|
||||||
+ lastP + " yielded " + p);
|
|
||||||
|
|
||||||
result.add(text.substring(lastP, p));
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if (lastP != text.length())
|
|
||||||
errln("next() returned DONE prematurely: offset was "
|
|
||||||
+ lastP + " instead of " + text.length());
|
|
||||||
}
|
|
||||||
lastP = p;
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
private List<String> _testLastAndPrevious(BreakIterator bi, String text) {
|
|
||||||
int p = bi.last();
|
|
||||||
int lastP = p;
|
|
||||||
List<String> result = new ArrayList<String>();
|
|
||||||
|
|
||||||
if (p != text.length())
|
|
||||||
errln("last() returned " + p + " instead of " + text.length());
|
|
||||||
while (p != BreakIterator.DONE) {
|
|
||||||
p = bi.previous();
|
|
||||||
if (p != BreakIterator.DONE) {
|
|
||||||
if (p >= lastP)
|
|
||||||
errln("previous() failed to move backward: previous() on position "
|
|
||||||
+ lastP + " yielded " + p);
|
|
||||||
|
|
||||||
result.add(0, text.substring(p, lastP));
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if (lastP != 0)
|
|
||||||
errln("previous() returned DONE prematurely: offset was "
|
|
||||||
+ lastP + " instead of 0");
|
|
||||||
}
|
|
||||||
lastP = p;
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
private void compareFragmentLists(String f1Name, String f2Name, List<String> f1, List<String> f2) {
|
|
||||||
int p1 = 0;
|
|
||||||
int p2 = 0;
|
|
||||||
String s1;
|
|
||||||
String s2;
|
|
||||||
int t1 = 0;
|
|
||||||
int t2 = 0;
|
|
||||||
|
|
||||||
while (p1 < f1.size() && p2 < f2.size()) {
|
|
||||||
s1 = f1.get(p1);
|
|
||||||
s2 = f2.get(p2);
|
|
||||||
t1 += s1.length();
|
|
||||||
t2 += s2.length();
|
|
||||||
|
|
||||||
if (s1.equals(s2)) {
|
|
||||||
debugLogln(" >" + s1 + "<");
|
|
||||||
++p1;
|
|
||||||
++p2;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
int tempT1 = t1;
|
|
||||||
int tempT2 = t2;
|
|
||||||
int tempP1 = p1;
|
|
||||||
int tempP2 = p2;
|
|
||||||
|
|
||||||
while (tempT1 != tempT2 && tempP1 < f1.size() && tempP2 < f2.size()) {
|
|
||||||
while (tempT1 < tempT2 && tempP1 < f1.size()) {
|
|
||||||
tempT1 += (f1.get(tempP1)).length();
|
|
||||||
++tempP1;
|
|
||||||
}
|
|
||||||
while (tempT2 < tempT1 && tempP2 < f2.size()) {
|
|
||||||
tempT2 += (f2.get(tempP2)).length();
|
|
||||||
++tempP2;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
logln("*** " + f1Name + " has:");
|
|
||||||
while (p1 <= tempP1 && p1 < f1.size()) {
|
|
||||||
s1 = f1.get(p1);
|
|
||||||
t1 += s1.length();
|
|
||||||
debugLogln(" *** >" + s1 + "<");
|
|
||||||
++p1;
|
|
||||||
}
|
|
||||||
logln("***** " + f2Name + " has:");
|
|
||||||
while (p2 <= tempP2 && p2 < f2.size()) {
|
|
||||||
s2 = f2.get(p2);
|
|
||||||
t2 += s2.length();
|
|
||||||
debugLogln(" ***** >" + s2 + "<");
|
|
||||||
++p2;
|
|
||||||
}
|
|
||||||
errln("Discrepancy between " + f1Name + " and " + f2Name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void _testFollowing(BreakIterator bi, String text, int[] boundaries) {
|
|
||||||
logln("testFollowing():");
|
|
||||||
int p = 2;
|
|
||||||
for (int i = 0; i <= text.length(); i++) {
|
|
||||||
if (i == boundaries[p])
|
|
||||||
++p;
|
|
||||||
|
|
||||||
int b = bi.following(i);
|
|
||||||
logln("bi.following(" + i + ") -> " + b);
|
|
||||||
if (b != boundaries[p])
|
|
||||||
errln("Wrong result from following() for " + i + ": expected " + boundaries[p]
|
|
||||||
+ ", got " + b);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void _testPreceding(BreakIterator bi, String text, int[] boundaries) {
|
|
||||||
logln("testPreceding():");
|
|
||||||
int p = 0;
|
|
||||||
for (int i = 0; i <= text.length(); i++) {
|
|
||||||
int b = bi.preceding(i);
|
|
||||||
logln("bi.preceding(" + i + ") -> " + b);
|
|
||||||
if (b != boundaries[p])
|
|
||||||
errln("Wrong result from preceding() for " + i + ": expected " + boundaries[p]
|
|
||||||
+ ", got " + b);
|
|
||||||
|
|
||||||
if (i == boundaries[p + 1])
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void _testIsBoundary(BreakIterator bi, String text, int[] boundaries) {
|
|
||||||
logln("testIsBoundary():");
|
|
||||||
int p = 1;
|
|
||||||
boolean isB;
|
|
||||||
for (int i = 0; i <= text.length(); i++) {
|
|
||||||
isB = bi.isBoundary(i);
|
|
||||||
logln("bi.isBoundary(" + i + ") -> " + isB);
|
|
||||||
|
|
||||||
if (i == boundaries[p]) {
|
|
||||||
if (!isB)
|
|
||||||
errln("Wrong result from isBoundary() for " + i + ": expected true, got false");
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if (isB)
|
|
||||||
errln("Wrong result from isBoundary() for " + i + ": expected false, got true");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private void doOtherInvariantTest(BreakIterator tb, String testChars)
|
private void doOtherInvariantTest(BreakIterator tb, String testChars)
|
||||||
{
|
{
|
||||||
@ -362,43 +188,7 @@ public class BreakIteratorTest extends TestFmwk
|
|||||||
errln("Didn't get break at end of string.");
|
errln("Didn't get break at end of string.");
|
||||||
}
|
}
|
||||||
|
|
||||||
// The Following two tests are ported from ICU4C 1.8.1 [Richard/GCL]
|
// The Following test is ported from ICU4C 1.8.1 [Richard/GCL]
|
||||||
/**
|
|
||||||
* Port From: ICU4C v1.8.1 : textbounds : IntlTestTextBoundary
|
|
||||||
* Source File: $ICU4CRoot/source/test/intltest/ittxtbd.cpp
|
|
||||||
**/
|
|
||||||
/**
|
|
||||||
* test methods preceding, following and isBoundary
|
|
||||||
**/
|
|
||||||
@Test
|
|
||||||
public void TestPreceding() {
|
|
||||||
String words3 = "aaa bbb ccc";
|
|
||||||
BreakIterator e = BreakIterator.getWordInstance(Locale.getDefault());
|
|
||||||
e.setText( words3 );
|
|
||||||
e.first();
|
|
||||||
int p1 = e.next();
|
|
||||||
int p2 = e.next();
|
|
||||||
int p3 = e.next();
|
|
||||||
int p4 = e.next();
|
|
||||||
|
|
||||||
int f = e.following(p2+1);
|
|
||||||
int p = e.preceding(p2+1);
|
|
||||||
if (f!=p3)
|
|
||||||
errln("IntlTestTextBoundary::TestPreceding: f!=p3");
|
|
||||||
if (p!=p2)
|
|
||||||
errln("IntlTestTextBoundary::TestPreceding: p!=p2");
|
|
||||||
|
|
||||||
if (p1+1!=p2)
|
|
||||||
errln("IntlTestTextBoundary::TestPreceding: p1+1!=p2");
|
|
||||||
|
|
||||||
if (p3+1!=p4)
|
|
||||||
errln("IntlTestTextBoundary::TestPreceding: p3+1!=p4");
|
|
||||||
|
|
||||||
if (!e.isBoundary(p2) || e.isBoundary(p2+1) || !e.isBoundary(p3))
|
|
||||||
{
|
|
||||||
errln("IntlTestTextBoundary::TestPreceding: isBoundary err");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Ticket#5615
|
* Ticket#5615
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user