public void SparseArraySimpleTest()
{
var stringArrayRef = new string[1000];
var stringArray = new SparseArray<string>(1000);
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
for (int idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
stringArrayRef[idx] = idx.ToString();
stringArray[idx] = idx.ToString();
}
else
{
stringArrayRef[idx] = null;
stringArray[idx] = null;
}
}
for (int idx = 0; idx < 1000; idx++)
{
Assert.AreEqual(stringArrayRef[idx], stringArray[idx]);
}
}
public void RTreeMemoryIndexAddTests()
{
// build test-data.
var testDataList = new List<KeyValuePair<BoxF2D, DataTestClass>>();
const int count = 10000;
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
for (int idx = 0; idx < count; idx++)
{
double x1 = randomGenerator.Generate(1.0);
double x2 = randomGenerator.Generate(1.0);
double y1 = randomGenerator.Generate(1.0);
double y2 = randomGenerator.Generate(1.0);
var box = new BoxF2D(new PointF2D(x1, y1), new PointF2D(x2, y2));
var testData = new DataTestClass();
testData.Data = idx.ToString(System.Globalization.CultureInfo.InvariantCulture);
testDataList.Add(new KeyValuePair<BoxF2D, DataTestClass>(
box, testData));
}
// create the index and reference index.
var index = new RTreeMemoryIndex<DataTestClass>();
var reference = new ReferenceImplementation<DataTestClass>();
// add all the data.
for (int idx = 0; idx < count; idx++)
{
var keyValuePair = testDataList[idx];
index.Add(keyValuePair.Key, keyValuePair.Value);
reference.Add(keyValuePair.Key, keyValuePair.Value);
//Assert.AreEqual(reference.Count(), index.Count());
}
//Assert.AreEqual(count, index.Count());
// generate random boxes and compare results.
for (int idx = 0; idx < 200; idx++)
{
double x1 = randomGenerator.Generate(1.0);
double x2 = randomGenerator.Generate(1.0);
double y1 = randomGenerator.Generate(1.0);
double y2 = randomGenerator.Generate(1.0);
var box = new BoxF2D(new PointF2D(x1, y1), new PointF2D(x2, y2));
var resultIndex = new HashSet<DataTestClass>(index.Get(box));
var resultReference = new HashSet<DataTestClass>(reference.Get(box));
foreach (var data in resultIndex)
{
Assert.IsTrue(resultReference.Contains(data));
}
foreach (var data in resultReference)
{
Assert.IsTrue(resultIndex.Contains(data));
}
}
}
public void TestStringHuge()
{
var randomGenerator = new RandomGenerator(66707770); // make this deterministic.
var index = new MemoryMappedIndex<string>(new MemoryMappedStream(new MemoryStream()),
MemoryMappedDelegates.ReadFromString, MemoryMappedDelegates.WriteToString, 1024, false);
var indexRef = new Dictionary<long, string>();
// add the data.
var testCount = 1000;
while (testCount > 0)
{
var data = randomGenerator.GenerateString(
randomGenerator.Generate(256) + 32);
indexRef.Add(index.Add(data), data);
testCount--;
}
// get the data and check.
foreach (var entry in indexRef)
{
var data = index.Get(entry.Key);
Assert.AreEqual(indexRef[entry.Key], data);
}
}
public void ByteCacheMemorySimpleTests()
{
int total = 1000;
var stringArrayRef = new string[total];
var memoryByteCache = new MemoryByteCache();
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
for (int idx = 0; idx < total; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
stringArrayRef[idx] = idx.ToString();
memoryByteCache.Add(ASCIIEncoding.ASCII.GetBytes(idx.ToString()));
}
else
{
stringArrayRef[idx] = "null";
memoryByteCache.Add(ASCIIEncoding.ASCII.GetBytes("null"));
}
}
for (uint idx = 0; idx < total; idx++)
{
string content = ASCIIEncoding.ASCII.GetString(memoryByteCache.Get(idx));
memoryByteCache.Remove(idx);
Assert.AreEqual(total - idx - 1, memoryByteCache.Size);
Assert.AreEqual(stringArrayRef[idx], content);
}
}
public void CompareToArrayTest()
{
using (var intArray = new MemoryMappedHugeArrayUInt32(
new MemoryMappedStream(new MemoryStream()), 1000, 1024))
{
var intArrayRef = new uint[1000];
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
for (uint idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
intArrayRef[idx] = idx;
intArray[idx] = idx;
}
else
{
intArrayRef[idx] = int.MaxValue;
intArray[idx] = int.MaxValue;
}
Assert.AreEqual(intArrayRef[idx], intArray[idx]);
}
for (var idx = 0; idx < 1000; idx++)
{
Assert.AreEqual(intArrayRef[idx], intArray[idx]);
}
}
}
public void HugeArrayResizeTests()
{
var stringArrayRef = new string[1000];
var stringArray = new HugeArray<string>(1000, 300);
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
for (int idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
stringArrayRef[idx] = idx.ToString();
stringArray[idx] = idx.ToString();
}
else
{
stringArrayRef[idx] = null;
stringArray[idx] = null;
}
}
Array.Resize<string>(ref stringArrayRef, 335);
stringArray.Resize(335);
Assert.AreEqual(stringArrayRef.Length, stringArray.Length);
for (int idx = 0; idx < stringArrayRef.Length; idx++)
{
Assert.AreEqual(stringArrayRef[idx], stringArray[idx]);
}
stringArrayRef = new string[1000];
stringArray = new HugeArray<string>(1000, 300);
for (int idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
stringArrayRef[idx] = idx.ToString();
stringArray[idx] = idx.ToString();
}
else
{
stringArrayRef[idx] = null;
stringArray[idx] = null;
}
}
Array.Resize<string>(ref stringArrayRef, 1235);
stringArray.Resize(1235);
Assert.AreEqual(stringArrayRef.Length, stringArray.Length);
for (int idx = 0; idx < stringArrayRef.Length; idx++)
{
Assert.AreEqual(stringArrayRef[idx], stringArray[idx]);
}
}
public void MemoryMappedHugeArrayResizeTests()
{
// make sure to initialize the native hooks to create a memory mapping.
Native.Initialize();
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
using (var intArray = new MemoryMappedHugeArray<int>(1000, 300))
{
var intArrayRef = new int[1000];
for (int idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
intArrayRef[idx] = idx;
intArray[idx] = idx;
}
else
{
intArrayRef[idx] = int.MaxValue;
intArray[idx] = int.MaxValue;
}
}
Array.Resize<int>(ref intArrayRef, 335);
intArray.Resize(335);
Assert.AreEqual(intArrayRef.Length, intArray.Length);
for (int idx = 0; idx < intArrayRef.Length; idx++)
{
Assert.AreEqual(intArrayRef[idx], intArray[idx]);
}
}
using (var intArray = new MemoryMappedHugeArray<int>(1000, 300))
{
var intArrayRef = new int[1000];
for (int idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
intArrayRef[idx] = idx;
intArray[idx] = idx;
}
else
{
intArrayRef[idx] = int.MaxValue;
intArray[idx] = int.MaxValue;
}
}
Array.Resize<int>(ref intArrayRef, 1235);
intArray.Resize(1235);
Assert.AreEqual(intArrayRef.Length, intArray.Length);
for (int idx = 0; idx < intArrayRef.Length; idx++)
{
Assert.AreEqual(intArrayRef[idx], intArray[idx]);
}
}
}
public void MemoryMappedHugeArraySimpleTest()
{
// make sure to initialize the native hooks to create a memory mapping.
Native.Initialize();
using (var intArray = new MemoryMappedHugeArray<int>(1000, 1024))
{
var intArrayRef = new int[1000];
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
for (int idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
intArrayRef[idx] = idx;
intArray[idx] = idx;
}
else
{
intArrayRef[idx] = int.MaxValue;
intArray[idx] = int.MaxValue;
}
}
for (int idx = 0; idx < 1000; idx++)
{
Assert.AreEqual(intArrayRef[idx], intArray[idx]);
}
}
}
public void TestHuge()
{
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
var buffer = new byte[255];
var readFrom = new MemoryMappedFile.ReadFromDelegate<string>((stream, position) =>
{
stream.Seek(position, System.IO.SeekOrigin.Begin);
var size = stream.ReadByte();
int pos = 0;
stream.Read(buffer, pos, size);
while (size == 255)
{
pos = pos + size;
size = stream.ReadByte();
if (buffer.Length < size + pos)
{
Array.Resize(ref buffer, size + pos);
}
stream.Read(buffer, pos, size);
}
pos = pos + size;
return System.Text.Encoding.Unicode.GetString(buffer, 0, pos);
});
var writeTo = new MemoryMappedFile.WriteToDelegate<string>((stream, position, structure) =>
{
stream.Seek(position, System.IO.SeekOrigin.Begin);
var bytes = System.Text.Encoding.Unicode.GetBytes(structure);
var length = bytes.Length;
for (int idx = 0; idx <= bytes.Length; idx = idx + 255)
{
var size = bytes.Length - idx;
if (size > 255)
{
size = 255;
}
if (stream.Length <= stream.Position + size + 1)
{ // past end of stream.
return -1;
}
stream.WriteByte((byte)size);
stream.Write(bytes, idx, size);
length++;
}
return length;
});
var dictionary = new MemoryMappedHugeDictionary<string, string>(new MemoryMappedStream(new MemoryStream()),
readFrom, writeTo, readFrom, writeTo);
var reference = new Dictionary<string, string>();
var keys = new List<string>();
for (int idx = 0; idx < 100; idx++)
{
keys.Add(string.Format("key{0}", idx));
}
var testCount = 1000;
while (testCount > 0)
{
var keyIdx = randomGenerator.Generate(keys.Count);
var value = randomGenerator.GenerateString(
randomGenerator.Generate(256) + 32);
dictionary[keys[keyIdx]] = value;
reference[keys[keyIdx]] = value;
testCount--;
}
foreach (var pair in reference)
{
var value = dictionary[pair.Key];
Assert.AreEqual(pair.Value, value);
Assert.IsTrue(dictionary.TryGetValue(pair.Key, out value));
Assert.AreEqual(pair.Value, value);
}
}
public void TestStructuresOfArraysSerialize()
{
var randomGenerator = new RandomGenerator(66707770); // make this deterministic.
var index = new MemoryMappedIndex<int[]>(new MemoryMappedStream(new MemoryStream()),
MemoryMappedDelegates.ReadFromIntArray, MemoryMappedDelegates.WriteToIntArray);
var indexRef = new Dictionary<long, int[]>();
// add the data.
var testCount = 10;
while (testCount > 0)
{
var data = randomGenerator.GenerateArray(512, 512);
indexRef.Add(index.Add(data), data);
testCount--;
}
MemoryMappedIndex<int[]> deserializedIndex;
using (var stream = new MemoryStream())
{
var size = index.Serialize(stream);
deserializedIndex = MemoryMappedIndex<int[]>.Deserialize(stream,
MemoryMappedDelegates.ReadFromIntArray, MemoryMappedDelegates.WriteToIntArray, false);
// get the data and check.
foreach (var entry in indexRef)
{
var data = index.Get(entry.Key);
Assert.AreEqual(indexRef[entry.Key], data);
}
}
}
public void MemoryMappedHugeArrayResizeTests()
{
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
using (var intArray = new MemoryMappedHugeArrayUInt32(new MemoryMappedStream(new MemoryStream()), 1000, 256))
{
var intArrayRef = new uint[1000];
for (uint idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
intArrayRef[idx] = idx;
intArray[idx] = idx;
}
else
{
intArrayRef[idx] = int.MaxValue;
intArray[idx] = int.MaxValue;
}
Assert.AreEqual(intArrayRef[idx], intArray[idx]);
}
Array.Resize<uint>(ref intArrayRef, 335);
intArray.Resize(335);
Assert.AreEqual(intArrayRef.Length, intArray.Length);
for (int idx = 0; idx < intArrayRef.Length; idx++)
{
Assert.AreEqual(intArrayRef[idx], intArray[idx]);
}
}
using (var intArray = new MemoryMappedHugeArrayUInt32(new MemoryMappedStream(new MemoryStream()), 1000, 256))
{
var intArrayRef = new uint[1000];
for (uint idx = 0; idx < 1000; idx++)
{
if (randomGenerator.Generate(2.0) > 1)
{ // add data.
intArrayRef[idx] = idx;
intArray[idx] = idx;
}
else
{
intArrayRef[idx] = int.MaxValue;
intArray[idx] = int.MaxValue;
}
Assert.AreEqual(intArrayRef[idx], intArray[idx]);
}
Array.Resize<uint>(ref intArrayRef, 1235);
var oldSize = intArray.Length;
intArray.Resize(1235);
// huge array is not initialized.
for (long idx = oldSize; idx < intArray.Length;idx++)
{
intArray[idx] = 0;
}
Assert.AreEqual(intArrayRef.Length, intArray.Length);
for (int idx = 0; idx < intArrayRef.Length; idx++)
{
Assert.AreEqual(intArrayRef[idx], intArray[idx], string.Format("Array element not equal at index: {0}. Expected {1}, found {2}",
idx, intArray[idx], intArrayRef[idx]));
}
}
}
public void RTreeMemoryIndexEnumerationTests()
{
// create the index.
var index = new RTreeMemoryIndex<DataTestClass>();
// build test-data.
var testDataList = new HashSet<DataTestClass>();
const int count = 10000;
var randomGenerator = new RandomGenerator(66707770); // make this deterministic
for (int idx = 0; idx < count; idx++)
{
double x1 = randomGenerator.Generate(1.0);
double x2 = randomGenerator.Generate(1.0);
double y1 = randomGenerator.Generate(1.0);
double y2 = randomGenerator.Generate(1.0);
var box = new BoxF2D(new PointF2D(x1, y1), new PointF2D(x2, y2));
var testData = new DataTestClass();
testData.Data = idx.ToString(System.Globalization.CultureInfo.InvariantCulture);
testDataList.Add(testData);
index.Add(box, testData);
}
// compare and check if all data gets enumerated.
HashSet<DataTestClass> reference = new HashSet<DataTestClass>();
foreach (DataTestClass dataTestClass in index)
{
reference.Add(dataTestClass);
Assert.IsTrue(testDataList.Contains(dataTestClass));
}
Assert.AreEqual(testDataList.Count, reference.Count);
Assert.AreEqual(testDataList.Count, index.Count);
}
