public virtual void TestNoBit()
{
BitSet bs = new BitSet(1);
T copy = CopyOf(bs, 0);
AssertEquals(0, bs, copy);
}
public virtual void TestAgainstBitSet()
{
int numBits = TestUtil.NextInt32(Random, 100, 1 << 20);
// test various random sets with various load factors
foreach (float percentSet in new float[] { 0f, 0.0001f, (float)Random.NextDouble() / 2, 0.9f, 1f })
{
BitSet set = RandomSet(numBits, percentSet);
T copy = CopyOf(set, numBits);
AssertEquals(numBits, set, copy);
}
// test one doc
BitSet set_ = new BitSet(numBits);
set_.Set(0); // 0 first
T copy_ = CopyOf(set_, numBits);
AssertEquals(numBits, set_, copy_);
set_.Clear(0);
set_.Set(Random.Next(numBits));
copy_ = CopyOf(set_, numBits); // then random index
AssertEquals(numBits, set_, copy_);
// test regular increments
for (int inc = 2; inc < 1000; inc += TestUtil.NextInt32(Random, 1, 100))
{
set_ = new BitSet(numBits);
for (int d = Random.Next(10); d < numBits; d += inc)
{
set_.Set(d);
}
copy_ = CopyOf(set_, numBits);
AssertEquals(numBits, set_, copy_);
}
}
private void CheckPrevSetBitArray(int[] a, int numBits)
{
Int64BitSet obs = MakeLongFixedBitSet(a, numBits);
BitSet bs = MakeBitSet(a);
DoPrevSetBit(bs, obs);
}
public virtual void TestUnion()
{
int numBits = TestUtil.NextInt32(Random, 100, 1 << 20);
int numDocIdSets = TestUtil.NextInt32(Random, 0, 4);
IList <BitSet> fixedSets = new List <BitSet>(numDocIdSets);
for (int i = 0; i < numDocIdSets; ++i)
{
fixedSets.Add(RandomSet(numBits, Random.NextSingle() / 16));
}
IList <WAH8DocIdSet> compressedSets = new List <WAH8DocIdSet>(numDocIdSets);
foreach (BitSet set in fixedSets)
{
compressedSets.Add(CopyOf(set, numBits));
}
WAH8DocIdSet union = WAH8DocIdSet.Union(compressedSets);
BitSet expected = new BitSet(numBits);
foreach (BitSet set in fixedSets)
{
for (int doc = set.NextSetBit(0); doc != -1; doc = set.NextSetBit(doc + 1))
{
expected.Set(doc);
}
}
AssertEquals(numBits, expected, union);
}
public DocIdSetAnonymousClass(FilterAnonymousClass3 outerInstance, bool nullBitset, AtomicReader reader, BitSet bitSet)
{
this.outerInstance = outerInstance;
this.nullBitset = nullBitset;
this.reader = reader;
this.bitSet = bitSet;
}
public virtual int DoConjunctions(int iter, int maxClauses)
{
int ret = 0;
for (int i = 0; i < iter; i++)
{
int nClauses = Random.Next(maxClauses - 1) + 2; // min 2 clauses
BooleanQuery bq = new BooleanQuery();
BitSet result = null;
for (int j = 0; j < nClauses; j++)
{
result = AddClause(bq, result);
}
CountingHitCollector hc = validate ? new MatchingHitCollector(result) : new CountingHitCollector();
s.Search(bq, hc);
ret += hc.Sum;
if (validate)
{
Assert.AreEqual(result.Cardinality, hc.Count);
}
// System.out.println(hc.getCount());
}
return(ret);
}
private void CheckNextSetBitArray(int[] a, int numBits)
{
FixedBitSet obs = MakeFixedBitSet(a, numBits);
BitSet bs = MakeBitSet(a);
DoNextSetBit(bs, obs);
}
internal virtual void DoPrevSetBit(BitSet a, FixedBitSet b)
{
int aa = a.Length + Random.Next(100);
int bb = aa;
do
{
// aa = a.PrevSetBit(aa-1);
aa--;
while ((aa >= 0) && (aa >= a.Length || !a.Get(aa)))
{
aa--;
}
if (b.Length == 0)
{
bb = -1;
}
else if (bb > b.Length - 1)
{
bb = b.PrevSetBit(b.Length - 1);
}
else if (bb < 1)
{
bb = -1;
}
else
{
bb = bb >= 1 ? b.PrevSetBit(bb - 1) : -1;
}
Assert.AreEqual(aa, bb);
} while (aa >= 0);
}
public override EliasFanoDocIdSet CopyOf(BitSet bs, int numBits)
{
EliasFanoDocIdSet set = new EliasFanoDocIdSet((int)bs.Cardinality, numBits - 1);
set.EncodeFromDisi(new DocIdSetIteratorAnonymousClass(bs, numBits));
return(set);
}
/// <summary>
/// Create a random set which has <paramref name="numBitsSet"/> of its <paramref name="numBits"/> bits set. </summary>
protected static BitSet RandomSet(int numBits, int numBitsSet)
{
Debug.Assert(numBitsSet <= numBits);
BitSet set = new BitSet(numBits);
Random random = Random;
if (numBitsSet == numBits)
{
set.Set(0, numBits);
}
else
{
for (int i = 0; i < numBitsSet; ++i)
{
while (true)
{
int o = random.Next(numBits);
if (!set.Get(o))
{
set.Set(o);
break;
}
}
}
}
return(set);
}
public DocIdSetIteratorAnonymousInnerClassHelper(TestEliasFanoDocIdSet outerInstance, BitSet bs, int numBits)
{
this.outerInstance = outerInstance;
this.bs = bs;
this.numBits = numBits;
doc = -1;
}
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
Assert.IsNull(acceptDocs, "acceptDocs should be null, as we have an index without deletions");
BitSet bitset = new BitSet(5);
bitset.Set(0, 5);
return(new DocIdBitSet(bitset));
}
public virtual BitSet[] RandBitSets(int numSets, int setSize)
{
BitSet[] sets = new BitSet[numSets];
for (int i = 0; i < sets.Length; i++)
{
sets[i] = RandBitSet(setSize, Random.Next(setSize));
}
return(sets);
}
public override PForDeltaDocIdSet CopyOf(BitSet bs, int length)
{
PForDeltaDocIdSet.Builder builder = (new PForDeltaDocIdSet.Builder()).SetIndexInterval(TestUtil.NextInt32(Random, 1, 20));
for (int doc = bs.NextSetBit(0); doc != -1; doc = bs.NextSetBit(doc + 1))
{
builder.Add(doc);
}
return(builder.Build());
}
public virtual BitSet RandBitSet(int sz, int numBitsToSet)
{
BitSet set = new BitSet(sz);
for (int i = 0; i < numBitsToSet; i++)
{
set.Set(Random.Next(sz));
}
return(set);
}
private BitSet MakeBitSet(int[] a)
{
BitSet bs = new BitSet();
foreach (int e in a)
{
bs.Set(e);
}
return(bs);
}
public override FixedBitSet CopyOf(BitSet bs, int length)
{
FixedBitSet set = new FixedBitSet(length);
for (int doc = bs.NextSetBit(0); doc != -1; doc = bs.NextSetBit(doc + 1))
{
set.Set(doc);
}
return(set);
}
internal virtual void DoNextSetBit(BitSet a, FixedBitSet b)
{
int aa = -1, bb = -1;
do
{
aa = a.NextSetBit(aa + 1);
bb = bb < b.Length - 1 ? b.NextSetBit(bb + 1) : -1;
Assert.AreEqual(aa, bb);
} while (aa >= 0);
}
// test interleaving different FixedBitSetIterator.Next()/skipTo()
internal virtual void DoIterate(BitSet a, FixedBitSet b, int mode)
{
if (mode == 1)
{
DoIterate1(a, b);
}
if (mode == 2)
{
DoIterate2(a, b);
}
}
public override WAH8DocIdSet CopyOf(BitSet bs, int length)
{
int indexInterval = TestUtil.NextInt32(Random, 8, 256);
WAH8DocIdSet.Builder builder = (WAH8DocIdSet.Builder)(new WAH8DocIdSet.Builder()).SetIndexInterval(indexInterval);
for (int i = bs.NextSetBit(0); i != -1; i = bs.NextSetBit(i + 1))
{
builder.Add(i);
}
return(builder.Build());
}
internal virtual void DoGet(BitSet a, FixedBitSet b)
{
int max = b.Length;
for (int i = 0; i < max; i++)
{
if (a.Get(i) != b.Get(i))
{
Assert.Fail("mismatch: BitSet=[" + i + "]=" + a.Get(i));
}
}
}
internal virtual void DoIterate2(BitSet a, FixedBitSet b)
{
int aa = -1, bb = -1;
DocIdSetIterator iterator = b.GetIterator();
do
{
aa = a.NextSetBit(aa + 1);
bb = Random.NextBoolean() ? iterator.NextDoc() : iterator.Advance(bb + 1);
Assert.AreEqual(aa == -1 ? DocIdSetIterator.NO_MORE_DOCS : aa, bb);
} while (aa >= 0);
}
public virtual void Test1Bit()
{
BitSet bs = new BitSet(1);
if (Random.NextBoolean())
{
bs.Set(0);
}
T copy = CopyOf(bs, 1);
AssertEquals(1, bs, copy);
}
public virtual int DoNestedTermConjunctions(IndexSearcher s, int termsInIndex, int maxOuterClauses, int maxClauses, int iter)
{
int ret = 0;
long nMatches = 0;
for (int i = 0; i < iter; i++)
{
int oClauses = Random.Next(maxOuterClauses - 1) + 2;
BooleanQuery oq = new BooleanQuery();
for (int o = 0; o < oClauses; o++)
{
int nClauses = Random.Next(maxClauses - 1) + 2; // min 2 clauses
BooleanQuery bq = new BooleanQuery();
BitSet termflag = new BitSet(termsInIndex);
for (int j = 0; j < nClauses; j++)
{
int tnum;
// don't pick same clause twice
tnum = Random.Next(termsInIndex);
if (termflag.Get(tnum))
{
tnum = termflag.NextClearBit(tnum);
}
if (tnum < 0 || tnum >= 25)
{
tnum = termflag.NextClearBit(0);
}
termflag.Set(tnum);
Query tq = new TermQuery(terms[tnum]);
bq.Add(tq, Occur.MUST);
} // inner
oq.Add(bq, Occur.MUST);
} // outer
CountingHitCollector hc = new CountingHitCollector();
s.Search(oq, hc);
nMatches += hc.Count;
ret += hc.Sum;
}
if (Verbose)
{
Console.WriteLine("Average number of matches=" + (nMatches / iter));
}
return(ret);
}
public virtual void TestCompact()
{
BytesRef @ref = new BytesRef();
int num = AtLeast(2);
for (int j = 0; j < num; j++)
{
int numEntries = 0;
const int size = 797;
BitSet bits = new BitSet(size);
for (int i = 0; i < size; i++)
{
string str;
do
{
str = TestUtil.RandomRealisticUnicodeString(Random, 1000);
} while (str.Length == 0);
@ref.CopyChars(str);
int key = hash.Add(@ref);
if (key < 0)
{
Assert.IsTrue(bits.Get((-key) - 1));
}
else
{
Assert.IsFalse(bits.Get(key));
bits.Set(key);
numEntries++;
}
}
Assert.AreEqual(hash.Count, bits.Cardinality);
Assert.AreEqual(numEntries, bits.Cardinality);
Assert.AreEqual(numEntries, hash.Count);
int[] compact = hash.Compact();
Assert.IsTrue(numEntries < compact.Length);
for (int i = 0; i < numEntries; i++)
{
bits.Clear(compact[i]);
}
Assert.AreEqual(0, bits.Cardinality);
hash.Clear();
Assert.AreEqual(0, hash.Count);
hash.Reinit();
}
}
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
if (acceptDocs == null)
{
acceptDocs = new Bits.MatchAllBits(5);
}
BitSet bitset = new BitSet(5);
if (acceptDocs.Get(1))
{
bitset.Set(1);
}
if (acceptDocs.Get(3))
{
bitset.Set(3);
}
return(new DocIdBitSet(bitset));
}
internal virtual BitSet AddClause(BooleanQuery bq, BitSet result)
{
BitSet rnd = sets[Random.Next(sets.Length)];
Query q = new ConstantScoreQuery(new FilterAnonymousClass(rnd));
bq.Add(q, Occur.MUST);
if (validate)
{
if (result == null)
{
result = (BitSet)rnd.Clone();
}
else
{
result.And(rnd);
}
}
return(result);
}
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
bool nullBitset = Random.Next(10) == 5;
AtomicReader reader = context.AtomicReader;
DocsEnum termDocsEnum = reader.GetTermDocsEnum(new Term("field", "0"));
if (termDocsEnum == null)
{
return(null); // no docs -- return null
}
BitSet bitSet = new BitSet(reader.MaxDoc);
int d;
while ((d = termDocsEnum.NextDoc()) != DocsEnum.NO_MORE_DOCS)
{
bitSet.Set(d);
}
return(new DocIdSetAnonymousClass(this, nullBitset, reader, bitSet));
}
public virtual int DoNestedConjunctions(int iter, int maxOuterClauses, int maxClauses)
{
int ret = 0;
long nMatches = 0;
for (int i = 0; i < iter; i++)
{
int oClauses = Random.Next(maxOuterClauses - 1) + 2;
BooleanQuery oq = new BooleanQuery();
BitSet result = null;
for (int o = 0; o < oClauses; o++)
{
int nClauses = Random.Next(maxClauses - 1) + 2; // min 2 clauses
BooleanQuery bq = new BooleanQuery();
for (int j = 0; j < nClauses; j++)
{
result = AddClause(bq, result);
}
oq.Add(bq, Occur.MUST);
} // outer
CountingHitCollector hc = validate ? new MatchingHitCollector(result) : new CountingHitCollector();
s.Search(oq, hc);
nMatches += hc.Count;
ret += hc.Sum;
if (validate)
{
Assert.AreEqual(result.Cardinality, hc.Count);
}
// System.out.println(hc.getCount());
}
if (Verbose)
{
Console.WriteLine("Average number of matches=" + (nMatches / iter));
}
return(ret);
}
public DocIdSetIteratorAnonymousClass(BitSet bs, int numBits)
{
this.bs = bs;
this.numBits = numBits;
doc = -1;
}
