protected internal RandomDocument(BaseTermVectorsFormatTestCase baseTermVectorsFormaTestCase, int fieldCount, int maxTermCount, Options options, string[] fieldNames, string[] sampleTerms, BytesRef[] sampleTermBytes)
{
if (fieldCount > fieldNames.Length)
{
throw new ArgumentException();
}
this.fieldNames = new string[fieldCount];
fieldTypes = new FieldType[fieldCount];
tokenStreams = new RandomTokenStream[fieldCount];
Arrays.Fill(fieldTypes, baseTermVectorsFormaTestCase.FieldType(options));
ISet <string> usedFileNames = new JCG.HashSet <string>();
for (int i = 0; i < fieldCount; ++i)
{
// LUCENENET NOTE: Using a simple Linq query to filter rather than using brute force makes this a lot
// faster (and won't infinitely retry due to poor random distribution).
this.fieldNames[i] = RandomPicks.RandomFrom(Random, fieldNames.Except(usedFileNames).ToArray());
//do
//{
// this.FieldNames[i] = RandomPicks.RandomFrom(Random(), fieldNames);
//} while (usedFileNames.Contains(this.FieldNames[i]));
usedFileNames.Add(this.fieldNames[i]);
tokenStreams[i] = new RandomTokenStream(baseTermVectorsFormaTestCase, TestUtil.NextInt32(Random, 1, maxTermCount), sampleTerms, sampleTermBytes);
}
}
public ThreadAnonymousClass(BaseTermVectorsFormatTestCase outerInstance, int numDocs, RandomDocument[] docs, IndexReader reader, AtomicReference <Exception> exception)
{
this.outerInstance = outerInstance;
this.numDocs = numDocs;
this.docs = docs;
this.reader = reader;
this.exception = exception;
}
public ThreadAnonymousInnerClassHelper(BaseTermVectorsFormatTestCase outerInstance, int numDocs, RandomDocument[] docs, IndexReader reader, AtomicObject <Exception> exception, int i)
{
this.outerInstance = outerInstance;
this.numDocs = numDocs;
this.docs = docs;
this.reader = reader;
this.exception = exception;
this.i = i;
}
protected internal RandomDocumentFactory(BaseTermVectorsFormatTestCase baseTermVectorsFormatTestCase, int distinctFieldNames, int disctinctTerms)
{
this.outerInstance = baseTermVectorsFormatTestCase;
ISet <string> fieldNames = new JCG.HashSet <string>();
while (fieldNames.Count < distinctFieldNames)
{
fieldNames.Add(TestUtil.RandomSimpleString(Random));
fieldNames.Remove("id");
}
this.fieldNames = fieldNames.ToArray(/*new string[0]*/);
terms = new string[disctinctTerms];
termBytes = new BytesRef[disctinctTerms];
for (int i = 0; i < disctinctTerms; ++i)
{
terms[i] = TestUtil.RandomRealisticUnicodeString(Random);
termBytes[i] = new BytesRef(terms[i]);
}
}
protected internal RandomTokenStream(BaseTermVectorsFormatTestCase baseTermVectorsFormatTestCase, int len, string[] sampleTerms, BytesRef[] sampleTermBytes, bool offsetsGoBackwards)
{
terms = new string[len];
termBytes = new BytesRef[len];
positionsIncrements = new int[len];
positions = new int[len];
startOffsets = new int[len];
endOffsets = new int[len];
payloads = new BytesRef[len];
for (int i = 0; i < len; ++i)
{
int o = Random.Next(sampleTerms.Length);
terms[i] = sampleTerms[o];
termBytes[i] = sampleTermBytes[o];
positionsIncrements[i] = TestUtil.NextInt32(Random, i == 0 ? 1 : 0, 10);
if (offsetsGoBackwards)
{
startOffsets[i] = Random.Next();
endOffsets[i] = Random.Next();
}
else
{
if (i == 0)
{
startOffsets[i] = TestUtil.NextInt32(Random, 0, 1 << 16);
}
else
{
startOffsets[i] = startOffsets[i - 1] + TestUtil.NextInt32(Random, 0, Rarely() ? 1 << 16 : 20);
}
endOffsets[i] = startOffsets[i] + TestUtil.NextInt32(Random, 0, Rarely() ? 1 << 10 : 20);
}
}
for (int i = 0; i < len; ++i)
{
if (i == 0)
{
positions[i] = positionsIncrements[i] - 1;
}
else
{
positions[i] = positions[i - 1] + positionsIncrements[i];
}
}
if (Rarely())
{
Arrays.Fill(payloads, baseTermVectorsFormatTestCase.RandomPayload());
}
else
{
for (int i = 0; i < len; ++i)
{
payloads[i] = baseTermVectorsFormatTestCase.RandomPayload();
}
}
positionToTerms = new Dictionary <int?, ISet <int?> >(len);
startOffsetToTerms = new Dictionary <int?, ISet <int?> >(len);
for (int i = 0; i < len; ++i)
{
if (!positionToTerms.TryGetValue(positions[i], out ISet <int?> positionTerms))
{
positionToTerms[positions[i]] = positionTerms = new JCG.HashSet <int?>(1);
}
positionTerms.Add(i);
if (!startOffsetToTerms.TryGetValue(startOffsets[i], out ISet <int?> startOffsetTerms))
{
startOffsetToTerms[startOffsets[i]] = startOffsetTerms = new JCG.HashSet <int?>(1);
}
startOffsetTerms.Add(i);
}
freqs = new Dictionary <string, int?>();
foreach (string term in terms)
{
if (freqs.TryGetValue(term, out int?freq))
{
freqs[term] = freq + 1;
}
else
{
freqs[term] = 1;
}
}
AddAttributeImpl(new PermissiveOffsetAttribute());
termAtt = AddAttribute <ICharTermAttribute>();
piAtt = AddAttribute <IPositionIncrementAttribute>();
oAtt = AddAttribute <IOffsetAttribute>();
pAtt = AddAttribute <IPayloadAttribute>();
}
protected internal RandomTokenStream(BaseTermVectorsFormatTestCase baseTermVectorsFormatTestCase, int len, string[] sampleTerms, BytesRef[] sampleTermBytes)
: this(baseTermVectorsFormatTestCase, len, sampleTerms, sampleTermBytes, Rarely())
{
}
protected internal RandomTokenStream(BaseTermVectorsFormatTestCase outerInstance, int len, string[] sampleTerms, BytesRef[] sampleTermBytes)
: this(outerInstance, len, sampleTerms, sampleTermBytes, Rarely())
{
this.outerInstance = outerInstance;
}
