mirror of
https://git.ryujinx.app/projects/Kenji-NX.git
synced 2026-11-19 09:21:15 +01:00
Update NUnit to 4.4.0
* NUnit3TestAdapter to 5.2.0 * Rename Assert class to ClassicAssert to align with NUnit 4.x changes
This commit is contained in:
1 parent
1724149443
commit
280461dc78
54 files changed
+629
-576
No files matched your search
@@ -1,4 +1,5 @@
|
||||
using NUnit.Framework;
|
||||
using NUnit.Framework.Legacy;
|
||||
using Ryujinx.Memory;
|
||||
using Ryujinx.Memory.Tracking;
|
||||
using System;
|
||||
@@ -56,8 +57,8 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
handle.QueryModified(startAddress, size, (address, _) =>
|
||||
{
|
||||
Assert.IsTrue(addressPredicate(address)); // Written pages must be even.
|
||||
Assert.GreaterOrEqual(address, lastAddress); // Must be signalled in ascending order, regardless of write order.
|
||||
ClassicAssert.IsTrue(addressPredicate(address)); // Written pages must be even.
|
||||
ClassicAssert.GreaterOrEqual(address, lastAddress); // Must be signalled in ascending order, regardless of write order.
|
||||
lastAddress = address;
|
||||
regionCount++;
|
||||
});
|
||||
@@ -72,8 +73,8 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
handle.QueryModified(startAddress, size, (address, _) =>
|
||||
{
|
||||
Assert.IsTrue(addressPredicate(address)); // Written pages must be even.
|
||||
Assert.GreaterOrEqual(address, lastAddress); // Must be signalled in ascending order, regardless of write order.
|
||||
ClassicAssert.IsTrue(addressPredicate(address)); // Written pages must be even.
|
||||
ClassicAssert.GreaterOrEqual(address, lastAddress); // Must be signalled in ascending order, regardless of write order.
|
||||
lastAddress = address;
|
||||
regionCount++;
|
||||
}, sequenceNumber);
|
||||
@@ -93,7 +94,7 @@ namespace Ryujinx.Tests.Memory
|
||||
{
|
||||
resultAddress = address;
|
||||
});
|
||||
Assert.AreEqual(resultAddress, (ulong)i * PageSize + address);
|
||||
ClassicAssert.AreEqual(resultAddress, (ulong)i * PageSize + address);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -119,7 +120,7 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
int oddRegionCount = ExpectQueryInOrder(handle, 0, PageSize * PageCount, (address) => (address / PageSize) % 2 == 1);
|
||||
|
||||
Assert.AreEqual(oddRegionCount, PageCount / 2); // Must have written to all odd pages.
|
||||
ClassicAssert.AreEqual(oddRegionCount, PageCount / 2); // Must have written to all odd pages.
|
||||
|
||||
// Write to all the even pages.
|
||||
RandomOrder(random, even, (i) =>
|
||||
@@ -129,7 +130,7 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
int evenRegionCount = ExpectQueryInOrder(handle, 0, PageSize * PageCount, (address) => (address / PageSize) % 2 == 0);
|
||||
|
||||
Assert.AreEqual(evenRegionCount, PageCount / 2);
|
||||
ClassicAssert.AreEqual(evenRegionCount, PageCount / 2);
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -172,7 +173,7 @@ namespace Ryujinx.Tests.Memory
|
||||
}, 1);
|
||||
}
|
||||
|
||||
Assert.AreEqual(oddRegionCount, PageCount / 2); // Must have written to all odd pages.
|
||||
ClassicAssert.AreEqual(oddRegionCount, PageCount / 2); // Must have written to all odd pages.
|
||||
|
||||
// Write to all pages.
|
||||
|
||||
@@ -182,19 +183,19 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
int evenRegionCount = ExpectQueryInOrder(handle, 0, PageSize * PageCount, (address) => (address / PageSize) % 2 == 0, 1);
|
||||
|
||||
Assert.AreEqual(evenRegionCount, PageCount / 2); // Must have written to all even pages.
|
||||
ClassicAssert.AreEqual(evenRegionCount, PageCount / 2); // Must have written to all even pages.
|
||||
|
||||
oddRegionCount = 0;
|
||||
|
||||
handle.QueryModified(0, PageSize * PageCount, (_, _) => { oddRegionCount++; }, 1);
|
||||
|
||||
Assert.AreEqual(oddRegionCount, 0); // Sequence number has not changed, so found no dirty subregions.
|
||||
ClassicAssert.AreEqual(oddRegionCount, 0); // Sequence number has not changed, so found no dirty subregions.
|
||||
|
||||
// With sequence number 2, all all pages should be reported as modified.
|
||||
|
||||
oddRegionCount = ExpectQueryInOrder(handle, 0, PageSize * PageCount, (address) => (address / PageSize) % 2 == 1, 2);
|
||||
|
||||
Assert.AreEqual(oddRegionCount, PageCount / 2); // Must have written to all odd pages.
|
||||
ClassicAssert.AreEqual(oddRegionCount, PageCount / 2); // Must have written to all odd pages.
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -242,8 +243,8 @@ namespace Ryujinx.Tests.Memory
|
||||
{
|
||||
int region = regionSizes[regionInd++];
|
||||
|
||||
Assert.AreEqual(address, expectedAddress);
|
||||
Assert.AreEqual(size, (ulong)(PageSize * region));
|
||||
ClassicAssert.AreEqual(address, expectedAddress);
|
||||
ClassicAssert.AreEqual(size, (ulong)(PageSize * region));
|
||||
|
||||
expectedAddress += (ulong)(PageSize * (region + 1));
|
||||
});
|
||||
@@ -256,12 +257,12 @@ namespace Ryujinx.Tests.Memory
|
||||
const int PageCount = 32;
|
||||
const int OverlapStart = 16;
|
||||
|
||||
Assert.AreEqual(0, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(0, _tracking.GetRegionCount());
|
||||
|
||||
IMultiRegionHandle handleLow = GetGranular(smart, 0, PageSize * PageCount, PageSize);
|
||||
PreparePages(handleLow, PageCount);
|
||||
|
||||
Assert.AreEqual(PageCount, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(PageCount, _tracking.GetRegionCount());
|
||||
|
||||
IMultiRegionHandle handleHigh = GetGranular(smart, PageSize * OverlapStart, PageSize * PageCount, PageSize);
|
||||
PreparePages(handleHigh, PageCount, PageSize * OverlapStart);
|
||||
@@ -269,15 +270,15 @@ namespace Ryujinx.Tests.Memory
|
||||
// Combined pages (and assuming overlapStart <= pageCount) should be pageCount after overlapStart.
|
||||
int totalPages = OverlapStart + PageCount;
|
||||
|
||||
Assert.AreEqual(totalPages, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(totalPages, _tracking.GetRegionCount());
|
||||
|
||||
handleLow.Dispose(); // After disposing one, the pages for the other remain.
|
||||
|
||||
Assert.AreEqual(PageCount, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(PageCount, _tracking.GetRegionCount());
|
||||
|
||||
handleHigh.Dispose(); // After disposing the other, there are no pages left.
|
||||
|
||||
Assert.AreEqual(0, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(0, _tracking.GetRegionCount());
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -357,19 +358,19 @@ namespace Ryujinx.Tests.Memory
|
||||
bool modified = false;
|
||||
combined.QueryModified(PageSize * (ulong)i, PageSize, (_, _) => { modified = true; });
|
||||
|
||||
Assert.AreEqual(expectedDirty[i], modified);
|
||||
ClassicAssert.AreEqual(expectedDirty[i], modified);
|
||||
}
|
||||
|
||||
Assert.AreEqual(new bool[3], actionsTriggered);
|
||||
ClassicAssert.AreEqual(new bool[3], actionsTriggered);
|
||||
|
||||
_tracking.VirtualMemoryEvent(PageSize * 5, PageSize, false);
|
||||
Assert.IsTrue(actionsTriggered[0]);
|
||||
ClassicAssert.IsTrue(actionsTriggered[0]);
|
||||
|
||||
_tracking.VirtualMemoryEvent(PageSize * 10, PageSize, false);
|
||||
Assert.IsTrue(actionsTriggered[1]);
|
||||
ClassicAssert.IsTrue(actionsTriggered[1]);
|
||||
|
||||
_tracking.VirtualMemoryEvent(PageSize * 15, PageSize, false);
|
||||
Assert.IsTrue(actionsTriggered[2]);
|
||||
ClassicAssert.IsTrue(actionsTriggered[2]);
|
||||
|
||||
// The double page handles should be disposed, as they were split into granular handles.
|
||||
foreach (RegionHandle doublePage in doublePages)
|
||||
@@ -386,18 +387,18 @@ namespace Ryujinx.Tests.Memory
|
||||
throws = true;
|
||||
}
|
||||
|
||||
Assert.IsTrue(throws);
|
||||
ClassicAssert.IsTrue(throws);
|
||||
}
|
||||
|
||||
IEnumerable<IRegionHandle> combinedHandles = combined.GetHandles();
|
||||
|
||||
Assert.AreEqual(handleGroups[0].ElementAt(0), combinedHandles.ElementAt(3));
|
||||
Assert.AreEqual(handleGroups[0].ElementAt(1), combinedHandles.ElementAt(4));
|
||||
Assert.AreEqual(handleGroups[0].ElementAt(2), combinedHandles.ElementAt(5));
|
||||
ClassicAssert.AreEqual(handleGroups[0].ElementAt(0), combinedHandles.ElementAt(3));
|
||||
ClassicAssert.AreEqual(handleGroups[0].ElementAt(1), combinedHandles.ElementAt(4));
|
||||
ClassicAssert.AreEqual(handleGroups[0].ElementAt(2), combinedHandles.ElementAt(5));
|
||||
|
||||
Assert.AreEqual(singlePages[0], combinedHandles.ElementAt(8));
|
||||
Assert.AreEqual(singlePages[1], combinedHandles.ElementAt(9));
|
||||
Assert.AreEqual(singlePages[2], combinedHandles.ElementAt(10));
|
||||
ClassicAssert.AreEqual(singlePages[0], combinedHandles.ElementAt(8));
|
||||
ClassicAssert.AreEqual(singlePages[1], combinedHandles.ElementAt(9));
|
||||
ClassicAssert.AreEqual(singlePages[2], combinedHandles.ElementAt(10));
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -413,11 +414,11 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
// Precise write to first handle in the multiregion.
|
||||
_tracking.VirtualMemoryEvent(PageSize * 3, PageSize, true, precise: true);
|
||||
Assert.IsFalse(actionTriggered); // Action not triggered.
|
||||
ClassicAssert.IsFalse(actionTriggered); // Action not triggered.
|
||||
|
||||
bool firstPageModified = false;
|
||||
granular.QueryModified(PageSize * 3, PageSize, (_, _) => { firstPageModified = true; });
|
||||
Assert.IsTrue(firstPageModified); // First page is modified.
|
||||
ClassicAssert.IsTrue(firstPageModified); // First page is modified.
|
||||
|
||||
// Precise write to all handles in the multiregion.
|
||||
_tracking.VirtualMemoryEvent(PageSize * 3, PageSize * 3, true, precise: true);
|
||||
@@ -430,10 +431,10 @@ namespace Ryujinx.Tests.Memory
|
||||
granular.QueryModified(PageSize * (ulong)i, PageSize, (_, _) => { pagesModified[index] = true; });
|
||||
}
|
||||
|
||||
Assert.IsTrue(actionTriggered); // Action triggered.
|
||||
ClassicAssert.IsTrue(actionTriggered); // Action triggered.
|
||||
|
||||
// Precise writes are ignored on two later handles due to the action returning true.
|
||||
Assert.AreEqual(pagesModified, new bool[] { true, false, false });
|
||||
ClassicAssert.AreEqual(pagesModified, new bool[] { true, false, false });
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
using NUnit.Framework;
|
||||
using NUnit.Framework.Legacy;
|
||||
using Ryujinx.Memory;
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
@@ -28,7 +29,7 @@ namespace Ryujinx.Tests.Memory
|
||||
{
|
||||
Marshal.WriteInt32(_memoryBlock.Pointer, 0x2020, 0x1234abcd);
|
||||
|
||||
Assert.AreEqual(_memoryBlock.Read<int>(0x2020), 0x1234abcd);
|
||||
ClassicAssert.AreEqual(_memoryBlock.Read<int>(0x2020), 0x1234abcd);
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -36,7 +37,7 @@ namespace Ryujinx.Tests.Memory
|
||||
{
|
||||
_memoryBlock.Write(0x2040, 0xbadc0de);
|
||||
|
||||
Assert.AreEqual(Marshal.ReadInt32(_memoryBlock.Pointer, 0x2040), 0xbadc0de);
|
||||
ClassicAssert.AreEqual(Marshal.ReadInt32(_memoryBlock.Pointer, 0x2040), 0xbadc0de);
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -54,7 +55,7 @@ namespace Ryujinx.Tests.Memory
|
||||
toAlias.UnmapView(backing, pageSize * 3, pageSize);
|
||||
|
||||
toAlias.Write(0, 0xbadc0de);
|
||||
Assert.AreEqual(Marshal.ReadInt32(backing.Pointer, (int)pageSize), 0xbadc0de);
|
||||
ClassicAssert.AreEqual(Marshal.ReadInt32(backing.Pointer, (int)pageSize), 0xbadc0de);
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -84,7 +85,7 @@ namespace Ryujinx.Tests.Memory
|
||||
int offset = rng.Next(0, (int)pageSize - sizeof(int));
|
||||
|
||||
toAlias.Write((ulong)((dstPage << pageBits) + offset), 0xbadc0de);
|
||||
Assert.AreEqual(Marshal.ReadInt32(backing.Pointer, (srcPage << pageBits) + offset), 0xbadc0de);
|
||||
ClassicAssert.AreEqual(Marshal.ReadInt32(backing.Pointer, (srcPage << pageBits) + offset), 0xbadc0de);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -109,7 +110,7 @@ namespace Ryujinx.Tests.Memory
|
||||
toAlias.MapView(backing, 0, offset, pageSize);
|
||||
|
||||
toAlias.Write(offset, 0xbadc0de);
|
||||
Assert.AreEqual(0xbadc0de, backing.Read<int>(0));
|
||||
ClassicAssert.AreEqual(0xbadc0de, backing.Read<int>(0));
|
||||
|
||||
toAlias.UnmapView(backing, offset, pageSize);
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
using NUnit.Framework;
|
||||
using NUnit.Framework.Legacy;
|
||||
using Ryujinx.Memory;
|
||||
using Ryujinx.Memory.Tracking;
|
||||
using System;
|
||||
@@ -53,46 +54,46 @@ namespace Ryujinx.Tests.Memory
|
||||
});
|
||||
|
||||
bool dirtyInitial = handle.Dirty;
|
||||
Assert.True(dirtyInitial); // Handle starts dirty.
|
||||
ClassicAssert.True(dirtyInitial); // Handle starts dirty.
|
||||
|
||||
handle.Reprotect();
|
||||
|
||||
bool dirtyAfterReprotect = handle.Dirty;
|
||||
Assert.False(dirtyAfterReprotect); // Handle is no longer dirty.
|
||||
ClassicAssert.False(dirtyAfterReprotect); // Handle is no longer dirty.
|
||||
|
||||
_tracking.VirtualMemoryEvent(PageSize * 2, 4, true);
|
||||
_tracking.VirtualMemoryEvent(PageSize * 2, 4, false);
|
||||
|
||||
bool dirtyAfterUnrelatedReadWrite = handle.Dirty;
|
||||
Assert.False(dirtyAfterUnrelatedReadWrite); // Not dirtied, as the write was to an unrelated address.
|
||||
ClassicAssert.False(dirtyAfterUnrelatedReadWrite); // Not dirtied, as the write was to an unrelated address.
|
||||
|
||||
Assert.IsNull(readTrackingTriggered); // Hasn't been triggered yet
|
||||
ClassicAssert.IsNull(readTrackingTriggered); // Hasn't been triggered yet
|
||||
|
||||
_tracking.VirtualMemoryEvent(0, 4, false);
|
||||
|
||||
bool dirtyAfterRelatedRead = handle.Dirty;
|
||||
Assert.False(dirtyAfterRelatedRead); // Only triggers on write.
|
||||
Assert.AreEqual(readTrackingTriggered, (0UL, 4UL)); // Read action was triggered.
|
||||
ClassicAssert.False(dirtyAfterRelatedRead); // Only triggers on write.
|
||||
ClassicAssert.AreEqual(readTrackingTriggered, (0UL, 4UL)); // Read action was triggered.
|
||||
|
||||
readTrackingTriggered = null;
|
||||
_tracking.VirtualMemoryEvent(0, 4, true);
|
||||
|
||||
bool dirtyAfterRelatedWrite = handle.Dirty;
|
||||
Assert.True(dirtyAfterRelatedWrite); // Dirty flag should now be set.
|
||||
ClassicAssert.True(dirtyAfterRelatedWrite); // Dirty flag should now be set.
|
||||
|
||||
_tracking.VirtualMemoryEvent(4, 4, true);
|
||||
bool dirtyAfterRelatedWrite2 = handle.Dirty;
|
||||
Assert.True(dirtyAfterRelatedWrite2); // Dirty flag should still be set.
|
||||
ClassicAssert.True(dirtyAfterRelatedWrite2); // Dirty flag should still be set.
|
||||
|
||||
handle.Reprotect();
|
||||
|
||||
bool dirtyAfterReprotect2 = handle.Dirty;
|
||||
Assert.False(dirtyAfterReprotect2); // Handle is no longer dirty.
|
||||
ClassicAssert.False(dirtyAfterReprotect2); // Handle is no longer dirty.
|
||||
|
||||
handle.Dispose();
|
||||
|
||||
bool dirtyAfterDispose = TestSingleWrite(handle, 0, 4);
|
||||
Assert.False(dirtyAfterDispose); // Handle cannot be triggered when disposed
|
||||
ClassicAssert.False(dirtyAfterDispose); // Handle cannot be triggered when disposed
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -126,27 +127,27 @@ namespace Ryujinx.Tests.Memory
|
||||
for (int i = 0; i < 16; i++)
|
||||
{
|
||||
// No handles are dirty.
|
||||
Assert.False(allHandle.Dirty);
|
||||
Assert.IsNull(readTrackingTriggeredAll);
|
||||
ClassicAssert.False(allHandle.Dirty);
|
||||
ClassicAssert.IsNull(readTrackingTriggeredAll);
|
||||
for (int j = 0; j < 16; j++)
|
||||
{
|
||||
Assert.False(containedHandles[j].Dirty);
|
||||
ClassicAssert.False(containedHandles[j].Dirty);
|
||||
}
|
||||
|
||||
_tracking.VirtualMemoryEvent((ulong)i * PageSize, 1, true);
|
||||
|
||||
// Only the handle covering the entire range and the relevant contained handle are dirty.
|
||||
Assert.True(allHandle.Dirty);
|
||||
Assert.AreEqual(readTrackingTriggeredAll, ((ulong)i * PageSize, 1UL)); // Triggered read tracking
|
||||
ClassicAssert.True(allHandle.Dirty);
|
||||
ClassicAssert.AreEqual(readTrackingTriggeredAll, ((ulong)i * PageSize, 1UL)); // Triggered read tracking
|
||||
for (int j = 0; j < 16; j++)
|
||||
{
|
||||
if (j == i)
|
||||
{
|
||||
Assert.True(containedHandles[j].Dirty);
|
||||
ClassicAssert.True(containedHandles[j].Dirty);
|
||||
}
|
||||
else
|
||||
{
|
||||
Assert.False(containedHandles[j].Dirty);
|
||||
ClassicAssert.False(containedHandles[j].Dirty);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -171,27 +172,27 @@ namespace Ryujinx.Tests.Memory
|
||||
// Anywhere inside the pages the region is contained on should trigger.
|
||||
|
||||
bool originalRangeTriggers = TestSingleWrite(handle, address, size);
|
||||
Assert.True(originalRangeTriggers);
|
||||
ClassicAssert.True(originalRangeTriggers);
|
||||
|
||||
bool alignedRangeTriggers = TestSingleWrite(handle, alignedStart, alignedSize);
|
||||
Assert.True(alignedRangeTriggers);
|
||||
ClassicAssert.True(alignedRangeTriggers);
|
||||
|
||||
bool alignedStartTriggers = TestSingleWrite(handle, alignedStart, 1);
|
||||
Assert.True(alignedStartTriggers);
|
||||
ClassicAssert.True(alignedStartTriggers);
|
||||
|
||||
bool alignedEndTriggers = TestSingleWrite(handle, alignedEnd - 1, 1);
|
||||
Assert.True(alignedEndTriggers);
|
||||
ClassicAssert.True(alignedEndTriggers);
|
||||
|
||||
// Outside the tracked range should not trigger.
|
||||
|
||||
bool alignedBeforeTriggers = TestSingleWrite(handle, alignedStart - 1, 1);
|
||||
Assert.False(alignedBeforeTriggers);
|
||||
ClassicAssert.False(alignedBeforeTriggers);
|
||||
|
||||
bool alignedAfterTriggers = TestSingleWrite(handle, alignedEnd, 1);
|
||||
Assert.False(alignedAfterTriggers);
|
||||
ClassicAssert.False(alignedAfterTriggers);
|
||||
}
|
||||
|
||||
[Test, Explicit, Timeout(1000)]
|
||||
[Test, Explicit, CancelAfter(1000)]
|
||||
public void Multithreading()
|
||||
{
|
||||
// Multithreading sanity test
|
||||
@@ -287,9 +288,9 @@ namespace Ryujinx.Tests.Memory
|
||||
thread.Join();
|
||||
}
|
||||
|
||||
Assert.Greater(dirtyFlagReprotects, 10);
|
||||
Assert.Greater(writeTriggers, 10);
|
||||
Assert.Greater(handleLifecycles, 10);
|
||||
ClassicAssert.Greater(dirtyFlagReprotects, 10);
|
||||
ClassicAssert.Greater(writeTriggers, 10);
|
||||
ClassicAssert.Greater(handleLifecycles, 10);
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -354,7 +355,7 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
// The action should trigger exactly once for every registration,
|
||||
// then we register once after all the threads signalling it cease.
|
||||
Assert.AreEqual(registeredCount, triggeredCount + 1);
|
||||
ClassicAssert.AreEqual(registeredCount, triggeredCount + 1);
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -365,11 +366,11 @@ namespace Ryujinx.Tests.Memory
|
||||
RegionHandle handle = _tracking.BeginTracking(0, PageSize, 0);
|
||||
handle.Reprotect();
|
||||
|
||||
Assert.AreEqual(1, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(1, _tracking.GetRegionCount());
|
||||
|
||||
handle.Dispose();
|
||||
|
||||
Assert.AreEqual(0, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(0, _tracking.GetRegionCount());
|
||||
|
||||
// Two handles, small entirely contains big.
|
||||
// We expect there to be three regions after creating both, one for the small region and two covering the big one around it.
|
||||
@@ -378,16 +379,16 @@ namespace Ryujinx.Tests.Memory
|
||||
RegionHandle handleSmall = _tracking.BeginTracking(PageSize, PageSize, 0);
|
||||
RegionHandle handleBig = _tracking.BeginTracking(0, PageSize * 4, 0);
|
||||
|
||||
Assert.AreEqual(3, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(3, _tracking.GetRegionCount());
|
||||
|
||||
// After disposing the big region, only the small one will remain.
|
||||
handleBig.Dispose();
|
||||
|
||||
Assert.AreEqual(1, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(1, _tracking.GetRegionCount());
|
||||
|
||||
handleSmall.Dispose();
|
||||
|
||||
Assert.AreEqual(0, _tracking.GetRegionCount());
|
||||
ClassicAssert.AreEqual(0, _tracking.GetRegionCount());
|
||||
}
|
||||
|
||||
[Test]
|
||||
@@ -397,22 +398,22 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
_memoryManager.OnProtect += (va, size, newProtection) =>
|
||||
{
|
||||
Assert.AreEqual((0, PageSize), (va, size)); // Should protect the exact region all the operations use.
|
||||
ClassicAssert.AreEqual((0, PageSize), (va, size)); // Should protect the exact region all the operations use.
|
||||
protection = newProtection;
|
||||
};
|
||||
|
||||
RegionHandle handle = _tracking.BeginTracking(0, PageSize, 0);
|
||||
|
||||
// After creating the handle, there is no protection yet.
|
||||
Assert.AreEqual(MemoryPermission.ReadAndWrite, protection);
|
||||
ClassicAssert.AreEqual(MemoryPermission.ReadAndWrite, protection);
|
||||
|
||||
bool dirtyInitial = handle.Dirty;
|
||||
Assert.True(dirtyInitial); // Handle starts dirty.
|
||||
ClassicAssert.True(dirtyInitial); // Handle starts dirty.
|
||||
|
||||
handle.Reprotect();
|
||||
|
||||
// After a reprotect, there is write protection, which will set a dirty flag when any write happens.
|
||||
Assert.AreEqual(MemoryPermission.Read, protection);
|
||||
ClassicAssert.AreEqual(MemoryPermission.Read, protection);
|
||||
|
||||
(ulong address, ulong size)? readTrackingTriggered = null;
|
||||
handle.RegisterAction((address, size) =>
|
||||
@@ -421,21 +422,21 @@ namespace Ryujinx.Tests.Memory
|
||||
});
|
||||
|
||||
// Registering an action adds read/write protection.
|
||||
Assert.AreEqual(MemoryPermission.None, protection);
|
||||
ClassicAssert.AreEqual(MemoryPermission.None, protection);
|
||||
|
||||
bool dirtyAfterReprotect = handle.Dirty;
|
||||
Assert.False(dirtyAfterReprotect); // Handle is no longer dirty.
|
||||
ClassicAssert.False(dirtyAfterReprotect); // Handle is no longer dirty.
|
||||
|
||||
// First we should read, which will trigger the action. This _should not_ remove write protection on the memory.
|
||||
|
||||
_tracking.VirtualMemoryEvent(0, 4, false);
|
||||
|
||||
bool dirtyAfterRead = handle.Dirty;
|
||||
Assert.False(dirtyAfterRead); // Not dirtied, as this was a read.
|
||||
ClassicAssert.False(dirtyAfterRead); // Not dirtied, as this was a read.
|
||||
|
||||
Assert.AreEqual(readTrackingTriggered, (0UL, 4UL)); // Read action was triggered.
|
||||
ClassicAssert.AreEqual(readTrackingTriggered, (0UL, 4UL)); // Read action was triggered.
|
||||
|
||||
Assert.AreEqual(MemoryPermission.Read, protection); // Write protection is still present.
|
||||
ClassicAssert.AreEqual(MemoryPermission.Read, protection); // Write protection is still present.
|
||||
|
||||
readTrackingTriggered = null;
|
||||
|
||||
@@ -444,11 +445,11 @@ namespace Ryujinx.Tests.Memory
|
||||
_tracking.VirtualMemoryEvent(0, 4, true);
|
||||
|
||||
bool dirtyAfterWriteAfterRead = handle.Dirty;
|
||||
Assert.True(dirtyAfterWriteAfterRead); // Should be dirty.
|
||||
ClassicAssert.True(dirtyAfterWriteAfterRead); // Should be dirty.
|
||||
|
||||
Assert.AreEqual(MemoryPermission.ReadAndWrite, protection); // All protection is now be removed from the memory.
|
||||
ClassicAssert.AreEqual(MemoryPermission.ReadAndWrite, protection); // All protection is now be removed from the memory.
|
||||
|
||||
Assert.IsNull(readTrackingTriggered); // Read tracking was removed when the action fired, as it can only fire once.
|
||||
ClassicAssert.IsNull(readTrackingTriggered); // Read tracking was removed when the action fired, as it can only fire once.
|
||||
|
||||
handle.Dispose();
|
||||
}
|
||||
@@ -476,22 +477,22 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
_tracking.VirtualMemoryEvent(0, 4, false, precise: true);
|
||||
|
||||
Assert.IsNull(readTrackingTriggered); // Hasn't been triggered - precise action returned true.
|
||||
Assert.AreEqual(preciseTriggered, (0UL, 4UL, false)); // Precise action was triggered.
|
||||
ClassicAssert.IsNull(readTrackingTriggered); // Hasn't been triggered - precise action returned true.
|
||||
ClassicAssert.AreEqual(preciseTriggered, (0UL, 4UL, false)); // Precise action was triggered.
|
||||
|
||||
_tracking.VirtualMemoryEvent(0, 4, true, precise: true);
|
||||
|
||||
Assert.IsNull(readTrackingTriggered); // Still hasn't been triggered.
|
||||
ClassicAssert.IsNull(readTrackingTriggered); // Still hasn't been triggered.
|
||||
bool dirtyAfterPreciseActionTrue = handle.Dirty;
|
||||
Assert.False(dirtyAfterPreciseActionTrue); // Not dirtied - precise action returned true.
|
||||
Assert.AreEqual(preciseTriggered, (0UL, 4UL, true)); // Precise action was triggered.
|
||||
ClassicAssert.False(dirtyAfterPreciseActionTrue); // Not dirtied - precise action returned true.
|
||||
ClassicAssert.AreEqual(preciseTriggered, (0UL, 4UL, true)); // Precise action was triggered.
|
||||
|
||||
// Handle is now dirty.
|
||||
handle.Reprotect(true);
|
||||
preciseTriggered = null;
|
||||
|
||||
_tracking.VirtualMemoryEvent(4, 4, true, precise: true);
|
||||
Assert.AreEqual(preciseTriggered, (4UL, 4UL, true)); // Precise action was triggered even though handle was dirty.
|
||||
ClassicAssert.AreEqual(preciseTriggered, (4UL, 4UL, true)); // Precise action was triggered even though handle was dirty.
|
||||
|
||||
handle.Reprotect();
|
||||
handle.RegisterPreciseAction((address, size, write) =>
|
||||
@@ -503,10 +504,10 @@ namespace Ryujinx.Tests.Memory
|
||||
|
||||
_tracking.VirtualMemoryEvent(8, 4, true, precise: true);
|
||||
|
||||
Assert.AreEqual(readTrackingTriggered, (8UL, 4UL)); // Read action triggered, as precise action returned false.
|
||||
ClassicAssert.AreEqual(readTrackingTriggered, (8UL, 4UL)); // Read action triggered, as precise action returned false.
|
||||
bool dirtyAfterPreciseActionFalse = handle.Dirty;
|
||||
Assert.True(dirtyAfterPreciseActionFalse); // Dirtied, as precise action returned false.
|
||||
Assert.AreEqual(preciseTriggered, (8UL, 4UL, true)); // Precise action was triggered.
|
||||
ClassicAssert.True(dirtyAfterPreciseActionFalse); // Dirtied, as precise action returned false.
|
||||
ClassicAssert.AreEqual(preciseTriggered, (8UL, 4UL, true)); // Precise action was triggered.
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user