public virtual void TestSize() { BytesRef @ref = new BytesRef(); int num = AtLeast(2); for (int j = 0; j < num; j++) { int mod = 1 + Random.Next(39); for (int i = 0; i < 797; i++) { string str; do { str = TestUtil.RandomRealisticUnicodeString(Random, 1000); } while (str.Length == 0); @ref.CopyChars(str); int count = Hash.Count; int key = Hash.Add(@ref); if (key < 0) { Assert.AreEqual(Hash.Count, count); } else { Assert.AreEqual(Hash.Count, count + 1); } if (i % mod == 0) { Hash.Clear(); Assert.AreEqual(0, Hash.Count); Hash.Reinit(); } } } }
public virtual void TestSort() { BytesRef @ref = new BytesRef(); int num = AtLeast(2); for (int j = 0; j < num; j++) { SortedSet <string> strings = new SortedSet <string>(); for (int k = 0; k < 797; k++) { string str; do { str = TestUtil.RandomRealisticUnicodeString(Random(), 1000); } while (str.Length == 0); @ref.CopyChars(str); Hash.Add(@ref); strings.Add(str); } // We use the UTF-16 comparator here, because we need to be able to // compare to native String.CompareTo() [UTF-16]: int[] sort = Hash.Sort(BytesRef.UTF8SortedAsUTF16Comparer); Assert.IsTrue(strings.Count < sort.Length); int i = 0; BytesRef scratch = new BytesRef(); foreach (string @string in strings) { @ref.CopyChars(@string); Assert.AreEqual(@ref, Hash.Get(sort[i++], scratch)); } Hash.Clear(); Assert.AreEqual(0, Hash.Size()); Hash.Reinit(); } }
public virtual void TestCopy() { int numIters = AtLeast(10); for (int i = 0; i < numIters; i++) { CharsRef @ref = new CharsRef(); char[] charArray = TestUtil.RandomRealisticUnicodeString(Random, 1, 100).ToCharArray(); int offset = Random.Next(charArray.Length); int length = charArray.Length - offset; string str = new string(charArray, offset, length); @ref.CopyChars(charArray, offset, length); Assert.AreEqual(str, @ref.ToString()); } }
public virtual void TestUTF8UTF16CharsRef() { int num = AtLeast(3989); for (int i = 0; i < num; i++) { string unicode = TestUtil.RandomRealisticUnicodeString(Random); BytesRef @ref = new BytesRef(unicode); char[] arr = new char[1 + Random.Next(100)]; int offset = Random.Next(arr.Length); int len = Random.Next(arr.Length - offset); CharsRef cRef = new CharsRef(arr, offset, len); UnicodeUtil.UTF8toUTF16(@ref, cRef); Assert.AreEqual(cRef.ToString(), unicode); } }
public virtual void TestAppendIterator() { Random random = Random; BytesRefArray list = new BytesRefArray(Util.Counter.NewCounter()); IList <string> stringList = new JCG.List <string>(); for (int j = 0; j < 2; j++) { if (j > 0 && random.NextBoolean()) { list.Clear(); stringList.Clear(); } int entries = AtLeast(500); BytesRef spare = new BytesRef(); int initSize = list.Length; for (int i = 0; i < entries; i++) { string randomRealisticUnicodeString = TestUtil.RandomRealisticUnicodeString(random); spare.CopyChars(randomRealisticUnicodeString); Assert.AreEqual(i + initSize, list.Append(spare)); stringList.Add(randomRealisticUnicodeString); } for (int i = 0; i < entries; i++) { Assert.IsNotNull(list.Get(spare, i)); Assert.AreEqual(stringList[i], spare.Utf8ToString(), "entry " + i + " doesn't match"); } // check random for (int i = 0; i < entries; i++) { int e = random.Next(entries); Assert.IsNotNull(list.Get(spare, e)); Assert.AreEqual(stringList[e], spare.Utf8ToString(), "entry " + i + " doesn't match"); } for (int i = 0; i < 2; i++) { IBytesRefEnumerator iterator = list.GetEnumerator(); foreach (string @string in stringList) { Assert.IsTrue(iterator.MoveNext()); Assert.AreEqual(@string, iterator.Current.Utf8ToString()); } } } }
public virtual void TestAppend() { CharsRef @ref = new CharsRef(); StringBuilder builder = new StringBuilder(); int numStrings = AtLeast(10); for (int i = 0; i < numStrings; i++) { char[] charArray = TestUtil.RandomRealisticUnicodeString(Random, 1, 100).ToCharArray(); int offset = Random.Next(charArray.Length); int length = charArray.Length - offset; builder.Append(charArray, offset, length); @ref.Append(charArray, offset, length); } Assert.AreEqual(builder.ToString(), @ref.ToString()); }
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; BitArray bits = new BitArray(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.SafeGet((-key) - 1)); } else { Assert.IsFalse(bits.SafeGet(key)); bits.SafeSet(key, true); 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.SafeSet(compact[i], false); } Assert.AreEqual(0, bits.Cardinality()); Hash.Clear(); Assert.AreEqual(0, Hash.Count); Hash.Reinit(); } }
public virtual void TestGet() { BytesRef @ref = new BytesRef(); BytesRef scratch = new BytesRef(); int num = AtLeast(2); for (int j = 0; j < num; j++) { IDictionary <string, int?> strings = new Dictionary <string, int?>(); int uniqueCount = 0; for (int i = 0; i < 797; i++) { string str; do { str = TestUtil.RandomRealisticUnicodeString(Random, 1000); } while (str.Length == 0); @ref.CopyChars(str); int count = Hash.Count; int key = Hash.Add(@ref); if (key >= 0) { Assert.IsFalse(strings.ContainsKey(str)); strings[str] = Convert.ToInt32(key); Assert.AreEqual(uniqueCount, key); uniqueCount++; Assert.AreEqual(Hash.Count, count + 1); } else { Assert.IsTrue((-key) - 1 < count); Assert.AreEqual(Hash.Count, count); } } foreach (KeyValuePair <string, int?> entry in strings) { @ref.CopyChars(entry.Key); Assert.AreEqual(@ref, Hash.Get((int)entry.Value, scratch)); } Hash.Clear(); Assert.AreEqual(0, Hash.Count); Hash.Reinit(); } }
public virtual void TestFind() { BytesRef @ref = new BytesRef(); BytesRef scratch = new BytesRef(); int num = AtLeast(2); for (int j = 0; j < num; j++) { ISet <string> strings = new JCG.HashSet <string>(); int uniqueCount = 0; for (int i = 0; i < 797; i++) { string str; do { str = TestUtil.RandomRealisticUnicodeString(Random, 1000); } while (str.Length == 0); @ref.CopyChars(str); int count = Hash.Count; int key = Hash.Find(@ref); //hash.Add(ref); if (key >= 0) // string found in hash { Assert.IsFalse(strings.Add(str)); Assert.IsTrue(key < count); Assert.AreEqual(str, Hash.Get(key, scratch).Utf8ToString()); Assert.AreEqual(count, Hash.Count); } else { key = Hash.Add(@ref); Assert.IsTrue(strings.Add(str)); Assert.AreEqual(uniqueCount, key); Assert.AreEqual(Hash.Count, count + 1); uniqueCount++; } } AssertAllIn(strings, Hash); Hash.Clear(); Assert.AreEqual(0, Hash.Count); Hash.Reinit(); } }
public virtual void TestReadAndWrite() { Counter bytesUsed = Util.Counter.NewCounter(); ByteBlockPool pool = new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(bytesUsed)); pool.NextBuffer(); bool reuseFirst = Random.NextBoolean(); for (int j = 0; j < 2; j++) { IList <BytesRef> list = new List <BytesRef>(); int maxLength = AtLeast(500); int numValues = AtLeast(100); BytesRef @ref = new BytesRef(); for (int i = 0; i < numValues; i++) { string value = TestUtil.RandomRealisticUnicodeString(Random, maxLength); list.Add(new BytesRef(value)); @ref.CopyChars(value); pool.Append(@ref); } // verify long position = 0; foreach (BytesRef expected in list) { @ref.Grow(expected.Length); @ref.Length = expected.Length; pool.ReadBytes(position, @ref.Bytes, @ref.Offset, @ref.Length); Assert.AreEqual(expected, @ref); position += @ref.Length; } pool.Reset(Random.NextBoolean(), reuseFirst); if (reuseFirst) { Assert.AreEqual(ByteBlockPool.BYTE_BLOCK_SIZE, bytesUsed.Get()); } else { Assert.AreEqual(0, bytesUsed.Get()); pool.NextBuffer(); // prepare for next iter } } }
public virtual void TestSort() { Random random = Random; BytesRefArray list = new BytesRefArray(Util.Counter.NewCounter()); List <string> stringList = new List <string>(); for (int j = 0; j < 2; j++) { if (j > 0 && random.NextBoolean()) { list.Clear(); stringList.Clear(); } int entries = AtLeast(500); BytesRef spare = new BytesRef(); int initSize = list.Length; for (int i = 0; i < entries; i++) { string randomRealisticUnicodeString = TestUtil.RandomRealisticUnicodeString(random); spare.CopyChars(randomRealisticUnicodeString); Assert.AreEqual(initSize + i, list.Append(spare)); stringList.Add(randomRealisticUnicodeString); } // LUCENENET NOTE: Must sort using ArrayUtil.GetNaturalComparator<T>() // to ensure culture isn't taken into consideration during the sort, // which will match the sort order of BytesRef.UTF8SortedAsUTF16Comparer. CollectionUtil.TimSort(stringList); #pragma warning disable 612, 618 IBytesRefIterator iter = list.GetIterator(BytesRef.UTF8SortedAsUTF16Comparer); #pragma warning restore 612, 618 int a = 0; while ((spare = iter.Next()) != null) { Assert.AreEqual(stringList[a], spare.Utf8ToString(), "entry " + a + " doesn't match"); a++; } Assert.IsNull(iter.Next()); Assert.AreEqual(a, stringList.Count); } }
public virtual void TestSort() { BytesRef @ref = new BytesRef(); int num = AtLeast(2); for (int j = 0; j < num; j++) { // LUCENENET specific - to ensure sorting strings works the same in the SortedSet, // we need to use StringComparer.Ordinal, which compares strings the same // way they are done in Java. JCG.SortedSet <string> strings = new JCG.SortedSet <string>(StringComparer.Ordinal); for (int k = 0; k < 797; k++) { string str; do { str = TestUtil.RandomRealisticUnicodeString(Random, 1000); } while (str.Length == 0); @ref.CopyChars(str); Hash.Add(@ref); strings.Add(str); } // We use the UTF-16 comparer here, because we need to be able to // compare to native String.CompareTo() [UTF-16]: #pragma warning disable 612, 618 int[] sort = Hash.Sort(BytesRef.UTF8SortedAsUTF16Comparer); #pragma warning restore 612, 618 Assert.IsTrue(strings.Count < sort.Length); int i = 0; BytesRef scratch = new BytesRef(); foreach (string @string in strings) { @ref.CopyChars(@string); Assert.AreEqual(@ref, Hash.Get(sort[i++], scratch)); } Hash.Clear(); Assert.AreEqual(0, Hash.Count); Hash.Reinit(); } }
public virtual void TestSort() { Random random = Random(); BytesRefArray list = new BytesRefArray(Util.Counter.NewCounter()); List <string> stringList = new List <string>(); for (int j = 0; j < 2; j++) { if (j > 0 && random.NextBoolean()) { list.Clear(); stringList.Clear(); } int entries = AtLeast(500); BytesRef spare = new BytesRef(); int initSize = list.Size(); for (int i = 0; i < entries; i++) { string randomRealisticUnicodeString = TestUtil.RandomRealisticUnicodeString(random); spare.CopyChars(randomRealisticUnicodeString); Assert.AreEqual(initSize + i, list.Append(spare)); stringList.Add(randomRealisticUnicodeString); } stringList.Sort(); BytesRefIterator iter = list.Iterator(BytesRef.UTF8SortedAsUTF16Comparer); int a = 0; while ((spare = iter.Next()) != null) { Assert.AreEqual(stringList[a], spare.Utf8ToString(), "entry " + a + " doesn't match"); a++; } Assert.IsNull(iter.Next()); Assert.AreEqual(a, stringList.Count); } }
public virtual void TestAddByPoolOffset() { BytesRef @ref = new BytesRef(); BytesRef scratch = new BytesRef(); BytesRefHash offsetHash = NewHash(Pool); int num = AtLeast(2); for (int j = 0; j < num; j++) { ISet <string> strings = new JCG.HashSet <string>(); int uniqueCount = 0; for (int i = 0; i < 797; i++) { string str; do { str = TestUtil.RandomRealisticUnicodeString(Random, 1000); } while (str.Length == 0); @ref.CopyChars(str); int count = Hash.Count; int key = Hash.Add(@ref); if (key >= 0) { Assert.IsTrue(strings.Add(str)); Assert.AreEqual(uniqueCount, key); Assert.AreEqual(Hash.Count, count + 1); int offsetKey = offsetHash.AddByPoolOffset(Hash.ByteStart(key)); Assert.AreEqual(uniqueCount, offsetKey); Assert.AreEqual(offsetHash.Count, count + 1); uniqueCount++; } else { Assert.IsFalse(strings.Add(str)); Assert.IsTrue((-key) - 1 < count); Assert.AreEqual(str, Hash.Get((-key) - 1, scratch).Utf8ToString()); Assert.AreEqual(count, Hash.Count); int offsetKey = offsetHash.AddByPoolOffset(Hash.ByteStart((-key) - 1)); Assert.IsTrue((-offsetKey) - 1 < count); Assert.AreEqual(str, Hash.Get((-offsetKey) - 1, scratch).Utf8ToString()); Assert.AreEqual(count, Hash.Count); } } AssertAllIn(strings, Hash); foreach (string @string in strings) { @ref.CopyChars(@string); int key = Hash.Add(@ref); BytesRef bytesRef = offsetHash.Get((-key) - 1, scratch); Assert.AreEqual(@ref, bytesRef); } Hash.Clear(); Assert.AreEqual(0, Hash.Count); offsetHash.Clear(); Assert.AreEqual(0, offsetHash.Count); Hash.Reinit(); // init for the next round offsetHash.Reinit(); } }
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()); } }