From 966747cdfdcab6a7f7575e1245cbcff656f8a0a1 Mon Sep 17 00:00:00 2001 From: TSR Berry <20988865+TSRBerry@users.noreply.github.com> Date: Sat, 8 Jul 2023 23:56:54 +0200 Subject: [PATCH] Convert ALU cpu tests to xUnit --- src/Ryujinx.Tests/Cpu/CpuTestAlu.cs | 135 +++++++++++++------------ src/Ryujinx.Tests/Cpu/CpuTestAlu32.cs | 140 +++++++++++++++----------- 2 files changed, 149 insertions(+), 126 deletions(-) diff --git a/src/Ryujinx.Tests/Cpu/CpuTestAlu.cs b/src/Ryujinx.Tests/Cpu/CpuTestAlu.cs index 34756afea..30bf295d1 100644 --- a/src/Ryujinx.Tests/Cpu/CpuTestAlu.cs +++ b/src/Ryujinx.Tests/Cpu/CpuTestAlu.cs @@ -1,5 +1,7 @@ -// #define Alu +#define Alu +using System; +using System.Collections.Generic; using Xunit; namespace Ryujinx.Tests.Cpu @@ -42,7 +44,7 @@ namespace Ryujinx.Tests.Cpu return 1u; } - uint rnd = TestContext.CurrentContext.Random.NextUInt(); + uint rnd = Random.Shared.NextUInt(); int mask = int.MinValue; return (rnd >> (cnt + 1)) | ((uint)mask >> cnt); @@ -60,7 +62,7 @@ namespace Ryujinx.Tests.Cpu return 1ul; } - ulong rnd = TestContext.CurrentContext.Random.NextULong(); + ulong rnd = Random.Shared.NextULong(); long mask = long.MinValue; return (rnd >> (cnt + 1)) | ((ulong)mask >> cnt); @@ -103,172 +105,175 @@ namespace Ryujinx.Tests.Cpu } #endregion - [Test, Pairwise, Description("CLS , ")] - public void Cls_64bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [ValueSource(nameof(GenLeadingSignsX))] ulong xn) + private static readonly uint[] _testData_rd = { 0u, 31u }; + private static readonly uint[] _testData_rn = { 1u, 31u }; + private static readonly ulong[] _testData_xn = + { + 0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul, + 0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul, + }; + private static readonly uint[] _testData_wn = + { + 0x00000000u, 0x7FFFFFFFu, + 0x80000000u, 0xFFFFFFFFu, + }; + + public static readonly MatrixTheoryData TestData_CLS_x = new(_testData_rd, _testData_rn, GenLeadingSignsX()); + public static readonly MatrixTheoryData TestData_CLS_w = new(_testData_rd, _testData_rn, GenLeadingSignsW()); + public static readonly MatrixTheoryData TestData_CLZ_x = new(_testData_rd, _testData_rn, GenLeadingZerosX()); + public static readonly MatrixTheoryData TestData_CLZ_w = new(_testData_rd, _testData_rn, GenLeadingZerosW()); + + public static readonly MatrixTheoryData TestData_64bit = new(_testData_rd, _testData_rn, _testData_xn); + public static readonly MatrixTheoryData TestData_32bit = new(_testData_rd, _testData_rn, _testData_wn); + + [Theory(DisplayName = "CLS , ")] + [MemberData(nameof(TestData_CLS_x))] + public void Cls_64bit(uint rd, uint rn, ulong xn) { uint opcode = 0xDAC01400; // CLS X0, X0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - ulong x31 = TestContext.CurrentContext.Random.NextULong(); + ulong x31 = Random.Shared.NextULong(); SingleOpcode(opcode, x1: xn, x31: x31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("CLS , ")] - public void Cls_32bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [ValueSource(nameof(GenLeadingSignsW))] uint wn) + [Theory(DisplayName = "CLS , ")] + [MemberData(nameof(TestData_CLS_w))] + public void Cls_32bit(uint rd, uint rn, uint wn) { uint opcode = 0x5AC01400; // CLS W0, W0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - uint w31 = TestContext.CurrentContext.Random.NextUInt(); + uint w31 = Random.Shared.NextUInt(); SingleOpcode(opcode, x1: wn, x31: w31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("CLZ , ")] - public void Clz_64bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [ValueSource(nameof(GenLeadingZerosX))] ulong xn) + [Theory(DisplayName = "CLZ , ")] + [MemberData(nameof(TestData_CLZ_x))] + public void Clz_64bit(uint rd, uint rn, ulong xn) { uint opcode = 0xDAC01000; // CLZ X0, X0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - ulong x31 = TestContext.CurrentContext.Random.NextULong(); + ulong x31 = Random.Shared.NextULong(); SingleOpcode(opcode, x1: xn, x31: x31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("CLZ , ")] - public void Clz_32bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [ValueSource(nameof(GenLeadingZerosW))] uint wn) + [Theory(DisplayName = "CLZ , ")] + [MemberData(nameof(TestData_CLZ_w))] + public void Clz_32bit(uint rd, uint rn, uint wn) { uint opcode = 0x5AC01000; // CLZ W0, W0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - uint w31 = TestContext.CurrentContext.Random.NextUInt(); + uint w31 = Random.Shared.NextUInt(); SingleOpcode(opcode, x1: wn, x31: w31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("RBIT , ")] - public void Rbit_64bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [Values(0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul, - 0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul)] ulong xn) + [Theory(DisplayName = "RBIT , ")] + [MemberData(nameof(TestData_64bit))] + public void Rbit_64bit(uint rd, uint rn, ulong xn) { uint opcode = 0xDAC00000; // RBIT X0, X0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - ulong x31 = TestContext.CurrentContext.Random.NextULong(); + ulong x31 = Random.Shared.NextULong(); SingleOpcode(opcode, x1: xn, x31: x31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("RBIT , ")] - public void Rbit_32bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [Values(0x00000000u, 0x7FFFFFFFu, - 0x80000000u, 0xFFFFFFFFu)] uint wn) + [Theory(DisplayName = "RBIT , ")] + [MemberData(nameof(TestData_32bit))] + public void Rbit_32bit(uint rd, uint rn, uint wn) { uint opcode = 0x5AC00000; // RBIT W0, W0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - uint w31 = TestContext.CurrentContext.Random.NextUInt(); + uint w31 = Random.Shared.NextUInt(); SingleOpcode(opcode, x1: wn, x31: w31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("REV16 , ")] - public void Rev16_64bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [Values(0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul, - 0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul)] ulong xn) + [Theory(DisplayName = "REV16 , ")] + [MemberData(nameof(TestData_64bit))] + public void Rev16_64bit(uint rd, uint rn, ulong xn) { uint opcode = 0xDAC00400; // REV16 X0, X0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - ulong x31 = TestContext.CurrentContext.Random.NextULong(); + ulong x31 = Random.Shared.NextULong(); SingleOpcode(opcode, x1: xn, x31: x31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("REV16 , ")] - public void Rev16_32bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [Values(0x00000000u, 0x7FFFFFFFu, - 0x80000000u, 0xFFFFFFFFu)] uint wn) + [Theory(DisplayName = "REV16 , ")] + [MemberData(nameof(TestData_32bit))] + public void Rev16_32bit(uint rd, uint rn, uint wn) { uint opcode = 0x5AC00400; // REV16 W0, W0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - uint w31 = TestContext.CurrentContext.Random.NextUInt(); + uint w31 = Random.Shared.NextUInt(); SingleOpcode(opcode, x1: wn, x31: w31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("REV32 , ")] - public void Rev32_64bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [Values(0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul, - 0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul)] ulong xn) + [Theory(DisplayName = "REV32 , ")] + [MemberData(nameof(TestData_64bit))] + public void Rev32_64bit(uint rd, uint rn, ulong xn) { uint opcode = 0xDAC00800; // REV32 X0, X0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - ulong x31 = TestContext.CurrentContext.Random.NextULong(); + ulong x31 = Random.Shared.NextULong(); SingleOpcode(opcode, x1: xn, x31: x31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("REV , ")] - public void Rev32_32bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [Values(0x00000000u, 0x7FFFFFFFu, - 0x80000000u, 0xFFFFFFFFu)] uint wn) + [Theory(DisplayName = "REV , ")] + [MemberData(nameof(TestData_32bit))] + public void Rev32_32bit(uint rd, uint rn, uint wn) { uint opcode = 0x5AC00800; // REV W0, W0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - uint w31 = TestContext.CurrentContext.Random.NextUInt(); + uint w31 = Random.Shared.NextUInt(); SingleOpcode(opcode, x1: wn, x31: w31); CompareAgainstUnicorn(); } - [Test, Pairwise, Description("REV64 , ")] - public void Rev64_64bit([Values(0u, 31u)] uint rd, - [Values(1u, 31u)] uint rn, - [Values(0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul, - 0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul)] ulong xn) + [Theory(DisplayName = "REV64 , ")] + [MemberData(nameof(TestData_64bit))] + public void Rev64_64bit(uint rd, uint rn, ulong xn) { uint opcode = 0xDAC00C00; // REV64 X0, X0 opcode |= ((rn & 31) << 5) | ((rd & 31) << 0); - ulong x31 = TestContext.CurrentContext.Random.NextULong(); + ulong x31 = Random.Shared.NextULong(); SingleOpcode(opcode, x1: xn, x31: x31); diff --git a/src/Ryujinx.Tests/Cpu/CpuTestAlu32.cs b/src/Ryujinx.Tests/Cpu/CpuTestAlu32.cs index d11ec4813..e2a3fc917 100644 --- a/src/Ryujinx.Tests/Cpu/CpuTestAlu32.cs +++ b/src/Ryujinx.Tests/Cpu/CpuTestAlu32.cs @@ -1,5 +1,6 @@ -// #define Alu32 +#define Alu32 +using System; using Xunit; namespace Ryujinx.Tests.Cpu @@ -59,27 +60,35 @@ namespace Ryujinx.Tests.Cpu private const int RndCnt = 2; - [Test, Pairwise, Description("RBIT , ")] - public void Rbit_32bit([Values(0u, 0xdu)] uint rd, - [Values(1u, 0xdu)] uint rm, - [Values(0x00000000u, 0x7FFFFFFFu, - 0x80000000u, 0xFFFFFFFFu)] uint wn) + private static readonly uint[] _testData_rd = {0u, 0xdu}; + private static readonly uint[] _testData_rm = {1u, 0xdu}; + private static readonly uint[] _testData_wn = + { + 0x00000000u, 0x7FFFFFFFu, + 0x80000000u, 0xFFFFFFFFu, + }; + + public static readonly MatrixTheoryData TestData_32bit = new(_testData_rd, _testData_rm, _testData_wn); + + [Theory(DisplayName = "RBIT , ")] + [MemberData(nameof(TestData_32bit))] + public void Rbit_32bit(uint rd, uint rm, uint wn) { uint opcode = 0xe6ff0f30u; // RBIT R0, R0 opcode |= ((rm & 15) << 0) | ((rd & 15) << 12); - uint w31 = TestContext.CurrentContext.Random.NextUInt(); + uint w31 = Random.Shared.NextUInt(); SingleOpcode(opcode, r1: wn, sp: w31); CompareAgainstUnicorn(); } - [Test, Pairwise] - public void Lsr_Lsl_Asr_Ror([ValueSource(nameof(LsrLslAsrRor))] uint opcode, - [Values(0x00000000u, 0x7FFFFFFFu, - 0x80000000u, 0xFFFFFFFFu)] uint shiftValue, - [Range(0, 31)] int shiftAmount) + public static readonly MatrixTheoryData TestData_Lsr = new(LsrLslAsrRor(), _testData_wn, RangeUtils.RangeData(0, 31, 1)); + + [Theory] + [MemberData(nameof(TestData_Lsr))] + public void Lsr_Lsl_Asr_Ror(uint opcode, uint shiftValue, int shiftAmount) { uint rd = 0; uint rm = 1; @@ -91,104 +100,113 @@ namespace Ryujinx.Tests.Cpu CompareAgainstUnicorn(); } - [Test, Pairwise] - public void Shadd8([Values(0u, 0xdu)] uint rd, - [Values(1u)] uint rm, - [Values(2u)] uint rn, - [Random(RndCnt)] uint w0, - [Random(RndCnt)] uint w1, - [Random(RndCnt)] uint w2) + private static readonly uint[] _testData_Sh_rm = + { + 1u, + }; + + private static readonly uint[] _testData_Sh_rn = + { + 2u, + }; + + public static readonly MatrixTheoryData TestData_Sh = new(_testData_rd, _testData_Sh_rm, _testData_Sh_rn, Random.Shared.NextUIntEnumerable(RndCnt), Random.Shared.NextUIntEnumerable(RndCnt), Random.Shared.NextUIntEnumerable(RndCnt)); + + [Theory] + [MemberData(nameof(TestData_Sh))] + public void Shadd8(uint rd, uint rm, uint rn, uint w0, uint w1, uint w2) { uint opcode = 0xE6300F90u; // SHADD8 R0, R0, R0 opcode |= ((rm & 15) << 0) | ((rd & 15) << 12) | ((rn & 15) << 16); - uint sp = TestContext.CurrentContext.Random.NextUInt(); + uint sp = Random.Shared.NextUInt(); SingleOpcode(opcode, r0: w0, r1: w1, r2: w2, sp: sp); CompareAgainstUnicorn(); } - [Test, Pairwise] - public void Shsub8([Values(0u, 0xdu)] uint rd, - [Values(1u)] uint rm, - [Values(2u)] uint rn, - [Random(RndCnt)] uint w0, - [Random(RndCnt)] uint w1, - [Random(RndCnt)] uint w2) + [Theory] + [MemberData(nameof(TestData_Sh))] + public void Shsub8(uint rd, uint rm, uint rn, uint w0, uint w1, uint w2) { uint opcode = 0xE6300FF0u; // SHSUB8 R0, R0, R0 opcode |= ((rm & 15) << 0) | ((rd & 15) << 12) | ((rn & 15) << 16); - uint sp = TestContext.CurrentContext.Random.NextUInt(); + uint sp = Random.Shared.NextUInt(); SingleOpcode(opcode, r0: w0, r1: w1, r2: w2, sp: sp); CompareAgainstUnicorn(); } - [Test, Pairwise] - public void Ssat_Usat([ValueSource(nameof(SsatUsat))] uint opcode, - [Values(0u, 0xdu)] uint rd, - [Values(1u, 0xdu)] uint rn, - [Values(0u, 7u, 8u, 0xfu, 0x10u, 0x1fu)] uint sat, - [Values(0u, 7u, 8u, 0xfu, 0x10u, 0x1fu)] uint shift, - [Values(0x00000000u, 0x7FFFFFFFu, - 0x80000000u, 0xFFFFFFFFu)] uint wn) + private static readonly uint[] _testData_sat = + { + 0u, 7u, 8u, 0xfu, 0x10u, 0x1fu, + }; + + public static readonly MatrixTheoryData TestData_Ssat = new(SsatUsat(), _testData_rd, _testData_rm, _testData_sat, _testData_sat, _testData_wn); + + [Theory] + [MemberData(nameof(TestData_Ssat))] + public void Ssat_Usat(uint opcode, uint rd, uint rn, uint sat, uint shift, uint wn) { opcode |= ((rn & 15) << 0) | ((shift & 31) << 7) | ((rd & 15) << 12) | ((sat & 31) << 16); - uint w31 = TestContext.CurrentContext.Random.NextUInt(); + uint w31 = Random.Shared.NextUInt(); SingleOpcode(opcode, r1: wn, sp: w31); CompareAgainstUnicorn(); } - [Test, Pairwise] - public void Ssat16_Usat16([ValueSource(nameof(Ssat16Usat16))] uint opcode, - [Values(0u, 0xdu)] uint rd, - [Values(1u, 0xdu)] uint rn, - [Values(0u, 7u, 8u, 0xfu)] uint sat, - [Values(0x00000000u, 0x7FFFFFFFu, - 0x80000000u, 0xFFFFFFFFu)] uint wn) + private static readonly uint[] _testData_sat16 = + { + 0u, 7u, 8u, 0xfu, + }; + + public static readonly MatrixTheoryData TestData_Ssat16 = new(Ssat16Usat16(), _testData_rd, _testData_rm, _testData_sat16, _testData_wn); + + [Theory] + [MemberData(nameof(TestData_Ssat16))] + public void Ssat16_Usat16(uint opcode, uint rd, uint rn, uint sat, uint wn) { opcode |= ((rn & 15) << 0) | ((rd & 15) << 12) | ((sat & 15) << 16); - uint w31 = TestContext.CurrentContext.Random.NextUInt(); + uint w31 = Random.Shared.NextUInt(); SingleOpcode(opcode, r1: wn, sp: w31); CompareAgainstUnicorn(); } - [Test, Pairwise] - public void SU_H_AddSub_8([ValueSource(nameof(SuHAddSub8))] uint opcode, - [Values(0u, 0xdu)] uint rd, - [Values(1u)] uint rm, - [Values(2u)] uint rn, - [Random(RndCnt)] uint w0, - [Random(RndCnt)] uint w1, - [Random(RndCnt)] uint w2) + public static readonly MatrixTheoryData TestData_Su = new(SuHAddSub8(), _testData_rd, _testData_Sh_rm, _testData_Sh_rn, Random.Shared.NextUIntEnumerable(RndCnt), Random.Shared.NextUIntEnumerable(RndCnt), Random.Shared.NextUIntEnumerable(RndCnt)); + + [Theory] + [MemberData(nameof(TestData_Su))] + public void SU_H_AddSub_8(uint opcode, uint rd, uint rm, uint rn, uint w0, uint w1, uint w2) { opcode |= ((rm & 15) << 0) | ((rd & 15) << 12) | ((rn & 15) << 16); - uint sp = TestContext.CurrentContext.Random.NextUInt(); + uint sp = Random.Shared.NextUInt(); SingleOpcode(opcode, r0: w0, r1: w1, r2: w2, sp: sp); CompareAgainstUnicorn(); } - [Test, Pairwise] - public void Uadd8_Sel([Values(0u)] uint rd, - [Values(1u)] uint rm, - [Values(2u)] uint rn, - [Random(RndCnt)] uint w0, - [Random(RndCnt)] uint w1, - [Random(RndCnt)] uint w2) + private static readonly uint[] _testData_Uadd_rd= + { + 0u, + }; + + public static readonly MatrixTheoryData TestData_Uadd = new(_testData_Uadd_rd, _testData_Sh_rm, _testData_Sh_rn, Random.Shared.NextUIntEnumerable(RndCnt), Random.Shared.NextUIntEnumerable(RndCnt), Random.Shared.NextUIntEnumerable(RndCnt)); + + [Theory] + [MemberData(nameof(TestData_Uadd))] + public void Uadd8_Sel(uint rd, uint rm, uint rn, uint w0, uint w1, uint w2) { uint opUadd8 = 0xE6500F90; // UADD8 R0, R0, R0 uint opSel = 0xE6800FB0; // SEL R0, R0, R0