void
getBySqrt_enhance_help(
long long a,
std::map<long long, int>& stores,
int ordr
) {
if (a == 1) { return; }
if (a == 2) { stores[a] += ordr;return; }
else {
int i;
for (i = sqrt(a);i >= 2;--i)
{
if (a%i == 0) {
long long rsrv = a;
int k = getOrders(rsrv, i);
getBySqrt_enhance_help(i, stores, k*ordr);
if(rsrv!=1)
getBySqrt_enhance_help(rsrv, stores, ordr);
break;
}
}
if (i<2)stores[a] += ordr;
}
}
void Tpreset::createPages(TffdshowPageDec *pages) const
{
Torders orders;
getOrders(orders);
for (Torders::const_iterator o=orders.begin(); o!=orders.end(); o++)
#if defined(_MSC_VER) && (_MSC_VER == 1600)
std::get<CFG-1>(*o)->createPages(pages);
#else
o->get<CFG>()->createPages(pages);
#endif
}
void Tpreset::createFilters(Tfilters *filters,TfilterQueue &queue) const
{
Torders orders;
getOrders(orders,true);
orders.sort();
for (Torders::const_iterator o=orders.begin(); o!=orders.end(); o++)
#if defined(_MSC_VER) && (_MSC_VER == 1600)
std::get<CFG-1>(*o)->createFilters(std::get<ORDER-1>(*o),filters,queue);
#else
o->get<CFG>()->createFilters(o->get<ORDER>(),filters,queue);
#endif
}
void Tpreset::fixOrder(void)
{
Torders orders;
getOrders(orders);
orders.sort();
int o=min_order;
for (Torders::iterator i=orders.begin(); i!=orders.end(); i++,o++)
#if defined(_MSC_VER) && (_MSC_VER == 1600)
std::get<CFG-1>(*i)->order=o;
#else
i->get<CFG>()->order=o;
#endif
}
void CollationIteratorTest::TestOffset(/* char* par */)
{
CollationElementIterator *iter = en_us->createCollationElementIterator(test1);
UErrorCode status = U_ZERO_ERROR;
// testing boundaries
iter->setOffset(0, status);
if (U_FAILURE(status) || iter->previous(status) != UCOL_NULLORDER) {
errln("Error: After setting offset to 0, we should be at the end "
"of the backwards iteration");
}
iter->setOffset(test1.length(), status);
if (U_FAILURE(status) || iter->next(status) != UCOL_NULLORDER) {
errln("Error: After setting offset to end of the string, we should "
"be at the end of the backwards iteration");
}
// Run all the way through the iterator, then get the offset
int32_t orderLength = 0;
Order *orders = getOrders(*iter, orderLength);
int32_t offset = iter->getOffset();
if (offset != test1.length())
{
UnicodeString msg1("offset at end != length: ");
UnicodeString msg2(" vs ");
errln(msg1 + offset + msg2 + test1.length());
}
// Now set the offset back to the beginning and see if it works
CollationElementIterator *pristine = en_us->createCollationElementIterator(test1);
iter->setOffset(0, status);
if (U_FAILURE(status))
{
errln("setOffset failed.");
}
else
{
assertEqual(*iter, *pristine);
}
// TODO: try iterating halfway through a messy string.
delete pristine;
delete[] orders;
delete iter;
}
bool Tpreset::resetOrder(void)
{
Torders orders;
getOrders(orders);
bool waschange=false;
for (Torders::iterator o=orders.begin(); o!=orders.end(); o++) {
#if defined(_MSC_VER) && (_MSC_VER == 1600)
waschange|=(std::get<CFG-1>(*o)->order!=std::get<ORDERDEF-1>(*o));
std::get<CFG-1>(*o)->order=std::get<ORDERDEF-1>(*o);
#else
waschange|=(o->get<CFG>()->order!=o->get<ORDERDEF>());
o->get<CFG>()->order=o->get<ORDERDEF>();
#endif
}
return waschange;
}
bool Tpreset::setFilterOrder(unsigned int filterID,unsigned int newOrder)
{
int *o;
TfilterSettings *fs=getSettings(filterID);
if (!fs) {
return false;
}
o=&fs->order;
Torders orders;
getOrders(orders);
for (Torders::iterator i=orders.begin(); i!=orders.end(); i++)
#if defined(_MSC_VER) && (_MSC_VER == 1600)
std::get<CFG-1>(*i)->order=std::get<CFG-1>(*i)->order*10+1;
#else
i->get<CFG>()->order=i->get<CFG>()->order*10+1;
#endif
*o=newOrder*10;
fixOrder();
return true;
}
void IntlTestCollator::backAndForth(CollationElementIterator &iter)
{
// Run through the iterator forwards and stick it into an array
int32_t orderLength = 0;
LocalArray<Order> orders(getOrders(iter, orderLength));
UErrorCode status = U_ZERO_ERROR;
// Now go through it backwards and make sure we get the same values
int32_t index = orderLength;
int32_t o;
// reset the iterator
iter.reset();
while ((o = iter.previous(status)) != CollationElementIterator::NULLORDER)
{
/*int32_t offset = */iter.getOffset();
if (index == 0) {
if(o == 0) {
continue;
} else { // this is an error, orders exhausted but there are non-ignorable CEs from
// going backwards
errln("Backward iteration returned a non ignorable after orders are exhausted");
break;
}
}
index -= 1;
if (o != orders[index].order) {
if (o == 0)
index += 1;
else {
while (index > 0 && orders[--index].order == 0) {
// nothing...
}
if (o != orders[index].order) {
errln("Mismatched order at index %d: 0x%0:8X vs. 0x%0:8X", index,
orders[index].order, o);
//break;
return;
}
}
}
#if TEST_OFFSETS
if (offset != orders[index].offset) {
errln("Mismatched offset at index %d: %d vs. %d", index,
orders[index].offset, offset);
//break;
return;
}
#endif
}
while (index != 0 && orders[index - 1].order == 0)
{
index --;
}
if (index != 0)
{
UnicodeString msg("Didn't get back to beginning - index is ");
errln(msg + index);
iter.reset();
err("next: ");
while ((o = iter.next(status)) != CollationElementIterator::NULLORDER)
{
UnicodeString hexString("0x");
appendHex(o, 8, hexString);
hexString += " ";
err(hexString);
}
errln("");
err("prev: ");
while ((o = iter.previous(status)) != CollationElementIterator::NULLORDER)
{
UnicodeString hexString("0x");
appendHex(o, 8, hexString);
hexString += " ";
err(hexString);
}
errln("");
}
}
void
backAndForth(UCollationElements *iter)
{
/* Run through the iterator forwards and stick it into an array */
int32_t index, o;
UErrorCode status = U_ZERO_ERROR;
int32_t orderLength = 0;
int32_t *orders;
orders= getOrders(iter, &orderLength);
/* Now go through it backwards and make sure we get the same values */
index = orderLength;
ucol_reset(iter);
/* synwee : changed */
while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER)
{
if (o != orders[-- index])
{
if (o == 0)
index ++;
else
{
while (index > 0 && orders[-- index] == 0)
{
}
if (o != orders[index])
{
log_err("Mismatch at index : 0x%x\n", index);
return;
}
}
}
}
while (index != 0 && orders[index - 1] == 0) {
index --;
}
if (index != 0)
{
log_err("Didn't get back to beginning - index is %d\n", index);
ucol_reset(iter);
log_err("\nnext: ");
if ((o = ucol_next(iter, &status)) != UCOL_NULLORDER)
{
log_err("Error at %x\n", o);
}
log_err("\nprev: ");
if ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER)
{
log_err("Error at %x\n", o);
}
log_verbose("\n");
}
free(orders);
}
void
backAndForth(UCollationElements *iter)
{
/* Run through the iterator forwards and stick it into an array */
int32_t idx, o;
UErrorCode status = U_ZERO_ERROR;
int32_t orderLength = 0;
OrderAndOffset *orders = getOrders(iter, &orderLength);
/* Now go through it backwards and make sure we get the same values */
idx = orderLength;
ucol_reset(iter);
/* synwee : changed */
while ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) {
#if TEST_OFFSETS
int32_t offset =
#endif
ucol_getOffset(iter);
idx -= 1;
if (o != orders[idx].order) {
if (o == 0)
idx ++;
else {
while (idx > 0 && orders[-- idx].order == 0) {
/* nothing... */
}
if (o != orders[idx].order) {
log_err("Mismatched order at index %d: 0x%8.8X vs. 0x%8.8X\n", idx,
orders[idx].order, o);
goto bail;
}
}
}
#if TEST_OFFSETS
if (offset != orders[idx].offset) {
log_err("Mismatched offset at index %d: %d vs. %d\n", idx,
orders[idx].offset, offset);
goto bail;
}
#endif
}
while (idx != 0 && orders[idx - 1].order == 0) {
idx -= 1;
}
if (idx != 0) {
log_err("Didn't get back to beginning - index is %d\n", idx);
ucol_reset(iter);
log_err("\nnext: ");
if ((o = ucol_next(iter, &status)) != UCOL_NULLORDER) {
log_err("Error at %x\n", o);
}
log_err("\nprev: ");
if ((o = ucol_previous(iter, &status)) != UCOL_NULLORDER) {
log_err("Error at %x\n", o);
}
log_verbose("\n");
}
bail:
free(orders);
}
/**
* Testing iterators with extremely small buffers
*/
static void TestSmallBuffer()
{
UErrorCode status = U_ZERO_ERROR;
UCollator *coll;
UCollationElements *testiter,
*iter;
int32_t count = 0;
OrderAndOffset *testorders,
*orders;
UChar teststr[500];
UChar str[] = {0x300, 0x31A, 0};
/*
creating a long string of decomposable characters,
since by default the writable buffer is of size 256
*/
while (count < 500) {
if ((count & 1) == 0) {
teststr[count ++] = 0x300;
}
else {
teststr[count ++] = 0x31A;
}
}
coll = ucol_open("th_TH", &status);
if(U_SUCCESS(status) && coll) {
testiter = ucol_openElements(coll, teststr, 500, &status);
iter = ucol_openElements(coll, str, 2, &status);
orders = getOrders(iter, &count);
if (count != 2) {
log_err("Error collation elements size is not 2 for \\u0300\\u031A\n");
}
/*
this will rearrange the string data to 250 characters of 0x300 first then
250 characters of 0x031A
*/
testorders = getOrders(testiter, &count);
if (count != 500) {
log_err("Error decomposition does not give the right sized collation elements\n");
}
while (count != 0) {
/* UCA collation element for 0x0F76 */
if ((count > 250 && testorders[-- count].order != orders[1].order) ||
(count <= 250 && testorders[-- count].order != orders[0].order)) {
log_err("Error decomposition does not give the right collation element at %d count\n", count);
break;
}
}
free(testorders);
free(orders);
ucol_reset(testiter);
/* ensures closing of elements done properly to clear writable buffer */
ucol_next(testiter, &status);
ucol_next(testiter, &status);
ucol_closeElements(testiter);
ucol_closeElements(iter);
ucol_close(coll);
} else {
log_err_status(status, "Couldn't open collator -> %s\n", u_errorName(status));
}
}
/**
* Test for getOffset() and setOffset()
*/
static void TestOffset()
{
UErrorCode status= U_ZERO_ERROR;
UCollator *en_us=NULL;
UCollationElements *iter, *pristine;
int32_t offset;
OrderAndOffset *orders;
int32_t orderLength=0;
int count = 0;
UChar test1[50];
UChar test2[50];
u_uastrcpy(test1, "What subset of all possible test cases?");
u_uastrcpy(test2, "has the highest probability of detecting");
en_us = ucol_open("en_US", &status);
log_verbose("Testing getOffset and setOffset for collations\n");
iter = ucol_openElements(en_us, test1, u_strlen(test1), &status);
if(U_FAILURE(status)){
log_err_status(status, "ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
myErrorName(status));
ucol_close(en_us);
return;
}
/* testing boundaries */
ucol_setOffset(iter, 0, &status);
if (U_FAILURE(status) || ucol_previous(iter, &status) != UCOL_NULLORDER) {
log_err("Error: After setting offset to 0, we should be at the end "
"of the backwards iteration");
}
ucol_setOffset(iter, u_strlen(test1), &status);
if (U_FAILURE(status) || ucol_next(iter, &status) != UCOL_NULLORDER) {
log_err("Error: After setting offset to end of the string, we should "
"be at the end of the backwards iteration");
}
/* Run all the way through the iterator, then get the offset */
orders = getOrders(iter, &orderLength);
offset = ucol_getOffset(iter);
if (offset != u_strlen(test1))
{
log_err("offset at end != length %d vs %d\n", offset,
u_strlen(test1) );
}
/* Now set the offset back to the beginning and see if it works */
pristine=ucol_openElements(en_us, test1, u_strlen(test1), &status);
if(U_FAILURE(status)){
log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
myErrorName(status));
ucol_close(en_us);
return;
}
status = U_ZERO_ERROR;
ucol_setOffset(iter, 0, &status);
if (U_FAILURE(status))
{
log_err("setOffset failed. %s\n", myErrorName(status));
}
else
{
assertEqual(iter, pristine);
}
ucol_closeElements(pristine);
ucol_closeElements(iter);
free(orders);
/* testing offsets in normalization buffer */
test1[0] = 0x61;
test1[1] = 0x300;
test1[2] = 0x316;
test1[3] = 0x62;
test1[4] = 0;
ucol_setAttribute(en_us, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
iter = ucol_openElements(en_us, test1, 4, &status);
if(U_FAILURE(status)){
log_err("ERROR: in creation of collation element iterator using ucol_openElements()\n %s\n",
myErrorName(status));
ucol_close(en_us);
return;
}
count = 0;
while (ucol_next(iter, &status) != UCOL_NULLORDER &&
U_SUCCESS(status)) {
switch (count) {
case 0:
if (ucol_getOffset(iter) != 1) {
log_err("ERROR: Offset of iteration should be 1\n");
}
break;
case 3:
if (ucol_getOffset(iter) != 4) {
log_err("ERROR: Offset of iteration should be 4\n");
}
break;
default:
if (ucol_getOffset(iter) != 3) {
log_err("ERROR: Offset of iteration should be 3\n");
}
}
count ++;
}
ucol_reset(iter);
count = 0;
while (ucol_previous(iter, &status) != UCOL_NULLORDER &&
U_SUCCESS(status)) {
switch (count) {
case 0:
case 1:
if (ucol_getOffset(iter) != 3) {
log_err("ERROR: Offset of iteration should be 3\n");
}
break;
case 2:
if (ucol_getOffset(iter) != 1) {
log_err("ERROR: Offset of iteration should be 1\n");
}
break;
default:
if (ucol_getOffset(iter) != 0) {
log_err("ERROR: Offset of iteration should be 0\n");
}
}
count ++;
}
if(U_FAILURE(status)){
log_err("ERROR: in iterating collation elements %s\n",
myErrorName(status));
}
ucol_closeElements(iter);
ucol_close(en_us);
}
