public void GetBytes()
{
// Build array of random integer structs.
int randomStructNumber = 1000;
RandomIntStruct[] randomIntegers = new RandomIntStruct[randomStructNumber];
for (int x = 0; x < randomStructNumber; x++)
{
randomIntegers[x] = RandomIntStruct.BuildRandomStruct();
}
// Convert integer struct to bytes.
// "New" and "Old" refer to original and optimized code paths. "New" is a micro-optimized path since 1.4.0.
byte[] bytesUnmanagedNew = Reloaded.Memory.StructArray.GetBytes(randomIntegers);
byte[] bytesUnmanagedOriginal = Reloaded.Memory.StructArray.GetBytes(randomIntegers, false);
// From bytes back to struct array.
Reloaded.Memory.StructArray.FromArray(bytesUnmanagedNew, out RandomIntStruct[] newRandomIntegersCopy);
Reloaded.Memory.StructArray.FromArray(bytesUnmanagedOriginal, out RandomIntStruct[] oldRandomIntegersCopy, false);
// From span back to struct array.
Reloaded.Memory.StructArray.FromArray(new Span <byte>(bytesUnmanagedNew), out RandomIntStruct[] newSpanRandomIntegersCopy);
// Compare both arrays.
Assert.Equal(randomIntegers, newRandomIntegersCopy);
Assert.Equal(randomIntegers, oldRandomIntegersCopy);
Assert.Equal(randomIntegers, newSpanRandomIntegersCopy);
}
public void FromToPtr()
{
// Build array of random integer structs.
int randomStructNumber = 1000;
RandomIntStruct[] randomIntegers = new RandomIntStruct[randomStructNumber];
for (int x = 0; x < randomStructNumber; x++)
{
randomIntegers[x] = RandomIntStruct.BuildRandomStruct();
}
// Allocate memory for these structs.
IntPtr memoryPtr = _currentProcess.Allocate(Reloaded.Memory.StructArray.GetSize <RandomIntStruct>(randomStructNumber));
// Write random int struct array to pointer.
Reloaded.Memory.StructArray.ToPtr(memoryPtr, randomIntegers);
// Read back struct array from pointer.
Reloaded.Memory.StructArray.FromPtr <RandomIntStruct>(memoryPtr, out var randomIntegersCopy, randomStructNumber);
// Now compare old and new array.
Assert.Equal(randomIntegers, randomIntegersCopy);
// Cleanup
_currentProcess.Free(memoryPtr);
}
public void SafeReadWrite(Reloaded.Memory.Sources.IMemory memorySource)
{
// Prepare
int structSize = Struct.GetSize <RandomIntStruct>();
IMemoryTools.SwapExternalMemorySource(ref memorySource, _helloWorldProcess);
IntPtr pointer = memorySource.Allocate(structSize);
/* Start Test */
// Generate random int struct to read/write to.
var randomIntStruct = RandomIntStruct.BuildRandomStruct();
// Run the change permission function to deny read/write access.
try { memorySource.ChangePermission(pointer, structSize, Kernel32.Kernel32.MEM_PROTECTION.PAGE_NOACCESS); }
catch (NotImplementedException) { return; } // ChangePermission is optional to implement
// Throws corrupted state exception if operations fail until restore.
memorySource.SafeWrite(pointer, ref randomIntStruct);
memorySource.SafeRead(pointer, out RandomIntStruct randomIntStructCopy);
// Restore or NETCore execution engine will complain.
try { memorySource.ChangePermission(pointer, structSize, Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE); }
catch (NotImplementedException) { return; } // ChangePermission is optional to implement
// Compare before exiting test.
Assert.Equal(randomIntStruct, randomIntStructCopy);
// Cleanup
memorySource.Free(pointer);
}
/// <summary>
/// Tests the "Add" functionality of the <see cref="MemoryBuffer"/>; including
/// the return of the correct pointer and CanItemFit.
/// </summary>
private unsafe void MemoryBufferAddGeneric(MemoryBuffer buffer, Process process)
{
// Setup test.
ExternalMemory externalMemory = new ExternalMemory(process);
// Disable item alignment.
var bufferHeader = buffer.Properties;
buffer.Properties = bufferHeader;
// Get remaining space, items to place.
int remainingBufferSpace = bufferHeader.Remaining;
int structSize = Struct.GetSize <RandomIntStruct>();
int itemsToFit = remainingBufferSpace / structSize;
// Generate array of random int structs.
RandomIntStruct[] randomIntStructs = new RandomIntStruct[itemsToFit];
for (int x = 0; x < itemsToFit; x++)
{
randomIntStructs[x] = RandomIntStruct.BuildRandomStruct();
}
// Fill the buffer and verify each item as it's added.
for (int x = 0; x < itemsToFit; x++)
{
IntPtr writeAddress = buffer.Add(ref randomIntStructs[x], false, 1);
// Read back and compare.
externalMemory.Read(writeAddress, out RandomIntStruct actual);
Assert.Equal(randomIntStructs[x], actual);
}
// Compare again, running the entire array this time.
IntPtr bufferStartPtr = bufferHeader.DataPointer;
for (int x = 0; x < itemsToFit; x++)
{
IntPtr readAddress = bufferStartPtr + (x * structSize);
// Read back and compare.
externalMemory.Read(readAddress, out RandomIntStruct actual);
Assert.Equal(randomIntStructs[x], actual);
}
// The array is full, calling CanItemFit should return false.
Assert.False(buffer.CanItemFit(ref randomIntStructs[0]));
// Likewise, calling Add should return IntPtr.Zero.
var randIntStr = RandomIntStruct.BuildRandomStruct();
Assert.Equal(IntPtr.Zero, buffer.Add(ref randIntStr, false, 1));
}
public void Foreach()
{
// Build array of random integer structs.
int randomStructNumber = 1000;
RandomIntStruct[] randomIntegers = new RandomIntStruct[randomStructNumber];
foreach (var randomInteger in randomIntegers)
{
if (!randomIntegers.Contains(randomInteger))
{
Assert.True(false, "Foreach is broken. RandomIntStruct from RandomIntStruct array not found in original array.");
}
}
}
public RandomIntStruct ReloadedStreamReader()
{
using (var fileStream = _generator.GetMemoryStream())
{
var reloadedReader = new BufferedStreamReader(fileStream, BufferSize);
RandomIntStruct randomIntStruct = new RandomIntStruct();
for (int x = 0; x < _generator.Structs.Length; x++)
{
BufferedStreamReaderGetStruct(reloadedReader, out randomIntStruct);
}
return(randomIntStruct);
}
}
public RandomIntStruct BinaryReader()
{
using (var fileStream = _generator.GetMemoryStream())
{
var binaryReader = new BinaryReader(fileStream);
RandomIntStruct randomIntStruct = new RandomIntStruct();
for (int x = 0; x < _generator.Structs.Length; x++)
{
BinaryReaderGetStruct(binaryReader, out randomIntStruct);
}
return(randomIntStruct);
}
}
public RandomIntStruct BinaryReaderCustomBufferSize()
{
using (var fileStream = _generator.GetFileStreamWithBufferSize(BufferSize))
{
var binaryReader = new BinaryReader(fileStream);
RandomIntStruct randomIntStruct = new RandomIntStruct();
for (int x = 0; x < _generator.Structs.Length; x++)
{
BinaryReaderGetStruct(binaryReader, out randomIntStruct);
}
return(randomIntStruct);
}
}
/* Construction/Destruction */
public RandomIntStructGenerator(int megabytes)
{
int totalBytes = Mathematics.MegaBytesToBytes(megabytes);
int structs = Mathematics.BytesToStructCount <RandomIntStruct>(totalBytes);
Structs = new RandomIntStruct[structs];
for (int x = 0; x < structs; x++)
{
Structs[x] = RandomIntStruct.BuildRandomStruct();
}
Bytes = StructArray.GetBytes(Structs);
File.WriteAllBytes(TestFileName, Bytes);
}
public void WriteRegularStruct()
{
var randomIntStruct = new RandomIntStruct()
{
A = 1,
B = 33,
C = 4214
};
using (var extendedStream = new LittleEndianMemoryStream(new Reloaded.Memory.Streams.ExtendedMemoryStream()))
{
extendedStream.Write(randomIntStruct);
Struct.FromArray <RandomIntStruct>(extendedStream.ToArray(), out var newStruct, 0);
Assert.Equal(randomIntStruct, newStruct);
};
}
public void GetBytes()
{
// Build array of random integer structs.
int randomStructNumber = 1000;
RandomIntStruct[] randomIntegers = new RandomIntStruct[randomStructNumber];
for (int x = 0; x < randomStructNumber; x++)
{
randomIntegers[x] = RandomIntStruct.BuildRandomStruct();
}
// Convert integer struct to bytes.
byte[] bytes = Reloaded.Memory.StructArray.GetBytes(randomIntegers);
// From bytes back to struct array.
Reloaded.Memory.StructArray.FromArray(bytes, out RandomIntStruct[] randomIntegersCopy);
// Compare both arrays.
Assert.Equal(randomIntegers, randomIntegersCopy);
}
public void ReadWriteStructs(Reloaded.Memory.Sources.IMemory memorySource)
{
// Prepare
IMemoryTools.SwapExternalMemorySource(ref memorySource, _helloWorldProcess);
IntPtr pointer = memorySource.Allocate(0x100);
/* Start Test */
// Random struct read/write.
for (int x = 0; x < 100; x++)
{
RandomIntStruct randomIntStruct = RandomIntStruct.BuildRandomStruct();
memorySource.Write(pointer, ref randomIntStruct);
memorySource.Read(pointer, out RandomIntStruct randomValueCopy);
Assert.Equal(randomIntStruct, randomValueCopy);
}
/* End Test */
// Cleanup
memorySource.Free(pointer);
}
public void BufferedStreamReaderGetStruct(BufferedStreamReader bufferedStreamReader, out RandomIntStruct randomIntStruct)
{
bufferedStreamReader.Read(out randomIntStruct);
}
/* Create */
public void BinaryReaderGetStruct(BinaryReader binaryReader, out RandomIntStruct randomIntStruct)
{
randomIntStruct.A = binaryReader.ReadByte();
randomIntStruct.B = binaryReader.ReadInt16();
randomIntStruct.C = binaryReader.ReadInt32();
}
public void TestBuffer()
{
// Setup
int bufferSize = 4096;
var memory = new Reloaded.Memory.Sources.Memory();
var buffer = new Reloaded.Memory.Utilities.CircularBuffer(bufferSize, memory);
// Properties.
int structSize = Struct.GetSize <RandomIntStruct>();
int bufferElements = bufferSize / structSize;
var randomIntStructs = new RandomIntStruct[bufferElements];
for (int x = 0; x < bufferElements; x++)
{
randomIntStructs[x] = RandomIntStruct.BuildRandomStruct();
}
// Fill circular buffer and validate.
for (int x = 0; x < bufferElements; x++)
{
// Save write pointer.
IntPtr nextPointer = buffer.WritePointer + structSize;
var address = buffer.Add(ref randomIntStructs[x]);
memory.Read(address, out RandomIntStruct randIntStruct);
// Check correct element and pointer did not loop.
Assert.Equal(randomIntStructs[x], randIntStruct);
Assert.Equal(nextPointer, buffer.WritePointer);
}
// Now check if item can fit, it should not.
// Buffer should require looping.
var randomIntStruct = RandomIntStruct.BuildRandomStruct();
var canFit = buffer.CanItemFit(ref randomIntStruct);
Assert.Equal(Reloaded.Memory.Utilities.CircularBuffer.ItemFit.StartOfBuffer, canFit);
// Add item to loop.
var lastItemPtr = buffer.Add(ref randomIntStruct);
Assert.Equal(buffer.Address, lastItemPtr); // New item should have been placed at offset 0.
// Item too big.
buffer.Offset = 0;
byte[] sameSizeAsBuffer = new byte[bufferSize];
byte[] tooBigForBuffer = new byte[bufferSize + 1];
// Will not fit.
Assert.Equal(Reloaded.Memory.Utilities.CircularBuffer.ItemFit.No, buffer.CanItemFit(tooBigForBuffer.Length));
Assert.Equal(IntPtr.Zero, buffer.Add(tooBigForBuffer));
// Will fit in current loop. Note Offset = 0.
Assert.Equal(Reloaded.Memory.Utilities.CircularBuffer.ItemFit.Yes, buffer.CanItemFit(sameSizeAsBuffer.Length));
Assert.NotEqual(IntPtr.Zero, buffer.Add(sameSizeAsBuffer));
buffer.Offset = 1; // Will fit on next loop.
Assert.Equal(Reloaded.Memory.Utilities.CircularBuffer.ItemFit.StartOfBuffer, buffer.CanItemFit(sameSizeAsBuffer.Length));
Assert.NotEqual(IntPtr.Zero, buffer.Add(sameSizeAsBuffer));
// Cleanup
buffer.Dispose();
}
