public virtual void TestMaxMergeCount() { Directory dir = NewDirectory(); IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)); int maxMergeCount = TestUtil.NextInt32(Random, 1, 5); int maxMergeThreads = TestUtil.NextInt32(Random, 1, maxMergeCount); CountdownEvent enoughMergesWaiting = new CountdownEvent(maxMergeCount); AtomicInt32 runningMergeCount = new AtomicInt32(0); AtomicBoolean failed = new AtomicBoolean(); if (VERBOSE) { Console.WriteLine("TEST: maxMergeCount=" + maxMergeCount + " maxMergeThreads=" + maxMergeThreads); } ConcurrentMergeScheduler cms = new ConcurrentMergeSchedulerAnonymousInnerClassHelper(this, maxMergeCount, enoughMergesWaiting, runningMergeCount, failed); cms.SetMaxMergesAndThreads(maxMergeCount, maxMergeThreads); iwc.SetMergeScheduler(cms); iwc.SetMaxBufferedDocs(2); TieredMergePolicy tmp = new TieredMergePolicy(); iwc.SetMergePolicy(tmp); tmp.MaxMergeAtOnce = 2; tmp.SegmentsPerTier = 2; IndexWriter w = new IndexWriter(dir, iwc); Document doc = new Document(); doc.Add(NewField("field", "field", TextField.TYPE_NOT_STORED)); while (enoughMergesWaiting.CurrentCount != 0 && !failed) { for (int i = 0; i < 10; i++) { w.AddDocument(doc); } } w.Dispose(false); dir.Dispose(); }
private void MostlyAscendingStrategy(Entry[] arr, int i) { arr[i] = i == 0 ? new Entry(random.nextInt(6), 0) : new Entry(arr[i - 1].Value + TestUtil.NextInt32(random, -8, 10), i); }
private void StrictlyDescendingStrategy(Entry[] arr, int i) { arr[i] = i == 0 ? new Entry(random.nextInt(6), 0) : new Entry(arr[i - 1].Value - TestUtil.NextInt32(random, 1, 5), i); }
public override Sorter NewSorter(Entry[] arr) { return(new ArrayTimSorter <Entry>(arr, ArrayUtil.GetNaturalComparer <Entry>(), TestUtil.NextInt32(Random, 0, arr.Length))); }
public virtual void TestDataInputOutput() { Random random = Random; for (int iter = 0; iter < 5 * RANDOM_MULTIPLIER; iter++) { BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("testOverflow")); if (dir is MockDirectoryWrapper) { ((MockDirectoryWrapper)dir).Throttling = Throttling.NEVER; } int blockBits = TestUtil.NextInt32(random, 1, 20); int blockSize = 1 << blockBits; PagedBytes p = new PagedBytes(blockBits); IndexOutput @out = dir.CreateOutput("foo", IOContext.DEFAULT); int numBytes = TestUtil.NextInt32(LuceneTestCase.Random, 2, 10000000); byte[] answer = new byte[numBytes]; LuceneTestCase.Random.NextBytes(answer); int written = 0; while (written < numBytes) { if (LuceneTestCase.Random.Next(10) == 7) { @out.WriteByte(answer[written++]); } else { int chunk = Math.Min(LuceneTestCase.Random.Next(1000), numBytes - written); @out.WriteBytes(answer, written, chunk); written += chunk; } } @out.Dispose(); IndexInput input = dir.OpenInput("foo", IOContext.DEFAULT); DataInput @in = (DataInput)input.Clone(); p.Copy(input, input.Length); PagedBytes.Reader reader = p.Freeze(random.NextBoolean()); byte[] verify = new byte[numBytes]; int read = 0; while (read < numBytes) { if (LuceneTestCase.Random.Next(10) == 7) { verify[read++] = @in.ReadByte(); } else { int chunk = Math.Min(LuceneTestCase.Random.Next(1000), numBytes - read); @in.ReadBytes(verify, read, chunk); read += chunk; } } Assert.IsTrue(Arrays.Equals(answer, verify)); BytesRef slice = new BytesRef(); for (int iter2 = 0; iter2 < 100; iter2++) { int pos = random.Next(numBytes - 1); int len = random.Next(Math.Min(blockSize + 1, numBytes - pos)); reader.FillSlice(slice, pos, len); for (int byteUpto = 0; byteUpto < len; byteUpto++) { Assert.AreEqual(answer[pos + byteUpto], (byte)slice.Bytes[slice.Offset + byteUpto]); } } input.Dispose(); dir.Dispose(); } }
public virtual void TestDataInputOutput2() { Random random = Random; for (int iter = 0; iter < 5 * RANDOM_MULTIPLIER; iter++) { int blockBits = TestUtil.NextInt32(random, 1, 20); int blockSize = 1 << blockBits; PagedBytes p = new PagedBytes(blockBits); DataOutput @out = p.GetDataOutput(); int numBytes = LuceneTestCase.Random.Next(10000000); byte[] answer = new byte[numBytes]; LuceneTestCase.Random.NextBytes(answer); int written = 0; while (written < numBytes) { if (LuceneTestCase.Random.Next(10) == 7) { @out.WriteByte(answer[written++]); } else { int chunk = Math.Min(LuceneTestCase.Random.Next(1000), numBytes - written); @out.WriteBytes(answer, written, chunk); written += chunk; } } PagedBytes.Reader reader = p.Freeze(random.NextBoolean()); DataInput @in = p.GetDataInput(); byte[] verify = new byte[numBytes]; int read = 0; while (read < numBytes) { if (LuceneTestCase.Random.Next(10) == 7) { verify[read++] = @in.ReadByte(); } else { int chunk = Math.Min(LuceneTestCase.Random.Next(1000), numBytes - read); @in.ReadBytes(verify, read, chunk); read += chunk; } } Assert.IsTrue(Arrays.Equals(answer, verify)); BytesRef slice = new BytesRef(); for (int iter2 = 0; iter2 < 100; iter2++) { int pos = random.Next(numBytes - 1); int len = random.Next(Math.Min(blockSize + 1, numBytes - pos)); reader.FillSlice(slice, pos, len); for (int byteUpto = 0; byteUpto < len; byteUpto++) { Assert.AreEqual(answer[pos + byteUpto], (byte)slice.Bytes[slice.Offset + byteUpto]); } } } }
public static string RandomSubString(Random random, int wordLength, bool simple) { if (wordLength == 0) { return(""); } int evilness = TestUtil.NextInt32(random, 0, 20); StringBuilder sb = new StringBuilder(); while (sb.Length < wordLength) { ; if (simple) { sb.Append(random.NextBoolean() ? TestUtil.RandomSimpleString(random, wordLength) : TestUtil.RandomHtmlishString(random, wordLength)); } else { if (evilness < 10) { sb.Append(TestUtil.RandomSimpleString(random, wordLength)); } else if (evilness < 15) { Assert.AreEqual(0, sb.Length); // we should always get wordLength back! sb.Append(TestUtil.RandomRealisticUnicodeString(random, wordLength, wordLength)); } else if (evilness == 16) { sb.Append(TestUtil.RandomHtmlishString(random, wordLength)); } else if (evilness == 17) { // gives a lot of punctuation sb.Append(TestUtil.RandomRegexpishString(random, wordLength)); } else { sb.Append(TestUtil.RandomUnicodeString(random, wordLength)); } } } if (sb.Length > wordLength) { sb.Length = wordLength; if (char.IsHighSurrogate(sb[wordLength - 1])) { sb.Length = wordLength - 1; } } if (random.Next(17) == 0) { // mix up case string mixedUp = TestUtil.RandomlyRecaseString(random, sb.ToString()); Assert.True(mixedUp.Length == sb.Length, "Lengths are not the same: mixedUp = " + mixedUp + ", length = " + mixedUp.Length + ", sb = " + sb + ", length = " + sb.Length); return(mixedUp); } else { return(sb.ToString()); } }
internal virtual void DoRandomSets(int maxSize, int iter, int mode) { BitSet a0 = null; FixedBitSet b0 = null; for (int i = 0; i < iter; i++) { int sz = TestUtil.NextInt32(Random, 2, maxSize); BitSet a = new BitSet(sz); FixedBitSet b = new FixedBitSet(sz); // test the various ways of setting bits if (sz > 0) { int nOper = Random.Next(sz); for (int j = 0; j < nOper; j++) { int idx; idx = Random.Next(sz); a.Set(idx); b.Set(idx); idx = Random.Next(sz); a.Clear(idx); b.Clear(idx); idx = Random.Next(sz); a.Flip(idx, idx + 1); b.Flip(idx, idx + 1); idx = Random.Next(sz); a.Flip(idx, idx + 1); b.Flip(idx, idx + 1); bool val2 = b.Get(idx); bool val = b.GetAndSet(idx); Assert.IsTrue(val2 == val); Assert.IsTrue(b.Get(idx)); if (!val) { b.Clear(idx); } Assert.IsTrue(b.Get(idx) == val); } } // test that the various ways of accessing the bits are equivalent DoGet(a, b); // test ranges, including possible extension int fromIndex, toIndex; fromIndex = Random.Next(sz / 2); toIndex = fromIndex + Random.Next(sz - fromIndex); BitSet aa = (BitSet)a.Clone(); aa.Flip(fromIndex, toIndex); FixedBitSet bb = b.Clone(); bb.Flip(fromIndex, toIndex); DoIterate(aa, bb, mode); // a problem here is from flip or doIterate fromIndex = Random.Next(sz / 2); toIndex = fromIndex + Random.Next(sz - fromIndex); aa = (BitSet)a.Clone(); aa.Clear(fromIndex, toIndex); bb = b.Clone(); bb.Clear(fromIndex, toIndex); DoNextSetBit(aa, bb); // a problem here is from clear() or nextSetBit DoPrevSetBit(aa, bb); fromIndex = Random.Next(sz / 2); toIndex = fromIndex + Random.Next(sz - fromIndex); aa = (BitSet)a.Clone(); aa.Set(fromIndex, toIndex); bb = b.Clone(); bb.Set(fromIndex, toIndex); DoNextSetBit(aa, bb); // a problem here is from set() or nextSetBit DoPrevSetBit(aa, bb); if (b0 != null && b0.Length <= b.Length) { Assert.AreEqual(a.Cardinality, b.Cardinality); BitSet a_and = (BitSet)a.Clone(); a_and.And(a0); BitSet a_or = (BitSet)a.Clone(); a_or.Or(a0); BitSet a_xor = (BitSet)a.Clone(); a_xor.Xor(a0); BitSet a_andn = (BitSet)a.Clone(); a_andn.AndNot(a0); FixedBitSet b_and = b.Clone(); Assert.AreEqual(b, b_and); b_and.And(b0); FixedBitSet b_or = b.Clone(); b_or.Or(b0); FixedBitSet b_xor = b.Clone(); b_xor.Xor(b0); FixedBitSet b_andn = b.Clone(); b_andn.AndNot(b0); Assert.AreEqual(a0.Cardinality, b0.Cardinality); Assert.AreEqual(a_or.Cardinality, b_or.Cardinality); DoIterate(a_and, b_and, mode); DoIterate(a_or, b_or, mode); DoIterate(a_andn, b_andn, mode); DoIterate(a_xor, b_xor, mode); Assert.AreEqual(a_and.Cardinality, b_and.Cardinality); Assert.AreEqual(a_or.Cardinality, b_or.Cardinality); Assert.AreEqual(a_xor.Cardinality, b_xor.Cardinality); Assert.AreEqual(a_andn.Cardinality, b_andn.Cardinality); } a0 = a; b0 = b; } }
public override PForDeltaDocIdSet CopyOf(BitArray 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()); }