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());
}
}
