/// Build a randomish document for both RAMDirectory and MemoryIndex, and run all the queries against it.
void checkAgainstRAMDirectory() {
StringStream fooField;
StringStream termField;
// add up to 250 terms to field "foo"
int32_t fieldCount = random->nextInt(250) + 1;
for (int32_t i = 0; i < fieldCount; ++i) {
fooField << L" " << randomTerm();
}
// add up to 250 terms to field "foo"
int32_t termCount = random->nextInt(250) + 1;
for (int32_t i = 0; i < termCount; ++i) {
termField << L" " << randomTerm();
}
RAMDirectoryPtr ramdir = newLucene<RAMDirectory>();
AnalyzerPtr analyzer = randomAnalyzer();
IndexWriterPtr writer = newLucene<IndexWriter>(ramdir, analyzer, IndexWriter::MaxFieldLengthUNLIMITED);
DocumentPtr doc = newLucene<Document>();
FieldPtr field1 = newLucene<Field>(L"foo", fooField.str(), Field::STORE_NO, Field::INDEX_ANALYZED);
FieldPtr field2 = newLucene<Field>(L"term", termField.str(), Field::STORE_NO, Field::INDEX_ANALYZED);
doc->add(field1);
doc->add(field2);
writer->addDocument(doc);
writer->close();
MemoryIndexPtr memory = newLucene<MemoryIndex>();
memory->addField(L"foo", fooField.str(), analyzer);
memory->addField(L"term", termField.str(), analyzer);
checkAllQueries(memory, ramdir, analyzer);
}
/// Return a random unicode term, like StressIndexingTest.
String randomString() {
int32_t end = random->nextInt(20);
if (buffer.size() < 1 + end) {
buffer.resize((int32_t)((double)(1 + end) * 1.25));
}
for (int32_t i = 0; i < end; ++i) {
int32_t t = random->nextInt(5);
if (t == 0 && i < end - 1) {
#ifdef LPP_UNICODE_CHAR_SIZE_2
// Make a surrogate pair
// High surrogate
buffer[i++] = (wchar_t)nextInt(0xd800, 0xdc00);
// Low surrogate
buffer[i] = (wchar_t)nextInt(0xdc00, 0xe000);
#else
buffer[i] = (wchar_t)nextInt(0xdc00, 0xe000);
#endif
} else if (t <= 1) {
buffer[i] = (wchar_t)nextInt(0x01, 0x80);
} else if (t == 2) {
buffer[i] = (wchar_t)nextInt(0x80, 0x800);
} else if (t == 3) {
buffer[i] = (wchar_t)nextInt(0x800, 0xd800);
} else if (t == 4) {
buffer[i] = (wchar_t)nextInt(0xe000, 0xfff0);
}
}
return String(buffer.get(), end);
}
/// half of the time, returns a random term from TEST_TERMS.
/// the other half of the time, returns a random unicode string.
String randomTerm() {
if (random->nextInt() % 2 == 1) {
// return a random TEST_TERM
return TEST_TERMS[random->nextInt(TEST_TERMS.size())];
} else {
// return a random unicode term
return randomString();
}
}
String randomToken()
{
static const wchar_t* alphabet = L"abcdefghijklmnopqrstuvwxyz";
int32_t tl = 1 + rndToken->nextInt(7);
StringStream sb;
for (int32_t cx = 0; cx < tl; ++cx)
sb << alphabet[rndToken->nextInt(25)];
return sb.str();
}
String randomField()
{
int32_t fl = 1 + rndToken->nextInt(3);
StringStream fb;
for (int32_t fx = 0; fx < fl; ++fx)
fb << randomToken() << L" ";
return fb.str();
}
AnalyzerPtr randomAnalyzer() {
switch (random->nextInt(3)) {
case 0:
return newLucene<SimpleAnalyzer>();
case 1:
return newLucene<StopAnalyzer>(LuceneVersion::LUCENE_CURRENT);
default:
return newLucene<StandardAnalyzer>(LuceneVersion::LUCENE_CURRENT);
}
}
void runReadBytes(IndexInputPtr input, int32_t bufferSize)
{
int32_t pos = 0;
RandomPtr random = newLucene<Random>();
// gradually increasing size
for (int32_t size = 1; size < bufferSize * 10; size = size + size / 200 + 1)
{
checkReadBytes(input, size, pos);
pos += size;
if (pos >= TEST_FILE_LENGTH)
{
// wrap
pos = 0;
input->seek(0);
}
}
// wildly fluctuating size
for (int64_t i = 0; i < 1000; ++i)
{
int32_t size = random->nextInt(10000);
checkReadBytes(input, 1 + size, pos);
pos += 1 + size;
if (pos >= TEST_FILE_LENGTH)
{
// wrap
pos = 0;
input->seek(0);
}
}
// constant small size (7 bytes)
for (int32_t i = 0; i < bufferSize; ++i)
{
checkReadBytes(input, 7, pos);
pos += 7;
if (pos >= TEST_FILE_LENGTH)
{
// wrap
pos = 0;
input->seek(0);
}
}
}
virtual bool testPoint(const String& name)
{
if (random->nextInt(4) == 2)
LuceneThread::threadYield();
return true;
}
/// start is inclusive and end is exclusive
int32_t nextInt(int32_t start, int32_t end) {
return start + random->nextInt(end - start);
}
String getTempDir(const String& desc) {
return FileUtils::joinPath(getTempDir(), desc + L"." + StringUtils::toString(randomTest->nextInt()));
}