int FileCopy(string source, string destination)
{
if(CaseInsensitiveCompare(source, destination))
return 1;
ifstream in;
in.open(source.c_str(), ios_base::binary);
ofstream out;
out.open(destination.c_str(), ios_base::binary);
if(in.fail() || out.fail())
return -1;
char *byte = new char;
// do the copy
while(true)
{
in.read(byte,1);
if(in.eof())
break;
out.write(byte,1);
}
in.close();
out.close();
return 0;
}
static void FuzzOneInvalidCaseConversion()
{
uint32_t aLen = rand() % 32;
uint32_t bLen = rand() % 32;
// We could use a static length-32 buffer for these, but then Valgrind
// wouldn't be able to detect errors.
unsigned char *aBuf = (unsigned char*)malloc(aLen * sizeof(unsigned char));
unsigned char *bBuf = (unsigned char*)malloc(bLen * sizeof(unsigned char));
for (uint32_t i = 0; i < aLen; i++) {
aBuf[i] = rand() & 0xff;
}
for (uint32_t i = 0; i < bLen; i++) {
bBuf[i] = rand() & 0xff;
}
if (!CaseInsensitiveCompare((char*)aBuf, (char*)bBuf, aLen, bLen))
printf("\tSurprise, two random strings compared insensitively as equal!\n");
if (CharByCharCompareEqual((char*)aBuf, (char*)bBuf, aLen, bLen))
printf("\tSurprise, two random strings compared as exactly equal!\n");
free(aBuf);
free(bBuf);
}
void WordMatchSearchImpl::query(const QString &req, QVector<Service::Item *> *res) const
{
QSet<Service::Item*>* resSet = nullptr;
QStringList words = req.split(' ', QString::SkipEmptyParts);
// Quit if there are no words in query
if (words.empty())
return;
for (QString &w : words)
{
InvertedIndex::const_iterator lb, ub;
lb = std::lower_bound (_invertedIndex.cbegin(), _invertedIndex.cend(), w, CaseInsensitiveCompare());
ub = std::upper_bound (_invertedIndex.cbegin(), _invertedIndex.cend(), w, CaseInsensitiveComparePrefix());
QSet<Service::Item*> tmpSet;
while (lb!=ub)
tmpSet.unite(lb++->second);
if (resSet == nullptr)
resSet = new QSet<Service::Item*>(tmpSet);
else
resSet->intersect(tmpSet);
}
if (resSet != nullptr) {
for (Service::Item *s : *resSet)
res->append(s);
delete resSet;
}
}
int32_t
nsCaseInsensitiveUTF8StringComparator::operator()(const char* lhs,
const char* rhs,
uint32_t lLength,
uint32_t rLength) const
{
return CaseInsensitiveCompare(lhs, rhs, lLength, rLength);
}
PRInt32
nsCaseInsensitiveUTF8StringComparator::operator()(const char* lhs,
const char* rhs,
PRUint32 lLength,
PRUint32 rLength) const
{
return CaseInsensitiveCompare(lhs, rhs, lLength, rLength);
}
int32_t
nsCaseInsensitiveStringComparator::operator()(const char16_t* lhs,
const char16_t* rhs,
uint32_t lLength,
uint32_t rLength) const
{
return (lLength == rLength) ? CaseInsensitiveCompare(lhs, rhs, lLength) :
(lLength > rLength) ? 1 : -1;
}
PRInt32
nsCaseInsensitiveStringComparator::operator()(const PRUnichar* lhs,
const PRUnichar* rhs,
PRUint32 lLength,
PRUint32 rLength) const
{
return (lLength == rLength) ? CaseInsensitiveCompare(lhs, rhs, lLength) :
(lLength > rLength) ? 1 : -1;
}
const XPCDispInterface::Member* XPCDispInterface::FindMemberCI(XPCCallContext& ccx, jsval name) const
{
size_t nameLength;
PRUnichar* sName = xpc_JSString2PRUnichar(ccx, name, &nameLength);
if(!sName)
return nsnull;
// Iterate backwards over the members array (more efficient)
const Member* member = mMembers + mMemberCount;
while(member > mMembers)
{
--member;
if(CaseInsensitiveCompare(ccx, sName, nameLength, member->GetName()))
{
return member;
}
}
return nsnull;
}
void WordMatchSearchImpl::prepare()
{
// Build inverted index
typedef QMap<QString, QSet<Service::Item*>> InvertedIndexMap;
InvertedIndexMap invertedIndexMap;
for (Service::Item *i : _indexRef)
{
QStringList words = i->title().split(QRegExp("\\W+"), QString::SkipEmptyParts);
for (QString &w : words)
invertedIndexMap[w].insert(i);
}
// Convert back to vector for fast random access search algorithms
for (InvertedIndexMap::const_iterator i = invertedIndexMap.cbegin(); i != invertedIndexMap.cend(); ++i)
_invertedIndex.push_back(QPair<QString, QSet<Service::Item*>>(i.key(), i.value()));
std::sort(_invertedIndex.begin(), _invertedIndex.end(), CaseInsensitiveCompare());
_invertedIndex.squeeze();
}
/* keyval
* Compares two buckets (case insensative)
*/
static int BucketCompare(const void *entry1, const void *entry2)
{
return CaseInsensitiveCompare(&((bucket_t *)entry1)->name,
&((bucket_t *)entry2)->name);
}
void TestCaseConversion()
{
printf("==========================\n");
printf("Start case conversion test\n");
printf("==========================\n");
int i;
PRUnichar buf[256];
printf("Test 1 - ToUpper(PRUnichar, PRUnichar*):\n");
for(i=0;i < T2LEN ; i++)
{
PRUnichar ch = ToUpperCase(t2data[i]);
if(ch != t2result[i])
printf("\tFailed!! result unexpected %d\n", i);
}
printf("Test 2 - ToLower(PRUnichar, PRUnichar*):\n");
for(i=0;i < T3LEN; i++)
{
PRUnichar ch = ToLowerCase(t3data[i]);
if(ch != t3result[i])
printf("\tFailed!! result unexpected %d\n", i);
}
printf("Test 3 - ToTitle(PRUnichar, PRUnichar*):\n");
for(i=0;i < T4LEN; i++)
{
PRUnichar ch = ToTitleCase(t4data[i]);
if(ch != t4result[i])
printf("\tFailed!! result unexpected %d\n", i);
}
printf("Test 4 - ToUpper(PRUnichar*, PRUnichar*, uint32_t):\n");
ToUpperCase(t2data, buf, T2LEN);
for(i = 0; i < T2LEN; i++)
{
if(buf[i] != t2result[i])
{
printf("\tFailed!! result unexpected %d\n", i);
break;
}
}
printf("Test 5 - ToLower(PRUnichar*, PRUnichar*, uint32_t):\n");
ToLowerCase(t3data, buf, T3LEN);
for(i = 0; i < T3LEN; i++)
{
if(buf[i] != t3result[i])
{
printf("\tFailed!! result unexpected %d\n", i);
break;
}
}
printf("Test 6 - CaseInsensitiveCompare UTF-8 (1):\n");
if (CaseInsensitiveCompare((char*)t6lhs, (char*)t6rhs, sizeof(t6lhs), sizeof(t6rhs)))
printf("\tFailed!\n");
if (!CharByCharCompareEqual((char*)t6lhs, (char*)t6rhs, sizeof(t6lhs), sizeof(t6rhs)))
printf("\tFailed character-by-character comparison!\n");
printf("Test 7 - CaseInsensitiveCompare UTF-8 (2):\n");
if (CaseInsensitiveCompare(t7lhs, t7rhs, strlen(t7lhs), strlen(t7rhs)))
printf("\tFailed!\n");
if (!CharByCharCompareEqual(t7lhs, t7rhs, sizeof(t7lhs), sizeof(t7rhs)))
printf("\tFailed character-by-character comparison!\n");
printf("Test 8a - CaseInsensitiveCompare UTF-8 (3):\n");
if (CaseInsensitiveCompare(t8lhs, t8rhs, strlen(t8lhs), strlen(t8rhs)) != -1)
printf("\tFailed!\n");
if (CharByCharCompareEqual(t8lhs, t8rhs, strlen(t8lhs), strlen(t8rhs)))
printf("\tFailed character-by-character comparison!\n");
printf("Test 8b - CaseInsensitiveCompare UTF-8 (4):\n");
if (CaseInsensitiveCompare(t8rhs, t8lhs, strlen(t8rhs), strlen(t8lhs)) != 1)
printf("\tFailed!\n");
// This test may seem a bit strange. But it's actually an easy bug to make
// if we tried to be clever and say that two ASCII characters x and y are
// case-insensitively equal if (x & ~0x20) == (y & ~0x20).
printf("Test 9 - CaseInsensitiveCompare UTF-8 (5):\n");
if (CaseInsensitiveCompare(t9rhs, t9lhs, strlen(t9lhs), strlen(t9rhs)) != 1)
printf("\tFailed!\n");
if (CharByCharCompareEqual(t9lhs, t9rhs, strlen(t9lhs), strlen(t9rhs)))
printf("\tFailed character-by-character comparison!\n");
printf("===========================\n");
printf("Finish case conversion test\n");
printf("===========================\n");
}
